@iotize/device-com-ble.cordova 3.5.2 → 3.6.2-alpha.2

package/src/android/src/ble/BLEScanner.java

@@ -0,0 +1,284 @@
+package com.iotize.plugin.cordova.ble;
+
+
+import static android.os.Build.VERSION_CODES.LOLLIPOP;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanFilter;
+import android.bluetooth.le.ScanRecord;
+import android.bluetooth.le.ScanResult;
+import android.bluetooth.le.ScanSettings;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.iotize.android.device.api.device.scanner.IDeviceScanner;
+import com.iotize.android.device.api.device.scanner.IOnDeviceDiscovered;
+
+import java.util.List;
+
+/**
+ *
+ */
+@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+public class BLEScanner implements IDeviceScanner<BLEScanner.BLEScanData> {
+
+    private static final String TAG = "BLEScanner";
+
+    @NonNull
+    private final BluetoothAdapter mBluetoothAdapter;
+    @NonNull
+    private final Context mContext;
+    @NonNull
+    private final List<ScanFilter> filters;
+
+    // Device scan callback.
+    protected BLE_Callback mLeScanCallback;
+    protected BLE_Callback_API21 mLeScanCallback_API21;
+    private BluetoothLeScanner mBluetoothScanner;
+    private IOnDeviceDiscovered<BLEScanData> onDeviceDiscovered;
+    private boolean mRunning;
+
+    public BLEScanner(@NonNull Context context,
+                      @NonNull BluetoothAdapter bluetoothAdapter,
+                      @NonNull List<ScanFilter> filters) {
+        this.mBluetoothAdapter = bluetoothAdapter;
+        if (Build.VERSION.SDK_INT < LOLLIPOP)
+            mLeScanCallback = new BLE_Callback();
+        else {
+            mLeScanCallback_API21 = new BLE_Callback_API21();
+        }
+        this.mContext = context;
+        this.filters = filters;
+    }
+
+    public void setOnDeviceDiscoveredCallback(IOnDeviceDiscovered<BLEScanData> onDeviceDiscovered) {
+        this.onDeviceDiscovered = onDeviceDiscovered;
+    }
+
+    public void start() {
+        if (mRunning) {
+            Log.w(TAG, "Scan is already running... ignoring this call");
+            return;
+        }
+        mRunning = true;
+        if (Build.VERSION.SDK_INT < LOLLIPOP) {
+            Log.i(TAG, "Starting Bluetooth scan...");
+            mBluetoothAdapter.startLeScan(mLeScanCallback);
+        } else {
+            Log.i(TAG, "Starting Bluetooth Low Energy scan...");
+            try {
+                ScanSettings.Builder buildSettings = new ScanSettings.Builder();
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                    buildSettings.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES);
+                }
+                buildSettings.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY);
+                buildSettings.setReportDelay(0);    // we want the result immediately
+                ScanSettings settings = buildSettings.build();
+                mBluetoothScanner = mBluetoothAdapter.getBluetoothLeScanner();
+                mBluetoothScanner.startScan(this.filters, settings, mLeScanCallback_API21);
+            } catch (Exception e) {
+                Log.e(TAG, "Cannot run bluetooth scan: " + e.getMessage(), e);
+                stop();
+            }
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public void stop() {
+        try {
+            if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
+                if (mBluetoothScanner != null) {
+                    mBluetoothScanner.stopScan(mLeScanCallback_API21);
+                }
+                mBluetoothAdapter.cancelDiscovery();
+            }
+        } catch (Throwable e) {
+            Log.e(TAG, "Error while stopping ble scan: " + e.getMessage(), e);
+        } finally {
+            mRunning = false;
+        }
+    }
+
+    protected void onDeviceDiscovered(BLEScanData device) {
+        Log.v(TAG, "onDeviceDiscovered() " + device.getDevice().getName());
+
+        if (this.onDeviceDiscovered != null) {
+            this.onDeviceDiscovered.onDeviceDiscovered(device);
+        }
+    }
+
+    /**
+     * @return true if device has bluetooth feature
+     */
+    public boolean isAvailable() {
+        PackageManager pm = mContext.getPackageManager();
+        return pm.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
+    }
+
+    /**
+     * @return true if device bluetooth is enabled
+     */
+    public boolean isEnabled() {
+        return mBluetoothAdapter != null && mBluetoothAdapter.isEnabled();
+    }
+
+
+    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+    class BLE_Callback implements BluetoothAdapter.LeScanCallback {
+        @Override
+        public void onLeScan(final BluetoothDevice device, int rssi, final byte[] scanRecord) {
+            Log.v(TAG, "Scan result: " + device + " RSSI: " + rssi);
+            onDeviceDiscovered(new BluetoothDeviceAdpaterBeforeLollipop(device, rssi, scanRecord));
+        }
+
+    }
+
+    //YRT170410    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    private class BLE_Callback_API21 extends ScanCallback {
+        @Override
+        public void onScanResult(int callbackType, android.bluetooth.le.ScanResult result) {
+            super.onScanResult(callbackType, result);
+            Log.v(TAG, "Scan result: " + result);
+            //if (callbackType == ScanSettings.CALLBACK_TYPE_ALL_MATCHES) {
+            BluetoothDevice device = result.getDevice();
+            onDeviceDiscovered(new BluetoothDeviceAdpaterFromLollipop(result));
+            //}
+        }
+
+        @Override
+        public void onScanFailed(int errorCode) {
+            Log.e(TAG, "Scan failed with error code: " + errorCode);
+            BLEScanner.this.onScanFailed(errorCode);
+        }
+    }
+
+    private void onScanFailed(int errorCode) {
+        if (this.onDeviceDiscovered != null) {
+            this.onDeviceDiscovered.onScanFailed(
+                    new BleScanError(errorCode)
+            );
+        }
+    }
+
+
+    public interface BLEScanData {
+
+        int getRssi();
+
+        int getTxPower();
+
+        BluetoothDevice getDevice();
+
+        byte[] getScanRecordBytes();
+
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    public class BluetoothDeviceAdpaterFromLollipop implements BLEScanner.BLEScanData {
+        private final ScanResult result;
+
+        public BluetoothDeviceAdpaterFromLollipop(ScanResult result) {
+            this.result = result;
+        }
+
+        @Override
+        public int getRssi() {
+            return this.result.getRssi();
+        }
+
+        @Override
+        public int getTxPower() {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                return this.result.getTxPower();
+            }
+            else {
+                return 0;
+            }
+        }
+
+        @Override
+        public BluetoothDevice getDevice() {
+            return this.result.getDevice();
+        }
+        @Override
+        public byte[] getScanRecordBytes() {
+            final ScanRecord scanRecord = this.result.getScanRecord();
+            if (scanRecord == null) {
+                return new byte[0];
+            }
+            return scanRecord.getBytes();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return this.getDevice() == null;
+            }
+            if (!(obj instanceof BLEScanner.BLEScanData)) {
+                return false;
+            }
+            return this.result.getDevice().equals(((BLEScanner.BLEScanData) obj).getDevice());
+        }
+    }
+
+    public class BluetoothDeviceAdpaterBeforeLollipop implements BLEScanner.BLEScanData {
+
+        private final BluetoothDevice device;
+        private final int rssi;
+        private final byte[] scanRecord;
+
+        public BluetoothDeviceAdpaterBeforeLollipop(BluetoothDevice device, int rssi, final byte[] scanRecord) {
+            this.device = device;
+            this.rssi = rssi;
+            this.scanRecord = scanRecord;
+        }
+
+        @Override
+        public int getRssi() {
+            return this.rssi;
+        }
+
+        @Override
+        public int getTxPower() {
+            return 0;
+        }
+
+        @Override
+        public BluetoothDevice getDevice() {
+            return this.device;
+        }
+
+        @Override
+        public byte[] getScanRecordBytes() {
+            return this.scanRecord;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return this.getDevice() == null;
+            }
+            if (!(obj instanceof BLEScanner.BLEScanData)) {
+                return false;
+            }
+            return this.device.equals(((BLEScanner.BLEScanData) obj).getDevice());
+        }
+    }
+
+    class BleScanError extends Exception {
+        public BleScanError(int errorCode) {
+            super("BLE scan failed (error code: " + errorCode + ")");
+        }
+    }
+
+
+}

package/src/android/src/ble/JSONBuilder.java

@@ -13,9 +13,9 @@ import android.util.Log;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-import com.iotize.android.communication.protocol.ble.scanner.BLEScanner;
 import com.iotize.plugin.cordova.ble.models.ServiceDescription;
 
+import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -39,6 +39,8 @@ public class JSONBuilder {
             json.put("address", bluetoothDevice.getAddress());
             // json.put("type", bluetoothDevice.getType());
             json.put("rssi", device.getRssi());
+            json.put("txPower", device.getTxPower());
+            json.put("scanRecord", JSONBuilder.toJSONObject(device.getScanRecordBytes()));
 
             return json;
         } catch (JSONException e) {
@@ -61,6 +63,15 @@ public class JSONBuilder {
         }
     }
 
+    static JSONArray toJSONObject(byte[] bytes) {
+        JSONArray json = new JSONArray();
+        for (byte aByte : bytes) {
+            json.put(aByte);
+        }
+        return json;
+    }
+
+
     public static ArrayList<ServiceDescription> toServicesDescription(List<BluetoothGattService> services) {
         ArrayList<ServiceDescription> result = new ArrayList<>();
         for (BluetoothGattService service : services) {

package/src/android/src/ble/PluginResponse.java

@@ -10,8 +10,8 @@ import android.bluetooth.BluetoothGatt;
 import android.bluetooth.BluetoothGattCharacteristic;
 
 import com.google.gson.JsonParser;
-import com.iotize.android.communication.protocol.ble.characteristics.CharacteristicAdapter;
 import com.iotize.android.core.util.Helper;
+import com.iotize.plugin.cordova.ble.characteristics.CharacteristicAdapter;
 
 import org.apache.cordova.CallbackContext;
 import org.apache.cordova.PluginResult;

package/src/android/src/ble/TapUtility.java

@@ -0,0 +1,27 @@
+package com.iotize.plugin.cordova.ble;
+
+import android.bluetooth.le.ScanFilter;
+import android.os.Build;
+import android.os.ParcelUuid;
+
+import com.iotize.android.communication.protocol.ble.Constants;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public  class TapUtility {
+
+    static List<ScanFilter> createTapFilter() {
+        if (Build.VERSION.SDK_INT >= 21) {
+            List<ScanFilter> filters = new ArrayList();
+            ScanFilter.Builder buildFilterTapService = new ScanFilter.Builder();
+            buildFilterTapService.setServiceUuid(new ParcelUuid(Constants.SERVICE_SPP_OVER_LE));
+            filters.add(buildFilterTapService.build());
+            return filters;
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+}

package/src/android/src/ble/characteristics/AbstractLwM2MRequestCharacteristic.java

@@ -0,0 +1,48 @@
+package com.iotize.plugin.cordova.ble.characteristics;
+
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.iotize.android.communication.protocol.ble.exception.BLEComException;
+import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharacteristicException;
+import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
+import com.iotize.plugin.cordova.ble.BLEProtocol;
+
+@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+public abstract class AbstractLwM2MRequestCharacteristic extends CharacteristicAdapter implements CharacteristicAdapterCallbacks {
+
+    @Nullable
+    protected Exception initializeError;
+    protected boolean isInitialized = false;
+
+    AbstractLwM2MRequestCharacteristic(@NonNull BLEProtocol protocol, @NonNull BluetoothGattCharacteristic characteristic) {
+        super(protocol, characteristic, null);
+        this.callbacks = this;
+    }
+
+    public abstract void sendLwM2MTapRequest(@NonNull BluetoothGatt gatt, @NonNull byte[] data) throws WritePacketIsTooBigException, CannotWriteCharacteristicException;
+
+    public abstract void reset();
+
+    @Nullable
+    public abstract byte[] getTapResponse();
+
+    public abstract void initialize(@NonNull BluetoothGatt gatt, @Nullable OnCharacteristicInitialized callback);
+
+    public boolean isInitialized() throws Exception {
+        if (initializeError != null) {
+            throw initializeError;
+        }
+        return isInitialized;
+    }
+
+    public interface OnCharacteristicInitialized {
+        void onCharacteristicInitializedSuccess();
+        void onCharacteristicInitializedFail(@NonNull Exception err);
+    }
+}

package/src/android/src/ble/characteristics/CharacteristicAdapter.java

@@ -0,0 +1,221 @@
+package com.iotize.plugin.cordova.ble.characteristics;
+
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.iotize.android.communication.protocol.ble.BLECommandRunnable;
+import com.iotize.android.communication.protocol.ble.exception.CannotSetCharacteristicNotification;
+import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharacteristicException;
+import com.iotize.android.communication.protocol.ble.exception.CharacteristicNotificationNotSupported;
+import com.iotize.android.communication.protocol.ble.exception.DescriptorNotAvailableException;
+import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
+import com.iotize.android.core.util.Helper;
+import com.iotize.plugin.cordova.ble.BLEProtocol;
+import com.iotize.plugin.cordova.ble.commands.BLECommand;
+import com.iotize.plugin.cordova.ble.commands.CharacteristicOperationCompletedNotifier;
+import com.iotize.plugin.cordova.ble.commands.DescriptorOperationCompletedNotifier;
+
+import java.util.UUID;
+
+@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+public class CharacteristicAdapter implements CharacteristicAdapterCallbacks {
+
+    static final UUID NOTIFICATION_DESCRIPTOR_UUID =
+            UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
+
+    private static final String TAG = "AbstractCharacteristicA";
+    @NonNull
+    public final BluetoothGattCharacteristic characteristic;
+
+    @NonNull
+    protected final BLEProtocol protocol;
+
+    @Nullable
+    private OnCharacteristicValueChangedCallback onCharacteristicValueChangedCallback;
+
+    @Nullable
+    protected CharacteristicAdapterCallbacks callbacks;
+
+    @Nullable
+    private OnCharacteristicOperationResult cmdCallback;
+
+    public CharacteristicAdapter(
+            @NonNull BLEProtocol protocol,
+            @NonNull BluetoothGattCharacteristic characteristic,
+            @Nullable CharacteristicAdapterCallbacks callbacks) {
+        this.protocol = protocol;
+        this.characteristic = characteristic;
+        this.callbacks = callbacks;
+    }
+
+    public void setCallbacks(CharacteristicAdapterCallbacks callbacks) {
+        this.callbacks = callbacks;
+    }
+
+    public boolean isWritable() {
+        int properties = this.characteristic.getProperties();
+        return (properties & (BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE)) != 0;
+    }
+
+    public void startNotification(BluetoothGatt gatt, OnCharacteristicOperationResult callback) {
+        this.startOrStopValueChangedSubscription(gatt, true, callback);
+    }
+
+    public void stopNotification(BluetoothGatt gatt, OnCharacteristicOperationResult callback) {
+        this.startOrStopValueChangedSubscription(gatt, false, callback);
+    }
+
+    private void startOrStopValueChangedSubscription(BluetoothGatt gatt, boolean start, OnCharacteristicOperationResult callback) {
+        queueCommand(callback, () -> {
+            if (gatt.setCharacteristicNotification(characteristic, start)) {
+
+                BluetoothGattDescriptor descriptor = characteristic.getDescriptor(NOTIFICATION_DESCRIPTOR_UUID);
+
+                if (descriptor == null) {
+                    throw new DescriptorNotAvailableException(characteristic, NOTIFICATION_DESCRIPTOR_UUID);
+                }
+
+                if (start) {
+                    int properties = characteristic.getProperties();
+                    if ((properties & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
+                        descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
+                    } else if ((properties & BluetoothGattCharacteristic.PROPERTY_INDICATE) != 0) {
+                        descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
+                    } else {
+                        throw new CharacteristicNotificationNotSupported(this.characteristic);
+                    }
+                } else {
+                    descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
+                }
+
+                if (!gatt.writeDescriptor(descriptor)) {
+                    throw new CannotSetCharacteristicNotification(this.characteristic);
+                }
+            } else {
+                throw new CannotSetCharacteristicNotification(this.characteristic);
+            }
+        });
+    }
+
+    void queueCommand(@Nullable OnCharacteristicOperationResult cb, @NonNull BLECommandRunnable runnable) {
+        this.protocol.queueCommand(new BLECommand(
+                runnable,
+                new CharacteristicOperationCompletedNotifier(cb, this.characteristic)
+        ));
+    }
+
+    void queueCommand(@Nullable OnDescriptorOperationResult cb, @NonNull BLECommandRunnable runnable, BluetoothGattDescriptor descriptor) {
+        this.protocol.queueCommand(new BLECommand(
+                        runnable,
+                        new DescriptorOperationCompletedNotifier(cb, descriptor)
+                )
+        );
+    }
+
+    public byte[] getValue() {
+        return this.characteristic.getValue();
+    }
+
+    public void read(@Nullable OnCharacteristicOperationResult callback) {
+        queueCommand(callback, () -> {
+            this.protocol.getGatt().readCharacteristic(this.characteristic);
+        });
+    }
+
+    public void readDescriptor(@NonNull UUID descriptorUUID, @Nullable OnDescriptorOperationResult callback) {
+        BluetoothGattDescriptor descriptor = this.characteristic.getDescriptor(descriptorUUID);
+        if (descriptor == null && callback != null) {
+            callback.onError(null, new DescriptorNotAvailableException(this.characteristic, descriptorUUID));
+            return;
+        }
+        queueCommand(callback, () -> {
+            this.protocol.getGatt().readDescriptor(descriptor);
+        }, descriptor);
+    }
+
+    public void onValueChanged(OnCharacteristicValueChangedCallback onCharacteristicValueChangedCallback) {
+        this.onCharacteristicValueChangedCallback = onCharacteristicValueChangedCallback;
+    }
+
+    public void write(BluetoothGatt gatt, byte[] packet, int writeType, @Nullable OnCharacteristicOperationResult callback) throws CannotWriteCharacteristicException, WritePacketIsTooBigException {
+        queueCommand(callback, () -> {
+            if (packet.length > protocol.getMTU()) {
+            //    throw new WritePacketIsTooBigException(packet);
+                Log.w(TAG, "current mtu is " + protocol.getMTU() + " bytes but writing " + packet.length + " bytes");
+            }
+            Log.d(TAG, "_writeData ... packet = 0x" + Helper.ByteArrayToHexString(packet) + " (size = " + packet.length + ")");
+            this.characteristic.setValue(packet);
+            this.characteristic.setWriteType(writeType);
+            boolean writeSuccess = gatt.writeCharacteristic(this.characteristic);
+            if (!writeSuccess) {
+                Log.w(TAG, "Cannot write on characteristic on first try. WRITE ENABLED: " + this.isWritable() + "/ Write type: " + this.characteristic.getWriteType());
+                throw new CannotWriteCharacteristicException(gatt, this.characteristic);
+            }
+            Log.d(TAG, "_writeData OK ! packet = 0x" + Helper.ByteArrayToHexString(packet) + " (size = " + packet.length + ")");
+        });
+    }
+
+    @Override
+    public void onCharacteristicValueChanged(BluetoothGatt gatt) {
+        if (this.onCharacteristicValueChangedCallback != null) {
+            this.onCharacteristicValueChangedCallback.onCharacteristicValueChanged(this.characteristic.getValue());
+        }
+        if (this.callbacks != null) {
+            this.callbacks.onCharacteristicValueChanged(gatt);
+        }
+    }
+
+    @Override
+    public void onCharacteristicWrite(BluetoothGatt gatt, int status) throws WritePacketIsTooBigException, CannotWriteCharacteristicException {
+        if (this.callbacks != null) {
+            this.callbacks.onCharacteristicWrite(gatt, status);
+        }
+    }
+
+    @Override
+    public void onCharacteristicRead(BluetoothGatt gatt, int status) {
+        if (this.callbacks != null) {
+            this.callbacks.onCharacteristicRead(gatt, status);
+        }
+    }
+
+    @Override
+    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
+        if (descriptor.getUuid().equals(NOTIFICATION_DESCRIPTOR_UUID)) {
+            if (this.cmdCallback != null) {
+                this.cmdCallback.onResult(this.characteristic, status);
+                this.cmdCallback = null;
+            }
+        }
+        if (this.callbacks != null) {
+            this.callbacks.onDescriptorWrite(gatt, descriptor, status);
+        }
+    }
+
+    public interface OnCharacteristicOperationResult {
+
+        void onResult(@NonNull BluetoothGattCharacteristic characteristic, int statusCode);
+
+        void onError(@NonNull BluetoothGattCharacteristic characteristic, @NonNull Exception ex);
+    }
+
+    public interface OnDescriptorOperationResult {
+
+        void onResult(@NonNull BluetoothGattDescriptor descriptor, int statusCode);
+
+        void onError(@Nullable BluetoothGattDescriptor descriptor, @NonNull Exception ex);
+    }
+
+    public interface OnCharacteristicValueChangedCallback {
+
+        void onCharacteristicValueChanged(byte[] value);
+
+    }
+}

package/src/android/src/ble/characteristics/CharacteristicAdapterCallbacks.java

@@ -0,0 +1,21 @@
+package com.iotize.plugin.cordova.ble.characteristics;
+
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattDescriptor;
+
+import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharacteristicException;
+import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
+
+import java.util.UUID;
+
+public interface CharacteristicAdapterCallbacks {
+
+    void onCharacteristicValueChanged(BluetoothGatt gatt);
+
+    void onCharacteristicWrite(BluetoothGatt gatt, int status) throws WritePacketIsTooBigException, CannotWriteCharacteristicException;
+
+    void onCharacteristicRead(BluetoothGatt gatt, int status);
+
+    void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status);
+
+}