@iotize/device-com-ble.cordova 3.2.1 → 3.3.2

package/src/android/src/ble/BLECom.java

@@ -1,559 +1,560 @@
-//
-//  Copyright 2018 IoTize SAS Inc.  Licensed under the MIT license. 
-//
-//  BLECom.java
-//  device-com-ble.cordova BLE Cordova Plugin
-//
-
-package com.iotize.plugin.cordova.ble;
-
-import static android.Manifest.permission.ACCESS_FINE_LOCATION;
-
-import android.annotation.SuppressLint;
-import android.app.Activity;
-import android.bluetooth.BluetoothAdapter;
-import android.bluetooth.BluetoothDevice;
-import android.bluetooth.BluetoothGatt;
-import android.bluetooth.BluetoothGattCharacteristic;
-import android.bluetooth.BluetoothGattService;
-import android.bluetooth.BluetoothManager;
-import android.content.Context;
-import android.content.Intent;
-import android.content.pm.PackageManager;
-import android.util.Log;
-
-import com.iotize.android.communication.protocol.ble.BLEProtocol;
-import com.iotize.android.communication.protocol.ble.DeviceManager;
-import com.iotize.android.communication.protocol.ble.characteristics.CharacteristicAdapter;
-import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharacteristicException;
-import com.iotize.android.communication.protocol.ble.exception.CharacteristicNotAvailableException;
-import com.iotize.android.communication.protocol.ble.exception.ServiceNotAvailableException;
-import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
-import com.iotize.android.communication.protocol.ble.scanner.BLEScanner;
-import com.iotize.android.core.util.Helper;
-import com.iotize.android.device.api.device.scanner.IOnDeviceDiscovered;
-import com.iotize.plugin.cordova.ble.models.RequestDeviceOptions;
-
-import org.apache.cordova.CallbackContext;
-import org.apache.cordova.CordovaInterface;
-import org.apache.cordova.CordovaPlugin;
-import org.apache.cordova.CordovaWebView;
-import org.apache.cordova.LOG;
-import org.apache.cordova.PermissionHelper;
-import org.jetbrains.annotations.NotNull;
-import org.json.JSONArray;
-
-import java.util.List;
-import java.util.UUID;
-
-import io.reactivex.annotations.NonNull;
-import io.reactivex.annotations.Nullable;
-
-public class BLECom extends CordovaPlugin {
-    // actions
-    private static final String CONNECT = "connect";
-    private static final String CONNECT_AND_DISCOVER_TAP_SERVICES = "connectAndDiscoverTapServices";
-    private static final String DISCONNECT = "disConnect";
-    private static final String CLOSE = "close";
-    private static final String SEND_REQUEST = "sendRequest";
-    private static final String GET_LAST_ERROR = "getLastError";
-    private static final String START_SCAN = "startScan";
-    private static final String STOP_SCAN = "stopScan";
-    private static final String IS_ENABLED = "isEnabled";
-    private static final String CHECK_AVAILABLE = "checkAvailable";
-    private static final String IS_CONNECTED = "isConnected";
-    private static final String ENABLE = "enable";
-    private static final String REQUEST_MTU = "requestMtu";
-
-    // New
-    private static final String CHARACTERISTIC_READ = "characteristicRead";
-    private static final String CHARACTERISTIC_WRITE = "characteristicWrite";
-    private static final String CHARACTERISTIC_WRITE_WITHOUT_RESPONSE = "characteristicWriteWithoutResponse";
-    private static final String START_NOTIFICATION = "characteristicStartNotification";
-    private static final String STOP_NOTIFICATION = "characteristicStopNotification";
-    private static final String CHARACTERISTIC_CHANGED = "characteristicChanged";
-    private static final String DISCOVER_SERVICES = "discoverServices";
-
-
-    private static final int REQUEST_ENABLE_BLUETOOTH = 1;
-    private static final int REQUEST_SCAN_PERMISSIONS = 2;
-
-    private static final String TAG = "BLECom";
-    private DeviceManager<BLEProtocol> peripherals;
-    private BluetoothAdapter bluetoothAdapter;
-    private PluginResponse enableBluetoothCallback;
-    private PluginResponse pluginResponseDiscoverDevice;
-    private PluginResponse permissionCallback;
-    private BLEScanner scanner;
-    private IOnDeviceDiscovered<BLEScanner.BLEScanData> onDeviceDiscoveredCallback;
-    @Nullable
-    private RequestDeviceOptions requestDeviceOptions;
-
-    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
-        super.initialize(cordova, webView);
-
-        this.peripherals = new DeviceManager<>();
-        Log.d(TAG, "Initializing IoTizeBLE Plugin");
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-    }
-
-    @SuppressLint("MissingPermission")
-    public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) {
-
-        PluginResponse pluginResponse = new PluginResponse(
-                action,
-                args,
-                callbackContext
-        );
-        ArgsHelper argsHelper = new ArgsHelper(args);
-        try {
-            this.setupBluetoothAdapter();
-            if (action.equals(STOP_SCAN)) {
-                Log.d(TAG, STOP_SCAN);
-                this.stopScan(pluginResponse);
-            } else if (action.equals(START_SCAN)) {
-                Log.d(TAG, START_SCAN);
-                RequestDeviceOptions scanOptions = null;
-                if (argsHelper.length() > 0) {
-                    scanOptions = argsHelper.parseJSONAt(0, RequestDeviceOptions.class);
-                }
-                this.startScan(scanOptions, pluginResponse);
-            } else if (action.equals(CONNECT)) {
-                Log.d(TAG, CONNECT);
-                String macAddress = argsHelper.getString(0);
-                this.connect(pluginResponse, macAddress);
-            } else if (action.equals(REQUEST_MTU)) {
-                Log.d(TAG, REQUEST_MTU);
-                String macAddress = argsHelper.getString(0);
-                int mtu = argsHelper.getInt(1);
-                this.requestMtu(pluginResponse, macAddress, mtu);
-            } else if (action.equals(CONNECT_AND_DISCOVER_TAP_SERVICES)) {
-                Log.d(TAG, CONNECT_AND_DISCOVER_TAP_SERVICES);
-                String macAddress = argsHelper.getString(0);
-                this.connectAndDiscoverTapServices(pluginResponse, macAddress);
-            } else if (action.equals(DISCONNECT)) {
-                Log.d(TAG, DISCONNECT);
-                String macAddress = argsHelper.getString(0);
-                this.disconnect(pluginResponse, macAddress);
-            } else if (action.equals(CLOSE)) {
-                Log.d(TAG, CLOSE);
-                String macAddress = argsHelper.getString(0);
-                this.close(pluginResponse, macAddress);
-            } else if (action.equals(GET_LAST_ERROR)) {
-                Log.d(TAG, GET_LAST_ERROR);
-                this.getLastError(pluginResponse);
-            } else if (action.equals(SEND_REQUEST)) {
-                String deviceId = argsHelper.getString(0);
-                byte[] data = argsHelper.getBytes(1);
-                this.sendLwm2mTapRequest(pluginResponse, deviceId, data);
-            } else if (action.equals(CHECK_AVAILABLE) || action.equals(IS_ENABLED)) {
-                pluginResponse.success(bluetoothAdapter.isEnabled());
-            } else if (action.equals(IS_CONNECTED)) {
-                String macAddress = argsHelper.getString(0);
-                boolean isConnected = peripherals.get(macAddress).isConnected();
-                pluginResponse.success(isConnected);
-            } else if (action.equals(ENABLE)) {
-                if (enableBluetoothCallback != null) {
-                    Log.w(TAG, "There is already an enable request pending...");
-                }
-                enableBluetoothCallback = pluginResponse;
-                Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
-                cordova.startActivityForResult(this, intent, REQUEST_ENABLE_BLUETOOTH);
-            } else if (action.equals(CHARACTERISTIC_READ)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                this.readCharacteristicValue(pluginResponse, macAddress, serviceUUID, characteristicUUID);
-            } else if (action.equals(CHARACTERISTIC_WRITE)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                byte[] data = argsHelper.getBytes(3);
-                this.writeCharacteristic(pluginResponse, macAddress, serviceUUID, characteristicUUID, data, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
-            } else if (action.equals(CHARACTERISTIC_WRITE_WITHOUT_RESPONSE)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                byte[] data = argsHelper.getBytes(3);
-                this.writeCharacteristic(pluginResponse, macAddress, serviceUUID, characteristicUUID, data, BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
-            } else if (action.equals(START_NOTIFICATION)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                this.startNotification(pluginResponse, macAddress, serviceUUID, characteristicUUID);
-            } else if (action.equals(STOP_NOTIFICATION)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                this.stopNotification(pluginResponse, macAddress, serviceUUID, characteristicUUID);
-            } else if (action.equals(CHARACTERISTIC_CHANGED)) {
-                String macAddress = argsHelper.getString(0);
-                UUID serviceUUID = argsHelper.getUUID(1);
-                UUID characteristicUUID = argsHelper.getUUID(2);
-                this.listenToCharacteristicChange(pluginResponse, macAddress, serviceUUID, characteristicUUID);
-            } else if (action.equals(DISCOVER_SERVICES)) {
-                String macAddress = argsHelper.getString(0);
-                this.discoverServices(pluginResponse, macAddress);
-            } else {
-                throw BLEComError.illegalAction("Illegal action " + action);
-            }
-            return true;
-        } catch (BLEComError err) {
-            pluginResponse.error(err);
-            return false;
-        } catch (Throwable err) {
-            pluginResponse.error(BLEComError.internalError(err));
-            return false;
-        }
-
-    }
-
-    private void discoverServices(PluginResponse pluginResponse, String macAddress) throws Exception {
-        // TODO async ? 
-        BLEProtocol peripheral = peripherals.get(macAddress);
-        peripheral.discoverServices();
-        List<BluetoothGattService> services = peripheral.getGatt().getServices();
-        pluginResponse.success(JSONBuilder.toServicesDescription(services));
-    }
-
-    private void listenToCharacteristicChange(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws CharacteristicNotAvailableException, ServiceNotAvailableException {
-        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
-        characteristic.onValueChanged(new CharacteristicAdapter.OnCharacteristicValueChangedCallback() {
-            @Override
-            public void onCharacteristicValueChanged(byte[] bytes) {
-                pluginResponse.newResult(bytes);
-            }
-        });
-    }
-
-    private void setupBluetoothAdapter() throws BLEComError {
-        if (bluetoothAdapter == null) {
-            Activity activity = cordova.getActivity();
-            boolean hardwareSupportsBLE = activity.getApplicationContext()
-                    .getPackageManager()
-                    .hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
-            if (!hardwareSupportsBLE) {
-                LOG.w(TAG, "This hardware does not support Bluetooth Low Energy.");
-                throw BLEComError.bleNotAvailable();
-            }
-            BluetoothManager bluetoothManager = (BluetoothManager) activity.getSystemService(Context.BLUETOOTH_SERVICE);
-            if (bluetoothManager == null) {
-                throw BLEComError.bleNotAvailable();
-            }
-            bluetoothAdapter = bluetoothManager.getAdapter();
-        }
-
-    }
-
-    private void startScan(@Nullable RequestDeviceOptions options, @NonNull PluginResponse pluginResponse) {
-        if (pluginResponseDiscoverDevice != null && pluginResponseDiscoverDevice != pluginResponse) {
-            Log.w(TAG, "Scan is already started...");
-        }
-        this.startBLEScanner(options, pluginResponse);
-    }
-
-
-    private void startBLEScanner(@Nullable RequestDeviceOptions options, @NonNull PluginResponse pluginResponse) {
-        pluginResponseDiscoverDevice = pluginResponse;
-
-        if (!PermissionHelper.hasPermission(this, ACCESS_FINE_LOCATION)) {
-            permissionCallback = pluginResponse;
-            PermissionHelper.requestPermission(this, REQUEST_SCAN_PERMISSIONS, ACCESS_FINE_LOCATION);
-            return;
-        }
-
-        this.requestDeviceOptions = options;
-        Log.d(TAG, "startBLEScanner() options: " + options);
-
-        if (this.scanner != null) {
-            this.scanner.stop();
-        }
-        if (options != null) {
-            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter(), options.getScanFilters());
-        } else {
-            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter());
-        }
-
-        if (onDeviceDiscoveredCallback == null) {
-            this.onDeviceDiscoveredCallback = new IOnDeviceDiscovered<BLEScanner.BLEScanData>() {
-                @Override
-                public void onDeviceDiscovered(BLEScanner.BLEScanData device) {
-                    Log.d(TAG, "Device discovered: " + device);
-                    if (pluginResponseDiscoverDevice != null) {
-                        try {
-                            pluginResponseDiscoverDevice.newResult(
-                                    JSONBuilder.toJSONObject(device)
-                            );
-                        } catch (Throwable e) {
-                            pluginResponseDiscoverDevice.newResult(BLEComError.internalError(e));
-                        }
-                    } else {
-                        Log.w(TAG, "Discovered device but no listener has been setup");
-                    }
-                }
-
-                @Override
-                public void onDeviceLost(BLEScanner.BLEScanData bleScanData) {
-                    Log.w(TAG, "Device lost" + bleScanData);
-                }
-
-                @Override
-                public void onScanFailed(Throwable throwable) {
-                    Log.w(TAG, "Scan failed", throwable);
-                    if (pluginResponseDiscoverDevice != null) {
-                        pluginResponseDiscoverDevice.error(BLEComError.internalError(throwable));
-                    }
-                }
-
-            };
-        }
-        this.scanner.setOnDeviceDiscoveredCallback(this.onDeviceDiscoveredCallback);
-        pluginResponse.newResult("Ok");
-        this.scanner.start();
-    }
-
-    @SuppressLint("NewApi")
-    private void stopScan(PluginResponse pluginResponse) {
-        pluginResponseDiscoverDevice = null;
-        if (scanner == null || !scanner.isEnabled()) {
-            Log.w(TAG, "Scanner is not running");
-            pluginResponse.success();
-            return;
-        }
-        scanner.stop();
-        pluginResponse.success();
-    }
-
-    private void getLastError(PluginResponse pluginResponse) {
-        throw new Error("Not implemented yet");
-    }
-
-    private void disconnect(final PluginResponse pluginResponse, String macAddress) {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-
-        executeAsync(() -> {
-            try {
-                peripheral.disconnect();
-                pluginResponse.success();
-            } catch (Exception e) {
-                pluginResponse.error(new BLEComError(BLEComError.Code.DISCONNECTION_ERROR, e));
-            }
-        });
-    }
-
-    private void close(final PluginResponse pluginResponse, String macAddress) {
-        executeAsync(() -> {
-            try {
-                BLEProtocol peripheral = peripherals.getIfExists(macAddress);
-                if (peripheral != null) {
-                    peripheral.getGatt().close();
-                    peripherals.remove(macAddress);
-                }
-                pluginResponse.success();
-            } catch (Exception e) {
-                pluginResponse.error(new BLEComError(BLEComError.Code.DISCONNECTION_ERROR, e));
-            }
-        });
-    }
-
-    private void requestMtu(final PluginResponse pluginResponse, String macAddress, int mtu) {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-        BluetoothGatt gatt = peripheral.getGatt();
-        peripheral.requestMtuSize(gatt, mtu, new BLEProtocol.OnGattOperationCallback() {
-            @Override
-            public void onResult(int statusCode) {
-                if (statusCode == BluetoothGatt.GATT_SUCCESS) {
-                    pluginResponse.success();
-                } else {
-                    pluginResponse.error(BLEComError.statusCodeError(statusCode));
-                }
-            }
-
-            @Override
-            public void onError(Exception ex) {
-                pluginResponse.error(BLEComError.internalError(ex));
-            }
-        });
-    }
-
-    private void sendLwm2mTapRequest(PluginResponse pluginResponse, String deviceId, byte[] data) throws BLEComError {
-        if (deviceId == null) {
-            throw new IllegalArgumentException("Device id must not be null");
-        }
-        Log.d(TAG, SEND_REQUEST + " " + deviceId + " 0x" + Helper.ByteArrayToHexString(data));
-
-        BLEProtocol peripheral = peripherals.get(deviceId);
-        executeAsync(() -> {
-            try {
-                byte[] response = peripheral.send(data);
-                pluginResponse.success(response);
-            } catch (Exception e) {
-                pluginResponse.error(BLEComError.lwM2MTapRequestError(e, deviceId, data));
-            }
-        });
-    }
-
-    private void readCharacteristicValue(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
-        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
-        characteristic.read(new CharacteristicAdapter.OnCharacteristicOperationResult() {
-            @Override
-            public void onResult(@NotNull BluetoothGattCharacteristic characteristic, int i) {
-                if (i == BluetoothGatt.GATT_SUCCESS) {
-                    pluginResponse.success(characteristic.getValue());
-                } else {
-                    pluginResponse.error(BLEComError.statusCodeError(i));
-                }
-            }
-
-            @Override
-            public void onError(@NotNull BluetoothGattCharacteristic characteristic, @NotNull Exception e) {
-                pluginResponse.error(BLEComError.internalError(e));
-            }
-        });
-    }
-
-    private void writeCharacteristic(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID,
-                                     byte[] data, int writeType) throws BLEComError, WritePacketIsTooBigException, CannotWriteCharacteristicException, CharacteristicNotAvailableException, ServiceNotAvailableException {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-
-        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
-        characteristic.write(peripheral.getGatt(), data, writeType, pluginResponse.createOnResultAdapter());
-    }
-
-    private void startNotification(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
-        characteristic.startNotification(peripheral.getGatt(), pluginResponse.createOnResultAdapter());
-    }
-
-    private void stopNotification(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
-        characteristic.stopNotification(peripheral.getGatt(), pluginResponse.createOnResultAdapter());
-        pluginResponse.success();
-    }
-
-    private CharacteristicAdapter getDeviceServiceCharacteristicAdapter(String macAddress, UUID serviceUUID, UUID characteristicUUID) throws CharacteristicNotAvailableException, ServiceNotAvailableException {
-        BLEProtocol peripheral = peripherals.get(macAddress);
-        return peripheral.getCharacteristicAdapter(serviceUUID, characteristicUUID);
-    }
-
-    private void executeAsync(Runnable runnable) {
-        cordova.getThreadPool().execute(runnable);
-        //runnable.run();
-    }
-
-    private void connect(PluginResponse pluginResponse, String macAddress) throws BLEComError {
-        BLEProtocol finalPeripheral = this.getOrCreatePeripheral(macAddress, null);
-        setConnectionStateCallback(pluginResponse, macAddress);
-        if (finalPeripheral.isConnected()) {
-            pluginResponse.newResult("CONNECTED");
-            return;
-        }
-        executeAsync(() -> {
-            try {
-                finalPeripheral.bleConnect();
-                pluginResponse.newResult("CONNECTED");
-            } catch (Exception e) {
-                pluginResponse.error(BLEComError.connectionError(e));
-            }
-        });
-    }
-
-    private void connectAndDiscoverTapServices(PluginResponse pluginResponse, String macAddress) throws BLEComError {
-        BLEProtocol finalPeripheral = this.getOrCreatePeripheral(macAddress, null);
-        setConnectionStateCallback(pluginResponse, macAddress);
-        if (finalPeripheral.isConnected()) {
-            pluginResponse.newResult("CONNECTED");
-            return;
-        }
-        executeAsync(() -> {
-            try {
-                finalPeripheral.connect();
-                pluginResponse.newResult("CONNECTED");
-            } catch (Exception e) {
-                pluginResponse.error(BLEComError.connectionError(e));
-            }
-        });
-    }
-
-    private BLEProtocol getOrCreatePeripheral(@NonNull String macAddress, @Nullable Integer initialMTU) throws BLEComError {
-        BLEProtocol peripheral = peripherals.getIfExists(macAddress);
-        if (peripheral == null) {
-            if (!BluetoothAdapter.checkBluetoothAddress(macAddress)) {
-                throw BLEComError.invalidMacAddress(macAddress);
-            }
-            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(macAddress);
-            peripheral = new BLEProtocol(cordova.getActivity(), device);
-            peripherals.put(macAddress, peripheral);
-            if (initialMTU != null) {
-                peripheral.setMTU(initialMTU);
-            }
-        }
-        return peripheral;
-    }
-
-    /* @Override */
-    public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
-        for (int result : grantResults) {
-            if (result == PackageManager.PERMISSION_DENIED) {
-                LOG.d(TAG, "User *rejected* Coarse Location Access");
-                if (permissionCallback != null) {
-                    this.permissionCallback.error("Location permission not granted.");
-                }
-                return;
-            }
-        }
-
-        switch (requestCode) {
-            case REQUEST_SCAN_PERMISSIONS:
-                LOG.d(TAG, "User granted scan permissions");
-                this.startScan(this.requestDeviceOptions, pluginResponseDiscoverDevice);
-                this.permissionCallback = null;
-                break;
-        }
-    }
-
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-
-        if (requestCode == REQUEST_ENABLE_BLUETOOTH) {
-
-            if (resultCode == Activity.RESULT_OK) {
-                LOG.d(TAG, "User enabled Bluetooth");
-                if (enableBluetoothCallback != null) {
-                    enableBluetoothCallback.success();
-                }
-            } else {
-                LOG.d(TAG, "User did *NOT* enable Bluetooth");
-                if (enableBluetoothCallback != null) {
-                    enableBluetoothCallback.error("User did not enable Bluetooth");
-                }
-            }
-
-            enableBluetoothCallback = null;
-        }
-    }
-
-    private void setConnectionStateCallback(PluginResponse pluginResponse, String macAddress) {
-        BLEProtocol peripheral = peripherals.getIfExists(macAddress);
-        if (peripheral == null) {
-            pluginResponse.error(BLEComError.illegalAction("unregistered peripheral"));
-            return;
-        }
-        peripheral.addOnConnectionStatusChangeListener(
-                (newConnectionState, oldConnectionState) -> {
-                    LOG.d(TAG, "Old State: " + oldConnectionState + ", New State: " + newConnectionState);
-                    pluginResponse.newResult(newConnectionState.toString());
-                });
-    }
+//
+//  Copyright 2018 IoTize SAS Inc.  Licensed under the MIT license. 
+//
+//  BLECom.java
+//  device-com-ble.cordova BLE Cordova Plugin
+//
+
+package com.iotize.plugin.cordova.ble;
+
+import static android.Manifest.permission.ACCESS_FINE_LOCATION;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.util.Log;
+
+import com.iotize.android.communication.protocol.ble.BLEProtocol;
+import com.iotize.android.communication.protocol.ble.DeviceManager;
+import com.iotize.android.communication.protocol.ble.characteristics.CharacteristicAdapter;
+import com.iotize.android.communication.protocol.ble.exception.CannotWriteCharacteristicException;
+import com.iotize.android.communication.protocol.ble.exception.CharacteristicNotAvailableException;
+import com.iotize.android.communication.protocol.ble.exception.ServiceNotAvailableException;
+import com.iotize.android.communication.protocol.ble.exception.WritePacketIsTooBigException;
+import com.iotize.android.communication.protocol.ble.scanner.BLEScanner;
+import com.iotize.android.core.util.Helper;
+import com.iotize.android.device.api.device.scanner.IOnDeviceDiscovered;
+import com.iotize.plugin.cordova.ble.models.RequestDeviceOptions;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.LOG;
+import org.apache.cordova.PermissionHelper;
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
+
+import java.util.List;
+import java.util.UUID;
+
+import io.reactivex.annotations.NonNull;
+import io.reactivex.annotations.Nullable;
+
+public class BLECom extends CordovaPlugin {
+    // actions
+    private static final String CONNECT = "connect";
+    private static final String CONNECT_AND_DISCOVER_TAP_SERVICES = "connectAndDiscoverTapServices";
+    private static final String DISCONNECT = "disConnect";
+    private static final String CLOSE = "close";
+    private static final String SEND_REQUEST = "sendRequest";
+    private static final String GET_LAST_ERROR = "getLastError";
+    private static final String START_SCAN = "startScan";
+    private static final String STOP_SCAN = "stopScan";
+    private static final String IS_ENABLED = "isEnabled";
+    private static final String CHECK_AVAILABLE = "checkAvailable";
+    private static final String IS_CONNECTED = "isConnected";
+    private static final String ENABLE = "enable";
+    private static final String REQUEST_MTU = "requestMtu";
+
+    // New
+    private static final String CHARACTERISTIC_READ = "characteristicRead";
+    private static final String CHARACTERISTIC_WRITE = "characteristicWrite";
+    private static final String CHARACTERISTIC_WRITE_WITHOUT_RESPONSE = "characteristicWriteWithoutResponse";
+    private static final String START_NOTIFICATION = "characteristicStartNotification";
+    private static final String STOP_NOTIFICATION = "characteristicStopNotification";
+    private static final String CHARACTERISTIC_CHANGED = "characteristicChanged";
+    private static final String DISCOVER_SERVICES = "discoverServices";
+
+
+    private static final int REQUEST_ENABLE_BLUETOOTH = 1;
+    private static final int REQUEST_SCAN_PERMISSIONS = 2;
+
+    private static final String TAG = "BLECom";
+    private DeviceManager<BLEProtocol> peripherals;
+    private BluetoothAdapter bluetoothAdapter;
+    private PluginResponse enableBluetoothCallback;
+    private PluginResponse pluginResponseDiscoverDevice;
+    private PluginResponse permissionCallback;
+    private BLEScanner scanner;
+    private IOnDeviceDiscovered<BLEScanner.BLEScanData> onDeviceDiscoveredCallback;
+    @Nullable
+    private RequestDeviceOptions requestDeviceOptions;
+
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+
+        this.peripherals = new DeviceManager<>();
+        Log.d(TAG, "Initializing IoTizeBLE Plugin");
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+    }
+
+    @SuppressLint("MissingPermission")
+    public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) {
+
+        PluginResponse pluginResponse = new PluginResponse(
+                action,
+                args,
+                callbackContext
+        );
+        ArgsHelper argsHelper = new ArgsHelper(args);
+        try {
+            this.setupBluetoothAdapter();
+            if (action.equals(STOP_SCAN)) {
+                Log.d(TAG, STOP_SCAN);
+                this.stopScan(pluginResponse);
+            } else if (action.equals(START_SCAN)) {
+                Log.d(TAG, START_SCAN);
+                RequestDeviceOptions scanOptions = null;
+                if (argsHelper.length() > 0) {
+                    scanOptions = argsHelper.parseJSONAt(0, RequestDeviceOptions.class);
+                }
+                this.startScan(scanOptions, pluginResponse);
+            } else if (action.equals(CONNECT)) {
+                Log.d(TAG, CONNECT);
+                String macAddress = argsHelper.getString(0);
+                this.connect(pluginResponse, macAddress);
+            } else if (action.equals(REQUEST_MTU)) {
+                Log.d(TAG, REQUEST_MTU);
+                String macAddress = argsHelper.getString(0);
+                int mtu = argsHelper.getInt(1);
+                this.requestMtu(pluginResponse, macAddress, mtu);
+            } else if (action.equals(CONNECT_AND_DISCOVER_TAP_SERVICES)) {
+                Log.d(TAG, CONNECT_AND_DISCOVER_TAP_SERVICES);
+                String macAddress = argsHelper.getString(0);
+                this.connectAndDiscoverTapServices(pluginResponse, macAddress);
+            } else if (action.equals(DISCONNECT)) {
+                Log.d(TAG, DISCONNECT);
+                String macAddress = argsHelper.getString(0);
+                this.disconnect(pluginResponse, macAddress);
+            } else if (action.equals(CLOSE)) {
+                Log.d(TAG, CLOSE);
+                String macAddress = argsHelper.getString(0);
+                this.close(pluginResponse, macAddress);
+            } else if (action.equals(GET_LAST_ERROR)) {
+                Log.d(TAG, GET_LAST_ERROR);
+                this.getLastError(pluginResponse);
+            } else if (action.equals(SEND_REQUEST)) {
+                String deviceId = argsHelper.getString(0);
+                byte[] data = argsHelper.getBytes(1);
+                this.sendLwm2mTapRequest(pluginResponse, deviceId, data);
+            } else if (action.equals(CHECK_AVAILABLE) || action.equals(IS_ENABLED)) {
+                pluginResponse.success(bluetoothAdapter.isEnabled());
+            } else if (action.equals(IS_CONNECTED)) {
+                String macAddress = argsHelper.getString(0);
+                boolean isConnected = peripherals.get(macAddress).isConnected();
+                pluginResponse.success(isConnected);
+            } else if (action.equals(ENABLE)) {
+                if (enableBluetoothCallback != null) {
+                    Log.w(TAG, "There is already an enable request pending...");
+                }
+                enableBluetoothCallback = pluginResponse;
+                Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
+                cordova.startActivityForResult(this, intent, REQUEST_ENABLE_BLUETOOTH);
+            } else if (action.equals(CHARACTERISTIC_READ)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                this.readCharacteristicValue(pluginResponse, macAddress, serviceUUID, characteristicUUID);
+            } else if (action.equals(CHARACTERISTIC_WRITE)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                byte[] data = argsHelper.getBytes(3);
+                this.writeCharacteristic(pluginResponse, macAddress, serviceUUID, characteristicUUID, data, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
+            } else if (action.equals(CHARACTERISTIC_WRITE_WITHOUT_RESPONSE)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                byte[] data = argsHelper.getBytes(3);
+                this.writeCharacteristic(pluginResponse, macAddress, serviceUUID, characteristicUUID, data, BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
+            } else if (action.equals(START_NOTIFICATION)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                this.startNotification(pluginResponse, macAddress, serviceUUID, characteristicUUID);
+            } else if (action.equals(STOP_NOTIFICATION)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                this.stopNotification(pluginResponse, macAddress, serviceUUID, characteristicUUID);
+            } else if (action.equals(CHARACTERISTIC_CHANGED)) {
+                String macAddress = argsHelper.getString(0);
+                UUID serviceUUID = argsHelper.getUUID(1);
+                UUID characteristicUUID = argsHelper.getUUID(2);
+                this.listenToCharacteristicChange(pluginResponse, macAddress, serviceUUID, characteristicUUID);
+            } else if (action.equals(DISCOVER_SERVICES)) {
+                String macAddress = argsHelper.getString(0);
+                this.discoverServices(pluginResponse, macAddress);
+            } else {
+                throw BLEComError.illegalAction("Illegal action " + action);
+            }
+            return true;
+        } catch (BLEComError err) {
+            pluginResponse.error(err);
+            return false;
+        } catch (Throwable err) {
+            pluginResponse.error(BLEComError.internalError(err));
+            return false;
+        }
+
+    }
+
+    private void discoverServices(PluginResponse pluginResponse, String macAddress) throws Exception {
+        // TODO async ? 
+        BLEProtocol peripheral = peripherals.get(macAddress);
+        peripheral.discoverServices();
+        List<BluetoothGattService> services = peripheral.getGatt().getServices();
+        pluginResponse.success(JSONBuilder.toServicesDescription(services));
+    }
+
+    private void listenToCharacteristicChange(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws CharacteristicNotAvailableException, ServiceNotAvailableException {
+        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
+        characteristic.onValueChanged(new CharacteristicAdapter.OnCharacteristicValueChangedCallback() {
+            @Override
+            public void onCharacteristicValueChanged(byte[] bytes) {
+                pluginResponse.newResult(bytes);
+            }
+        });
+    }
+
+    private void setupBluetoothAdapter() throws BLEComError {
+        if (bluetoothAdapter == null) {
+            Activity activity = cordova.getActivity();
+            boolean hardwareSupportsBLE = activity.getApplicationContext()
+                    .getPackageManager()
+                    .hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE);
+            if (!hardwareSupportsBLE) {
+                LOG.w(TAG, "This hardware does not support Bluetooth Low Energy.");
+                throw BLEComError.bleNotAvailable();
+            }
+            BluetoothManager bluetoothManager = (BluetoothManager) activity.getSystemService(Context.BLUETOOTH_SERVICE);
+            if (bluetoothManager == null) {
+                throw BLEComError.bleNotAvailable();
+            }
+            bluetoothAdapter = bluetoothManager.getAdapter();
+        }
+
+    }
+
+    private void startScan(@Nullable RequestDeviceOptions options, @NonNull PluginResponse pluginResponse) {
+        if (pluginResponseDiscoverDevice != null && pluginResponseDiscoverDevice != pluginResponse) {
+            Log.w(TAG, "Scan is already started...");
+        }
+        this.startBLEScanner(options, pluginResponse);
+    }
+
+
+    private void startBLEScanner(@Nullable RequestDeviceOptions options, @NonNull PluginResponse pluginResponse) {
+        pluginResponseDiscoverDevice = pluginResponse;
+
+        if (!PermissionHelper.hasPermission(this, ACCESS_FINE_LOCATION)) {
+            permissionCallback = pluginResponse;
+            PermissionHelper.requestPermission(this, REQUEST_SCAN_PERMISSIONS, ACCESS_FINE_LOCATION);
+            return;
+        }
+
+        this.requestDeviceOptions = options;
+        Log.d(TAG, "startBLEScanner() options: " + options);
+
+        if (this.scanner != null) {
+            this.scanner.stop();
+        }
+        if (options != null) {
+            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter(), options.getScanFilters());
+        } else {
+            this.scanner = new BLEScanner(cordova.getContext(), BluetoothAdapter.getDefaultAdapter());
+        }
+
+        if (onDeviceDiscoveredCallback == null) {
+            this.onDeviceDiscoveredCallback = new IOnDeviceDiscovered<BLEScanner.BLEScanData>() {
+                @Override
+                public void onDeviceDiscovered(BLEScanner.BLEScanData device) {
+                    Log.d(TAG, "Device discovered: " + device);
+                    if (pluginResponseDiscoverDevice != null) {
+                        try {
+                            pluginResponseDiscoverDevice.newResult(
+                                    JSONBuilder.toJSONObject(device)
+                            );
+                        } catch (Throwable e) {
+                            pluginResponseDiscoverDevice.newResult(BLEComError.internalError(e));
+                        }
+                    } else {
+                        Log.w(TAG, "Discovered device but no listener has been setup");
+                    }
+                }
+
+                @Override
+                public void onDeviceLost(BLEScanner.BLEScanData bleScanData) {
+                    Log.w(TAG, "Device lost" + bleScanData);
+                }
+
+                @Override
+                public void onScanFailed(Throwable throwable) {
+                    Log.w(TAG, "Scan failed", throwable);
+                    if (pluginResponseDiscoverDevice != null) {
+                        pluginResponseDiscoverDevice.error(BLEComError.internalError(throwable));
+                    }
+                }
+
+            };
+        }
+        this.scanner.setOnDeviceDiscoveredCallback(this.onDeviceDiscoveredCallback);
+        pluginResponse.newResult("Ok");
+        this.scanner.start();
+    }
+
+    @SuppressLint("NewApi")
+    private void stopScan(PluginResponse pluginResponse) {
+        pluginResponseDiscoverDevice = null;
+        if (scanner == null || !scanner.isEnabled()) {
+            Log.w(TAG, "Scanner is not running");
+            pluginResponse.success();
+            return;
+        }
+        scanner.stop();
+        pluginResponse.success();
+    }
+
+    private void getLastError(PluginResponse pluginResponse) {
+        throw new Error("Not implemented yet");
+    }
+
+    private void disconnect(final PluginResponse pluginResponse, String macAddress) {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+
+        executeAsync(() -> {
+            try {
+                peripheral.disconnect();
+                pluginResponse.success();
+            } catch (Exception e) {
+                pluginResponse.error(new BLEComError(BLEComError.Code.DISCONNECTION_ERROR, e));
+            }
+        });
+    }
+
+    private void close(final PluginResponse pluginResponse, String macAddress) {
+        executeAsync(() -> {
+            try {
+                BLEProtocol peripheral = peripherals.getIfExists(macAddress);
+                if (peripheral != null) {
+                    peripheral.getGatt().close();
+                    peripherals.remove(macAddress);
+                }
+                pluginResponse.success();
+            } catch (Exception e) {
+                pluginResponse.error(new BLEComError(BLEComError.Code.DISCONNECTION_ERROR, e));
+            }
+        });
+    }
+
+    private void requestMtu(final PluginResponse pluginResponse, String macAddress, int mtu) {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+        BluetoothGatt gatt = peripheral.getGatt();
+        peripheral.requestMtuSize(gatt, mtu, new BLEProtocol.OnGattOperationCallback() {
+            @Override
+            public void onResult(int statusCode) {
+                if (statusCode == BluetoothGatt.GATT_SUCCESS) {
+                    pluginResponse.success();
+                } else {
+                    pluginResponse.error(BLEComError.statusCodeError(statusCode));
+                }
+            }
+
+            @Override
+            public void onError(Exception ex) {
+                pluginResponse.error(BLEComError.internalError(ex));
+            }
+        });
+    }
+
+    private void sendLwm2mTapRequest(PluginResponse pluginResponse, String deviceId, byte[] data) throws BLEComError {
+        if (deviceId == null) {
+            throw new IllegalArgumentException("Device id must not be null");
+        }
+        Log.d(TAG, SEND_REQUEST + " " + deviceId + " 0x" + Helper.ByteArrayToHexString(data));
+
+        BLEProtocol peripheral = peripherals.get(deviceId);
+        executeAsync(() -> {
+            try {
+                byte[] response = peripheral.send(data);
+                pluginResponse.success(response);
+            } catch (Exception e) {
+                pluginResponse.error(BLEComError.lwM2MTapRequestError(e, deviceId, data));
+            }
+        });
+    }
+
+    private void readCharacteristicValue(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
+        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
+        characteristic.read(new CharacteristicAdapter.OnCharacteristicOperationResult() {
+            @Override
+            public void onResult(@NotNull BluetoothGattCharacteristic characteristic, int i) {
+                if (i == BluetoothGatt.GATT_SUCCESS) {
+                    pluginResponse.success(characteristic.getValue());
+                } else {
+                    pluginResponse.error(BLEComError.statusCodeError(i));
+                }
+            }
+
+            @Override
+            public void onError(@NotNull BluetoothGattCharacteristic characteristic, @NotNull Exception e) {
+                pluginResponse.error(BLEComError.internalError(e));
+            }
+        });
+    }
+
+    private void writeCharacteristic(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID,
+                                     byte[] data, int writeType) throws BLEComError, WritePacketIsTooBigException, CannotWriteCharacteristicException, CharacteristicNotAvailableException, ServiceNotAvailableException {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+
+        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
+        characteristic.write(peripheral.getGatt(), data, writeType, pluginResponse.createOnResultAdapter());
+    }
+
+    private void startNotification(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
+        characteristic.startNotification(peripheral.getGatt(), pluginResponse.createOnResultAdapter());
+    }
+
+    private void stopNotification(PluginResponse pluginResponse, String macAddress, UUID serviceUUID, UUID characteristicUUID) throws BLEComError, CharacteristicNotAvailableException, ServiceNotAvailableException {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+        CharacteristicAdapter characteristic = this.getDeviceServiceCharacteristicAdapter(macAddress, serviceUUID, characteristicUUID);
+        characteristic.stopNotification(peripheral.getGatt(), pluginResponse.createOnResultAdapter());
+        pluginResponse.success();
+    }
+
+    private CharacteristicAdapter getDeviceServiceCharacteristicAdapter(String macAddress, UUID serviceUUID, UUID characteristicUUID) throws CharacteristicNotAvailableException, ServiceNotAvailableException {
+        BLEProtocol peripheral = peripherals.get(macAddress);
+        return peripheral.getCharacteristicAdapter(serviceUUID, characteristicUUID);
+    }
+
+    private void executeAsync(Runnable runnable) {
+        cordova.getThreadPool().execute(runnable);
+        //runnable.run();
+    }
+
+    private void connect(PluginResponse pluginResponse, String macAddress) throws BLEComError {
+        BLEProtocol finalPeripheral = this.getOrCreatePeripheral(macAddress, null);
+        setConnectionStateCallback(pluginResponse, macAddress);
+        if (finalPeripheral.isConnected()) {
+            pluginResponse.newResult("CONNECTED");
+            return;
+        }
+        executeAsync(() -> {
+            try {
+                finalPeripheral.bleConnect();
+                pluginResponse.newResult("CONNECTED");
+            } catch (Exception e) {
+                pluginResponse.error(BLEComError.connectionError(e));
+            }
+        });
+    }
+
+    private void connectAndDiscoverTapServices(PluginResponse pluginResponse, String macAddress) throws BLEComError {
+        BLEProtocol finalPeripheral = this.getOrCreatePeripheral(macAddress, null);
+        setConnectionStateCallback(pluginResponse, macAddress);
+        if (finalPeripheral.isConnected()) {
+            pluginResponse.newResult("CONNECTED");
+            return;
+        }
+        executeAsync(() -> {
+            try {
+                finalPeripheral.connect();
+                pluginResponse.newResult("CONNECTED");
+            } catch (Exception e) {
+                pluginResponse.error(BLEComError.connectionError(e));
+            }
+        });
+    }
+
+    private BLEProtocol getOrCreatePeripheral(@NonNull String macAddress, @Nullable Integer initialMTU) throws BLEComError {
+        BLEProtocol peripheral = peripherals.getIfExists(macAddress);
+        if (peripheral == null) {
+            if (!BluetoothAdapter.checkBluetoothAddress(macAddress)) {
+                throw BLEComError.invalidMacAddress(macAddress);
+            }
+            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(macAddress);
+            peripheral = new BLEProtocol(cordova.getActivity(), device);
+            peripheral.setConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_BALANCED);
+            peripherals.put(macAddress, peripheral);
+            if (initialMTU != null) {
+                peripheral.setMTU(initialMTU);
+            }
+        }
+        return peripheral;
+    }
+
+    /* @Override */
+    public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
+        for (int result : grantResults) {
+            if (result == PackageManager.PERMISSION_DENIED) {
+                LOG.d(TAG, "User *rejected* Coarse Location Access");
+                if (permissionCallback != null) {
+                    this.permissionCallback.error("Location permission not granted.");
+                }
+                return;
+            }
+        }
+
+        switch (requestCode) {
+            case REQUEST_SCAN_PERMISSIONS:
+                LOG.d(TAG, "User granted scan permissions");
+                this.startScan(this.requestDeviceOptions, pluginResponseDiscoverDevice);
+                this.permissionCallback = null;
+                break;
+        }
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+
+        if (requestCode == REQUEST_ENABLE_BLUETOOTH) {
+
+            if (resultCode == Activity.RESULT_OK) {
+                LOG.d(TAG, "User enabled Bluetooth");
+                if (enableBluetoothCallback != null) {
+                    enableBluetoothCallback.success();
+                }
+            } else {
+                LOG.d(TAG, "User did *NOT* enable Bluetooth");
+                if (enableBluetoothCallback != null) {
+                    enableBluetoothCallback.error("User did not enable Bluetooth");
+                }
+            }
+
+            enableBluetoothCallback = null;
+        }
+    }
+
+    private void setConnectionStateCallback(PluginResponse pluginResponse, String macAddress) {
+        BLEProtocol peripheral = peripherals.getIfExists(macAddress);
+        if (peripheral == null) {
+            pluginResponse.error(BLEComError.illegalAction("unregistered peripheral"));
+            return;
+        }
+        peripheral.addOnConnectionStatusChangeListener(
+                (newConnectionState, oldConnectionState) -> {
+                    LOG.d(TAG, "Old State: " + oldConnectionState + ", New State: " + newConnectionState);
+                    pluginResponse.newResult(newConnectionState.toString());
+                });
+    }
 }