@iotize/device-com-ble.cordova 3.6.0 → 3.6.3

package/src/android/src/ble/BLEProtocol.java

@@ -0,0 +1,874 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by FernFlower decompiler)
+//
+
+package com.iotize.plugin.cordova.ble;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.content.Context;
+import android.os.Build.VERSION;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import com.iotize.android.communication.client.impl.protocol.BluetoothProtocol;
+import com.iotize.android.communication.client.impl.protocol.ConnectionState;
+import com.iotize.android.communication.client.impl.protocol.HostProtocol;
+import com.iotize.android.communication.client.impl.protocol.exception.AdapterNotAvailableException;
+import com.iotize.android.communication.client.impl.protocol.exception.ProtocolNotConnectedException;
+import com.iotize.android.communication.client.impl.protocol.exception.TimeOutException;
+import com.iotize.android.communication.client.impl.protocol.listener.OnConnectionStepProgress;
+import com.iotize.android.communication.protocol.ble.BLECommandRunnable;
+import com.iotize.android.communication.protocol.ble.BLEConfig;
+import com.iotize.android.communication.protocol.ble.Constants;
+import com.iotize.android.communication.protocol.ble.exception.CannotWriteDescriptorException;
+import com.iotize.android.communication.protocol.ble.exception.CharacteristicNotAvailableException;
+import com.iotize.android.communication.protocol.ble.exception.InvalidGattStatusException;
+import com.iotize.android.communication.protocol.ble.exception.LwM2MCharacteristicNotAvailable;
+import com.iotize.android.communication.protocol.ble.exception.ServiceNotAvailableException;
+import com.iotize.android.communication.protocol.ble.exception.UnexpectedDisconnectionException;
+import com.iotize.android.core.buffer.ByteArrayHelper;
+import com.iotize.android.core.util.Helper;
+import com.iotize.android.device.api.client.exceptions.NotATapDeviceException;
+import com.iotize.plugin.cordova.ble.characteristics.CharacteristicAdapterCallbacks;
+import com.iotize.plugin.cordova.ble.characteristics.LwM2M20BytesRequestCharacteristicAdapter;
+import com.iotize.plugin.cordova.ble.characteristics.LwM2MMTURequestCharacteristicAdapter;
+import com.iotize.plugin.cordova.ble.characteristics.AbstractLwM2MRequestCharacteristic;
+import com.iotize.plugin.cordova.ble.characteristics.CharacteristicAdapter;
+import com.iotize.plugin.cordova.ble.commands.BLECommand;
+import com.iotize.plugin.cordova.ble.commands.CommandCompletedNotifier;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+@RequiresApi(
+        api = 18
+)
+public class BLEProtocol extends BluetoothProtocol {
+    public static final long RX_TX_DELAY_MILLISECONDS = 10L;
+    public static final long CONNECT_DELAY_MILLISECONDS = 100L;
+    private static final int TIMEOUT_CONNECT_DISCONNECT = 8000;
+    private static final int TIMEOUT_COM = 10000;
+    private static final int RECEIVED_BUFFER_LENGTH = 255;
+    @NonNull
+    private static final String TAG = "BLEProtocol";
+    private static final int DEFAULT_MTU_SIZE = 20;
+    @NonNull
+    private final BluetoothManager bluetoothManager;
+    private int connectionPriority = 1;
+    @NonNull
+    private final BluetoothDevice mDevice;
+    @Nullable
+    private MyBluetoothGattCallback mBluetoothGattCallback;
+    @NonNull
+    private final Context mContext;
+    @Nullable
+    private Exception lastInternalBLEError;
+    @NonNull
+    public BLEConfig bleConfig = new BLEConfig();
+    @Nullable
+    protected BluetoothGatt gatt;
+    private ConcurrentLinkedQueue<BLECommand> commandQueue = new ConcurrentLinkedQueue();
+    @Nullable
+    private AbstractLwM2MRequestCharacteristic lwM2MCharacteristic;
+    LinkedList<CharacteristicAdapter> characteristicsAdapters = new LinkedList();
+    private AtomicReference<BLECommand> currentBleCommand = new AtomicReference((Object)null);
+    @NonNull
+    private AtomicBoolean isServiceDiscovered;
+    @Nullable
+    private OnConnectionStepProgress connectionEventListener;
+    private int currentMTU = 20;
+    private int requestedMtuSize;
+    private Lock readLock;
+    private Lock writeLock;
+
+    private boolean registerLWM2MCharacteristics = true;
+
+    private void setLwM2MCharacteristic(@NonNull AbstractLwM2MRequestCharacteristic lwM2MCharacteristic) {
+        this.characteristicsAdapters.add(lwM2MCharacteristic);
+        this.lwM2MCharacteristic = lwM2MCharacteristic;
+        this.lwM2MCharacteristic.initialize(this.getGatt(), (AbstractLwM2MRequestCharacteristic.OnCharacteristicInitialized)null);
+    }
+
+    @NonNull
+    public BluetoothGatt getGatt() {
+        if (this.gatt == null) {
+            throw new ProtocolNotConnectedException();
+        } else {
+            return this.gatt;
+        }
+    }
+
+    public BLEProtocol(@NonNull Context context, @NonNull BluetoothDevice mDevice) {
+        this.requestedMtuSize = this.currentMTU;
+        this.readLock = new ReentrantLock();
+        this.writeLock = new ReentrantLock();
+        this.mContext = context;
+        this.mDevice = mDevice;
+        this.protocolConfiguration.connectionTimeoutMillis = 10000L;
+        this.isServiceDiscovered = new AtomicBoolean(false);
+        BluetoothManager manager = (BluetoothManager)context.getSystemService("bluetooth");
+        if (manager == null) {
+            throw new IllegalStateException("Bluetooth manager is not available");
+        } else {
+            this.bluetoothManager = manager;
+        }
+    }
+
+    public BLEProtocol setConnectionEventListener(OnConnectionStepProgress connectionEventListener) {
+        this.connectionEventListener = connectionEventListener;
+        return this;
+    }
+
+    public void setConnectionPriority(int connectionPriority) {
+        this.connectionPriority = connectionPriority;
+    }
+
+    public int getConnectionPriority() {
+        return this.connectionPriority;
+    }
+
+    public static BLEProtocol fromAddress(@NonNull Context context, @NonNull String address) throws AdapterNotAvailableException {
+        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        if (bluetoothAdapter == null) {
+            throw new AdapterNotAvailableException("Bluetooth adapter is not available on this device");
+        } else {
+            BluetoothDevice bluetoothDevice = bluetoothAdapter.getRemoteDevice(address);
+            return new BLEProtocol(context, bluetoothDevice);
+        }
+    }
+
+    public static BLEProtocol fromDevice(@NonNull Context context, BluetoothDevice bluetoothDevice) throws AdapterNotAvailableException {
+        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        if (bluetoothAdapter == null) {
+            throw new AdapterNotAvailableException("Bluetooth adapter is not available on this device");
+        } else {
+            return new BLEProtocol(context, bluetoothDevice);
+        }
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    public long bleConnect() throws Exception {
+        try {
+            this.currentMTU = 20;
+            this.lastInternalBLEError = null;
+            int bleRetryCount = 0;
+            long count = 0L;
+
+            while(bleRetryCount <= this.bleConfig.maxConnectRetry) {
+                try {
+                    this.connectToGatt();
+                    count = this.waitForAndroidBleConnection(count, this.protocolConfiguration.connectionTimeoutMillis);
+                    break;
+                } catch (InvalidGattStatusException var6) {
+                    InvalidGattStatusException gattStatusError = (InvalidGattStatusException)this.lastInternalBLEError;
+                    if (gattStatusError.getStatus() != 133) {
+                        throw var6;
+                    }
+
+                    Log.w("BLEProtocol", "Retry after GATT_ERROR", gattStatusError);
+                    ++bleRetryCount;
+                    this.lastInternalBLEError = null;
+                } catch (Exception var7) {
+                    throw var7;
+                }
+            }
+
+            Log.d("BLEProtocol", "Connection successful (nb retry=" + bleRetryCount + ")");
+            return count;
+        } catch (Exception var8) {
+            this.closeAndDisconnect();
+            throw var8;
+        }
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    public void _connect() throws Exception {
+        try {
+            long duration = this.bleConnect();
+            this.discoverServices(this.protocolConfiguration.connectionTimeoutMillis - duration);
+            Log.d("BLEProtocol", "Connection to Tap and services discovered");
+        } catch (Exception var3) {
+            this.closeAndDisconnect();
+            throw var3;
+        }
+    }
+
+    protected long prepareLwm2mService(long count) throws Exception {
+        count = this.waitForCharacteristicInitialized(count, this.protocolConfiguration.connectionTimeoutMillis);
+        return count;
+    }
+
+    private void disconnectIfErrorAndThrow() throws Exception {
+        if (this.lastInternalBLEError != null) {
+            this.closeAndDisconnect();
+            throw this.lastInternalBLEError;
+        }
+    }
+
+    private long waitForAndroidBleConnection(long count, long timeout) throws Exception {
+        Log.d("BLEProtocol", "waitForAndroidBleConnection STARTING");
+        this.waitUntilConditionOrInternalError(() -> {
+            return this.getBluetoothConnectionState() == 2;
+        }, timeout, 100L);
+        Log.d("BLEProtocol", "waitForAndroidBleConnection DONE count = " + count);
+        return count;
+    }
+
+    private long waitForCharacteristicInitialized(long count, long timeout) throws Exception {
+        Log.v("BLEProtocol", "waitForCharacteristicRead STARTING");
+        count = this.waitUntilConditionOrInternalError(() -> {
+            return this.lwM2MCharacteristic != null && this.lwM2MCharacteristic.isInitialized();
+        }, timeout, 10L);
+        Log.v("BLEProtocol", "waitForCharacteristicRead DONE count = " + count);
+        return count;
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    public void _disconnect() throws Exception {
+        try {
+            this.currentMTU = 20;
+            this.cancelPendingOperations();
+            this.closeAndDisconnect();
+        } finally {
+            this.lastInternalBLEError = null;
+        }
+
+    }
+
+    private void cancelPendingOperations() {
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    public void write(byte[] data) throws Exception {
+        if (data == null) {
+            Log.w("BLEProtocol", "Writing null data. Skip...");
+        } else if (data.length > 245) {
+            throw new IllegalArgumentException("Maximum frame size with ble is 245 bytes (found " + data.length + " bytes)");
+        } else {
+            this.beforeReadWriteLwm2m();
+            if (this.writeLock.tryLock(15000L, TimeUnit.MILLISECONDS)) {
+                try {
+                    this.lwM2MCharacteristic.sendLwM2MTapRequest(this.getGatt(), data);
+                } finally {
+                    this.writeLock.unlock();
+                }
+            }
+
+        }
+    }
+
+    private void beforeReadWriteLwm2m() throws Exception {
+        if (!this.isServiceDiscovered.get()) {
+            this.discoverServices(this.protocolConfiguration.sendTimeoutMillis);
+        }
+
+        if (!this.hasTapLwM2MService()) {
+            throw new NotATapDeviceException("Tap LwM2M BLE service to communicate using LwM2M Tap requests does not exist on this device.");
+        } else {
+            this.prepareLwm2mService(0L);
+            this.assertLwm2mServicePrepared();
+        }
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    public void connectToGatt() throws AdapterNotAvailableException {
+        if (this.mBluetoothGattCallback == null) {
+            this.mBluetoothGattCallback = new MyBluetoothGattCallback();
+        }
+
+        if (this.gatt != null) {
+            Log.w("BLEProtocol", "connectToGatt() Reusing previous connection " + this.gatt);
+            switch (this.getBluetoothConnectionState()) {
+                case 0:
+                    this.gatt.connect();
+                    break;
+                case 1:
+                    Log.w("BLEProtocol", "connectToGatt() already connecting...");
+                    break;
+                case 2:
+                    return;
+                case 3:
+                    throw new IllegalStateException("Already disconnecting");
+            }
+        } else {
+            this.notifyStepProgress(1);
+            if (VERSION.SDK_INT >= 23) {
+                this.gatt = this.mDevice.connectGatt(this.mContext, false, this.mBluetoothGattCallback, 2);
+            } else {
+                this.gatt = this.mDevice.connectGatt(this.mContext, false, this.mBluetoothGattCallback);
+            }
+        }
+
+        if (this.gatt == null) {
+            throw new AdapterNotAvailableException("Bluetooth gatt is not available");
+        } else {
+            Log.i("BLEProtocol", "connectToGatt() with " + this.gatt);
+        }
+    }
+
+    private void notifyStepProgress(int code) {
+        this.notifyStepProgress(code, (Object)null);
+    }
+
+    private void notifyStepProgress(int code, Object payload) {
+        Log.i("BLEProtocol", "notifyStepProgress() code = " + code + "; payload= " + payload);
+        if (this.connectionEventListener != null) {
+            this.connectionEventListener.onStepProgress(code, payload);
+        }
+
+    }
+
+    public byte[] read() throws Exception {
+        if (this.readLock.tryLock(15000L, TimeUnit.MILLISECONDS)) {
+            byte[] data;
+            try {
+                data = this.waitForData();
+            } finally {
+                this.readLock.unlock();
+            }
+
+            Log.d("BLEProtocol", "Received: 0x" + Helper.ByteArrayToHexString(data));
+            return data;
+        } else {
+            throw new TimeOutException("While waiting for BLE write");
+        }
+    }
+
+    private void assertLwm2mServicePrepared() throws LwM2MCharacteristicNotAvailable {
+        if (this.gatt != null && this.isServiceDiscovered.get()) {
+            if (this.lwM2MCharacteristic == null) {
+                throw new LwM2MCharacteristicNotAvailable();
+            }
+        } else {
+            this.closeAndDisconnect();
+            throw new ProtocolNotConnectedException();
+        }
+    }
+
+    private byte[] waitForData() throws Exception {
+        byte[] var2;
+        try {
+            this.waitUntilConditionOrInternalError(() -> {
+                return this.lwM2MCharacteristic.getTapResponse() != null;
+            }, 10000L, 100L);
+            byte[] tapResponseBytes = this.lwM2MCharacteristic.getTapResponse();
+            Log.d("BLEProtocol", "Read stream has " + tapResponseBytes.length + " bytes of data");
+            var2 = ByteArrayHelper.copy(tapResponseBytes);
+        } finally {
+            this.lwM2MCharacteristic.reset();
+        }
+
+        return var2;
+    }
+
+    private long waitUntilConditionOrInternalError(Callable<Boolean> condition, long timeoutCom, long waitDelayMilliseconds) throws Exception {
+        long time = (long)this.waitUntilCondition(() -> {
+            return this.lastInternalBLEError != null || (Boolean)condition.call();
+        }, timeoutCom, waitDelayMilliseconds);
+        if (this.lastInternalBLEError != null) {
+            throw this.lastInternalBLEError;
+        } else {
+            return time;
+        }
+    }
+
+    private void waitForMtuSizeChanged(long timeout) throws Exception {
+        this.waitUntilConditionOrInternalError(() -> {
+            return this.currentMTU >= this.requestedMtuSize;
+        }, timeout, 100L);
+    }
+
+    public HostProtocol getType() {
+        return HostProtocol.BLE;
+    }
+
+    private synchronized void closeAndDisconnect() {
+        try {
+            if (this.gatt != null) {
+                this.gatt.disconnect();
+
+                try {
+                    this.waitForConnectionState(0);
+                } catch (UnexpectedDisconnectionException var6) {
+                } catch (Exception var7) {
+                    Log.e("BLEProtocol", "Cannot disconnect properly", var7);
+                }
+
+                this.gatt.close();
+            }
+        } finally {
+            this.gatt = null;
+            this.lwM2MCharacteristic = null;
+            this.isServiceDiscovered.set(false);
+            this.characteristicsAdapters.clear();
+            this.currentBleCommand.set(null);
+            this.setConnectionStatus(ConnectionState.DISCONNECTED);
+        }
+
+    }
+
+    private long waitForConnectionState(int connectionState) throws Exception {
+        return this.waitUntilConditionOrInternalError(() -> {
+            return this.getBluetoothConnectionState() == connectionState;
+        }, 8000L, 100L);
+    }
+
+    private int waitUntilCondition(Callable<Boolean> condition, long timeout, long delay) throws Exception {
+        int count;
+        for(count = 0; (timeout < 0L || (long)count < timeout) && !(Boolean)condition.call(); count = (int)((long)count + delay)) {
+            Thread.sleep(delay);
+        }
+
+        if (timeout >= 0L && (long)count >= timeout) {
+            throw new TimeOutException("BLE timeout after " + timeout + "ms");
+        } else {
+            return count;
+        }
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    @NonNull
+    private BluetoothGattCharacteristic getCharacteristic(@NonNull UUID svcUuid, @NonNull UUID charUuid) throws ServiceNotAvailableException, CharacteristicNotAvailableException {
+        BluetoothGattService services = this.getGatt().getService(svcUuid);
+        if (services == null) {
+            Log.e("BLEProtocol", "Bluetooth service " + svcUuid + " is null");
+            throw new ServiceNotAvailableException(svcUuid);
+        } else {
+            BluetoothGattCharacteristic characteristic = services.getCharacteristic(charUuid);
+            if (characteristic == null) {
+                throw new CharacteristicNotAvailableException(svcUuid, charUuid);
+            } else {
+                return characteristic;
+            }
+        }
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    @Nullable
+    private BluetoothGattCharacteristic findCharacteristic(@NonNull UUID svcUuid, @NonNull UUID charUuid) {
+        BluetoothGattService services = this.getGatt().getService(svcUuid);
+        return services == null ? null : services.getCharacteristic(charUuid);
+    }
+
+    public CharacteristicAdapter getCharacteristicAdapter(@NonNull UUID svcUuid, @NonNull UUID charUuid) throws ServiceNotAvailableException, CharacteristicNotAvailableException {
+        CharacteristicAdapter adapter = this.findCharacteristicAdapter(svcUuid, charUuid);
+        if (adapter == null) {
+            throw new CharacteristicNotAvailableException(svcUuid, charUuid);
+        } else {
+            return adapter;
+        }
+    }
+
+    public boolean hasTapLwM2MService() {
+        this.assertBleConnnected();
+        BluetoothGatt gatt = this.getGatt();
+        return gatt.getService(Constants.SERVICE_SPP_OVER_LE) != null || gatt.getService(Constants.SERVICE_SPP_OVER_LE_FAST) != null;
+    }
+
+    public void discoverServices(boolean registerLWM2MCharacteristics) throws Exception {
+        this.registerLWM2MCharacteristics = registerLWM2MCharacteristics;
+        this.discoverServices();
+    }
+
+    public void discoverServices() throws Exception {
+        this.discoverServices(this.protocolConfiguration.connectionTimeoutMillis);
+    }
+
+    public void discoverServices(long timeoutMillis) throws Exception {
+        this.discoverServicesAsync();
+        this.waitForServiceDiscovery(0L, timeoutMillis);
+    }
+
+    public void discoverServicesAsync() {
+        this.assertBleConnnected();
+        this.isServiceDiscovered.set(false);
+        this.characteristicsAdapters.clear();
+        Log.i("BLEProtocol", "Bluetooth is now connected to device. Start service discovery");
+        this.getGatt().discoverServices();
+    }
+
+    private void assertBleConnnected() throws ProtocolNotConnectedException {
+        if (this.gatt == null) {
+            throw new IllegalStateException("Bluetooth gatt is not connected yet");
+        } else if (this.getBluetoothConnectionState() != 2) {
+            throw new ProtocolNotConnectedException();
+        }
+    }
+
+    private long waitForServiceDiscovery(long count, long timeoutMillis) throws Exception {
+        count += this.waitUntilConditionOrInternalError(() -> {
+            return this.isServiceDiscovered.get();
+        }, timeoutMillis, 100L);
+        return count;
+    }
+
+    public BluetoothDevice getBluetoothDevice() {
+        return this.mDevice;
+    }
+
+    private int getBluetoothConnectionState() {
+        return this.bluetoothManager.getConnectionState(this.mDevice, 7);
+    }
+
+    @Nullable
+    private CharacteristicAdapter findCharacteristicAdapter(@NonNull BluetoothGattCharacteristic characteristic) {
+        return this.findCharacteristicAdapter(characteristic.getService().getUuid(), characteristic.getUuid());
+    }
+
+    @Nullable
+    private CharacteristicAdapter findCharacteristicAdapter(UUID serviceId, UUID characId) {
+        Iterator var3 = this.characteristicsAdapters.iterator();
+
+        CharacteristicAdapter adapter;
+        do {
+            if (!var3.hasNext()) {
+                BluetoothGattCharacteristic characteristic = this.findCharacteristic(serviceId, characId);
+                if (characteristic != null) {
+                    adapter = new CharacteristicAdapter(this, characteristic, (CharacteristicAdapterCallbacks)null);
+                    this.characteristicsAdapters.add(adapter);
+                    return adapter;
+                }
+
+                return null;
+            }
+
+            adapter = (CharacteristicAdapter)var3.next();
+        } while(!adapter.characteristic.getUuid().equals(characId) || !adapter.characteristic.getService().getUuid().equals(serviceId));
+
+        return adapter;
+    }
+
+    public void queueCommand(BLECommand command) {
+        Log.d("BLEProtocol", "Queuing Command (total: " + this.commandQueue.size() + ")");
+        this.commandQueue.add(command);
+        if (this.currentBleCommand.get() == null) {
+            this.processCommands();
+        }
+
+    }
+
+    private synchronized void processCommands() {
+        if (this.currentBleCommand.get() == null) {
+            Log.d("BLEProtocol", "Processing next command...");
+            BLECommand command = (BLECommand)this.commandQueue.poll();
+            this.currentBleCommand.set(command);
+            if (command != null) {
+                try {
+                    command.runnable.run();
+                } catch (Exception var3) {
+                    command.notifier.notifyError(var3);
+                }
+            } else {
+                Log.d("BLEProtocol", "Command Queue is empty.");
+            }
+
+        }
+    }
+
+    public int getMTU() {
+        return this.currentMTU;
+    }
+
+    public int setMTU(int mtu) {
+        return this.currentMTU = mtu;
+    }
+
+    private synchronized void notifyGattOperationResult(int status) {
+        BLECommand command = (BLECommand)this.currentBleCommand.get();
+        this.currentBleCommand.set(null);
+        if (command != null) {
+            command.notifier.notifyResult(status);
+        }
+
+        this.processCommands();
+    }
+
+    public void requestMtuSize(@NonNull final BluetoothGatt gatt, final int requestedMtuSize, @Nullable OnGattOperationCallback callback) {
+        if (VERSION.SDK_INT >= 21 && this.currentMTU < requestedMtuSize) {
+            this.queueCommand(new BLECommand(new BLECommandRunnable() {
+                public void run() throws Exception {
+                    Log.d("BLEProtocol", "request mtu size: " + requestedMtuSize);
+                    BLEProtocol.this.requestedMtuSize = requestedMtuSize;
+                    gatt.requestMtu(requestedMtuSize);
+                }
+            }, new GattOperationCompletedNotifier(callback)));
+        } else if (callback != null) {
+            callback.onResult(0);
+        }
+
+    }
+
+    public String toString() {
+        return "BLEProtocol{" + this.getConnectionStatus().toString() + ", mDevice=" + this.mDevice + '}';
+    }
+
+    public interface OnGattOperationCallback {
+        void onResult(int var1);
+
+        void onError(@NonNull Exception var1);
+    }
+
+    public interface StepCode {
+        int CONNECT_TO_GATT = 1;
+        int CONNECTING_TO_GATT = 2;
+        int CONNECTED_TO_GATT = 3;
+        int SERVICE_DISCOVERED = 4;
+        int READ_CHARACTERISTIC_UPGRADE_APP_INFO = 5;
+        int READ_CHARACTERISTIC_SPP_OVER_LE = 6;
+        int SEND_PACKET_CHUNK = 7;
+    }
+
+    @RequiresApi(
+            api = 18
+    )
+    private class MyBluetoothGattCallback extends BluetoothGattCallback {
+        private MyBluetoothGattCallback() {
+        }
+
+        @RequiresApi(
+                api = 18
+        )
+        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
+            Log.i("BLEProtocol", "onConnectionStateChange(): status=" + status + ", newState: " + newState);
+            BLEProtocol.this.gatt = gatt;
+            this.checkGattStatusCode(gatt, status);
+            switch (newState) {
+                case 0:
+                default:
+                    if (BLEProtocol.this.lastInternalBLEError == null) {
+                        BLEProtocol.this.lastInternalBLEError = new UnexpectedDisconnectionException();
+                    }
+
+                    BLEProtocol.this.closeAndDisconnect();
+                    break;
+                case 1:
+                    BLEProtocol.this.notifyStepProgress(2);
+                    break;
+                case 2:
+                    BLEProtocol.this.notifyStepProgress(3);
+                    break;
+                case 3:
+                    BLEProtocol.this.setConnectionStatus(ConnectionState.DISCONNECTING);
+            }
+
+        }
+
+        @RequiresApi(
+                api = 18
+        )
+        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+            Log.i("BLEProtocol", "onServicesDiscovered received: '" + status + "' for gatt " + gatt);
+            if (this.checkGattStatusCode(gatt, status)) {
+                try {
+                    BLEProtocol.this.notifyStepProgress(4);
+                    BLEProtocol.this.gatt = gatt;
+                    if (VERSION.SDK_INT >= 21) {
+                        Log.d("BLEProtocol", "Setting priority to '" + BLEProtocol.this.connectionPriority + "' for gatt: " + gatt.toString());
+                        gatt.requestConnectionPriority(BLEProtocol.this.connectionPriority);
+                    }
+                    if (registerLWM2MCharacteristics) {
+                        if (gatt.getService(Constants.SERVICE_SPP_OVER_LE_FAST) != null) {
+                            BLEProtocol.this.setLwM2MCharacteristic(new LwM2MMTURequestCharacteristicAdapter(BLEProtocol.this, BLEProtocol.this.getCharacteristic(Constants.SERVICE_SPP_OVER_LE_FAST, Constants.CHARACTERISTIC_SPP_Over_LE_BUFFER_FAST)));
+                        } else if (gatt.getService(Constants.SERVICE_SPP_OVER_LE) != null) {
+                            BLEProtocol.this.setLwM2MCharacteristic(new LwM2M20BytesRequestCharacteristicAdapter(BLEProtocol.this, BLEProtocol.this.getCharacteristic(Constants.SERVICE_SPP_OVER_LE, Constants.CHARACTERISTIC_SPP_Over_LE_BUFFER)));
+                        }
+                    }
+
+
+                    BLEProtocol.this.isServiceDiscovered.set(true);
+                } catch (Exception var4) {
+                    BLEProtocol.this.lastInternalBLEError = var4;
+                }
+
+            }
+        }
+
+        @RequiresApi(
+                api = 18
+        )
+        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+            Log.d("BLEProtocol", "onCharacteristicRead: status:" + status + ". characteristic: " + characteristic.getUuid() + ". Gatt: " + gatt);
+            this.checkGattStatusCode(gatt, status);
+
+            try {
+                CharacteristicAdapter characteristicAdapter = BLEProtocol.this.findCharacteristicAdapter(characteristic);
+                if (characteristicAdapter != null) {
+                    characteristicAdapter.onCharacteristicRead(gatt, status);
+                } else {
+                    Log.w("BLEProtocol", "onCharacteristicRead(" + characteristic.getUuid() + ") no action defined");
+                }
+            } catch (Exception var5) {
+                BLEProtocol.this.lastInternalBLEError = var5;
+            }
+
+            BLEProtocol.this.notifyGattOperationResult(status);
+        }
+
+        private boolean checkGattStatusCode(BluetoothGatt gatt, int status) {
+            if (status != 0) {
+                Log.e("BLEProtocol", "onCharacteristicRead ERROR");
+                BLEProtocol.this.lastInternalBLEError = new InvalidGattStatusException(gatt, status);
+                return false;
+            } else {
+                return true;
+            }
+        }
+
+        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
+            try {
+                CharacteristicAdapterCallbacks characteristicAdapter = BLEProtocol.this.findCharacteristicAdapter(characteristic);
+                if (characteristicAdapter != null) {
+                    characteristicAdapter.onCharacteristicValueChanged(gatt);
+                } else {
+                    Log.w("BLEProtocol", "onCharacteristicChanged(" + characteristic.getUuid() + ") no action defined");
+                }
+            } catch (Exception var4) {
+                Log.e("BLEProtocol", "Unexpected error:", var4);
+                BLEProtocol.this.lastInternalBLEError = var4;
+            }
+
+        }
+
+        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+            try {
+                Log.d("BLEProtocol", "onCharacteristicWrite() status: " + status + ". characteristic: " + characteristic + ". Gatt: " + gatt);
+                if (!this.checkGattStatusCode(gatt, status)) {
+                    Log.e("BLEProtocol", "onCharacteristicWrite error with code " + status);
+                }
+
+                CharacteristicAdapter characteristicAdapter = BLEProtocol.this.findCharacteristicAdapter(characteristic);
+                if (characteristicAdapter != null) {
+                    characteristicAdapter.onCharacteristicWrite(gatt, status);
+                } else {
+                    Log.w("BLEProtocol", "onCharacteristicWrite(" + characteristic.getUuid() + ") no action defined");
+                }
+            } catch (Exception var5) {
+                BLEProtocol.this.lastInternalBLEError = var5;
+            }
+
+            BLEProtocol.this.notifyGattOperationResult(status);
+        }
+
+        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
+            Log.d("BLEProtocol", "onDescriptorWrite() status: " + status + ". Characteristic: " + descriptor.getCharacteristic().getUuid() + ", descriptor value: " + Helper.ByteArrayToHexString(descriptor.getValue()) + ". Gatt: " + gatt);
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onDescriptorWrite FAILED: " + status);
+                BLEProtocol.this.lastInternalBLEError = new CannotWriteDescriptorException(descriptor);
+            }
+
+            try {
+                CharacteristicAdapter characteristicAdapter = BLEProtocol.this.findCharacteristicAdapter(descriptor.getCharacteristic());
+                if (characteristicAdapter != null) {
+                    characteristicAdapter.onDescriptorWrite(gatt, descriptor, status);
+                } else {
+                    Log.w("BLEProtocol", "onDescriptorWrite(" + descriptor.getUuid() + ") no action defined");
+                }
+            } catch (Exception var5) {
+                BLEProtocol.this.lastInternalBLEError = var5;
+            }
+
+            BLEProtocol.this.notifyGattOperationResult(status);
+        }
+
+        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
+            Log.d("BLEProtocol", "onMtuChanged() status: " + status + ". mtu: " + mtu + ". Gatt: " + gatt);
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onMtuChanged FAILED: " + status);
+            } else {
+                BLEProtocol.this.currentMTU = mtu;
+                BLEProtocol.this.notifyGattOperationResult(status);
+            }
+        }
+
+        public void onPhyUpdate(BluetoothGatt gatt, int txPhy, int rxPhy, int status) {
+            Log.d("BLEProtocol", "onPhyUpdate");
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onPhyUpdate FAILED: " + status);
+            }
+        }
+
+        public void onPhyRead(BluetoothGatt gatt, int txPhy, int rxPhy, int status) {
+            Log.d("BLEProtocol", "onPhyRead");
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onPhyRead FAILED: " + status);
+            }
+        }
+
+        public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
+            Log.d("BLEProtocol", "onDescriptorRead");
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onDescriptorRead FAILED: " + status);
+            }
+
+            BLEProtocol.this.notifyGattOperationResult(status);
+        }
+
+        public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
+            Log.d("BLEProtocol", "onReliableWriteCompleted");
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onReliableWriteCompleted FAILED: " + status);
+            }
+        }
+
+        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
+            Log.d("BLEProtocol", "onReadRemoteRssi");
+            if (!this.checkGattStatusCode(gatt, status)) {
+                Log.e("BLEProtocol", "onReadRemoteRssi FAILED: " + status);
+            }
+        }
+    }
+
+    public class GattOperationCompletedNotifier implements CommandCompletedNotifier {
+        @Nullable
+        public final OnGattOperationCallback callback;
+
+        public GattOperationCompletedNotifier(@Nullable OnGattOperationCallback callback) {
+            this.callback = callback;
+        }
+
+        public void notifyResult(int status) {
+            if (this.callback != null) {
+                this.callback.onResult(status);
+            }
+
+        }
+
+        public void notifyError(@NonNull Exception err) {
+            if (this.callback != null) {
+                this.callback.onError(err);
+            }
+
+        }
+    }
+}