react-native-ble-manager 8.6.0 → 8.8.0

package/BleManager.js

@@ -250,7 +250,7 @@ class BleManager {
       }
 
       // (ANDROID) Match as many advertisement per filter as hw could allow
-      // dependes on current capability and availability of the resources in hw.
+      // depends on current capability and availability of the resources in hw.
       if (scanningOptions.numberOfMatches == null) {
         scanningOptions.numberOfMatches = 3;
       }
@@ -260,11 +260,19 @@ class BleManager {
         scanningOptions.matchMode = 1;
       }
 
-      // (ANDROID) Defaults to SCAN_MODE_LOW_POWER on android
+      // (ANDROID) Defaults to SCAN_MODE_LOW_POWER
       if (scanningOptions.scanMode == null) {
         scanningOptions.scanMode = 0;
       }
+      
+      // (ANDROID) Defaults to CALLBACK_TYPE_ALL_MATCHES 
+      // WARN: sometimes, setting a scanSetting instead of leaving it untouched might result in unexpected behaviors.
+      // https://github.com/dariuszseweryn/RxAndroidBle/issues/462
+      if (scanningOptions.callbackType == null) {
+        scanningOptions.callbackType = 1;
+      }
 
+      // (ANDROID) Defaults to 0ms (report results immediately).
       if (scanningOptions.reportDelay == null) {
         scanningOptions.reportDelay = 0;
       }

package/README.md

@@ -122,7 +122,7 @@ BleManager.start({ showAlert: false }).then(() => {
 
 ### scan(serviceUUIDs, seconds, allowDuplicates, scanningOptions)
 
-Scan for availables peripherals.
+Scan for available peripherals.
 Returns a `Promise` object.
 
 **Arguments**
@@ -131,10 +131,11 @@ Returns a `Promise` object.
 - `seconds` - `Integer` - the amount of seconds to scan.
 - `allowDuplicates` - `Boolean` - [iOS only] allow duplicates in device scanning
 - `scanningOptions` - `JSON` - [Android only] after Android 5.0, user can control specific ble scan behaviors:
-  - `numberOfMatches` - `Number` - [Android only] corresponding to [`setNumOfMatches`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setNumOfMatches(int)>)
-  - `matchMode` - `Number` - [Android only] corresponding to [`setMatchMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setMatchMode(int)>)
-  - `scanMode` - `Number` - [Android only] corresponding to [`setScanMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setScanMode(int)>)
-  - `reportDelay` - `Number` - [Android only] corresponding to [`setReportDelay`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setReportDelay(long)>)
+  - `numberOfMatches` - `Number` - [Android only] corresponding to [`setNumOfMatches`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setNumOfMatches(int)>). Defaults to `ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT`.
+  - `matchMode` - `Number` - [Android only] corresponding to [`setMatchMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setMatchMode(int)>). Defaults to `ScanSettings.MATCH_MODE_AGGRESSIVE`.
+  - `callbackType` - `Number` - [Android only] corresponding to [`setCallbackType`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setCallbackType(int)>). Defaults `ScanSettings.CALLBACK_TYPE_ALL_MATCHES`.
+  - `scanMode` - `Number` - [Android only] corresponding to [`setScanMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setScanMode(int)>). Defaults to `ScanSettings.SCAN_MODE_LOW_POWER`.
+  - `reportDelay` - `Number` - [Android only] corresponding to [`setReportDelay`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setReportDelay(long)>). Defaults to `0ms`.
   - `phy` - `Number` - [Android only] corresponding to [`setPhy`](https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setPhy(int))
   - `legacy` - `Boolean` - [Android only] corresponding to [`setLegacy`](https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setLegacy(boolean))
 
@@ -440,7 +441,7 @@ BleManager.writeWithoutResponse(
 ### readRSSI(peripheralId)
 
 Read the current value of the RSSI.
-Returns a `Promise` object.
+Returns a `Promise` object resolving with the updated RSSI value (`number`) if it succeeds.
 
 **Arguments**
 
@@ -463,7 +464,7 @@ BleManager.readRSSI("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")
 ### requestConnectionPriority(peripheralId, connectionPriority) [Android only API 21+]
 
 Request a connection parameter update.
-Returns a `Promise` object.
+Returns a `Promise` object which fulfills with the status of the request.
 
 **Arguments**
 
@@ -707,7 +708,7 @@ The BLE change state.
 
 **Arguments**
 
-- `state` - `String` - the new BLE state ('on'/'off').
+- `state` - `String` - the new BLE state. can be one of `unknown` (iOS only), `resetting` (iOS only), `unsupported`, `unauthorized` (iOS only), `on`, `off`, `turning_on` (android only), `turning_off` (android only).
 
 **Examples**
 

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

@@ -470,8 +470,19 @@ class BleManager extends ReactContextBaseJavaModule {
                 case BluetoothAdapter.STATE_ON:
                     state = "on";
                     break;
+                case BluetoothAdapter.STATE_TURNING_ON:
+                    state = "turning_on";
+                    break;
                 case BluetoothAdapter.STATE_OFF:
                     state = "off";
+                    break;
+                case BluetoothAdapter.STATE_TURNING_OFF:
+                    state = "turning_off";
+                    break;
+                default:
+                    // should not happen as per https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#getState()
+                    state = "off";
+                    break;
             }
         }
 
@@ -512,6 +523,10 @@ class BleManager extends ReactContextBaseJavaModule {
                     case BluetoothAdapter.STATE_TURNING_ON:
                         stringState = "turning_on";
                         break;
+                    default:
+                        // should not happen as per https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#EXTRA_STATE
+                        stringState = "off";
+                        break;
                 }
 
                 WritableMap map = Arguments.createMap();

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

@@ -3,94 +3,95 @@ package it.innove;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.util.Log;
+
 import com.facebook.react.bridge.*;
 
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
 
 public class LegacyScanManager extends ScanManager {
 
-	public LegacyScanManager(ReactApplicationContext reactContext, BleManager bleManager) {
-		super(reactContext, bleManager);
-	}
-
-	@Override
-	public void stopScan(Callback callback) {
-		// update scanSessionId to prevent stopping next scan by running timeout thread
-		scanSessionId.incrementAndGet();
-
-		getBluetoothAdapter().stopLeScan(mLeScanCallback);
-		callback.invoke();
-	}
-
-	private BluetoothAdapter.LeScanCallback mLeScanCallback =
-			new BluetoothAdapter.LeScanCallback() {
-
-				@Override
-				public void onLeScan(final BluetoothDevice device, final int rssi,
-									 final byte[] scanRecord) {
-					runOnUiThread(new Runnable() {
-						@Override
-						public void run() {
-							Log.i(bleManager.LOG_TAG, "DiscoverPeripheral: " + device.getName());
-
-                            Peripheral peripheral = bleManager.getPeripheral(device);
-                            if (peripheral == null) {
-                            	peripheral = new Peripheral(device, rssi, scanRecord, bleManager.getReactContext());
-							} else {
-                            	peripheral.updateData(scanRecord);
-                            	peripheral.updateRssi(rssi);
-							}
-                            bleManager.savePeripheral(peripheral);
-
-							WritableMap map = peripheral.asWritableMap();
-							bleManager.sendEvent("BleManagerDiscoverPeripheral", map);
-						}
-					});
-				}
-
-
-			};
-
-	@Override
-	public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options, Callback callback) {
-		if (serviceUUIDs.size() > 0) {
-			Log.d(bleManager.LOG_TAG, "Filter is not working in pre-lollipop devices");
-		}
-		getBluetoothAdapter().startLeScan(mLeScanCallback);
-
-		if (scanSeconds > 0) {
-			Thread thread = new Thread() {
-				private int currentScanSession = scanSessionId.incrementAndGet();
-
-				@Override
-				public void run() {
-
-					try {
-						Thread.sleep(scanSeconds * 1000);
-					} catch (InterruptedException ignored) {
-					}
-
-					runOnUiThread(new Runnable() {
-						@Override
-						public void run() {
-							BluetoothAdapter btAdapter = getBluetoothAdapter();
-							// check current scan session was not stopped
-							if (scanSessionId.intValue() == currentScanSession) {
-								if (btAdapter.getState() == BluetoothAdapter.STATE_ON) {
-									btAdapter.stopLeScan(mLeScanCallback);
-								}
-								WritableMap map = Arguments.createMap();
-								map.putInt("status", 0);
-								bleManager.sendEvent("BleManagerStopScan", map);
-							}
-						}
-					});
-
-				}
-
-			};
-			thread.start();
-		}
-		callback.invoke();
-	}
+    public LegacyScanManager(ReactApplicationContext reactContext, BleManager bleManager) {
+        super(reactContext, bleManager);
+    }
+
+    @Override
+    public void stopScan(Callback callback) {
+        // update scanSessionId to prevent stopping next scan by running timeout thread
+        scanSessionId.incrementAndGet();
+
+        getBluetoothAdapter().stopLeScan(mLeScanCallback);
+        callback.invoke();
+    }
+
+    private BluetoothAdapter.LeScanCallback mLeScanCallback =
+        new BluetoothAdapter.LeScanCallback() {
+
+            @Override
+            public void onLeScan(final BluetoothDevice device, final int rssi,
+                                 final byte[] scanRecord) {
+                runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        Log.i(bleManager.LOG_TAG, "DiscoverPeripheral: " + device.getName());
+
+                        Peripheral peripheral = bleManager.getPeripheral(device);
+                        if (peripheral == null) {
+                            peripheral = new Peripheral(device, rssi, scanRecord, bleManager.getReactContext());
+                        } else {
+                            peripheral.updateData(scanRecord);
+                            peripheral.updateRssi(rssi);
+                        }
+                        bleManager.savePeripheral(peripheral);
+
+                        WritableMap map = peripheral.asWritableMap();
+                        bleManager.sendEvent("BleManagerDiscoverPeripheral", map);
+                    }
+                });
+            }
+
+
+        };
+
+    @Override
+    public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options, Callback callback) {
+        if (serviceUUIDs.size() > 0) {
+            Log.d(bleManager.LOG_TAG, "Filter is not working in pre-lollipop devices");
+        }
+        getBluetoothAdapter().startLeScan(mLeScanCallback);
+
+        if (scanSeconds > 0) {
+            Thread thread = new Thread() {
+                private int currentScanSession = scanSessionId.incrementAndGet();
+
+                @Override
+                public void run() {
+
+                    try {
+                        Thread.sleep(scanSeconds * 1000);
+                    } catch (InterruptedException ignored) {
+                    }
+
+                    runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            BluetoothAdapter btAdapter = getBluetoothAdapter();
+                            // check current scan session was not stopped
+                            if (scanSessionId.intValue() == currentScanSession) {
+                                if (btAdapter.getState() == BluetoothAdapter.STATE_ON) {
+                                    btAdapter.stopLeScan(mLeScanCallback);
+                                }
+                                WritableMap map = Arguments.createMap();
+                                map.putInt("status", 0);
+                                bleManager.sendEvent("BleManagerStopScan", map);
+                            }
+                        }
+                    });
+
+                }
+
+            };
+            thread.start();
+        }
+        callback.invoke();
+    }
 }

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

@@ -1,52 +1,63 @@
 package it.innove;
 
 
+import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
+
+import android.Manifest;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.ScanCallback;
 import android.bluetooth.le.ScanFilter;
+import android.bluetooth.le.ScanRecord;
 import android.bluetooth.le.ScanResult;
 import android.bluetooth.le.ScanSettings;
+import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.ParcelUuid;
-import androidx.annotation.RequiresApi;
 import android.util.Log;
-import com.facebook.react.bridge.*;
+
+import androidx.annotation.RequiresApi;
+import androidx.core.app.ActivityCompat;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
-
 @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
 public class LollipopScanManager extends ScanManager {
 
-	public LollipopScanManager(ReactApplicationContext reactContext, BleManager bleManager) {
-		super(reactContext, bleManager);
-	}
+    public LollipopScanManager(ReactApplicationContext reactContext, BleManager bleManager) {
+        super(reactContext, bleManager);
+    }
 
-	@Override
-	public void stopScan(Callback callback) {
-		// update scanSessionId to prevent stopping next scan by running timeout thread
-		scanSessionId.incrementAndGet();
+    @Override
+    public void stopScan(Callback callback) {
+        // update scanSessionId to prevent stopping next scan by running timeout thread
+        scanSessionId.incrementAndGet();
 
-		getBluetoothAdapter().getBluetoothLeScanner().stopScan(mScanCallback);
-		callback.invoke();
-	}
+        getBluetoothAdapter().getBluetoothLeScanner().stopScan(mScanCallback);
+        callback.invoke();
+    }
 
     @Override
-    public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options,  Callback callback) {
+    public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options, Callback callback) {
         ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder();
         List<ScanFilter> filters = new ArrayList<>();
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && options.hasKey("legacy")) {
             scanSettingsBuilder.setLegacy(options.getBoolean("legacy"));
         }
-        
+
         if (options.hasKey("scanMode")) {
             scanSettingsBuilder.setScanMode(options.getInt("scanMode"));
         }
-        
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             if (options.hasKey("numberOfMatches")) {
                 scanSettingsBuilder.setNumOfMatches(options.getInt("numberOfMatches"));
@@ -54,6 +65,9 @@ public class LollipopScanManager extends ScanManager {
             if (options.hasKey("matchMode")) {
                 scanSettingsBuilder.setMatchMode(options.getInt("matchMode"));
             }
+            if (options.hasKey("callbackType")) {
+                scanSettingsBuilder.setCallbackType(options.getInt("callbackType"));
+            }
         }
 
         if (options.hasKey("reportDelay")) {
@@ -69,60 +83,69 @@ public class LollipopScanManager extends ScanManager {
                 scanSettingsBuilder.setPhy(BluetoothDevice.PHY_LE_2M);
             }
         }
-        
+
         if (serviceUUIDs.size() > 0) {
-            for(int i = 0; i < serviceUUIDs.size(); i++){
-				ScanFilter filter = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(UUIDHelper.uuidFromString(serviceUUIDs.getString(i)))).build();
+            for (int i = 0; i < serviceUUIDs.size(); i++) {
+                ScanFilter filter = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(UUIDHelper.uuidFromString(serviceUUIDs.getString(i)))).build();
                 filters.add(filter);
                 Log.d(bleManager.LOG_TAG, "Filter service: " + serviceUUIDs.getString(i));
             }
         }
-        
+
         getBluetoothAdapter().getBluetoothLeScanner().startScan(filters, scanSettingsBuilder.build(), mScanCallback);
         if (scanSeconds > 0) {
             Thread thread = new Thread() {
                 private int currentScanSession = scanSessionId.incrementAndGet();
-                
+
                 @Override
                 public void run() {
-                    
+
                     try {
                         Thread.sleep(scanSeconds * 1000);
                     } catch (InterruptedException ignored) {
                     }
-                    
+
                     runOnUiThread(new Runnable() {
                         @Override
                         public void run() {
                             BluetoothAdapter btAdapter = getBluetoothAdapter();
                             // check current scan session was not stopped
                             if (scanSessionId.intValue() == currentScanSession) {
-                                if(btAdapter.getState() == BluetoothAdapter.STATE_ON) {
+                                if (btAdapter.getState() == BluetoothAdapter.STATE_ON) {
                                     btAdapter.getBluetoothLeScanner().stopScan(mScanCallback);
                                 }
                                 WritableMap map = Arguments.createMap();
-																map.putInt("status", 10);
+                                map.putInt("status", 10);
                                 bleManager.sendEvent("BleManagerStopScan", map);
                             }
                         }
                     });
-                    
+
                 }
-                
+
             };
             thread.start();
         }
         callback.invoke();
     }
 
-	private ScanCallback mScanCallback = new ScanCallback() {
-		@Override
-		public void onScanResult(final int callbackType, final ScanResult result) {
+    private ScanCallback mScanCallback = new ScanCallback() {
+        @Override
+        public void onScanResult(final int callbackType, final ScanResult result) {
 
-			runOnUiThread(new Runnable() {
-				@Override
-				public void run() {
-					Log.i(bleManager.LOG_TAG, "DiscoverPeripheral: " + result.getDevice().getName());
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    String info;
+                    ScanRecord record = result.getScanRecord();
+                    if (record != null)
+                        info = record.getDeviceName();
+                    else if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED)
+                        info = result.getDevice().getName();
+                    else
+                        info = result.toString();
+
+                    Log.i(bleManager.LOG_TAG, "DiscoverPeripheral: " + info);
 
                     LollipopPeripheral peripheral = (LollipopPeripheral) bleManager.getPeripheral(result.getDevice());
                     if (peripheral == null) {
@@ -133,21 +156,21 @@ public class LollipopScanManager extends ScanManager {
                     }
                     bleManager.savePeripheral(peripheral);
 
-					WritableMap map = peripheral.asWritableMap();
-					bleManager.sendEvent("BleManagerDiscoverPeripheral", map);
-				}
-			});
-		}
+                    WritableMap map = peripheral.asWritableMap();
+                    bleManager.sendEvent("BleManagerDiscoverPeripheral", map);
+                }
+            });
+        }
 
-		@Override
-		public void onBatchScanResults(final List<ScanResult> results) {
-		}
+        @Override
+        public void onBatchScanResults(final List<ScanResult> results) {
+        }
 
-		@Override
-		public void onScanFailed(final int errorCode) {
+        @Override
+        public void onScanFailed(final int errorCode) {
             WritableMap map = Arguments.createMap();
-						map.putInt("status", errorCode);
+            map.putInt("status", errorCode);
             bleManager.sendEvent("BleManagerStopScan", map);
-		}
-	};
+        }
+    };
 }

package/index.d.ts

@@ -1,4 +1,18 @@
 declare module "react-native-ble-manager" {
+
+  // android states: https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#EXTRA_STATE
+  // ios states: https://developer.apple.com/documentation/corebluetooth/cbcentralmanagerstate
+  export enum BleState {
+    Unknown = 'unknown', // [iOS only]
+    Resetting = 'resetting', // [iOS only]
+    Unsupported = 'unsupported',
+    Unauthorized = 'unauthorized', // [iOS only]
+    On = 'on',
+    Off = 'off',
+    TurningOn = 'turning_on', // [android only]
+    TurningOff = 'turning_off', // [android only]
+  }
+
   export interface Peripheral {
     id: string;
     rssi: number;
@@ -9,29 +23,75 @@ declare module "react-native-ble-manager" {
   export interface AdvertisingData {
     isConnectable?: boolean;
     localName?: string;
-    manufacturerData?: any;
+    manufacturerData?: CustomAdvertisingData,
+    serviceData?: CustomAdvertisingData,
     serviceUUIDs?: string[];
     txPowerLevel?: number;
   }
 
+  export interface CustomAdvertisingData {
+    CDVType : 'ArrayBuffer',
+    bytes: Uint8Array,
+    data: string // base64-encoded string of the data
+  }
+
   export interface StartOptions {
-    showAlert?: boolean;
-    restoreIdentifierKey?: string;
-    queueIdentifierKey?: string;
-    forceLegacy?: boolean;
+    showAlert?: boolean; // [iOS only]
+    restoreIdentifierKey?: string; // [iOS only]
+    queueIdentifierKey?: string; // [iOS only]
+    forceLegacy?: boolean; // [android only]
   }
 
   export function start(options?: StartOptions): Promise<void>;
 
+  // [android only]
+  // https://developer.android.com/reference/android/bluetooth/le/ScanSettings
   export interface ScanOptions {
-    numberOfMatches?: number;
-    matchMode?: number;
-    scanMode?: number;
+    numberOfMatches?: BleScanMatchCount;
+    matchMode?: BleScanMatchMode;
+    callbackType?: BleScanCallbackType;
+    scanMode?: BleScanMode;
     reportDelay?: number;
-    phy?: number;
+    phy?: BleScanPhyMode;
     legacy?: boolean;
   }
 
+  // [android only]
+  export enum BleScanMode {
+    Opportunistic = -1,
+    LowPower = 0,
+    Balanced = 1,
+    LowLatency = 2,
+  }
+
+  // [android only]
+  export enum BleScanMatchMode {
+    Aggressive = 1,
+    Sticky = 2,
+  }
+
+  // [android only]
+  export enum BleScanCallbackType {
+    AllMatches = 1,
+    FirstMatch = 2,
+    MatchLost = 4,
+  }
+
+  // [android only]
+  export enum BleScanMatchCount {
+    OneAdvertisement = 1,
+    FewAdvertisements = 2,
+    MaxAdvertisements = 3,
+  }
+
+  // [android only]
+  export enum BleScanPhyMode {
+    LE_1M = 1,
+    LE_2M = 2,
+    LE_CODED = 3,
+    ALL_SUPPORTED = 255,
+  }
+
   export function scan(
     serviceUUIDs: string[],
     seconds: number,
@@ -44,14 +104,16 @@ declare module "react-native-ble-manager" {
     peripheralID: string,
     force?: boolean
   ): Promise<void>;
+
   export function checkState(): void;
+
   export function startNotification(
     peripheralID: string,
     serviceUUID: string,
     characteristicUUID: string
   ): Promise<void>;
 
-  /// Android only
+  // [android only]
   export function startNotificationUseBuffer(
     peripheralID: string,
     serviceUUID: string,
@@ -70,6 +132,7 @@ declare module "react-native-ble-manager" {
     serviceUUID: string,
     characteristicUUID: string
   ): Promise<any>;
+
   export function write(
     peripheralID: string,
     serviceUUID: string,
@@ -77,6 +140,7 @@ declare module "react-native-ble-manager" {
     data: any,
     maxByteSize?: number
   ): Promise<void>;
+
   export function writeWithoutResponse(
     peripheralID: string,
     serviceUUID: string,
@@ -86,12 +150,14 @@ declare module "react-native-ble-manager" {
     queueSleepTime?: number
   ): Promise<void>;
 
-  export function readRSSI(peripheralID: string): Promise<void>;
+  export function readRSSI(peripheralID: string): Promise<number>;
 
   export function getConnectedPeripherals(
     serviceUUIDs: string[]
   ): Promise<Peripheral[]>;
+
   export function getDiscoveredPeripherals(): Promise<Peripheral[]>;
+
   export function isPeripheralConnected(
     peripheralID: string,
     serviceUUIDs: string[]
@@ -103,14 +169,19 @@ declare module "react-native-ble-manager" {
     high = 1,
     low = 2,
   }
+
+  // [Android only 21+]
   export function requestConnectionPriority(
     peripheralID: string,
     connectionPriority: ConnectionPriority
-  ): Promise<void>;
-  /// Android only
+  ): Promise<boolean>;
+
+  // [Android only]
   export function enableBluetooth(): Promise<void>;
+
   // [Android only]
   export function refreshCache(peripheralID: string): Promise<void>;
+
   // [Android only API 21+]
   export function requestMTU(peripheralID: string, mtu: number): Promise<number>;
 
@@ -118,8 +189,11 @@ declare module "react-native-ble-manager" {
     peripheralID: string,
     peripheralPin?: string
   ): Promise<void>;
+
   export function removeBond(peripheralID: string): Promise<void>;
+
   export function getBondedPeripherals(): Promise<Peripheral[]>;
+
   export function removePeripheral(peripheralID: string): Promise<void>;
 
   // [Android only]
@@ -164,4 +238,57 @@ declare module "react-native-ble-manager" {
     peripheralID: string,
     serviceUUIDs?: string[]
   ): Promise<PeripheralInfo>;
+
+  export enum BleEventType {
+    BleManagerDidUpdateState = 'BleManagerDidUpdateState',
+    BleManagerStopScan = 'BleManagerStopScan',
+    BleManagerDiscoverPeripheral = 'BleManagerDiscoverPeripheral',
+    BleManagerDidUpdateValueForCharacteristic = 'BleManagerDidUpdateValueForCharacteristic',
+    BleManagerConnectPeripheral = 'BleManagerConnectPeripheral',
+    BleManagerDisconnectPeripheral = 'BleManagerDisconnectPeripheral',
+    BleManagerPeripheralDidBond = 'BleManagerPeripheralDidBond', // [Android only]
+    BleManagerCentralManagerWillRestoreState = 'BleManagerCentralManagerWillRestoreState', // [iOS only]
+    BleManagerDidUpdateNotificationStateFor = 'BleManagerDidUpdateNotificationStateFor', // [iOS only]
+  }
+
+  export interface BleStopScanEvent {
+    status?: number; // [iOS only]
+  }
+
+  export interface BleManagerDidUpdateStateEvent {
+    state: BleState;
+  }
+
+  export interface BleConnectPeripheralEvent {
+    readonly peripheral: string; // peripheral id
+    readonly status?: number; // [android only]
+  }
+
+  export type BleDiscoverPeripheralEvent = Peripheral;
+
+  // [Android only]
+  export type BleBondedPeripheralEvent = Peripheral;
+
+  export interface BleDisconnectPeripheralEvent {
+    readonly peripheral: string; // peripheral id
+    readonly status?: number; // [android only] disconnect reason.
+    readonly domain?: string; // [iOS only] disconnect error domain.
+    readonly code?: number; // [iOS only] disconnect error code.
+  }
+
+  export interface BleManagerDidUpdateValueForCharacteristicEvent {
+    readonly characteristic: string; // characteristic UUID
+    readonly peripheral: string; // peripheral id
+    readonly service: string; // service UUID
+    readonly value: Uint8Array;
+  }
+
+  // [iOS only]
+  export interface BleManagerDidUpdateNotificationStateForEvent {
+    readonly peripheral: string; // peripheral id
+    readonly characteristic: string; // characteristic UUID
+    readonly isNotifying: boolean; // is the characteristic notifying or not
+    readonly domain: string; // error domain.
+    readonly code: number; // error code.
+  }
 }

package/package.json

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