androidX org.eclipse.paho.android.service:报错Program type already present

报错原因

项目升级至Android X环境下面这个包不支持

implementation 'org.eclipse.paho:org.eclipse.paho.android.service:1.0.2'
1

对应的另一个包却支持AndroidX环境，无须修改

implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.0.2'
1

解决方案

• 源码导入项目，适配源码到AndroidX环境，官方未适配，只能自己适配
• 记得修改新的MqttService路径
• 同时记得删除官方依赖org.eclipse.paho:org.eclipse.paho.android.service:1.0.2

解决方案二

---

-我已经帮你改好该包并适配Android X
-你只需要逐个新建以下几个类到项目某个文件夹下面即可

• AndroidManifest

<service android:name="com.iot.listeninsoul.service.MqttService" />
1

• 同时记得删除官方依赖org.eclipse.paho:org.eclipse.paho.android.service:1.0.2
• 但保留另一个库org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.0.2

AlarmPingSender.java

package com.iot.listeninsoul.service;


import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Build;
import android.os.PowerManager;
import android.util.Log;

import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttPingSender;
import org.eclipse.paho.client.mqttv3.internal.ClientComms;

/**
 * Default ping sender implementation on Android. It is based on AlarmManager.
 *
 * 
This class implements the {@link MqttPingSender} pinger interface
 * allowing applications to send ping packet to server every keep alive interval.
 * 
 *
 * @see MqttPingSender
 */
public class AlarmPingSender implements MqttPingSender {
    static final String TAG = "AlarmPingSender";
    private ClientComms comms;
    private MqttService service;
    private BroadcastReceiver alarmReceiver;
    private AlarmPingSender that;
    private PendingIntent pendingIntent;
    private volatile boolean hasStarted = false;

    public AlarmPingSender(MqttService service) {
        if (service == null) {
            throw new IllegalArgumentException("Neither service nor client can be null.");
        } else {
            this.service = service;
            this.that = this;
        }
    }

    public void init(ClientComms comms) {
        this.comms = comms;
        this.alarmReceiver = new AlarmPingSender.AlarmReceiver();
    }

    public void start() {
        String action = "MqttService.pingSender." + this.comms.getClient().getClientId();
        Log.d("AlarmPingSender", "Register alarmreceiver to MqttService" + action);
        this.service.registerReceiver(this.alarmReceiver, new IntentFilter(action));
        this.pendingIntent = PendingIntent.getBroadcast(this.service, 0, new Intent(action), PendingIntent.FLAG_UPDATE_CURRENT);
        this.schedule(this.comms.getKeepAlive());
        this.hasStarted = true;
    }

    public void stop() {

        AlarmManager alarmManager = (AlarmManager)this.service.getSystemService(Context.ALARM_SERVICE);
        alarmManager.cancel(this.pendingIntent);
        Log.d("AlarmPingSender", "Unregister alarmreceiver to MqttService" + this.comms.getClient().getClientId());
        if (this.hasStarted) {
            this.hasStarted = false;
            try {
                this.service.unregisterReceiver(this.alarmReceiver);
            } catch (IllegalArgumentException var3) {

            }
        }

    }

    public void schedule(long delayInMilliseconds) {
        long nextAlarmInMilliseconds = System.currentTimeMillis() + delayInMilliseconds;
        Log.d("AlarmPingSender", "Schedule next alarm at " + nextAlarmInMilliseconds);
        AlarmManager alarmManager = (AlarmManager)this.service.getSystemService(Context.ALARM_SERVICE);
        if (Build.VERSION.SDK_INT >= 19) {
            alarmManager.setExact(AlarmManager.RTC_WAKEUP, nextAlarmInMilliseconds, this.pendingIntent);
        } else {
            alarmManager.set(AlarmManager.RTC_WAKEUP, nextAlarmInMilliseconds, this.pendingIntent);
        }

    }

    class AlarmReceiver extends BroadcastReceiver {
        private PowerManager.WakeLock wakelock;
        private String wakeLockTag;

        AlarmReceiver() {
            this.wakeLockTag = "MqttService.client." + AlarmPingSender.this.that.comms.getClient().getClientId();
        }

        public void onReceive(Context context, Intent intent) {
            int count;
            try {
                count = intent.getIntExtra("android.intent.extra.ALARM_COUNT", -1);
            } catch (ClassCastException var6) {
                Long longCount = intent.getLongExtra("android.intent.extra.ALARM_COUNT", -1L);
                count = longCount.intValue();
            }

            Log.d("AlarmPingSender", "Ping " + count + " times.");
            Log.d("AlarmPingSender", "Check time :" + System.currentTimeMillis());
            PowerManager pm = (PowerManager) AlarmPingSender.this.service.getSystemService(Context.POWER_SERVICE);
            this.wakelock = pm.newWakeLock(1, this.wakeLockTag);
            this.wakelock.acquire();
            IMqttToken token = AlarmPingSender.this.comms.checkForActivity(new IMqttActionListener() {
                public void onSuccess(IMqttToken asyncActionToken) {
                    Log.d("AlarmPingSender", "Success. Release lock(" + AlarmPingSender.AlarmReceiver.this.wakeLockTag + "):" + System.currentTimeMillis());
                    AlarmPingSender.AlarmReceiver.this.wakelock.release();
                }

                public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                    Log.d("AlarmPingSender", "Failure. Release lock(" + AlarmPingSender.AlarmReceiver.this.wakeLockTag + "):" + System.currentTimeMillis());
                    AlarmPingSender.AlarmReceiver.this.wakelock.release();
                }
            });
            if (token == null && this.wakelock.isHeld()) {
                this.wakelock.release();
            }

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

DatabaseMessageStore.java

package com.iot.listeninsoul.service;

import java.util.Iterator;
import java.util.UUID;
import org.eclipse.paho.client.mqttv3.MqttMessage;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/**
 * Implementation of the {@link MessageStore} interface, using a SQLite database
 */
class DatabaseMessageStore implements MessageStore {

    private static String TAG = "DatabaseMessageStore";
    private static final String MTIMESTAMP = "mtimestamp";
    private static final String ARRIVED_MESSAGE_TABLE_NAME = "MqttArrivedMessageTable";
    private SQLiteDatabase db = null;
    private DatabaseMessageStore.MQTTDatabaseHelper mqttDb = null;
    private MqttTraceHandler traceHandler = null;

    public DatabaseMessageStore(MqttService service, Context context) {
        this.traceHandler = service;
        this.mqttDb = new DatabaseMessageStore.MQTTDatabaseHelper(this.traceHandler, context);
        this.traceHandler.traceDebug(TAG, "DatabaseMessageStore complete");
    }

    public String storeArrived(String clientHandle, String topic, MqttMessage message) {

        this.db = this.mqttDb.getWritableDatabase();
        this.traceHandler.traceDebug(TAG, "storeArrived{" + clientHandle + "}, {" + message.toString() + "}");
        byte[] payload = message.getPayload();
        int qos = message.getQos();
        boolean retained = message.isRetained();
        boolean duplicate = message.isDuplicate();
        ContentValues values = new ContentValues();
        String id = UUID.randomUUID().toString();
        values.put("messageId", id);
        values.put("clientHandle", clientHandle);
        values.put("destinationName", topic);
        values.put("payload", payload);
        values.put("qos", qos);
        values.put("retained", retained);
        values.put("duplicate", duplicate);
        values.put("mtimestamp", System.currentTimeMillis());

        try {
            this.db.insertOrThrow("MqttArrivedMessageTable", (String)null, values);
        } catch (SQLException var11) {
            this.traceHandler.traceException(TAG, "onUpgrade", var11);
            throw var11;
        }

        int count = this.getArrivedRowCount(clientHandle);
        this.traceHandler.traceDebug(TAG, "storeArrived: inserted message with id of {" + id + "} - Number of messages in database for this clientHandle = " + count);
        return id;

    }

    private int getArrivedRowCount(String clientHandle) {
        int count = 0;
        String[] projection = new String[]{"messageId"};
        String selection = "clientHandle=?";
        String[] selectionArgs = new String[]{clientHandle};
        Cursor c = this.db.query("MqttArrivedMessageTable", projection, selection, selectionArgs, (String)null, (String)null, (String)null);
        if (c.moveToFirst()) {
            count = c.getInt(0);
        }

        c.close();
        return count;
    }

    public boolean discardArrived(String clientHandle, String id) {
        this.db = this.mqttDb.getWritableDatabase();
        this.traceHandler.traceDebug(TAG, "discardArrived{" + clientHandle + "}, {" + id + "}");
        String[] selectionArgs = new String[]{id, clientHandle};

        int rows;
        try {
            rows = this.db.delete("MqttArrivedMessageTable", "messageId=? AND clientHandle=?", selectionArgs);
        } catch (SQLException var6) {
            this.traceHandler.traceException(TAG, "discardArrived", var6);
            throw var6;
        }

        if (rows != 1) {
            this.traceHandler.traceError(TAG, "discardArrived - Error deleting message {" + id + "} from database: Rows affected = " + rows);
            return false;
        } else {
            int count = this.getArrivedRowCount(clientHandle);
            this.traceHandler.traceDebug(TAG, "discardArrived - Message deleted successfully. - messages in db for this clientHandle " + count);
            return true;
        }
    }

    public Iterator<MessageStore.StoredMessage> getAllArrivedMessages(final String clientHandle) {
        return new Iterator<MessageStore.StoredMessage>() {
            private Cursor c;
            private boolean hasNext;
            private String[] selectionArgs = new String[]{clientHandle};

            {
                DatabaseMessageStore.this.db = DatabaseMessageStore.this.mqttDb.getWritableDatabase();
                if (clientHandle == null) {
                    this.c = DatabaseMessageStore.this.db.query("MqttArrivedMessageTable", (String[])null, (String)null, (String[])null, (String)null, (String)null, "mtimestamp ASC");
                } else {
                    this.c = DatabaseMessageStore.this.db.query("MqttArrivedMessageTable", (String[])null, "clientHandle=?", this.selectionArgs, (String)null, (String)null, "mtimestamp ASC");
                }

                this.hasNext = this.c.moveToFirst();
            }

            public boolean hasNext() {
                if (!this.hasNext) {
                    this.c.close();
                }

                return this.hasNext;
            }

            public MessageStore.StoredMessage next() {
                String messageId = this.c.getString(this.c.getColumnIndex("messageId"));
                String clientHandlex = this.c.getString(this.c.getColumnIndex("clientHandle"));
                String topic = this.c.getString(this.c.getColumnIndex("destinationName"));
                byte[] payload = this.c.getBlob(this.c.getColumnIndex("payload"));
                int qos = this.c.getInt(this.c.getColumnIndex("qos"));
                boolean retained = Boolean.parseBoolean(this.c.getString(this.c.getColumnIndex("retained")));
                boolean dup = Boolean.parseBoolean(this.c.getString(this.c.getColumnIndex("duplicate")));
                DatabaseMessageStore.MqttMessageHack message = DatabaseMessageStore.this.new MqttMessageHack(payload);
                message.setQos(qos);
                message.setRetained(retained);
                message.setDuplicate(dup);
                this.hasNext = this.c.moveToNext();
                return DatabaseMessageStore.this.new DbStoredData(messageId, clientHandlex, topic, message);
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

            protected void finalize() throws Throwable {
                this.c.close();
                super.finalize();
            }
        };
    }

    public void clearArrivedMessages(String clientHandle) {
        this.db = this.mqttDb.getWritableDatabase();
        String[] selectionArgs = new String[]{clientHandle};
        int rows = 0;
        if (clientHandle == null) {
            this.traceHandler.traceDebug(TAG, "clearArrivedMessages: clearing the table");
            rows = this.db.delete("MqttArrivedMessageTable", (String)null, (String[])null);
        } else {
            this.traceHandler.traceDebug(TAG, "clearArrivedMessages: clearing the table of " + clientHandle + " messages");
            rows = this.db.delete("MqttArrivedMessageTable", "clientHandle=?", selectionArgs);
        }

        this.traceHandler.traceDebug(TAG, "clearArrivedMessages: rows affected = " + rows);
    }

    public void close() {
        if (this.db != null) {
            this.db.close();
        }

    }

    private class MqttMessageHack extends MqttMessage {
        public MqttMessageHack(byte[] payload) {
            super(payload);
        }

        protected void setDuplicate(boolean dup) {
            super.setDuplicate(dup);
        }
    }

    private class DbStoredData implements MessageStore.StoredMessage {
        private String messageId;
        private String clientHandle;
        private String topic;
        private MqttMessage message;

        DbStoredData(String messageId, String clientHandle, String topic, MqttMessage message) {
            this.messageId = messageId;
            this.topic = topic;
            this.message = message;
        }

        public String getMessageId() {
            return this.messageId;
        }

        public String getClientHandle() {
            return this.clientHandle;
        }

        public String getTopic() {
            return this.topic;
        }

        public MqttMessage getMessage() {
            return this.message;
        }
    }

    private static class MQTTDatabaseHelper extends SQLiteOpenHelper {
        private static String TAG = "MQTTDatabaseHelper";
        private static final String DATABASE_NAME = "mqttAndroidService.db";
        private static final int DATABASE_VERSION = 1;
        private MqttTraceHandler traceHandler = null;

        public MQTTDatabaseHelper(MqttTraceHandler traceHandler, Context context) {
            super(context, "mqttAndroidService.db", (SQLiteDatabase.CursorFactory)null, 1);
            this.traceHandler = traceHandler;
        }

        public void onCreate(SQLiteDatabase database) {
            String createArrivedTableStatement = "CREATE TABLE MqttArrivedMessageTable(messageId TEXT PRIMARY KEY, clientHandle TEXT, destinationName TEXT, payload BLOB, qos INTEGER, retained TEXT, duplicate TEXT, mtimestamp INTEGER);";
            this.traceHandler.traceDebug(TAG, "onCreate {" + createArrivedTableStatement + "}");

            try {
                database.execSQL(createArrivedTableStatement);
                this.traceHandler.traceDebug(TAG, "created the table");
            } catch (SQLException var4) {
                this.traceHandler.traceException(TAG, "onCreate", var4);
                throw var4;
            }
        }

        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            this.traceHandler.traceDebug(TAG, "onUpgrade");

            try {
                db.execSQL("DROP TABLE IF EXISTS MqttArrivedMessageTable");
            } catch (SQLException var5) {
                this.traceHandler.traceException(TAG, "onUpgrade", var5);
                throw var5;
            }

            this.onCreate(db);
            this.traceHandler.traceDebug(TAG, "onUpgrade complete");
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253

MessageStore.java

---

package com.iot.listeninsoul.service;

import java.util.Iterator;

import org.eclipse.paho.client.mqttv3.MqttMessage;

/**
 * 

 * Mechanism for persisting messages until we know they have been received
 * 
 * 

 * 
A Service should store messages as they arrive via
 * {@link #storeArrived(String, String, MqttMessage)}.
 * 
When a message has been passed to the consuming entity,
 * {@link #discardArrived(String, String)} should be called.
 * 
To recover messages which have not been definitely passed to the
 * consumer, {@link MessageStore#getAllArrivedMessages(String)} is used.
 * 
When a clean session is started {@link #clearArrivedMessages(String)} is
 * used.
 * 
 */
interface MessageStore {

	String storeArrived(String var1, String var2, MqttMessage var3);

	boolean discardArrived(String var1, String var2);

	Iterator<StoredMessage> getAllArrivedMessages(String var1);

	void clearArrivedMessages(String var1);

	void close();

	public interface StoredMessage {
		String getMessageId();

		String getClientHandle();

		String getTopic();

		MqttMessage getMessage();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

MqttAndroidClient.java

package com.iot.listeninsoul.service;

import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.SparseArray;

import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import org.eclipse.paho.client.mqttv3.DisconnectedBufferOptions;
import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttAsyncClient;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.IMqttMessageListener;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
import org.eclipse.paho.client.mqttv3.MqttClientPersistence;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
import org.eclipse.paho.client.mqttv3.MqttSecurityException;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;

/**
 * Enables an android application to communicate with an MQTT server using non-blocking methods.
 * 

 * Using the MQTT
 * android service to actually interface with MQTT server. It provides android applications a simple programming interface to all features of the MQTT version 3.1
 * specification including:
 * 
 * 

 * 
connect
 * 
publish
 * 
subscribe
 * 
unsubscribe
 * 
disconnect
 * 
 */
public class MqttAndroidClient extends BroadcastReceiver implements IMqttAsyncClient {
    private static final String SERVICE_NAME = "MqttService";
    private static final int BIND_SERVICE_FLAG = 0;
    private static ExecutorService pool = Executors.newCachedThreadPool();
    private MyServiceConnection serviceConnection;
    private MqttService mqttService;
    private String clientHandle;
    Context myContext;
    private SparseArray<IMqttToken> tokenMap;
    private int tokenNumber;
    private String serverURI;
    private String clientId;
    private MqttClientPersistence persistence;
    private MqttConnectOptions connectOptions;
    private IMqttToken connectToken;
    private MqttCallback callback;
    private MqttTraceHandler traceCallback;
    private MqttAndroidClient.Ack messageAck;
    private boolean traceEnabled;
    private volatile boolean receiverRegistered;
    private volatile boolean bindedService;

    public MqttAndroidClient(Context context, String serverURI, String clientId) {
        this(context, serverURI, clientId, (MqttClientPersistence)null, MqttAndroidClient.Ack.AUTO_ACK);
    }

    public MqttAndroidClient(Context ctx, String serverURI, String clientId, MqttAndroidClient.Ack ackType) {
        this(ctx, serverURI, clientId, (MqttClientPersistence)null, ackType);
    }

    public MqttAndroidClient(Context ctx, String serverURI, String clientId, MqttClientPersistence persistence) {
        this(ctx, serverURI, clientId, persistence, MqttAndroidClient.Ack.AUTO_ACK);
    }

    public MqttAndroidClient(Context context, String serverURI, String clientId, MqttClientPersistence persistence, MqttAndroidClient.Ack ackType) {
        this.serviceConnection = new MyServiceConnection();
        this.tokenMap = new SparseArray();
        this.tokenNumber = 0;
        this.persistence = null;
        this.traceEnabled = false;
        this.receiverRegistered = false;
        this.bindedService = false;
        this.myContext = context;
        this.serverURI = serverURI;
        this.clientId = clientId;
        this.persistence = persistence;
        this.messageAck = ackType;
    }

    public boolean isConnected() {
        return this.clientHandle != null && this.mqttService != null ? this.mqttService.isConnected(this.clientHandle) : false;
    }

    public String getClientId() {
        return this.clientId;
    }

    public String getServerURI() {
        return this.serverURI;
    }

    public void close() {
        if (this.clientHandle == null) {
            System.out.println(this.serverURI);
            System.out.println(this.clientId);
            System.out.println(this.myContext.getApplicationInfo().packageName);
            System.out.println(this.persistence);
            this.clientHandle = this.mqttService.getClient(this.serverURI, this.clientId, this.myContext.getApplicationInfo().packageName, this.persistence);
        }

        this.mqttService.close(this.clientHandle);
    }

    public IMqttToken connect() throws MqttException {
        return this.connect((Object)null, (IMqttActionListener)null);
    }

    public IMqttToken connect(MqttConnectOptions options) throws MqttException {
        return this.connect(options, (Object)null, (IMqttActionListener)null);
    }

    public IMqttToken connect(Object userContext, IMqttActionListener callback) throws MqttException {
        return this.connect(new MqttConnectOptions(), userContext, callback);
    }

    public IMqttToken connect(MqttConnectOptions options, Object userContext, IMqttActionListener callback) throws MqttException {

        IMqttToken token = new MqttTokenAndroid(this, userContext, callback);
        this.connectOptions = options;
        this.connectToken = token;
        if (this.mqttService == null) {

            Intent serviceStartIntent = new Intent();
            serviceStartIntent.setClassName(this.myContext, String.valueOf(MqttService.class));

            Object service = this.myContext.startService(serviceStartIntent);
            if (service == null) {
                IMqttActionListener listener = token.getActionCallback();
                if (listener != null) {
                    listener.onFailure(token, new RuntimeException("cannot start service MqttService"));
                }
            }

            this.myContext.bindService(serviceStartIntent, this.serviceConnection, Context.BIND_AUTO_CREATE);
            if (!this.receiverRegistered) {
                this.registerReceiver(this);
            }

        } else {
            pool.execute(new Runnable() {
                public void run() {
                    MqttAndroidClient.this.doConnect();
                    if (!MqttAndroidClient.this.receiverRegistered) {
                        MqttAndroidClient.this.registerReceiver(MqttAndroidClient.this);
                    }

                }
            });
        }

        return token;
    }

    private void registerReceiver(BroadcastReceiver receiver) {
        IntentFilter filter = new IntentFilter();
        filter.addAction("MqttService.callbackToActivity.v0");
        LocalBroadcastManager.getInstance(this.myContext).registerReceiver(receiver, filter);
        this.receiverRegistered = true;
    }

    private void doConnect() {
        if (this.clientHandle == null) {
            this.clientHandle = this.mqttService.getClient(this.serverURI, this.clientId, this.myContext.getApplicationInfo().packageName, this.persistence);
        }

        this.mqttService.setTraceEnabled(this.traceEnabled);
        this.mqttService.setTraceCallbackId(this.clientHandle);
        String activityToken = this.storeToken(this.connectToken);

        try {
            this.mqttService.connect(this.clientHandle, this.connectOptions, (String)null, activityToken);
        } catch (MqttException var4) {
            IMqttActionListener listener = this.connectToken.getActionCallback();
            if (listener != null) {
                listener.onFailure(this.connectToken, var4);
            }
        }

    }

    public IMqttToken disconnect() throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, (Object)null, (IMqttActionListener)null);
        String activityToken = this.storeToken(token);
        this.mqttService.disconnect(this.clientHandle, (String)null, activityToken);
        return token;
    }

    public IMqttToken disconnect(long quiesceTimeout) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, (Object)null, (IMqttActionListener)null);
        String activityToken = this.storeToken(token);
        this.mqttService.disconnect(this.clientHandle, quiesceTimeout, (String)null, activityToken);
        return token;
    }

    public IMqttToken disconnect(Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback);
        String activityToken = this.storeToken(token);
        this.mqttService.disconnect(this.clientHandle, (String)null, activityToken);
        return token;
    }

    public IMqttToken disconnect(long quiesceTimeout, Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback);
        String activityToken = this.storeToken(token);
        this.mqttService.disconnect(this.clientHandle, quiesceTimeout, (String)null, activityToken);
        return token;
    }

    public IMqttDeliveryToken publish(String topic, byte[] payload, int qos, boolean retained) throws MqttException, MqttPersistenceException {
        return this.publish(topic, payload, qos, retained, (Object)null, (IMqttActionListener)null);
    }

    public IMqttDeliveryToken publish(String topic, MqttMessage message) throws MqttException, MqttPersistenceException {
        return this.publish(topic, message, (Object)null, (IMqttActionListener)null);
    }

    public IMqttDeliveryToken publish(String topic, byte[] payload, int qos, boolean retained, Object userContext, IMqttActionListener callback) throws MqttException, MqttPersistenceException {
        MqttMessage message = new MqttMessage(payload);
        message.setQos(qos);
        message.setRetained(retained);
        MqttDeliveryTokenAndroid token = new MqttDeliveryTokenAndroid(this, userContext, callback, message);
        String activityToken = this.storeToken(token);
        IMqttDeliveryToken internalToken = this.mqttService.publish(this.clientHandle, topic, payload, qos, retained, (String)null, activityToken);
        token.setDelegate(internalToken);
        return token;
    }

    public IMqttDeliveryToken publish(String topic, MqttMessage message, Object userContext, IMqttActionListener callback) throws MqttException, MqttPersistenceException {
        MqttDeliveryTokenAndroid token = new MqttDeliveryTokenAndroid(this, userContext, callback, message);
        String activityToken = this.storeToken(token);
        IMqttDeliveryToken internalToken = this.mqttService.publish(this.clientHandle, topic, message, (String)null, activityToken);
        token.setDelegate(internalToken);
        return token;
    }

    public IMqttToken subscribe(String topic, int qos) throws MqttException, MqttSecurityException {
        return this.subscribe(topic, qos, (Object)null, (IMqttActionListener)null);
    }

    public IMqttToken subscribe(String[] topic, int[] qos) throws MqttException, MqttSecurityException {
        return this.subscribe(topic, qos, (Object)null, (IMqttActionListener)null);
    }

    public IMqttToken subscribe(String topic, int qos, Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback, new String[]{topic});
        String activityToken = this.storeToken(token);
        this.mqttService.subscribe(this.clientHandle, topic, qos, (String)null, activityToken);
        return token;
    }

    public IMqttToken subscribe(String[] topic, int[] qos, Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback, topic);
        String activityToken = this.storeToken(token);
        this.mqttService.subscribe(this.clientHandle, topic, qos, (String)null, activityToken);
        return token;
    }

    public IMqttToken subscribe(String topicFilter, int qos, Object userContext, IMqttActionListener callback, IMqttMessageListener messageListener) throws MqttException {
        return this.subscribe(new String[]{topicFilter}, new int[]{qos}, userContext, callback, new IMqttMessageListener[]{messageListener});
    }

    public IMqttToken subscribe(String topicFilter, int qos, IMqttMessageListener messageListener) throws MqttException {
        return this.subscribe(topicFilter, qos, (Object)null, (IMqttActionListener)null, messageListener);
    }

    public IMqttToken subscribe(String[] topicFilters, int[] qos, IMqttMessageListener[] messageListeners) throws MqttException {
        return this.subscribe(topicFilters, qos, (Object)null, (IMqttActionListener)null, messageListeners);
    }

    public IMqttToken subscribe(String[] topicFilters, int[] qos, Object userContext, IMqttActionListener callback, IMqttMessageListener[] messageListeners) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback, topicFilters);
        String activityToken = this.storeToken(token);
        this.mqttService.subscribe(this.clientHandle, topicFilters, qos, (String)null, activityToken, messageListeners);
        return null;
    }

    public IMqttToken unsubscribe(String topic) throws MqttException {
        return this.unsubscribe((String)topic, (Object)null, (IMqttActionListener)null);
    }

    public IMqttToken unsubscribe(String[] topic) throws MqttException {
        return this.unsubscribe((String[])topic, (Object)null, (IMqttActionListener)null);
    }

    public IMqttToken unsubscribe(String topic, Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback);
        String activityToken = this.storeToken(token);
        this.mqttService.unsubscribe(this.clientHandle, topic, (String)null, activityToken);
        return token;
    }

    public IMqttToken unsubscribe(String[] topic, Object userContext, IMqttActionListener callback) throws MqttException {
        IMqttToken token = new MqttTokenAndroid(this, userContext, callback);
        String activityToken = this.storeToken(token);
        this.mqttService.unsubscribe(this.clientHandle, topic, (String)null, activityToken);
        return token;
    }

    public IMqttDeliveryToken[] getPendingDeliveryTokens() {
        return this.mqttService.getPendingDeliveryTokens(this.clientHandle);
    }

    public void setCallback(MqttCallback callback) {
        this.callback = callback;
    }

    public void setTraceCallback(MqttTraceHandler traceCallback) {
        this.traceCallback = traceCallback;
    }

    public void setTraceEnabled(boolean traceEnabled) {
        this.traceEnabled = traceEnabled;
        if (this.mqttService != null) {
            this.mqttService.setTraceEnabled(traceEnabled);
        }

    }

    public void onReceive(Context context, Intent intent) {
        Bundle data = intent.getExtras();
        String handleFromIntent = data.getString("MqttService.clientHandle");
        if (handleFromIntent != null && handleFromIntent.equals(this.clientHandle)) {
            String action = data.getString("MqttService.callbackAction");
            if ("connect".equals(action)) {
                this.connectAction(data);
            } else if ("connectExtended".equals(action)) {
                this.connectExtendedAction(data);
            } else if ("messageArrived".equals(action)) {
                this.messageArrivedAction(data);
            } else if ("subscribe".equals(action)) {
                this.subscribeAction(data);
            } else if ("unsubscribe".equals(action)) {
                this.unSubscribeAction(data);
            } else if ("send".equals(action)) {
                this.sendAction(data);
            } else if ("messageDelivered".equals(action)) {
                this.messageDeliveredAction(data);
            } else if ("onConnectionLost".equals(action)) {
                this.connectionLostAction(data);
            } else if ("disconnect".equals(action)) {
                this.disconnected(data);
            } else if ("trace".equals(action)) {
                this.traceAction(data);
            } else {
                this.mqttService.traceError("MqttService", "Callback action doesn't exist.");
            }

        }
    }

    public boolean acknowledgeMessage(String messageId) {
        if (this.messageAck == MqttAndroidClient.Ack.MANUAL_ACK) {
            Status status = this.mqttService.acknowledgeMessageArrival(this.clientHandle, messageId);
            return status == Status.OK;
        } else {
            return false;
        }
    }

    public void messageArrivedComplete(int messageId, int qos) throws MqttException {
        throw new UnsupportedOperationException();
    }

    public void setManualAcks(boolean manualAcks) {
        throw new UnsupportedOperationException();
    }

    private void connectAction(Bundle data) {
        IMqttToken token = this.connectToken;
        this.removeMqttToken(data);
        this.simpleAction(token, data);
    }

    private void disconnected(Bundle data) {
        this.clientHandle = null;
        IMqttToken token = this.removeMqttToken(data);
        if (token != null) {
            ((MqttTokenAndroid)token).notifyComplete();
        }

        if (this.callback != null) {
            this.callback.connectionLost((Throwable)null);
        }

    }

    private void connectionLostAction(Bundle data) {
        if (this.callback != null) {
            Exception reason = (Exception)data.getSerializable("MqttService.exception");
            this.callback.connectionLost(reason);
        }

    }

    private void connectExtendedAction(Bundle data) {
        if (this.callback instanceof MqttCallbackExtended) {
            boolean reconnect = data.getBoolean("MqttService.reconnect", false);
            String serverURI = data.getString("MqttService.serverURI");
            ((MqttCallbackExtended)this.callback).connectComplete(reconnect, serverURI);
        }

    }

    private void simpleAction(IMqttToken token, Bundle data) {
        if (token != null) {
            Status status = (Status)data.getSerializable("MqttService.callbackStatus");
            if (status == Status.OK) {
                ((MqttTokenAndroid)token).notifyComplete();
            } else {
                Exception exceptionThrown = (Exception)data.getSerializable("MqttService.exception");
                ((MqttTokenAndroid)token).notifyFailure(exceptionThrown);
            }
        } else {
            this.mqttService.traceError("MqttService", "simpleAction : token is null");
        }

    }

    private void sendAction(Bundle data) {
        IMqttToken token = this.getMqttToken(data);
        this.simpleAction(token, data);
    }

    private void subscribeAction(Bundle data) {
        IMqttToken token = this.removeMqttToken(data);
        this.simpleAction(token, data);
    }

    private void unSubscribeAction(Bundle data) {
        IMqttToken token = this.removeMqttToken(data);
        this.simpleAction(token, data);
    }

    private void messageDeliveredAction(Bundle data) {
        IMqttToken token = this.removeMqttToken(data);
        if (token != null && this.callback != null) {
            Status status = (Status)data.getSerializable("MqttService.callbackStatus");
            if (status == Status.OK && token instanceof IMqttDeliveryToken) {
                this.callback.deliveryComplete((IMqttDeliveryToken)token);
            }
        }

    }

    private void messageArrivedAction(Bundle data) {
        if (this.callback != null) {
            String messageId = data.getString("MqttService.messageId");
            String destinationName = data.getString("MqttService.destinationName");
            ParcelableMqttMessage message = (ParcelableMqttMessage)data.getParcelable("MqttService.PARCEL");

            try {
                if (this.messageAck == MqttAndroidClient.Ack.AUTO_ACK) {
                    this.callback.messageArrived(destinationName, message);
                    this.mqttService.acknowledgeMessageArrival(this.clientHandle, messageId);
                } else {
                    message.messageId = messageId;
                    this.callback.messageArrived(destinationName, message);
                }
            } catch (Exception var6) {
            }
        }

    }

    private void traceAction(Bundle data) {
        if (this.traceCallback != null) {
            String severity = data.getString("MqttService.traceSeverity");
            String message = data.getString("MqttService.errorMessage");
            String tag = data.getString("MqttService.traceTag");
            if ("debug".equals(severity)) {
                this.traceCallback.traceDebug(tag, message);
            } else if ("error".equals(severity)) {
                this.traceCallback.traceError(tag, message);
            } else {
                Exception e = (Exception)data.getSerializable("MqttService.exception");
                this.traceCallback.traceException(tag, message, e);
            }
        }

    }

    private synchronized String storeToken(IMqttToken token) {
        this.tokenMap.put(this.tokenNumber, token);
        return Integer.toString(this.tokenNumber++);
    }

    private synchronized IMqttToken removeMqttToken(Bundle data) {
        String activityToken = data.getString("MqttService.activityToken");
        if (activityToken != null) {
            int tokenNumber = Integer.parseInt(activityToken);
            IMqttToken token = (IMqttToken)this.tokenMap.get(tokenNumber);
            this.tokenMap.delete(tokenNumber);
            return token;
        } else {
            return null;
        }
    }

    private synchronized IMqttToken getMqttToken(Bundle data) {
        String activityToken = data.getString("MqttService.activityToken");
        IMqttToken token = (IMqttToken)this.tokenMap.get(Integer.parseInt(activityToken));
        return token;
    }

    public void setBufferOpts(DisconnectedBufferOptions bufferOpts) {
        this.mqttService.setBufferOpts(this.clientHandle, bufferOpts);
    }

    public int getBufferedMessageCount() {
        return this.mqttService.getBufferedMessageCount(this.clientHandle);
    }

    public MqttMessage getBufferedMessage(int bufferIndex) {
        return this.mqttService.getBufferedMessage(this.clientHandle, bufferIndex);
    }

    public void deleteBufferedMessage(int bufferIndex) {
        this.mqttService.deleteBufferedMessage(this.clientHandle, bufferIndex);
    }

    public SSLSocketFactory getSSLSocketFactory(InputStream keyStore, String password) throws MqttSecurityException {
        try {
            SSLContext ctx = null;
            SSLSocketFactory sslSockFactory = null;
            KeyStore ts = KeyStore.getInstance("BKS");
            ts.load(keyStore, password.toCharArray());
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("X509");
            tmf.init(ts);
            TrustManager[] tm = tmf.getTrustManagers();
            ctx = SSLContext.getInstance("TLSv1");
            ctx.init((KeyManager[])null, tm, (SecureRandom)null);
            sslSockFactory = ctx.getSocketFactory();
            return sslSockFactory;
        } catch (KeyStoreException var8) {
            throw new MqttSecurityException(var8);
        } catch (CertificateException var9) {
            throw new MqttSecurityException(var9);
        } catch (FileNotFoundException var10) {
            throw new MqttSecurityException(var10);
        } catch (IOException var11) {
            throw new MqttSecurityException(var11);
        } catch (NoSuchAlgorithmException var12) {
            throw new MqttSecurityException(var12);
        } catch (KeyManagementException var13) {
            throw new MqttSecurityException(var13);
        }
    }

    public void disconnectForcibly() throws MqttException {
        throw new UnsupportedOperationException();
    }

    public void disconnectForcibly(long disconnectTimeout) throws MqttException {
        throw new UnsupportedOperationException();
    }

    public void disconnectForcibly(long quiesceTimeout, long disconnectTimeout) throws MqttException {
        throw new UnsupportedOperationException();
    }

    public void unregisterResources() {
        if (this.myContext != null && this.receiverRegistered) {
            synchronized(this) {
                LocalBroadcastManager.getInstance(this.myContext).unregisterReceiver(this);
                this.receiverRegistered = false;
            }

            if (this.bindedService) {
                try {
                    this.myContext.unbindService(this.serviceConnection);
                    this.bindedService = false;
                } catch (IllegalArgumentException var3) {
                }
            }
        }

    }

    public void registerResources(Context context) {
        if (context != null) {
            this.myContext = context;
            if (!this.receiverRegistered) {
                this.registerReceiver(this);
            }
        }

    }

    private final class MyServiceConnection implements ServiceConnection {
        private MyServiceConnection() {
        }

        public void onServiceConnected(ComponentName name, IBinder binder) {
            MqttAndroidClient.this.mqttService = ((MqttServiceBinder)binder).getService();
            MqttAndroidClient.this.bindedService = true;
            MqttAndroidClient.this.doConnect();
        }

        public void onServiceDisconnected(ComponentName name) {
            MqttAndroidClient.this.mqttService = null;
        }
    }

    public static enum Ack {
        AUTO_ACK,
        MANUAL_ACK;

        private Ack() {
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643

MqttConnection.java

package com.iot.listeninsoul.service;

import android.content.Context;
import android.os.Bundle;
import android.os.PowerManager;
import android.util.Log;


import org.eclipse.paho.client.mqttv3.DisconnectedBufferOptions;
import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.IMqttMessageListener;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
import org.eclipse.paho.client.mqttv3.MqttClientPersistence;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
import org.eclipse.paho.client.mqttv3.persist.MqttDefaultFilePersistence;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

class MqttConnection implements MqttCallbackExtended {
   private static final String TAG = "MqttConnection";
   private static final String NOT_CONNECTED = "not connected";
   private String serverURI;
   private String clientId;
   private MqttClientPersistence persistence = null;
   private MqttConnectOptions connectOptions;
   private String clientHandle;
   private String reconnectActivityToken = null;
   private MqttAsyncClient myClient = null;
   private MqttService service = null;
   private volatile boolean disconnected = true;
   private boolean cleanSession = true;
   private volatile boolean isConnecting = false;
   private Map<IMqttDeliveryToken, String> savedTopics = new HashMap();
   private Map<IMqttDeliveryToken, MqttMessage> savedSentMessages = new HashMap();
   private Map<IMqttDeliveryToken, String> savedActivityTokens = new HashMap();
   private Map<IMqttDeliveryToken, String> savedInvocationContexts = new HashMap();
   private PowerManager.WakeLock wakelock = null;
   private String wakeLockTag = null;
   private DisconnectedBufferOptions bufferOpts = null;

   public String getServerURI() {
      return this.serverURI;
   }

   public void setServerURI(String serverURI) {
      this.serverURI = serverURI;
   }

   public String getClientId() {
      return this.clientId;
   }

   public void setClientId(String clientId) {
      this.clientId = clientId;
   }

   public MqttConnectOptions getConnectOptions() {
      return this.connectOptions;
   }

   public void setConnectOptions(MqttConnectOptions connectOptions) {
      this.connectOptions = connectOptions;
   }

   public String getClientHandle() {
      return this.clientHandle;
   }

   public void setClientHandle(String clientHandle) {
      this.clientHandle = clientHandle;
   }

   MqttConnection(MqttService service, String serverURI, String clientId, MqttClientPersistence persistence, String clientHandle) {
      this.serverURI = serverURI.toString();
      this.service = service;
      this.clientId = clientId;
      this.persistence = persistence;
      this.clientHandle = clientHandle;
      StringBuffer buff = new StringBuffer(this.getClass().getCanonicalName());
      buff.append(" ");
      buff.append(clientId);
      buff.append(" ");
      buff.append("on host ");
      buff.append(serverURI);
      this.wakeLockTag = buff.toString();
   }

   public void connect(MqttConnectOptions options, String invocationContext, String activityToken) {
      this.connectOptions = options;
      this.reconnectActivityToken = activityToken;
      if (options != null) {
         this.cleanSession = options.isCleanSession();
      }

      if (this.connectOptions.isCleanSession()) {
         this.service.messageStore.clearArrivedMessages(this.clientHandle);
      }

      this.service.traceDebug("MqttConnection", "Connecting {" + this.serverURI + "} as {" + this.clientId + "}");
      final Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      resultBundle.putString("MqttService.callbackAction", "connect");

      try {
         if (this.persistence == null) {
            File myDir = this.service.getExternalFilesDir("MqttConnection");
            if (myDir == null) {
               myDir = this.service.getDir("MqttConnection", 0);
               if (myDir == null) {
                  resultBundle.putString("MqttService.errorMessage", "Error! No external and internal storage available");
                  resultBundle.putSerializable("MqttService.exception", new MqttPersistenceException());
                  this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
                  return;
               }
            }

            this.persistence = new MqttDefaultFilePersistence(myDir.getAbsolutePath());
         }

         IMqttActionListener listener = new MqttConnection.MqttConnectionListener(resultBundle) {
            public void onSuccess(IMqttToken asyncActionToken) {
               MqttConnection.this.doAfterConnectSuccess(resultBundle);
               MqttConnection.this.service.traceDebug("MqttConnection", "connect success!");
            }

            public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
               resultBundle.putString("MqttService.errorMessage", exception.getLocalizedMessage());
               resultBundle.putSerializable("MqttService.exception", exception);
               MqttConnection.this.service.traceError("MqttConnection", "connect fail, call connect to reconnect.reason:" + exception.getMessage());
               MqttConnection.this.doAfterConnectFail(resultBundle);
            }
         };
         if (this.myClient != null) {
            if (this.isConnecting) {
               this.service.traceDebug("MqttConnection", "myClient != null and the client is connecting. Connect return directly.");
               this.service.traceDebug("MqttConnection", "Connect return:isConnecting:" + this.isConnecting + ".disconnected:" + this.disconnected);
               return;
            }

            if (!this.disconnected) {
               this.service.traceDebug("MqttConnection", "myClient != null and the client is connected and notify!");
               this.doAfterConnectSuccess(resultBundle);
            } else {
               this.service.traceDebug("MqttConnection", "myClient != null and the client is not connected");
               this.service.traceDebug("MqttConnection", "Do Real connect!");
               this.setConnectingState(true);
               this.myClient.connect(this.connectOptions, invocationContext, listener);
            }
         } else {
            this.myClient = new MqttAsyncClient(this.serverURI, this.clientId, this.persistence, new AlarmPingSender(this.service));
            this.myClient.setCallback(this);
            this.service.traceDebug("MqttConnection", "Do Real connect!");
            this.setConnectingState(true);
            this.myClient.connect(this.connectOptions, invocationContext, listener);
         }
      } catch (Exception var6) {
         this.handleException(resultBundle, var6);
      }

   }

   private void doAfterConnectSuccess(Bundle resultBundle) {
      this.acquireWakeLock();
      this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
      this.deliverBacklog();
      this.setConnectingState(false);
      this.disconnected = false;
      this.releaseWakeLock();
   }

   public void connectComplete(boolean reconnect, String serverURI) {
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "connectExtended");
      resultBundle.putBoolean("MqttService.reconnect", reconnect);
      resultBundle.putString("MqttService.serverURI", serverURI);
      this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
   }

   private void doAfterConnectFail(Bundle resultBundle) {
      this.acquireWakeLock();
      this.disconnected = true;
      this.setConnectingState(false);
      this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      this.releaseWakeLock();
   }

   private void handleException(Bundle resultBundle, Exception e) {
      resultBundle.putString("MqttService.errorMessage", e.getLocalizedMessage());
      resultBundle.putSerializable("MqttService.exception", e);
      this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
   }

   private void deliverBacklog() {
      Iterator backlog = this.service.messageStore.getAllArrivedMessages(this.clientHandle);

      while(backlog.hasNext()) {
         MessageStore.StoredMessage msgArrived = (MessageStore.StoredMessage)backlog.next();
         Bundle resultBundle = this.messageToBundle(msgArrived.getMessageId(), msgArrived.getTopic(), msgArrived.getMessage());
         resultBundle.putString("MqttService.callbackAction", "messageArrived");
         this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
      }

   }

   private Bundle messageToBundle(String messageId, String topic, MqttMessage message) {
      Bundle result = new Bundle();
      result.putString("MqttService.messageId", messageId);
      result.putString("MqttService.destinationName", topic);
      result.putParcelable("MqttService.PARCEL", new ParcelableMqttMessage(message));
      return result;
   }

   void close() {
      this.service.traceDebug("MqttConnection", "close()");

      try {
         if (this.myClient != null) {
            this.myClient.close();
         }
      } catch (MqttException var2) {
         this.handleException(new Bundle(), var2);
      }

   }

   void disconnect(long quiesceTimeout, String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "disconnect()");
      this.disconnected = true;
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      resultBundle.putString("MqttService.callbackAction", "disconnect");
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.disconnect(quiesceTimeout, invocationContext, listener);
         } catch (Exception var8) {
            this.handleException(resultBundle, var8);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("disconnect", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

      if (this.connectOptions != null && this.connectOptions.isCleanSession()) {
         this.service.messageStore.clearArrivedMessages(this.clientHandle);
      }

      this.releaseWakeLock();
   }

   void disconnect(String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "disconnect()");
      this.disconnected = true;
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      resultBundle.putString("MqttService.callbackAction", "disconnect");
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnection.MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.disconnect(invocationContext, listener);
         } catch (Exception var6) {
            this.handleException(resultBundle, var6);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("disconnect", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

      if (this.connectOptions != null && this.connectOptions.isCleanSession()) {
         this.service.messageStore.clearArrivedMessages(this.clientHandle);
      }

      this.releaseWakeLock();
   }

   public boolean isConnected() {
      return this.myClient != null ? this.myClient.isConnected() : false;
   }

   public IMqttDeliveryToken publish(String topic, byte[] payload, int qos, boolean retained, String invocationContext, String activityToken) {
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "send");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      IMqttDeliveryToken sendToken = null;
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            MqttMessage message = new MqttMessage(payload);
            message.setQos(qos);
            message.setRetained(retained);
            sendToken = this.myClient.publish(topic, payload, qos, retained, invocationContext, listener);
            this.storeSendDetails(topic, message, sendToken, invocationContext, activityToken);
         } catch (Exception var11) {
            this.handleException(resultBundle, var11);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("send", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

      return sendToken;
   }

   public IMqttDeliveryToken publish(String topic, MqttMessage message, String invocationContext, String activityToken) {
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "send");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      IMqttDeliveryToken sendToken = null;
      MqttConnection.MqttConnectionListener listener;
      if (this.myClient != null && this.myClient.isConnected()) {
         listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            sendToken = this.myClient.publish(topic, message, invocationContext, listener);
            this.storeSendDetails(topic, message, sendToken, invocationContext, activityToken);
         } catch (Exception var10) {
            this.handleException(resultBundle, var10);
         }
      } else if (this.myClient != null && this.bufferOpts != null && this.bufferOpts.isBufferEnabled()) {
         listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            sendToken = this.myClient.publish(topic, message, invocationContext, listener);
            this.storeSendDetails(topic, message, sendToken, invocationContext, activityToken);
         } catch (Exception var9) {
            this.handleException(resultBundle, var9);
         }
      } else {
         Log.i("MqttConnection", "Client is not connected, so not sending message");
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("send", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

      return sendToken;
   }

   public void subscribe(String topic, int qos, String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "subscribe({" + topic + "}," + qos + ",{" + invocationContext + "}, {" + activityToken + "}");
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "subscribe");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnection.MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.subscribe(topic, qos, invocationContext, listener);
         } catch (Exception var8) {
            this.handleException(resultBundle, var8);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("subscribe", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

   }

   public void subscribe(String[] topic, int[] qos, String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "subscribe({" + topic + "}," + qos + ",{" + invocationContext + "}, {" + activityToken + "}");
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "subscribe");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.subscribe(topic, qos, invocationContext, listener);
         } catch (Exception var8) {
            this.handleException(resultBundle, var8);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("subscribe", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

   }

   public void subscribe(String[] topicFilters, int[] qos, String invocationContext, String activityToken, IMqttMessageListener[] messageListeners) {
      this.service.traceDebug("MqttConnection", "subscribe({" + topicFilters + "}," + qos + ",{" + invocationContext + "}, {" + activityToken + "}");
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "subscribe");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      if (this.myClient != null && this.myClient.isConnected()) {
         new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.subscribe(topicFilters, qos, messageListeners);
         } catch (Exception var9) {
            this.handleException(resultBundle, var9);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("subscribe", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

   }

   void unsubscribe(String topic, String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "unsubscribe({" + topic + "},{" + invocationContext + "}, {" + activityToken + "})");
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "unsubscribe");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.unsubscribe(topic, invocationContext, listener);
         } catch (Exception var7) {
            this.handleException(resultBundle, var7);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("subscribe", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

   }

   void unsubscribe(String[] topic, String invocationContext, String activityToken) {
      this.service.traceDebug("MqttConnection", "unsubscribe({" + topic + "},{" + invocationContext + "}, {" + activityToken + "})");
      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "unsubscribe");
      resultBundle.putString("MqttService.activityToken", activityToken);
      resultBundle.putString("MqttService.invocationContext", invocationContext);
      if (this.myClient != null && this.myClient.isConnected()) {
         MqttConnection.MqttConnectionListener listener = new MqttConnection.MqttConnectionListener(resultBundle);

         try {
            this.myClient.unsubscribe(topic, invocationContext, listener);
         } catch (Exception var7) {
            this.handleException(resultBundle, var7);
         }
      } else {
         resultBundle.putString("MqttService.errorMessage", "not connected");
         this.service.traceError("subscribe", "not connected");
         this.service.callbackToActivity(this.clientHandle, Status.ERROR, resultBundle);
      }

   }

   public IMqttDeliveryToken[] getPendingDeliveryTokens() {
      return this.myClient.getPendingDeliveryTokens();
   }

   public void connectionLost(Throwable why) {
      this.service.traceDebug("MqttConnection", "connectionLost(" + why.getMessage() + ")");
      this.disconnected = true;

      try {
         this.myClient.disconnect((Object)null, new IMqttActionListener() {
            public void onSuccess(IMqttToken asyncActionToken) {
            }

            public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
            }
         });
      } catch (Exception var3) {
      }

      Bundle resultBundle = new Bundle();
      resultBundle.putString("MqttService.callbackAction", "onConnectionLost");
      if (why != null) {
         resultBundle.putString("MqttService.errorMessage", why.getMessage());
         if (why instanceof MqttException) {
            resultBundle.putSerializable("MqttService.exception", why);
         }

         resultBundle.putString("MqttService.exceptionStack", Log.getStackTraceString(why));
      }

      this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
      this.releaseWakeLock();
   }

   public void deliveryComplete(IMqttDeliveryToken messageToken) {
      this.service.traceDebug("MqttConnection", "deliveryComplete(" + messageToken + ")");
      MqttMessage message = (MqttMessage)this.savedSentMessages.remove(messageToken);
      if (message != null) {
         String topic = (String)this.savedTopics.remove(messageToken);
         String activityToken = (String)this.savedActivityTokens.remove(messageToken);
         String invocationContext = (String)this.savedInvocationContexts.remove(messageToken);
         Bundle resultBundle = this.messageToBundle((String)null, topic, message);
         if (activityToken != null) {
            resultBundle.putString("MqttService.callbackAction", "send");
            resultBundle.putString("MqttService.activityToken", activityToken);
            resultBundle.putString("MqttService.invocationContext", invocationContext);
            this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
         }

         resultBundle.putString("MqttService.callbackAction", "messageDelivered");
         this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
      }

   }

   public void messageArrived(String topic, MqttMessage message) throws Exception {
      this.service.traceDebug("MqttConnection", "messageArrived(" + topic + ",{" + message.toString() + "})");
      String messageId = this.service.messageStore.storeArrived(this.clientHandle, topic, message);
      Bundle resultBundle = this.messageToBundle(messageId, topic, message);
      resultBundle.putString("MqttService.callbackAction", "messageArrived");
      resultBundle.putString("MqttService.messageId", messageId);
      this.service.callbackToActivity(this.clientHandle, Status.OK, resultBundle);
   }

   private void storeSendDetails(String topic, MqttMessage msg, IMqttDeliveryToken messageToken, String invocationContext, String activityToken) {
      this.savedTopics.put(messageToken, topic);
      this.savedSentMessages.put(messageToken, msg);
      this.savedActivityTokens.put(messageToken, activityToken);
      this.savedInvocationContexts.put(messageToken, invocationContext);
   }

   private void acquireWakeLock() {
      if (this.wakelock == null) {
         PowerManager pm = (PowerManager)this.service.getSystemService(Context.POWER_SERVICE);
         this.wakelock = pm.newWakeLock(1, this.wakeLockTag);
      }

      this.wakelock.acquire();
   }

   private void releaseWakeLock() {
      if (this.wakelock != null && this.wakelock.isHeld()) {
         this.wakelock.release();
      }

   }

   void offline() {
      if (!this.disconnected && !this.cleanSession) {
         Exception e = new Exception("Android offline");
         this.connectionLost(e);
      }

   }

   synchronized void reconnect() {
      if (this.isConnecting) {
         this.service.traceDebug("MqttConnection", "The client is connecting. Reconnect return directly.");
      } else if (!this.service.isOnline()) {
         this.service.traceDebug("MqttConnection", "The network is not reachable. Will not do reconnect");
      } else {
         if (this.disconnected && !this.cleanSession) {
            this.service.traceDebug("MqttConnection", "Do Real Reconnect!");
            final Bundle resultBundle = new Bundle();
            resultBundle.putString("MqttService.activityToken", this.reconnectActivityToken);
            resultBundle.putString("MqttService.invocationContext", (String)null);
            resultBundle.putString("MqttService.callbackAction", "connect");

            try {
               IMqttActionListener listener = new MqttConnection.MqttConnectionListener(resultBundle) {
                  public void onSuccess(IMqttToken asyncActionToken) {
                     MqttConnection.this.service.traceDebug("MqttConnection", "Reconnect Success!");
                     MqttConnection.this.service.traceDebug("MqttConnection", "DeliverBacklog when reconnect.");
                     MqttConnection.this.doAfterConnectSuccess(resultBundle);
                  }

                  public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                     resultBundle.putString("MqttService.errorMessage", exception.getLocalizedMessage());
                     resultBundle.putSerializable("MqttService.exception", exception);
                     MqttConnection.this.service.callbackToActivity(MqttConnection.this.clientHandle, Status.ERROR, resultBundle);
                     MqttConnection.this.doAfterConnectFail(resultBundle);
                  }
               };
               this.myClient.connect(this.connectOptions, (Object)null, listener);
               this.setConnectingState(true);
            } catch (MqttException var3) {
               this.service.traceError("MqttConnection", "Cannot reconnect to remote server." + var3.getMessage());
               this.setConnectingState(false);
               this.handleException(resultBundle, var3);
            }
         }

      }
   }

   synchronized void setConnectingState(boolean isConnecting) {
      this.isConnecting = isConnecting;
   }

   public void setBufferOpts(DisconnectedBufferOptions bufferOpts) {
      this.bufferOpts = bufferOpts;
      this.myClient.setBufferOpts(bufferOpts);
   }

   public int getBufferedMessageCount() {
      return this.myClient.getBufferedMessageCount();
   }

   public MqttMessage getBufferedMessage(int bufferIndex) {
      return this.myClient.getBufferedMessage(bufferIndex);
   }

   public void deleteBufferedMessage(int bufferIndex) {
      this.myClient.deleteBufferedMessage(bufferIndex);
   }

   private class MqttConnectionListener implements IMqttActionListener {
      private final Bundle resultBundle;

      private MqttConnectionListener(Bundle resultBundle) {
         this.resultBundle = resultBundle;
      }

      public void onSuccess(IMqttToken asyncActionToken) {
         MqttConnection.this.service.callbackToActivity(MqttConnection.this.clientHandle, Status.OK, this.resultBundle);
      }

      public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
         this.resultBundle.putString("MqttService.errorMessage", exception.getLocalizedMessage());
         this.resultBundle.putSerializable("MqttService.exception", exception);
         MqttConnection.this.service.callbackToActivity(MqttConnection.this.clientHandle, Status.ERROR, this.resultBundle);
      }
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642

MqttDeliveryTokenAndroid.java

package com.iot.listeninsoul.service;
import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;

// edit
class MqttDeliveryTokenAndroid extends MqttTokenAndroid implements IMqttDeliveryToken {
   private MqttMessage message;

   MqttDeliveryTokenAndroid(MqttAndroidClient client, Object userContext, IMqttActionListener listener, MqttMessage message) {
      super(client, userContext, listener);
      this.message = message;
   }

   public MqttMessage getMessage() throws MqttException {
      return this.message;
   }

   void setMessage(MqttMessage message) {
      this.message = message;
   }

   void notifyDelivery(MqttMessage delivered) {
      this.message = delivered;
      super.notifyComplete();
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

MqttService.java

package com.iot.listeninsoul.service;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import android.annotation.SuppressLint;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;

import androidx.localbroadcastmanager.content.LocalBroadcastManager;

import org.eclipse.paho.client.mqttv3.DisconnectedBufferOptions;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.IMqttMessageListener;
import org.eclipse.paho.client.mqttv3.MqttClientPersistence;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
import org.eclipse.paho.client.mqttv3.MqttSecurityException;

/**
 * 

 * The android service which interfaces with an MQTT client implementation
 * 
 * 

 * The main API of MqttService is intended to pretty much mirror the
 * IMqttAsyncClient with appropriate adjustments for the Android environment.

 * These adjustments usually consist of adding two parameters to each method :-
 * 
 * 

 * 
invocationContext - a string passed from the application to identify the
 * context of the operation (mainly included for support of the javascript API
 * implementation)
 * 
activityToken - a string passed from the Activity to relate back to a
 * callback method or other context-specific data
 * 
 * 

 * To support multiple client connections, the bulk of the MQTT work is
 * delegated to MqttConnection objects. These are identified by "client
 * handle" strings, which is how the Activity, and the higher-level APIs refer
 * to them.
 * 
 * 

 * Activities using this service are expected to start it and bind to it using
 * the BIND_AUTO_CREATE flag. The life cycle of this service is based on this
 * approach.
 * 
 */

// edit
@SuppressLint("Registered")
public class MqttService extends Service implements MqttTraceHandler {

    static final String TAG = "MqttService";
    private String traceCallbackId;
    private boolean traceEnabled = false;
    MessageStore messageStore;
    private MqttService.NetworkConnectionIntentReceiver networkConnectionMonitor;
    private MqttService.BackgroundDataPreferenceReceiver backgroundDataPreferenceMonitor;
    private volatile boolean backgroundDataEnabled = true;
    private MqttServiceBinder mqttServiceBinder;
    private Map<String, MqttConnection> connections = new ConcurrentHashMap();

    public MqttService() {
    }

    void callbackToActivity(String clientHandle, Status status, Bundle dataBundle) {
        Intent callbackIntent = new Intent("MqttService.callbackToActivity.v0");
        if (clientHandle != null) {
            callbackIntent.putExtra("MqttService.clientHandle", clientHandle);
        }

        callbackIntent.putExtra("MqttService.callbackStatus", status);
        if (dataBundle != null) {
            callbackIntent.putExtras(dataBundle);
        }

        LocalBroadcastManager.getInstance(this).sendBroadcast(callbackIntent);
    }

    public String getClient(String serverURI, String clientId, String contextId, MqttClientPersistence persistence) {
        String clientHandle = serverURI + ":" + clientId + ":" + contextId;
        if (!this.connections.containsKey(clientHandle)) {
            MqttConnection client = new MqttConnection(this, serverURI, clientId, persistence, clientHandle);
            this.connections.put(clientHandle, client);
        }

        return clientHandle;
    }

    public void connect(String clientHandle, MqttConnectOptions connectOptions, String invocationContext, String activityToken) throws MqttSecurityException, MqttException {
        MqttConnection client = this.getConnection(clientHandle);
        client.connect(connectOptions, invocationContext, activityToken);
    }

    void reconnect() {
        this.traceDebug("MqttService", "Reconnect to server, client size=" + this.connections.size());
        Iterator i$ = this.connections.values().iterator();

        while(i$.hasNext()) {
            MqttConnection client = (MqttConnection)i$.next();
            this.traceDebug("Reconnect Client:", client.getClientId() + '/' + client.getServerURI());
            if (this.isOnline()) {
                client.reconnect();
            }
        }

    }

    public void close(String clientHandle) {
        MqttConnection client = this.getConnection(clientHandle);
        client.close();
    }

    public void disconnect(String clientHandle, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.disconnect(invocationContext, activityToken);
        this.connections.remove(clientHandle);
        this.stopSelf();
    }

    public void disconnect(String clientHandle, long quiesceTimeout, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.disconnect(quiesceTimeout, invocationContext, activityToken);
        this.connections.remove(clientHandle);
        this.stopSelf();
    }

    public boolean isConnected(String clientHandle) {
        MqttConnection client = this.getConnection(clientHandle);
        return client.isConnected();
    }

    public IMqttDeliveryToken publish(String clientHandle, String topic, byte[] payload, int qos, boolean retained, String invocationContext, String activityToken) throws MqttPersistenceException, MqttException {
        MqttConnection client = this.getConnection(clientHandle);
        return client.publish(topic, payload, qos, retained, invocationContext, activityToken);
    }

    public IMqttDeliveryToken publish(String clientHandle, String topic, MqttMessage message, String invocationContext, String activityToken) throws MqttPersistenceException, MqttException {
        MqttConnection client = this.getConnection(clientHandle);
        return client.publish(topic, message, invocationContext, activityToken);
    }

    public void subscribe(String clientHandle, String topic, int qos, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.subscribe(topic, qos, invocationContext, activityToken);
    }

    public void subscribe(String clientHandle, String[] topic, int[] qos, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.subscribe(topic, qos, invocationContext, activityToken);
    }

    public void subscribe(String clientHandle, String[] topicFilters, int[] qos, String invocationContext, String activityToken, IMqttMessageListener[] messageListeners) {
        MqttConnection client = this.getConnection(clientHandle);
        client.subscribe(topicFilters, qos, invocationContext, activityToken, messageListeners);
    }

    public void unsubscribe(String clientHandle, String topic, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.unsubscribe(topic, invocationContext, activityToken);
    }

    public void unsubscribe(String clientHandle, String[] topic, String invocationContext, String activityToken) {
        MqttConnection client = this.getConnection(clientHandle);
        client.unsubscribe(topic, invocationContext, activityToken);
    }

    public IMqttDeliveryToken[] getPendingDeliveryTokens(String clientHandle) {
        MqttConnection client = this.getConnection(clientHandle);
        return client.getPendingDeliveryTokens();
    }

    private MqttConnection getConnection(String clientHandle) {
        MqttConnection client = (MqttConnection)this.connections.get(clientHandle);
        if (client == null) {
            throw new IllegalArgumentException("Invalid ClientHandle");
        } else {
            return client;
        }
    }

    public Status acknowledgeMessageArrival(String clientHandle, String id) {
        return this.messageStore.discardArrived(clientHandle, id) ? Status.OK : Status.ERROR;
    }

    public void onCreate() {
        super.onCreate();
        this.mqttServiceBinder = new MqttServiceBinder(this);
        this.messageStore = new DatabaseMessageStore(this, this);
    }

    public void onDestroy() {
        Iterator i$ = this.connections.values().iterator();

        while(i$.hasNext()) {
            MqttConnection client = (MqttConnection)i$.next();
            client.disconnect((String)null, (String)null);
        }

        if (this.mqttServiceBinder != null) {
            this.mqttServiceBinder = null;
        }

        this.unregisterBroadcastReceivers();
        if (this.messageStore != null) {
            this.messageStore.close();
        }

        super.onDestroy();
    }

    public IBinder onBind(Intent intent) {
        String activityToken = intent.getStringExtra("MqttService.activityToken");
        this.mqttServiceBinder.setActivityToken(activityToken);
        return this.mqttServiceBinder;
    }

    public int onStartCommand(Intent intent, int flags, int startId) {
        this.registerBroadcastReceivers();
        return Service.START_STICKY;
    }

    public void setTraceCallbackId(String traceCallbackId) {
        this.traceCallbackId = traceCallbackId;
    }

    public void setTraceEnabled(boolean traceEnabled) {
        this.traceEnabled = traceEnabled;
    }

    public boolean isTraceEnabled() {
        return this.traceEnabled;
    }

    public void traceDebug(String tag, String message) {
        this.traceCallback("debug", tag, message);
    }

    public void traceError(String tag, String message) {
        this.traceCallback("error", tag, message);
    }

    private void traceCallback(String severity, String tag, String message) {
        if (this.traceCallbackId != null && this.traceEnabled) {
            Bundle dataBundle = new Bundle();
            dataBundle.putString("MqttService.callbackAction", "trace");
            dataBundle.putString("MqttService.traceSeverity", severity);
            dataBundle.putString("MqttService.traceTag", tag);
            dataBundle.putString("MqttService.errorMessage", message);
            this.callbackToActivity(this.traceCallbackId, Status.ERROR, dataBundle);
        }

    }

    public void traceException(String tag, String message, Exception e) {
        if (this.traceCallbackId != null) {
            Bundle dataBundle = new Bundle();
            dataBundle.putString("MqttService.callbackAction", "trace");
            dataBundle.putString("MqttService.traceSeverity", "exception");
            dataBundle.putString("MqttService.errorMessage", message);
            dataBundle.putSerializable("MqttService.exception", e);
            dataBundle.putString("MqttService.traceTag", tag);
            this.callbackToActivity(this.traceCallbackId, Status.ERROR, dataBundle);
        }

    }

    private void registerBroadcastReceivers() {
        if (this.networkConnectionMonitor == null) {
            this.networkConnectionMonitor = new MqttService.NetworkConnectionIntentReceiver();
            this.registerReceiver(this.networkConnectionMonitor, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
        }

        if (Build.VERSION.SDK_INT < 14) {
            ConnectivityManager cm = (ConnectivityManager)this.getSystemService(Context.CONNECTIVITY_SERVICE);
            this.backgroundDataEnabled = cm.getBackgroundDataSetting();
            if (this.backgroundDataPreferenceMonitor == null) {
                this.backgroundDataPreferenceMonitor = new MqttService.BackgroundDataPreferenceReceiver();
                this.registerReceiver(this.backgroundDataPreferenceMonitor, new IntentFilter("android.net.conn.BACKGROUND_DATA_SETTING_CHANGED"));
            }
        }

    }

    private void unregisterBroadcastReceivers() {
        if (this.networkConnectionMonitor != null) {
            this.unregisterReceiver(this.networkConnectionMonitor);
            this.networkConnectionMonitor = null;
        }

        if (Build.VERSION.SDK_INT < 14 && this.backgroundDataPreferenceMonitor != null) {
            this.unregisterReceiver(this.backgroundDataPreferenceMonitor);
        }

    }

    public boolean isOnline() {
        ConnectivityManager cm = (ConnectivityManager)this.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        return networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && this.backgroundDataEnabled;
    }

    public void notifyClientsOffline() {
        Iterator i$ = this.connections.values().iterator();

        while(i$.hasNext()) {
            MqttConnection connection = (MqttConnection)i$.next();
            connection.offline();
        }

    }

    public void setBufferOpts(String clientHandle, DisconnectedBufferOptions bufferOpts) {
        MqttConnection client = this.getConnection(clientHandle);
        client.setBufferOpts(bufferOpts);
    }

    public int getBufferedMessageCount(String clientHandle) {
        MqttConnection client = this.getConnection(clientHandle);
        return client.getBufferedMessageCount();
    }

    public MqttMessage getBufferedMessage(String clientHandle, int bufferIndex) {
        MqttConnection client = this.getConnection(clientHandle);
        return client.getBufferedMessage(bufferIndex);
    }

    public void deleteBufferedMessage(String clientHandle, int bufferIndex) {
        MqttConnection client = this.getConnection(clientHandle);
        client.deleteBufferedMessage(bufferIndex);
    }

    private class BackgroundDataPreferenceReceiver extends BroadcastReceiver {
        private BackgroundDataPreferenceReceiver() {
        }

        public void onReceive(Context context, Intent intent) {
            ConnectivityManager cm = (ConnectivityManager) MqttService.this.getSystemService(Context.CONNECTIVITY_SERVICE);
            MqttService.this.traceDebug("MqttService", "Reconnect since BroadcastReceiver.");
            if (cm.getBackgroundDataSetting()) {
                if (!MqttService.this.backgroundDataEnabled) {
                    MqttService.this.backgroundDataEnabled = true;
                    MqttService.this.reconnect();
                }
            } else {
                MqttService.this.backgroundDataEnabled = false;
                MqttService.this.notifyClientsOffline();
            }

        }
    }

    private class NetworkConnectionIntentReceiver extends BroadcastReceiver {
        private NetworkConnectionIntentReceiver() {
        }

        public void onReceive(Context context, Intent intent) {
            MqttService.this.traceDebug("MqttService", "Internal network status receive.");
            PowerManager pm = (PowerManager) MqttService.this.getSystemService(Context.POWER_SERVICE);
            WakeLock wl = pm.newWakeLock(1, "MQTT");
            wl.acquire();
            MqttService.this.traceDebug("MqttService", "Reconnect for Network recovery.");
            if (MqttService.this.isOnline()) {
                MqttService.this.traceDebug("MqttService", "Online,reconnect.");
                MqttService.this.reconnect();
            } else {
                MqttService.this.notifyClientsOffline();
            }

            wl.release();
        }
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389

MqttServiceBinder.java

package com.iot.listeninsoul.service;

import android.os.Binder;


class MqttServiceBinder  extends Binder {
   private MqttService mqttService;
   private String activityToken;

   MqttServiceBinder(MqttService mqttService) {
      this.mqttService = mqttService;
   }

   public MqttService getService() {
      return this.mqttService;
   }

   void setActivityToken(String activityToken) {
      this.activityToken = activityToken;
   }

   public String getActivityToken() {
      return this.activityToken;
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

MqttServiceConstants.java

package com.iot.listeninsoul.service;

//edit
class MqttServiceConstants {
    String VERSION = "v0";
    String DUPLICATE = "duplicate";
    String RETAINED = "retained";
    String QOS = "qos";
    String PAYLOAD = "payload";
    String DESTINATION_NAME = "destinationName";
    String CLIENT_HANDLE = "clientHandle";
    String MESSAGE_ID = "messageId";
    String SEND_ACTION = "send";
    String UNSUBSCRIBE_ACTION = "unsubscribe";
    String SUBSCRIBE_ACTION = "subscribe";
    String DISCONNECT_ACTION = "disconnect";
    String CONNECT_ACTION = "connect";
    String CONNECT_EXTENDED_ACTION = "connectExtended";
    String MESSAGE_ARRIVED_ACTION = "messageArrived";
    String MESSAGE_DELIVERED_ACTION = "messageDelivered";
    String ON_CONNECTION_LOST_ACTION = "onConnectionLost";
    String TRACE_ACTION = "trace";
    String CALLBACK_TO_ACTIVITY = "MqttService.callbackToActivity.v0";
    String CALLBACK_ACTION = "MqttService.callbackAction";
    String CALLBACK_STATUS = "MqttService.callbackStatus";
    String CALLBACK_CLIENT_HANDLE = "MqttService.clientHandle";
    String CALLBACK_ERROR_MESSAGE = "MqttService.errorMessage";
    String CALLBACK_EXCEPTION_STACK = "MqttService.exceptionStack";
    String CALLBACK_INVOCATION_CONTEXT = "MqttService.invocationContext";
    String CALLBACK_ACTIVITY_TOKEN = "MqttService.activityToken";
    String CALLBACK_DESTINATION_NAME = "MqttService.destinationName";
    String CALLBACK_MESSAGE_ID = "MqttService.messageId";
    String CALLBACK_RECONNECT = "MqttService.reconnect";
    String CALLBACK_SERVER_URI = "MqttService.serverURI";
    String CALLBACK_MESSAGE_PARCEL = "MqttService.PARCEL";
    String CALLBACK_TRACE_SEVERITY = "MqttService.traceSeverity";
    String CALLBACK_TRACE_TAG = "MqttService.traceTag";
    String CALLBACK_TRACE_ID = "MqttService.traceId";
    String CALLBACK_ERROR_NUMBER = "MqttService.ERROR_NUMBER";
    String CALLBACK_EXCEPTION = "MqttService.exception";
    String PING_SENDER = "MqttService.pingSender.";
    String PING_WAKELOCK = "MqttService.client.";
    String WAKELOCK_NETWORK_INTENT = "MqttService";
    String TRACE_ERROR = "error";
    String TRACE_DEBUG = "debug";
    String TRACE_EXCEPTION = "exception";
    int NON_MQTT_EXCEPTION = -1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

MqttTokenAndroid.java

package com.iot.listeninsoul.service;

import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttAsyncClient;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttSecurityException;
import org.eclipse.paho.client.mqttv3.internal.wire.MqttWireMessage;

class MqttTokenAndroid implements IMqttToken {
   private IMqttActionListener listener;
   private volatile boolean isComplete;
   private volatile MqttException lastException;
   private Object waitObject;
   private MqttAndroidClient client;
   private Object userContext;
   private String[] topics;
   private IMqttToken delegate;
   private MqttException pendingException;

   MqttTokenAndroid(MqttAndroidClient client, Object userContext, IMqttActionListener listener) {
      this(client, userContext, listener, (String[])null);
   }

   MqttTokenAndroid(MqttAndroidClient client, Object userContext, IMqttActionListener listener, String[] topics) {
      this.waitObject = new Object();
      this.client = client;
      this.userContext = userContext;
      this.listener = listener;
      this.topics = topics;
   }

   public void waitForCompletion() throws MqttException, MqttSecurityException {
      synchronized(this.waitObject) {
         try {
            this.waitObject.wait();
         } catch (InterruptedException var4) {
         }
      }

      if (this.pendingException != null) {
         throw this.pendingException;
      }
   }

   public void waitForCompletion(long timeout) throws MqttException, MqttSecurityException {
      synchronized(this.waitObject) {
         try {
            this.waitObject.wait(timeout);
         } catch (InterruptedException var6) {
         }

         if (!this.isComplete) {
            throw new MqttException(32000);
         } else if (this.pendingException != null) {
            throw this.pendingException;
         }
      }
   }

   void notifyComplete() {
      synchronized(this.waitObject) {
         this.isComplete = true;
         this.waitObject.notifyAll();
         if (this.listener != null) {
            this.listener.onSuccess(this);
         }

      }
   }

   void notifyFailure(Throwable exception) {
      synchronized(this.waitObject) {
         this.isComplete = true;
         if (exception instanceof MqttException) {
            this.pendingException = (MqttException)exception;
         } else {
            this.pendingException = new MqttException(exception);
         }

         this.waitObject.notifyAll();
         if (exception instanceof MqttException) {
            this.lastException = (MqttException)exception;
         }

         if (this.listener != null) {
            this.listener.onFailure(this, exception);
         }

      }
   }

   public boolean isComplete() {
      return this.isComplete;
   }

   void setComplete(boolean complete) {
      this.isComplete = complete;
   }

   public MqttException getException() {
      return this.lastException;
   }

   void setException(MqttException exception) {
      this.lastException = exception;
   }

   public IMqttAsyncClient getClient() {
      return this.client;
   }

   public void setActionCallback(IMqttActionListener listener) {
      this.listener = listener;
   }

   public IMqttActionListener getActionCallback() {
      return this.listener;
   }

   public String[] getTopics() {
      return this.topics;
   }

   public void setUserContext(Object userContext) {
      this.userContext = userContext;
   }

   public Object getUserContext() {
      return this.userContext;
   }

   void setDelegate(IMqttToken delegate) {
      this.delegate = delegate;
   }

   public int getMessageId() {
      return this.delegate != null ? this.delegate.getMessageId() : 0;
   }

   public MqttWireMessage getResponse() {
      return this.delegate.getResponse();
   }

   public boolean getSessionPresent() {
      return this.delegate.getSessionPresent();
   }

   public int[] getGrantedQos() {
      return this.delegate.getGrantedQos();
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

MqttTraceHandler.java

package com.iot.listeninsoul.service;

/**
 * Interface for simple trace handling, pass the trace message to trace
 * callback.
 */
//edit
public interface MqttTraceHandler {

	void traceDebug(String var1, String var2);

	void traceError(String var1, String var2);

	void traceException(String var1, String var2, Exception var3);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ParcelableMqttMessage.java

package com.iot.listeninsoul.service;

import android.os.Parcel;
import android.os.Parcelable;

import org.eclipse.paho.client.mqttv3.MqttMessage;


//edit
class ParcelableMqttMessage extends MqttMessage implements Parcelable {
    String messageId = null;
    public static final Creator<ParcelableMqttMessage> CREATOR = new Creator<ParcelableMqttMessage>() {
        public ParcelableMqttMessage createFromParcel(Parcel parcel) {
            return new ParcelableMqttMessage(parcel);
        }

        public ParcelableMqttMessage[] newArray(int size) {
            return new ParcelableMqttMessage[size];
        }
    };

    ParcelableMqttMessage(MqttMessage original) {
        super(original.getPayload());
        this.setQos(original.getQos());
        this.setRetained(original.isRetained());
        this.setDuplicate(original.isDuplicate());
    }

    ParcelableMqttMessage(Parcel parcel) {
        super(parcel.createByteArray());
        this.setQos(parcel.readInt());
        boolean[] flags = parcel.createBooleanArray();
        this.setRetained(flags[0]);
        this.setDuplicate(flags[1]);
        this.messageId = parcel.readString();
    }

    public String getMessageId() {
        return this.messageId;
    }

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeByteArray(this.getPayload());
        parcel.writeInt(this.getQos());
        parcel.writeBooleanArray(new boolean[]{this.isRetained(), this.isDuplicate()});
        parcel.writeString(this.messageId);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Status.java

package com.iot.listeninsoul.service;

//edit
enum Status {
 OK,
 ERROR,
 NO_RESULT;

 private Status() {
 }
}

1
2
3
4
5
6
7
8
9
10
11
12