react-native-ble-manager 8.4.4 → 8.6.0

package/README.md

@@ -691,12 +691,12 @@ The scanning for peripherals is ended.
 
 **Arguments**
 
-- `none`
+- `status` - `Number` - [iOS] the reason for stopping the scan. Error code 10 is used for timeouts, 0 covers everything else. [Android] the reason for stopping the scan (<https://developer.android.com/reference/android/bluetooth/le/ScanCallback#constants_1>). Error code 10 is used for timeouts
 
 **Examples**
 
 ```js
-bleManagerEmitter.addListener("BleManagerStopScan", () => {
+bleManagerEmitter.addListener("BleManagerStopScan", (args) => {
   // Scanning is stopped
 });
 ```

package/android/src/main/java/it/innove/BleManager.java

@@ -218,6 +218,7 @@ class BleManager extends ReactContextBaseJavaModule {
         if (scanManager != null) {
             scanManager.stopScan(callback);
             WritableMap map = Arguments.createMap();
+						map.putInt("status", 0);
             sendEvent("BleManagerStopScan", map);
         }
     }
@@ -290,8 +291,7 @@ class BleManager extends ReactContextBaseJavaModule {
 
         Peripheral peripheral = peripherals.get(peripheralUUID);
         if (peripheral != null) {
-            peripheral.disconnect(force);
-            callback.invoke();
+            peripheral.disconnect(callback, force);
         } else
             callback.invoke("Peripheral not found");
     }
@@ -589,7 +589,7 @@ class BleManager extends ReactContextBaseJavaModule {
             synchronized (peripherals) {
                 for (Peripheral peripheral : peripherals.values()) {
                     if (peripheral.isConnected()) {
-                        peripheral.disconnect(true);
+                        peripheral.disconnect(null,true);
                     }
                 }
             }

package/android/src/main/java/it/innove/LegacyScanManager.java

@@ -80,6 +80,7 @@ public class LegacyScanManager extends ScanManager {
 									btAdapter.stopLeScan(mLeScanCallback);
 								}
 								WritableMap map = Arguments.createMap();
+								map.putInt("status", 0);
 								bleManager.sendEvent("BleManagerStopScan", map);
 							}
 						}

package/android/src/main/java/it/innove/LollipopScanManager.java

@@ -39,7 +39,7 @@ public class LollipopScanManager extends ScanManager {
         ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder();
         List<ScanFilter> filters = new ArrayList<>();
 
-        if (options.hasKey("legacy")) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && options.hasKey("legacy")) {
             scanSettingsBuilder.setLegacy(options.getBoolean("legacy"));
         }
         
@@ -101,6 +101,7 @@ public class LollipopScanManager extends ScanManager {
                                     btAdapter.getBluetoothLeScanner().stopScan(mScanCallback);
                                 }
                                 WritableMap map = Arguments.createMap();
+																map.putInt("status", 10);
                                 bleManager.sendEvent("BleManagerStopScan", map);
                             }
                         }
@@ -145,6 +146,7 @@ public class LollipopScanManager extends ScanManager {
 		@Override
 		public void onScanFailed(final int errorCode) {
             WritableMap map = Arguments.createMap();
+						map.putInt("status", errorCode);
             bleManager.sendEvent("BleManagerStopScan", map);
 		}
 	};

package/android/src/main/java/it/innove/Peripheral.java

@@ -28,12 +28,12 @@ import org.json.JSONException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Map;
-import java.util.HashMap;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.UUID;
 import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
 import static android.os.Build.VERSION_CODES.LOLLIPOP;
@@ -50,10 +50,10 @@ public class Peripheral extends BluetoothGattCallback {
 
 	private final BluetoothDevice device;
 	private final Map<String, NotifyBufferContainer> bufferedCharacteristics;
-	protected byte[] advertisingDataBytes = new byte[0];
-	protected int advertisingRSSI;
-	private boolean connected = false;
-	private boolean connecting = false;
+	protected volatile byte[] advertisingDataBytes = new byte[0];
+	protected volatile int advertisingRSSI;
+	private volatile boolean connected = false;
+	private volatile boolean connecting = false;
 	private ReactContext reactContext;
 
 	private BluetoothGatt gatt;
@@ -75,7 +75,7 @@ public class Peripheral extends BluetoothGattCallback {
 
 	public Peripheral(BluetoothDevice device, int advertisingRSSI, byte[] scanRecord, ReactContext reactContext) {
 		this.device = device;
-		this.bufferedCharacteristics = new HashMap<String, NotifyBufferContainer>();
+		this.bufferedCharacteristics = new ConcurrentHashMap<String, NotifyBufferContainer>();
 		this.advertisingRSSI = advertisingRSSI;
 		this.advertisingDataBytes = scanRecord;
 		this.reactContext = reactContext;
@@ -83,12 +83,14 @@ public class Peripheral extends BluetoothGattCallback {
 
 	public Peripheral(BluetoothDevice device, ReactContext reactContext) {
 		this.device = device;
-		this.bufferedCharacteristics = new HashMap<String, NotifyBufferContainer>();
+		this.bufferedCharacteristics = new ConcurrentHashMap<String, NotifyBufferContainer>();
 		this.reactContext = reactContext;
 	}
 
 	private void sendEvent(String eventName, @Nullable WritableMap params) {
-		reactContext.getJSModule(RCTNativeAppEventEmitter.class).emit(eventName, params);
+		synchronized (reactContext) {
+			reactContext.getJSModule(RCTNativeAppEventEmitter.class).emit(eventName, params);
+		}
 	}
 
 	private void sendConnectionEvent(BluetoothDevice device, String eventName, int status) {
@@ -101,61 +103,67 @@ public class Peripheral extends BluetoothGattCallback {
 		Log.d(BleManager.LOG_TAG, "Peripheral event (" + eventName + "):" + device.getAddress());
 	}
 
-	public void connect(Callback callback, Activity activity) {
-		if (!connected) {
-			BluetoothDevice device = getDevice();
-			this.connectCallback = callback;
-			this.connecting = true;
-			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-				Log.d(BleManager.LOG_TAG, " Is Or Greater than M $mBluetoothDevice");
-				gatt = device.connectGatt(activity, false, this, BluetoothDevice.TRANSPORT_LE);
-			} else {
-				Log.d(BleManager.LOG_TAG, " Less than M");
-				try {
-					Log.d(BleManager.LOG_TAG, " Trying TRANPORT LE with reflection");
-					Method m = device.getClass().getDeclaredMethod("connectGatt", Context.class, Boolean.class,
-							BluetoothGattCallback.class, Integer.class);
-					m.setAccessible(true);
-					Integer transport = device.getClass().getDeclaredField("TRANSPORT_LE").getInt(null);
-					gatt = (BluetoothGatt) m.invoke(device, activity, false, this, transport);
-				} catch (Exception e) {
-					e.printStackTrace();
-					Log.d(TAG, " Catch to call normal connection");
-					gatt = device.connectGatt(activity, false, this);
+	public void connect(final Callback callback, Activity activity) {
+		mainHandler.post(() -> {
+			if (!connected) {
+				BluetoothDevice device = getDevice();
+				this.connectCallback = callback;
+				this.connecting = true;
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+					Log.d(BleManager.LOG_TAG, " Is Or Greater than M $mBluetoothDevice");
+					gatt = device.connectGatt(activity, false, this, BluetoothDevice.TRANSPORT_LE);
+				} else {
+					Log.d(BleManager.LOG_TAG, " Less than M");
+					try {
+						Log.d(BleManager.LOG_TAG, " Trying TRANPORT LE with reflection");
+						Method m = device.getClass().getDeclaredMethod("connectGatt", Context.class, Boolean.class,
+								BluetoothGattCallback.class, Integer.class);
+						m.setAccessible(true);
+						Integer transport = device.getClass().getDeclaredField("TRANSPORT_LE").getInt(null);
+						gatt = (BluetoothGatt) m.invoke(device, activity, false, this, transport);
+					} catch (Exception e) {
+						e.printStackTrace();
+						Log.d(TAG, " Catch to call normal connection");
+						gatt = device.connectGatt(activity, false, this);
+					}
 				}
-			}
-		} else {
-			if (gatt != null) {
-				callback.invoke();
 			} else {
-				callback.invoke("BluetoothGatt is null");
+				if (gatt != null) {
+					callback.invoke();
+				} else {
+					callback.invoke("BluetoothGatt is null");
+				}
 			}
-		}
+		});
 	}
 	// bt_btif : Register with GATT stack failed.
 
-	public void disconnect(boolean force) {
-		connectCallback = null;
-		connected = false;
-		clearBuffers();
-		commandQueue.clear();
-		commandQueueBusy = false;
+	public void disconnect(final Callback callback, final boolean force) {
+		mainHandler.post(() -> {
+			connectCallback = null;
+			connected = false;
+			clearBuffers();
+			commandQueue.clear();
+			commandQueueBusy = false;
 
-		if (gatt != null) {
-			try {
-				gatt.disconnect();
-				if (force) {
-					gatt.close();
-					gatt = null;
-					sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_SUCCESS);
+			if (gatt != null) {
+				try {
+					gatt.disconnect();
+					if (force) {
+						gatt.close();
+						gatt = null;
+						sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_SUCCESS);
+					}
+					Log.d(BleManager.LOG_TAG, "Disconnect");
+				} catch (Exception e) {
+					sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_FAILURE);
+					Log.d(BleManager.LOG_TAG, "Error on disconnect", e);
 				}
-				Log.d(BleManager.LOG_TAG, "Disconnect");
-			} catch (Exception e) {
-				sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_FAILURE);
-				Log.d(BleManager.LOG_TAG, "Error on disconnect", e);
-			}
-		} else
-			Log.d(BleManager.LOG_TAG, "GATT is null");
+			} else
+				Log.d(BleManager.LOG_TAG, "GATT is null");
+			if (callback != null)
+				callback.invoke();
+		});
 	}
 
 	public WritableMap asWritableMap() {
@@ -262,97 +270,102 @@ public class Peripheral extends BluetoothGattCallback {
 		return device;
 	}
 
-	public Boolean hasService(UUID uuid) {
-		if (gatt == null) {
-			return null;
-		}
-		return gatt.getService(uuid) != null;
-	}
-
 	@Override
 	public void onServicesDiscovered(BluetoothGatt gatt, int status) {
 		super.onServicesDiscovered(gatt, status);
-
-		if (retrieveServicesCallback != null) {
-			WritableMap map = this.asWritableMap(gatt);
-			retrieveServicesCallback.invoke(null, map);
-			retrieveServicesCallback = null;
-		}
+		mainHandler.post(() -> {
+			if (retrieveServicesCallback != null) {
+				WritableMap map = this.asWritableMap(gatt);
+				retrieveServicesCallback.invoke(null, map);
+				retrieveServicesCallback = null;
+			}
+			completedCommand();
+		});
 	}
 
 	@Override
-	public void onConnectionStateChange(BluetoothGatt gatta, int status, int newState) {
+	public void onConnectionStateChange(BluetoothGatt gatta, int status, final int newState) {
 
 		Log.d(BleManager.LOG_TAG, "onConnectionStateChange to " + newState + " on peripheral: " + device.getAddress()
 				+ " with status " + status);
 
-		gatt = gatta;
+		mainHandler.post(() -> {
+			gatt = gatta;
 
-		if (status != BluetoothGatt.GATT_SUCCESS) {
-		    gatt.close();
-		    // change the state to ensure the connection is teared down properly in the code below
-		    newState = BluetoothProfile.STATE_DISCONNECTED;
-		}
+			if (status != BluetoothGatt.GATT_SUCCESS) {
+				gatt.close();
+			}
 
-		connecting = false;
-		if (newState == BluetoothProfile.STATE_CONNECTED) {
-			connected = true;
+			connecting = false;
+			if (newState == BluetoothProfile.STATE_CONNECTED && status == BluetoothGatt.GATT_SUCCESS) {
+				connected = true;
 
-			discoverServicesRunnable = new Runnable() {
-				@Override
-				public void run() {
-					try {
-						gatt.discoverServices();
-					} catch (NullPointerException e) {
-						Log.d(BleManager.LOG_TAG, "onConnectionStateChange connected but gatt of Run method was null");
+				discoverServicesRunnable = new Runnable() {
+					@Override
+					public void run() {
+						try {
+							gatt.discoverServices();
+						} catch (NullPointerException e) {
+							Log.d(BleManager.LOG_TAG, "onConnectionStateChange connected but gatt of Run method was null");
+						}
+						discoverServicesRunnable = null;
 					}
-					discoverServicesRunnable = null;
-				}
-			};
+				};
 
-			mainHandler.post(discoverServicesRunnable);
+				mainHandler.post(discoverServicesRunnable);
 
-			sendConnectionEvent(device, "BleManagerConnectPeripheral", status);
+				sendConnectionEvent(device, "BleManagerConnectPeripheral", status);
 
-			if (connectCallback != null) {
-				Log.d(BleManager.LOG_TAG, "Connected to: " + device.getAddress());
-				connectCallback.invoke();
-				connectCallback = null;
-			}
+				if (connectCallback != null) {
+					Log.d(BleManager.LOG_TAG, "Connected to: " + device.getAddress());
+					connectCallback.invoke();
+					connectCallback = null;
+				}
 
-		} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+			} else if (newState == BluetoothProfile.STATE_DISCONNECTED || status != BluetoothGatt.GATT_SUCCESS) {
 
-			if (discoverServicesRunnable != null) {
-				mainHandler.removeCallbacks(discoverServicesRunnable);
-				discoverServicesRunnable = null;
-			}
+				if (discoverServicesRunnable != null) {
+					mainHandler.removeCallbacks(discoverServicesRunnable);
+					discoverServicesRunnable = null;
+				}
 
-			List<Callback> callbacks = Arrays.asList(writeCallback, retrieveServicesCallback, readRSSICallback,
-					readCallback, registerNotifyCallback, requestMTUCallback);
-			for (Callback currentCallback : callbacks) {
-				if (currentCallback != null) {
-					try {
-						currentCallback.invoke("Device disconnected");
-					} catch (Exception e) {
-						e.printStackTrace();
-					}				}
-			}
-			if (connectCallback != null) {
-				connectCallback.invoke("Connection error");
+				List<Callback> callbacks = Arrays.asList(writeCallback, retrieveServicesCallback, readRSSICallback,
+						readCallback, registerNotifyCallback, requestMTUCallback);
+				for (Callback currentCallback : callbacks) {
+					if (currentCallback != null) {
+						try {
+							currentCallback.invoke("Device disconnected");
+						} catch (Exception e) {
+							e.printStackTrace();
+						}				}
+				}
+				if (connectCallback != null) {
+					connectCallback.invoke("Connection error");
+					connectCallback = null;
+				}
+				writeCallback = null;
+				writeQueue.clear();
+				readCallback = null;
+				retrieveServicesCallback = null;
+				readRSSICallback = null;
+				registerNotifyCallback = null;
+				requestMTUCallback = null;
+				commandQueue.clear();
+				commandQueueBusy = false;
 				connectCallback = null;
+				connected = false;
+				clearBuffers();
+				commandQueue.clear();
+				commandQueueBusy = false;
+
+				gatt.disconnect();
+				gatt.close();
+				gatt = null;
+				sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_SUCCESS);
+
 			}
-			writeCallback = null;
-			writeQueue.clear();
-			readCallback = null;
-			retrieveServicesCallback = null;
-			readRSSICallback = null;
-			registerNotifyCallback = null;
-			requestMTUCallback = null;
-			commandQueue.clear();
-			commandQueueBusy = false;
 
-			this.disconnect(true);
-		}
+		});
 
 	}
 
@@ -382,7 +395,7 @@ public class Peripheral extends BluetoothGattCallback {
 			if (buffer != null) {
 				buffer.put(dataValue);
 				Log.d(BleManager.LOG_TAG, "onCharacteristicChanged-buffering: " +
-				buffer.size() + " from peripheral: " + device.getAddress());
+						buffer.size() + " from peripheral: " + device.getAddress());
 
 				if (buffer.isBufferFull()) {
 					Log.d(BleManager.LOG_TAG, "onCharacteristicChanged sending buffered data " + buffer.size());
@@ -412,93 +425,87 @@ public class Peripheral extends BluetoothGattCallback {
 	public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
 		super.onCharacteristicRead(gatt, characteristic, status);
 
-		if (status != BluetoothGatt.GATT_SUCCESS) {
-			if (status == GATT_AUTH_FAIL || status == GATT_INSUFFICIENT_AUTHENTICATION) {
-				Log.d(BleManager.LOG_TAG, "Read needs bonding");
-				// *not* doing completedCommand()
-				return;
+		mainHandler.post(() -> {
+			if (status != BluetoothGatt.GATT_SUCCESS) {
+				if (status == GATT_AUTH_FAIL || status == GATT_INSUFFICIENT_AUTHENTICATION) {
+					Log.d(BleManager.LOG_TAG, "Read needs bonding");
+				}
+				readCallback.invoke("Error reading " + characteristic.getUuid() + " status=" + status, null);
+				readCallback = null;
+			} else if (readCallback != null) {
+				final byte[] dataValue = copyOf(characteristic.getValue());
+				readCallback.invoke(null, BleManager.bytesToWritableArray(dataValue));
+				readCallback = null;
 			}
-			sendBackrError(readCallback, "Error reading " + characteristic.getUuid() + " status=" + status);
-			readCallback = null;
-		} else if (readCallback != null) {
-			final byte[] dataValue = copyOf(characteristic.getValue());
-			final Callback callback = readCallback;
-			readCallback = null;
-			mainHandler.post(new Runnable() {
-					@Override
-					public void run() {
-						callback.invoke(null, BleManager.bytesToWritableArray(dataValue));
-					}
-				});
-		}
+			completedCommand();
+		});
 
-		completedCommand();
 	}
 
 	@Override
 	public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
 		super.onCharacteristicWrite(gatt, characteristic, status);
 
-		if (writeQueue.size() > 0) {
-			byte[] data = writeQueue.get(0);
-			writeQueue.remove(0);
-			doWrite(characteristic, data, writeCallback);
-		} else if (status != BluetoothGatt.GATT_SUCCESS) {
-			if (status == GATT_AUTH_FAIL || status == GATT_INSUFFICIENT_AUTHENTICATION) {
-				Log.d(BleManager.LOG_TAG, "Write needs bonding");
-				// *not* doing completedCommand()
-				return;
+		mainHandler.post(() -> {
+			if (writeQueue.size() > 0) {
+				byte[] data = writeQueue.get(0);
+				writeQueue.remove(0);
+				doWrite(characteristic, data, writeCallback);
+			} else if (status != BluetoothGatt.GATT_SUCCESS) {
+				if (status == GATT_AUTH_FAIL || status == GATT_INSUFFICIENT_AUTHENTICATION) {
+					Log.d(BleManager.LOG_TAG, "Write needs bonding");
+					// *not* doing completedCommand()
+					return;
+				}
+				writeCallback.invoke( "Error writing " + characteristic.getUuid() + " status=" + status, null);
+				writeCallback = null;
+			} else if (writeCallback != null) {
+				writeCallback.invoke();
+				writeCallback = null;
 			}
-			sendBackrError(writeCallback, "Error writing " + characteristic.getUuid() + " status=" + status);
-			writeCallback = null;
-		} else if (writeCallback != null) {
-			final Callback callback = writeCallback;
-			mainHandler.post(new Runnable() {
-					@Override
-					public void run() {
-						callback.invoke();
-					}
-				});
-			writeCallback = null;
-		}
-
-		completedCommand();
+			completedCommand();
+		});
 	}
 
 	@Override
 	public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
-		if (registerNotifyCallback != null) {
-			if (status == BluetoothGatt.GATT_SUCCESS) {
-				registerNotifyCallback.invoke();
-				Log.d(BleManager.LOG_TAG, "onDescriptorWrite success");
+		mainHandler.post(() -> {
+			if (registerNotifyCallback != null) {
+				if (status == BluetoothGatt.GATT_SUCCESS) {
+					registerNotifyCallback.invoke();
+					Log.d(BleManager.LOG_TAG, "onDescriptorWrite success");
+				} else {
+					registerNotifyCallback.invoke("Error writing descriptor status=" + status, null);
+					Log.e(BleManager.LOG_TAG, "Error writing descriptor status=" + status);
+				}
+
+				registerNotifyCallback = null;
 			} else {
-				registerNotifyCallback.invoke("Error writing descriptor status=" + status, null);
-				Log.e(BleManager.LOG_TAG, "Error writing descriptor status=" + status);
+				Log.e(BleManager.LOG_TAG, "onDescriptorWrite with no callback");
 			}
 
-			registerNotifyCallback = null;
-		} else {
-			Log.e(BleManager.LOG_TAG, "onDescriptorWrite with no callback");
-		}
-
-		completedCommand();
+			completedCommand();
+		});
 	}
 
 	@Override
 	public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
 		super.onReadRemoteRssi(gatt, rssi, status);
-		if (readRSSICallback != null) {
-			if (status == BluetoothGatt.GATT_SUCCESS) {
-				updateRssi(rssi);
-				readRSSICallback.invoke(null, rssi);
-			} else {
-				readRSSICallback.invoke("Error reading RSSI status=" + status, null);
-			}
 
-			readRSSICallback = null;
-		}
+		mainHandler.post(() -> {
+			if (readRSSICallback != null) {
+				if (status == BluetoothGatt.GATT_SUCCESS) {
+					updateRssi(rssi);
+					readRSSICallback.invoke(null, rssi);
+				} else {
+					readRSSICallback.invoke("Error reading RSSI status=" + status, null);
+				}
+
+				readRSSICallback = null;
+			}
 
-		completedCommand();
+			completedCommand();
+		});
 	}
 
 	private String bufferedCharacteristicsKey(String serviceUUID, String characteristicUUID) {
@@ -513,6 +520,7 @@ public class Peripheral extends BluetoothGattCallback {
 	private void setNotify(UUID serviceUUID, UUID characteristicUUID, final Boolean notify, Callback callback) {
 		if (! isConnected() || gatt == null) {
 			callback.invoke("Device is not connected", null);
+			completedCommand();
 			return;
 		}
 
@@ -520,18 +528,21 @@ public class Peripheral extends BluetoothGattCallback {
 		final BluetoothGattCharacteristic characteristic = findNotifyCharacteristic(service, characteristicUUID);
 
 		if (characteristic == null) {
-			callback.invoke("Characteristic " + characteristicUUID + " not found");			
+			callback.invoke("Characteristic " + characteristicUUID + " not found");
+			completedCommand();
 			return;
 		}
 
 		if (! gatt.setCharacteristicNotification(characteristic, notify)) {
 			callback.invoke("Failed to register notification for " + characteristicUUID);
+			completedCommand();
 			return;
 		}
 
 		final BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUIDHelper.uuidFromString(CHARACTERISTIC_NOTIFICATION_CONFIG));
 		if (descriptor == null) {
 			callback.invoke("Set notification failed for " + characteristicUUID);
+			completedCommand();
 			return;
 		}
 
@@ -547,63 +558,56 @@ public class Peripheral extends BluetoothGattCallback {
 			String msg = "Characteristic " + characteristicUUID + " does not have NOTIFY or INDICATE property set";
 			Log.d(BleManager.LOG_TAG, msg);
 			callback.invoke(msg);
+			completedCommand();
 			return;
 		}
 		final byte[] finalValue = notify ? value : BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE;
 		final Callback finalCallback = callback;
 
-		boolean result = commandQueue.add(new Runnable() {
-				@Override
-				public void run() {
-					if (! isConnected()) {
-						completedCommand();
-						return;
-					}
-
-					boolean result = false;
-					try {
-						result = gatt.setCharacteristicNotification(characteristic, notify);
-						// Then write to descriptor
-						descriptor.setValue(finalValue);
-						registerNotifyCallback = finalCallback;
-						result = gatt.writeDescriptor(descriptor);
-					} catch(Exception e) {
-						Log.d(BleManager.LOG_TAG, "Exception in setNotify", e);
-					}
-
-					if (! result) {
-						sendBackrError(registerNotifyCallback, "writeDescriptor failed for descriptor: " + descriptor.getUuid());
-						registerNotifyCallback = null;
-						completedCommand();
-					}
-				}
-			});
+		boolean result = false;
+		try {
+			result = gatt.setCharacteristicNotification(characteristic, notify);
+			// Then write to descriptor
+			descriptor.setValue(finalValue);
+			registerNotifyCallback = finalCallback;
+			result &= gatt.writeDescriptor(descriptor);
+		} catch(Exception e) {
+			Log.d(BleManager.LOG_TAG, "Exception in setNotify", e);
+		}
 
-		if (result) {
-			nextCommand();
-		} else {
-			Log.e(BleManager.LOG_TAG, "Could not enqueue setNotify command");
+		if (! result) {
+			callback.invoke( "writeDescriptor failed for descriptor: " + descriptor.getUuid(), null);
+			registerNotifyCallback = null;
+			completedCommand();
 		}
 	}
 
 	public void registerNotify(UUID serviceUUID, UUID characteristicUUID, Integer buffer, Callback callback) {
-		Log.d(BleManager.LOG_TAG, "registerNotify");
-		if (buffer > 1) {
-			Log.d(BleManager.LOG_TAG, "registerNotify using buffer");
-			String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
-			this.bufferedCharacteristics.put(bufferKey, new NotifyBufferContainer(buffer));
+		if (!enqueue(() -> {
+			Log.d(BleManager.LOG_TAG, "registerNotify");
+			if (buffer > 1) {
+				Log.d(BleManager.LOG_TAG, "registerNotify using buffer");
+				String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
+				this.bufferedCharacteristics.put(bufferKey, new NotifyBufferContainer(buffer));
+			}
+			this.setNotify(serviceUUID, characteristicUUID, true, callback);
+		})) {
+			Log.e(BleManager.LOG_TAG, "Could not enqueue setNotify command to register notify");
 		}
-		this.setNotify(serviceUUID, characteristicUUID, true, callback);
 	}
 
 	public void removeNotify(UUID serviceUUID, UUID characteristicUUID, Callback callback) {
-		Log.d(BleManager.LOG_TAG, "removeNotify");
-		String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
-		if (this.bufferedCharacteristics.containsKey(bufferKey)) {
-			NotifyBufferContainer buffer = this.bufferedCharacteristics.get(bufferKey);	
-			this.bufferedCharacteristics.remove(bufferKey);
+		if (!enqueue(() -> {
+			Log.d(BleManager.LOG_TAG, "removeNotify");
+			String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
+			if (this.bufferedCharacteristics.containsKey(bufferKey)) {
+				NotifyBufferContainer buffer = this.bufferedCharacteristics.get(bufferKey);
+				this.bufferedCharacteristics.remove(bufferKey);
+			}
+			this.setNotify(serviceUUID, characteristicUUID, false, callback);
+		})) {
+			Log.e(BleManager.LOG_TAG, "Could not enqueue setNotify command to remove notify");
 		}
-		this.setNotify(serviceUUID, characteristicUUID, false, callback);
 	}
 
 	// Some devices reuse UUIDs across characteristics, so we can't use
@@ -612,7 +616,7 @@ public class Peripheral extends BluetoothGattCallback {
 	// until we find the best match
 	// This function prefers Notify over Indicate
 	private BluetoothGattCharacteristic findNotifyCharacteristic(BluetoothGattService service,
-			UUID characteristicUUID) {
+																 UUID characteristicUUID) {
 
 		try {
 			// Check for Notify first
@@ -641,48 +645,31 @@ public class Peripheral extends BluetoothGattCallback {
 		}
 	}
 
-	public void read(UUID serviceUUID, UUID characteristicUUID, Callback callback) {
-
-		if (!isConnected() || gatt == null) {
-			callback.invoke("Device is not connected", null);
-			return;
-		}
-
-		BluetoothGattService service = gatt.getService(serviceUUID);
-		final BluetoothGattCharacteristic characteristic = findReadableCharacteristic(service, characteristicUUID);
+	public void read(UUID serviceUUID, UUID characteristicUUID, final Callback callback) {
+		enqueue(() -> {
+			if (!isConnected() || gatt == null) {
+				callback.invoke("Device is not connected", null);
+				completedCommand();
+				return;
+			}
 
-		if (characteristic == null) {
-			callback.invoke("Characteristic " + characteristicUUID + " not found.", null);
-			return;
-		}
+			BluetoothGattService service = gatt.getService(serviceUUID);
+			final BluetoothGattCharacteristic characteristic = findReadableCharacteristic(service, characteristicUUID);
 
-		final Callback reactcb = callback;
-		boolean result = commandQueue.add(new Runnable() {
-				@Override
-				public void run() {
-					readCallback = reactcb;
-					if (! gatt.readCharacteristic(characteristic)) {
-						readCallback = null;
-						sendBackrError(reactcb, "Read failed");
-						completedCommand();
-					}
-				}
-			});
+			if (characteristic == null) {
+				callback.invoke("Characteristic " + characteristicUUID + " not found.", null);
+				completedCommand();
+				return;
+			}
 
-		if (result) {
-			nextCommand();
-		} else {
-			Log.d(BleManager.LOG_TAG, "Could not queue read characteristic command");
-		}
-	}
+			readCallback = callback;
+			if (!gatt.readCharacteristic(characteristic)) {
+				callback.invoke("Read failed", null);
+				readCallback = null;
+				completedCommand();
+			}
 
-	private void sendBackrError(final Callback callback, final String message) {
-		new Handler(Looper.getMainLooper()).post(new Runnable() {
-				@Override
-				public void run() {
-					callback.invoke(message, null);
-				}
-			});
+		});
 	}
 
 	private byte[] copyOf(byte[] source) {
@@ -693,6 +680,16 @@ public class Peripheral extends BluetoothGattCallback {
 		return copy;
 	}
 
+	private boolean enqueue(Runnable command) {
+		final boolean result = commandQueue.add(command);
+		if (result) {
+			nextCommand();
+		} else {
+			Log.d(BleManager.LOG_TAG, "could not enqueue command");
+		}
+		return result;
+	}
+
 	private void completedCommand() {
 		commandQueue.poll();
 		commandQueueBusy = false;
@@ -723,78 +720,76 @@ public class Peripheral extends BluetoothGattCallback {
 			// Execute the next command in the queue
 			commandQueueBusy = true;
 			mainHandler.post(new Runnable() {
-					@Override
-					public void run() {
-						try {
-							nextCommand.run();
-						} catch (Exception ex) {
-							Log.d(BleManager.LOG_TAG, "Error, command exception");
-							completedCommand();
-						}
+				@Override
+				public void run() {
+					try {
+						nextCommand.run();
+					} catch (Exception ex) {
+						Log.d(BleManager.LOG_TAG, "Error, command exception");
+						completedCommand();
 					}
-				});
+				}
+			});
 		}
 	}
 
 	public void readRSSI(final Callback callback) {
-		if (!isConnected()) {
-			callback.invoke("Device is not connected", null);
-			return;
-		}
-		if (gatt == null) {
-			callback.invoke("BluetoothGatt is null", null);
-			return;
-		}
-
-		final boolean result = commandQueue.add(new Runnable() {
-			@Override
-			public void run() {
-			    if (isConnected()) {
+		if (!enqueue(() -> {
+			if (!isConnected()) {
+				callback.invoke("Device is not connected", null);
+				completedCommand();
+				return;
+			} else if (gatt == null) {
+				callback.invoke("BluetoothGatt is null", null);
+				completedCommand();
+				return;
+			} else {
 				readRSSICallback = callback;
-				if (! gatt.readRemoteRssi()) {
+				if (!gatt.readRemoteRssi()) {
+					callback.invoke("Read RSSI failed", null);
 					readRSSICallback = null;
-				    sendBackrError(callback, "Read RSSI failed");
-				    completedCommand();
+					completedCommand();
 				}
-			    } else {
-				completedCommand();
-			    }
 			}
-		    });
-
-		if (result) {
-		    nextCommand();
-		} else {
-		    Log.d(BleManager.LOG_TAG, "Could not queue readRemoteRssi command");
+		})) {
+			Log.d(BleManager.LOG_TAG, "Could not queue readRemoteRssi command");
 		}
 	}
 
 	public void refreshCache(Callback callback) {
-		try {
-			Method localMethod = gatt.getClass().getMethod("refresh", new Class[0]);
-			if (localMethod != null) {
-				boolean res = ((Boolean) localMethod.invoke(gatt, new Object[0])).booleanValue();
-				callback.invoke(null, res);
-			} else {
-				callback.invoke("Could not refresh cache for device.");
+		enqueue(() -> {
+			try {
+				Method localMethod = gatt.getClass().getMethod("refresh", new Class[0]);
+				if (localMethod != null) {
+					boolean res = ((Boolean) localMethod.invoke(gatt, new Object[0])).booleanValue();
+					callback.invoke(null, res);
+				} else {
+					callback.invoke("Could not refresh cache for device.");
+				}
+			} catch (Exception localException) {
+				Log.e(TAG, "An exception occured while refreshing device");
+				callback.invoke(localException.getMessage());
+			} finally {
+				completedCommand();
 			}
-		} catch (Exception localException) {
-			Log.e(TAG, "An exception occured while refreshing device");
-			callback.invoke(localException.getMessage());
-		}
+		});
 	}
 
 	public void retrieveServices(Callback callback) {
-		if (!isConnected()) {
-			callback.invoke("Device is not connected", null);
-			return;
-		}
-		if (gatt == null) {
-			callback.invoke("BluetoothGatt is null", null);
-			return;
-		}
-		this.retrieveServicesCallback = callback;
-		gatt.discoverServices();
+		enqueue(() -> {
+			if (!isConnected()) {
+				callback.invoke("Device is not connected", null);
+				completedCommand();
+				return;
+			} else if (gatt == null) {
+				callback.invoke("BluetoothGatt is null", null);
+				completedCommand();
+				return;
+			} else {
+				this.retrieveServicesCallback = callback;
+				gatt.discoverServices();
+			}
+		});
 	}
 
 	// Some peripherals re-use UUIDs for multiple characteristics so we need to
@@ -802,7 +797,7 @@ public class Peripheral extends BluetoothGattCallback {
 	// and UUID of all characteristics instead of using
 	// service.getCharacteristic(characteristicUUID)
 	private BluetoothGattCharacteristic findReadableCharacteristic(BluetoothGattService service,
-			UUID characteristicUUID) {
+																   UUID characteristicUUID) {
 
 		if (service != null) {
 			int read = BluetoothGattCharacteristic.PROPERTY_READ;
@@ -825,157 +820,172 @@ public class Peripheral extends BluetoothGattCallback {
 
 	public boolean doWrite(final BluetoothGattCharacteristic characteristic, byte[] data, final Callback callback) {
 		final byte[] copyOfData = copyOf(data);
-		boolean result = commandQueue.add(new Runnable() {
-				@Override
-				public void run() {
-					characteristic.setValue(copyOfData);
-					if (characteristic.getWriteType() == BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
-						writeCallback = callback;
-					else
-						writeCallback = null;
-					if (!gatt.writeCharacteristic(characteristic)) {
-						sendBackrError(writeCallback, "Write failed");
+		return enqueue(new Runnable() {
+			@Override
+			public void run() {
+				characteristic.setValue(copyOfData);
+				if (characteristic.getWriteType() == BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
+					writeCallback = callback;
+				else
+					writeCallback = null;
+				if (!gatt.writeCharacteristic(characteristic)) {
+					// write without response, caller will handle the callback
+					if (writeCallback != null) {
+						writeCallback.invoke("Write failed", writeCallback);
 						writeCallback = null;
-						completedCommand();
 					}
+					completedCommand();
 				}
-			});
-
-		if (result) {
-			nextCommand();
-		} else {
-			Log.d(BleManager.LOG_TAG, "Could not queue write characteristic command");
-		}
-
-		return result;
+			}
+		});
 	}
 
 	public void write(UUID serviceUUID, UUID characteristicUUID, byte[] data, Integer maxByteSize, Integer queueSleepTime, Callback callback, int writeType) {
-		if (!isConnected() || gatt == null) {
-			callback.invoke("Device is not connected", null);
-			return;
-		}
+		enqueue(() -> {
+			if (!isConnected() || gatt == null) {
+				callback.invoke("Device is not connected", null);
+				completedCommand();
+				return;
+			}
 
-		BluetoothGattService service = gatt.getService(serviceUUID);
-		BluetoothGattCharacteristic characteristic = findWritableCharacteristic(service, characteristicUUID, writeType);
+			BluetoothGattService service = gatt.getService(serviceUUID);
+			BluetoothGattCharacteristic characteristic = findWritableCharacteristic(service, characteristicUUID, writeType);
 
-		if (characteristic == null) {
-			callback.invoke("Characteristic " + characteristicUUID + " not found.");
-			return;
-		}
+			if (characteristic == null) {
+				callback.invoke("Characteristic " + characteristicUUID + " not found.");
+				completedCommand();
+				return;
+			}
 
-		characteristic.setWriteType(writeType);
+			characteristic.setWriteType(writeType);
 
-		if (data.length <= maxByteSize) {
-			if (! doWrite(characteristic, data, callback)) {
-				callback.invoke("Write failed");
-				writeCallback = null;
+			if (data.length <= maxByteSize) {
+				if (! doWrite(characteristic, data, callback)) {
+					callback.invoke("Write failed");
+				} else {
+					if (BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE == writeType) {
+						callback.invoke();
+					}
+				}
 			} else {
-				if (BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE == writeType) {
-					callback.invoke();
+				int dataLength = data.length;
+				int count = 0;
+				byte[] firstMessage = null;
+				List<byte[]> splittedMessage = new ArrayList<>();
+
+				while (count < dataLength && (dataLength - count > maxByteSize)) {
+					if (count == 0) {
+						firstMessage = Arrays.copyOfRange(data, count, count + maxByteSize);
+					} else {
+						byte[] splitMessage = Arrays.copyOfRange(data, count, count + maxByteSize);
+						splittedMessage.add(splitMessage);
+					}
+					count += maxByteSize;
 				}
-			}
-		} else {
-			int dataLength = data.length;
-			int count = 0;
-			byte[] firstMessage = null;
-			List<byte[]> splittedMessage = new ArrayList<>();
-
-			while (count < dataLength && (dataLength - count > maxByteSize)) {
-				if (count == 0) {
-					firstMessage = Arrays.copyOfRange(data, count, count + maxByteSize);
-				} else {
-					byte[] splitMessage = Arrays.copyOfRange(data, count, count + maxByteSize);
+				if (count < dataLength) {
+					// Other bytes in queue
+					byte[] splitMessage = Arrays.copyOfRange(data, count, data.length);
 					splittedMessage.add(splitMessage);
 				}
-				count += maxByteSize;
-			}
-			if (count < dataLength) {
-				// Other bytes in queue
-				byte[] splitMessage = Arrays.copyOfRange(data, count, data.length);
-				splittedMessage.add(splitMessage);
-			}
 
-			if (BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT == writeType) {
-				writeQueue.addAll(splittedMessage);
-				if (! doWrite(characteristic, firstMessage, callback)) {
-					writeQueue.clear();
-					writeCallback = null;
-					callback.invoke("Write failed");
-				}
-			} else {
-				try {
-					boolean writeError = false;
+				if (BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT == writeType) {
+					writeQueue.addAll(splittedMessage);
 					if (! doWrite(characteristic, firstMessage, callback)) {
-						writeError = true;
+						writeQueue.clear();
 						callback.invoke("Write failed");
 					}
-					if (! writeError) {
-						Thread.sleep(queueSleepTime);
-						for (byte[] message : splittedMessage) {
-							if (! doWrite(characteristic, message, callback)) {
-								writeError = true;
-								callback.invoke("Write failed");
-								break;
-							}
-							Thread.sleep(queueSleepTime);
+				} else {
+					try {
+						boolean writeError = false;
+						if (! doWrite(characteristic, firstMessage, callback)) {
+							writeError = true;
+							callback.invoke("Write failed");
 						}
 						if (! writeError) {
-							callback.invoke();
+							Thread.sleep(queueSleepTime);
+							for (byte[] message : splittedMessage) {
+								if (! doWrite(characteristic, message, callback)) {
+									writeError = true;
+									callback.invoke("Write failed");
+									break;
+								}
+								Thread.sleep(queueSleepTime);
+							}
+							if (! writeError) {
+								callback.invoke();
+							}
 						}
+					} catch (InterruptedException e) {
+						callback.invoke("Error during writing");
 					}
-				} catch (InterruptedException e) {
-					callback.invoke("Error during writing");
 				}
 			}
-		}
+
+			completedCommand();
+		});
 	}
 
 	public void requestConnectionPriority(int connectionPriority, Callback callback) {
-		if (gatt == null) {
-			callback.invoke("BluetoothGatt is null", null);
-			return;
-		}
+		enqueue(() -> {
+			if (gatt != null) {
+				if (Build.VERSION.SDK_INT >= LOLLIPOP) {
+					boolean status = gatt.requestConnectionPriority(connectionPriority);
+					callback.invoke(null, status);
+				} else {
+					callback.invoke("Requesting connection priority requires at least API level 21", null);
+				}
+			} else {
+				callback.invoke("BluetoothGatt is null", null);
+			}
 
-		if (Build.VERSION.SDK_INT >= LOLLIPOP) {
-			boolean status = gatt.requestConnectionPriority(connectionPriority);
-			callback.invoke(null, status);
-		} else {
-			callback.invoke("Requesting connection priority requires at least API level 21", null);
-		}
+			completedCommand();
+		});
 	}
 
 	public void requestMTU(int mtu, Callback callback) {
-		if (!isConnected()) {
-			callback.invoke("Device is not connected", null);
-			return;
-		}
+		enqueue(() -> {
+			if (!isConnected()) {
+				callback.invoke("Device is not connected", null);
+				completedCommand();
+				return;
+			}
 
-		if (gatt == null) {
-			callback.invoke("BluetoothGatt is null", null);
-			return;
-		}
+			if (gatt == null) {
+				callback.invoke("BluetoothGatt is null", null);
+				completedCommand();
+				return;
+			}
 
-		if (Build.VERSION.SDK_INT >= LOLLIPOP) {
-			requestMTUCallback = callback;
-			gatt.requestMtu(mtu);
-		} else {
-			callback.invoke("Requesting MTU requires at least API level 21", null);
-		}
+			if (Build.VERSION.SDK_INT >= LOLLIPOP) {
+				requestMTUCallback = callback;
+				if (!gatt.requestMtu(mtu)) {
+					requestMTUCallback.invoke("Request MTU failed", null);
+					requestMTUCallback = null;
+					completedCommand();
+				}
+			} else {
+				callback.invoke("Requesting MTU requires at least API level 21", null);
+				completedCommand();
+			}
+		});
 	}
 
 	@Override
 	public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
 		super.onMtuChanged(gatt, mtu, status);
-		if (requestMTUCallback != null) {
-			if (status == BluetoothGatt.GATT_SUCCESS) {
-				requestMTUCallback.invoke(null, mtu);
-			} else {
-				requestMTUCallback.invoke("Error requesting MTU status = " + status, null);
+		mainHandler.post(() -> {
+			if (requestMTUCallback != null) {
+				if (status == BluetoothGatt.GATT_SUCCESS) {
+					requestMTUCallback.invoke(null, mtu);
+				} else {
+					requestMTUCallback.invoke("Error requesting MTU status = " + status, null);
+				}
+
+				requestMTUCallback = null;
 			}
 
-			requestMTUCallback = null;
-		}
+			completedCommand();
+		});
 	}
 
 	// Some peripherals re-use UUIDs for multiple characteristics so we need to
@@ -983,7 +993,7 @@ public class Peripheral extends BluetoothGattCallback {
 	// and UUID of all characteristics instead of using
 	// service.getCharacteristic(characteristicUUID)
 	private BluetoothGattCharacteristic findWritableCharacteristic(BluetoothGattService service,
-			UUID characteristicUUID, int writeType) {
+																   UUID characteristicUUID, int writeType) {
 		try {
 			// get write property
 			int writeProperty = BluetoothGattCharacteristic.PROPERTY_WRITE;

package/ios/BleManager.m

@@ -378,7 +378,7 @@ RCT_EXPORT_METHOD(stopScan:(nonnull RCTResponseSenderBlock)callback)
     }
     [manager stopScan];
     if (hasListeners) {
-        [self sendEventWithName:@"BleManagerStopScan" body:@{}];
+				[self sendEventWithName:@"BleManagerStopScan" body:@{@"status": @0}];
     }
     callback(@[[NSNull null]]);
 }
@@ -390,7 +390,7 @@ RCT_EXPORT_METHOD(stopScan:(nonnull RCTResponseSenderBlock)callback)
     [manager stopScan];
     if (hasListeners) {
         if (self.bridge) {
-            [self sendEventWithName:@"BleManagerStopScan" body:@{}];
+            [self sendEventWithName:@"BleManagerStopScan" body:@{@"status": @10}];
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-manager",
-  "version": "8.4.4",
+  "version": "8.6.0",
   "description": "A BLE module for react native.",
   "main": "BleManager",
   "types": "./index.d.ts",