react-native-ble-manager 11.5.7 → 12.0.0-rc.0

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

@@ -132,20 +132,20 @@ public class DefaultScanManager extends ScanManager {
                     return;
                 }
                 Log.d(
-                    BleManager.LOG_TAG,
-                    String.format(
-                        "Filter on manufacturerId: %d; manufacturerData: %s; manufacturerDataMask: %s",
-                        manufacturerId,
-                        Arrays.toString(manufacturerDataBytes),
-                        Arrays.toString(manufacturerDataMaskBytes)
-                    )
+                        BleManager.LOG_TAG,
+                        String.format(
+                                "Filter on manufacturerId: %d; manufacturerData: %s; manufacturerDataMask: %s",
+                                manufacturerId,
+                                Arrays.toString(manufacturerDataBytes),
+                                Arrays.toString(manufacturerDataMaskBytes)
+                        )
                 );
                 ScanFilter filter = new ScanFilter.Builder()
-                    .setManufacturerData(
-                        manufacturerId,
-                        manufacturerDataBytes,
-                        manufacturerDataMaskBytes
-                    ).build();
+                        .setManufacturerData(
+                                manufacturerId,
+                                manufacturerDataBytes,
+                                manufacturerDataMaskBytes
+                        ).build();
                 filters.add(filter);
             }
         }
@@ -179,7 +179,7 @@ public class DefaultScanManager extends ScanManager {
 
                                 WritableMap map = Arguments.createMap();
                                 map.putInt("status", 10);
-                                bleManager.sendEvent("BleManagerStopScan", map);
+                                bleManager.emitOnStopScan(map);
                             }
                         }
                     });
@@ -208,7 +208,7 @@ public class DefaultScanManager extends ScanManager {
 
         DefaultPeripheral peripheral = (DefaultPeripheral) bleManager.getPeripheral(result.getDevice());
         if (peripheral == null) {
-            peripheral = new DefaultPeripheral(bleManager.getReactContext(), result);
+            peripheral = new DefaultPeripheral(bleManager, result);
         } else {
             peripheral.updateData(result);
             peripheral.updateRssi(result.getRssi());
@@ -216,7 +216,7 @@ public class DefaultScanManager extends ScanManager {
         bleManager.savePeripheral(peripheral);
 
         WritableMap map = peripheral.asWritableMap();
-        bleManager.sendEvent("BleManagerDiscoverPeripheral", map);
+        bleManager.emitOnDiscoverPeripheral(map);
     }
 
     private final ScanCallback mScanCallback = new ScanCallback() {
@@ -251,7 +251,7 @@ public class DefaultScanManager extends ScanManager {
             isScanning = false;
             WritableMap map = Arguments.createMap();
             map.putInt("status", errorCode);
-            bleManager.sendEvent("BleManagerStopScan", map);
+            bleManager.emitOnStopScan(map);
         }
     };
 

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

@@ -60,7 +60,7 @@ public class Peripheral extends BluetoothGattCallback {
     protected volatile int advertisingRSSI;
     private volatile boolean connected = false;
     private volatile boolean connecting = false;
-    private ReactContext reactContext;
+    private BleManager bleManager;
 
     private BluetoothGatt gatt;
 
@@ -81,34 +81,38 @@ public class Peripheral extends BluetoothGattCallback {
 
     private List<byte[]> writeQueue = new ArrayList<>();
 
-    public Peripheral(BluetoothDevice device, int advertisingRSSI, byte[] scanRecord, ReactContext reactContext) {
+    public Peripheral(BluetoothDevice device, int advertisingRSSI, byte[] scanRecord, BleManager bleManager) {
         this.device = device;
         this.bufferedCharacteristics = new ConcurrentHashMap<String, NotifyBufferContainer>();
         this.advertisingRSSI = advertisingRSSI;
         this.advertisingDataBytes = scanRecord;
-        this.reactContext = reactContext;
+        this.bleManager = bleManager;
     }
 
-    public Peripheral(BluetoothDevice device, ReactContext reactContext) {
+    public Peripheral(BluetoothDevice device, BleManager bleManager) {
         this.device = device;
         this.bufferedCharacteristics = new ConcurrentHashMap<String, NotifyBufferContainer>();
-        this.reactContext = reactContext;
+        this.bleManager = bleManager;
     }
 
-    private void sendEvent(String eventName, @Nullable WritableMap params) {
-        synchronized (reactContext) {
-            reactContext.getJSModule(RCTNativeAppEventEmitter.class).emit(eventName, params);
+    private void sendConnectionEvent(BluetoothDevice device, int status) {
+        WritableMap map = Arguments.createMap();
+        map.putString("peripheral", device.getAddress());
+        if (status != -1) {
+            map.putInt("status", status);
         }
+        bleManager.emitOnConnectPeripheral(map);
+        Log.d(BleManager.LOG_TAG, "Peripheral connected:" + device.getAddress());
     }
 
-    private void sendConnectionEvent(BluetoothDevice device, String eventName, int status) {
+    private void sendDisconnectionEvent(BluetoothDevice device, int status) {
         WritableMap map = Arguments.createMap();
         map.putString("peripheral", device.getAddress());
         if (status != -1) {
             map.putInt("status", status);
         }
-        sendEvent(eventName, map);
-        Log.d(BleManager.LOG_TAG, "Peripheral event (" + eventName + "):" + device.getAddress());
+        bleManager.emitOnDisconnectPeripheral(map);
+        Log.d(BleManager.LOG_TAG, "Peripheral disconnected:" + device.getAddress());
     }
 
     public void connect(final Callback callback, Activity activity, ReadableMap options) {
@@ -172,11 +176,11 @@ public class Peripheral extends BluetoothGattCallback {
                     if (force) {
                         gatt.close();
                         gatt = null;
-                        sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_SUCCESS);
+                        sendDisconnectionEvent(device, BluetoothGatt.GATT_SUCCESS);
                     }
                     Log.d(BleManager.LOG_TAG, "Disconnect");
                 } catch (Exception e) {
-                    sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_FAILURE);
+                    sendDisconnectionEvent(device, BluetoothGatt.GATT_FAILURE);
                     Log.d(BleManager.LOG_TAG, "Error on disconnect", e);
                 }
             } else
@@ -335,7 +339,7 @@ public class Peripheral extends BluetoothGattCallback {
 
                 mainHandler.post(discoverServicesRunnable);
 
-                sendConnectionEvent(device, "BleManagerConnectPeripheral", status);
+                sendConnectionEvent(device, status);
 
                 Log.d(BleManager.LOG_TAG, "Connected to: " + device.getAddress());
                 for (Callback connectCallback : connectCallbacks) {
@@ -406,8 +410,7 @@ public class Peripheral extends BluetoothGattCallback {
                 gatt.disconnect();
                 gatt.close();
                 gatt = null;
-                sendConnectionEvent(device, "BleManagerDisconnectPeripheral", BluetoothGatt.GATT_SUCCESS);
-
+                sendDisconnectionEvent(device, BluetoothGatt.GATT_SUCCESS);
             }
 
         });
@@ -464,7 +467,7 @@ public class Peripheral extends BluetoothGattCallback {
                 map.putString("characteristic", charString);
                 map.putString("service", service);
                 map.putArray("value", BleManager.bytesToWritableArray(dataValue));
-                sendEvent("BleManagerDidUpdateValueForCharacteristic", map);
+                bleManager.emitOnDidUpdateNotificationStateFor(map);
 
                 // Check if rest exists. If so it needs to be added to the clean buffer
                 dataValue = rest;

package/dist/cjs/NativeBleManager.d.ts

@@ -0,0 +1,241 @@
+import { TurboModule } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * This represents the Turbo Module version of react-native-ble-manager.
+ * This adds the codegen definition to react-native generate the c++ bindings on compile time.
+ * That should work only on 0.75 and higher.
+ * Don't remove it! and please modify with caution! Knowing that can create wrong bindings into jsi and break at compile or execution time.
+ *  - Knowing that also every type needs to match the current Objective C++ and Java callbacks types and callbacks type definitions and be aware of the current differences between implementation in both platforms.
+ */
+export interface Spec extends TurboModule {
+    start(options: Object, callback: (error: CallbackError) => void): void;
+    scan(serviceUUIDStrings: string[], timeoutSeconds: number, allowDuplicates: boolean, scanningOptions: Object, callback: (error: CallbackError) => void): void;
+    stopScan(callback: (error: CallbackError) => void): void;
+    connect(peripheralUUID: string, options: Object, callback: (error: CallbackError) => void): void;
+    disconnect(peripheralUUID: string, force: boolean, callback: (error: CallbackError) => void): void;
+    retrieveServices(peripheralUUID: string, services: string[], callback: (error: CallbackError, peripheral: PeripheralInfo) => void): void;
+    readRSSI(peripheralUUID: string, callback: (error: string | null, rssi: number) => void): void;
+    readDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, callback: (error: string | null, data: number[]) => void): void;
+    writeDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, data: object[], callback: (error: string | null) => void): void;
+    getDiscoveredPeripherals(callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    checkState(callback: (state: BleState) => void): void;
+    write(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: object[], maxByteSize: number, callback: (error: string | null) => void): void;
+    writeWithoutResponse(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: object[], maxByteSize: number, queueSleepTime: number, callback: (error: string | null) => void): void;
+    read(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null, data: number[]) => void): void;
+    startNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null) => void): void;
+    stopNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: string | null) => void): void;
+    getConnectedPeripherals(serviceUUIDStrings: string[], callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    isPeripheralConnected(peripheralUUID: string, callback: (error: Peripheral[]) => void): void;
+    isScanning(callback: (error: string | null, status: boolean) => void): void;
+    getMaximumWriteValueLengthForWithoutResponse(peripheralUUID: string, callback: (error: string | null, max: number) => void): void;
+    getMaximumWriteValueLengthForWithResponse(deviceUUID: string, callback: (error: string | null, max: number) => void): void;
+    enableBluetooth(callback: (error: string | null) => void): void;
+    getBondedPeripherals(callback: (error: string | null, result: Peripheral[] | null) => void): void;
+    createBond(peripheralUUID: string, devicePin: string, callback: (error: string | null) => void): void;
+    removeBond(peripheralUUID: string, callback: (error: string | null) => void): void;
+    removePeripheral(peripheralUUID: string, callback: (error: string | null) => void): void;
+    requestMTU(peripheralUUID: string, mtu: number, callback: (error: string | null, mtu: number) => void): void;
+    requestConnectionPriority(peripheralUUID: string, connectionPriority: number, callback: (error: string | null, status: boolean) => void): void;
+    refreshCache(peripheralUUID: string, callback: (error: string | null, result: boolean) => void): void;
+    setName(name: string): void;
+    getAssociatedPeripherals(callback: (error: string | null, peripherals: Peripheral[] | null) => void): void;
+    removeAssociatedPeripheral(peripheralUUID: string, callback: (error: string | null) => void): void;
+    supportsCompanion(callback: (supports: boolean) => void): void;
+    companionScan(serviceUUIDs: string[], option: Object, callback: (error: string | null, peripheral: Peripheral | null) => void): void;
+    /**
+     * Supported events.
+     */
+    readonly onDiscoverPeripheral: EventEmitter<Peripheral>;
+    readonly onStopScan: EventEmitter<EventStopScan>;
+    readonly onDidUpdateState: EventEmitter<EventDidUpdateState>;
+    readonly onDidUpdateValueForCharacteristic: EventEmitter<EventDidUpdateValueForCharacteristic>;
+    readonly onConnectPeripheral: EventEmitter<EventConnectPeripheral>;
+    readonly onDisconnectPeripheral: EventEmitter<EventDisconnectPeripheral>;
+    readonly onPeripheralDidBond: EventEmitter<EventPeripheralDidBond>;
+    readonly onCentralManagerWillRestoreState: EventEmitter<EventCentralManagerWillRestoreState>;
+    readonly onDidUpdateNotificationStateFor: EventEmitter<EventDidUpdateNotificationStateFor>;
+    readonly onCompanionPeripheral: EventEmitter<EventCompanionPeripheral>;
+    readonly onCompanionFailure: EventEmitter<EventCompanionFailure>;
+}
+declare const _default: Spec;
+export default _default;
+/** Turbo Module Type Definitions */
+export type BleScanCallbackType = number;
+export type BleScanMatchCount = number;
+export type BleScanMatchMode = number;
+export type BleScanMode = number;
+export type BleScanPhyMode = number;
+export type CallbackError = string | null;
+export type BleState = string;
+export type Peripheral = {
+    id: string;
+    rssi: number;
+    name: string | null;
+    advertising: {
+        isConnectable?: boolean;
+        localName?: string | null;
+        rawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        };
+        manufacturerData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        manufacturerRawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        serviceData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        serviceUUIDs?: string[];
+        txPowerLevel?: number;
+    };
+};
+export type PeripheralInfo = {
+    id: string;
+    rssi: number;
+    name: string | null;
+    advertising: {
+        isConnectable?: boolean;
+        localName?: string | null;
+        rawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        manufacturerData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        manufacturerRawData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        } | null;
+        serviceData?: {
+            CDVType: number[];
+            bytes: number[];
+            data: string;
+        }[] | null;
+        serviceUUIDs?: string[];
+        txPowerLevel?: number;
+    };
+    serviceUUIDs?: string[];
+    characteristics?: {
+        properties: {
+            Broadcast?: string;
+            Read?: string;
+            WriteWithoutResponse?: string;
+            Write?: string;
+            Notify?: string;
+            Indicate?: string;
+            AuthenticatedSignedWrites?: string;
+            ExtendedProperties?: string;
+            NotifyEncryptionRequired?: string;
+            IndicateEncryptionRequired?: string;
+        };
+        characteristic: string;
+        service: string;
+        descriptors?: {
+            value: string;
+            uuid: string;
+        }[];
+    }[];
+    services?: {
+        uuid: string;
+    }[];
+};
+export type EventStopScan = {
+    status: number;
+};
+export type EventDidUpdateState = {
+    state: string;
+};
+export type EventDiscoverPeripheral = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventDidUpdateValueForCharacteristic = {
+    value: number[];
+    peripheral: string;
+    characteristic: string;
+    service: string;
+};
+export type EventConnectPeripheral = {
+    peripheral: string;
+    status?: number | null;
+};
+export type EventDisconnectPeripheral = {
+    peripheral: string;
+    status?: number | null;
+    domain?: string | null;
+    code?: number | null;
+};
+export type EventPeripheralDidBond = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventCentralManagerWillRestoreState = {
+    peripherals: {
+        id: string;
+        name: string;
+        rssi: number;
+        advertising: {
+            isConnectable: boolean;
+            serviceUUIDs: string[];
+            manufacturerData: number[];
+            serviceData: number[];
+            txPowerLevel: number;
+            rawData?: number | null;
+        };
+    }[];
+};
+export type EventDidUpdateNotificationStateFor = {
+    peripheral: string;
+    characteristic: string;
+    isNotifying: boolean;
+    domain?: string | null;
+    code?: number | null;
+};
+export type EventCompanionPeripheral = {
+    id: string;
+    name: string;
+    rssi: number;
+    advertising: {
+        isConnectable: boolean;
+        serviceUUIDs: string[];
+        manufacturerData: number[];
+        serviceData: number[];
+        txPowerLevel: number;
+        rawData?: number | null;
+    };
+};
+export type EventCompanionFailure = {
+    error: string;
+};

package/dist/cjs/NativeBleManager.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.get('BleManager');
+//# sourceMappingURL=NativeBleManager.js.map

package/dist/cjs/NativeBleManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeBleManager.js","sourceRoot":"","sources":["../../src/NativeBleManager.ts"],"names":[],"mappings":";;AAAA,+CAAgE;AA8MhE,kBAAe,kCAAmB,CAAC,GAAG,CAAO,YAAY,CAAS,CAAC"}

package/dist/cjs/index.d.ts

@@ -1,6 +1,6 @@
-import { NativeEventEmitter } from "react-native";
-import { BleState, ConnectOptions, ConnectionPriority, CompanionScanOptions, Peripheral, PeripheralInfo, ScanOptions, StartOptions } from "./types";
-export * from "./types";
+import { EventSubscription, NativeEventEmitter } from 'react-native';
+import { BleState, ConnectOptions, ConnectionPriority, CompanionScanOptions, Peripheral, PeripheralInfo, ScanOptions, StartOptions } from './types';
+export * from './types';
 declare class BleManager extends NativeEventEmitter {
     constructor();
     /**
@@ -207,6 +207,18 @@ declare class BleManager extends NativeEventEmitter {
      * @returns
      */
     getMaximumWriteValueLengthForWithResponse(peripheralId: string): Promise<number>;
+    onDiscoverPeripheral(callback: any): EventSubscription;
+    onStopScan(callback: any): EventSubscription;
+    onDidUpdateState(callback: any): EventSubscription;
+    onCentralManagerDidUpdateState(callback: any): EventSubscription;
+    onConnectPeripheral(callback: any): EventSubscription;
+    onDisconnectPeripheral(callback: any): EventSubscription;
+    onDidUpdateValueForCharacteristic(callback: any): EventSubscription;
+    onPeripheralDidBond(callback: any): EventSubscription;
+    onCentralManagerWillRestoreState(callback: any): EventSubscription;
+    onDidUpdateNotificationStateFor(callback: any): EventSubscription;
+    onCompanionPeripheral(callback: any): EventSubscription;
+    onCompanionAvailability(callback: any): EventSubscription;
 }
 declare const _default: BleManager;
 export default _default;