react-native-ble-manager 12.2.2 → 12.4.0

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

@@ -2,6 +2,7 @@ package it.innove;
 
 import static com.facebook.react.common.ReactConstants.TAG;
 
+import android.Manifest;
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.bluetooth.BluetoothDevice;
@@ -12,7 +13,7 @@ import android.bluetooth.BluetoothGattDescriptor;
 import android.bluetooth.BluetoothGattService;
 import android.bluetooth.BluetoothProfile;
 import android.bluetooth.BluetoothStatusCodes;
-
+import android.content.pm.PackageManager;
 import android.content.Context;
 import android.os.Build;
 import android.os.Handler;
@@ -22,6 +23,7 @@ import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
@@ -79,7 +81,7 @@ public class Peripheral extends BluetoothGattCallback {
     private final Handler mainHandler = new Handler(Looper.getMainLooper());
     private boolean commandQueueBusy = false;
 
-    private List<byte[]> writeQueue = new ArrayList<>();
+    private final Queue<byte[]> writeQueue = new LinkedList<>();
 
     public Peripheral(BluetoothDevice device, int advertisingRSSI, byte[] scanRecord, BleManager bleManager) {
         this.device = device;
@@ -160,10 +162,10 @@ public class Peripheral extends BluetoothGattCallback {
     // bt_btif : Register with GATT stack failed.
 
     public void disconnect(final Callback callback, final boolean force) {
+        connected = false;
         mainHandler.post(() -> {
             errorAndClearAllCallbacks("Disconnect called before the command completed");
             resetQueuesAndBuffers();
-            connected = false;
 
             if (gatt != null) {
                 try {
@@ -190,11 +192,11 @@ public class Peripheral extends BluetoothGattCallback {
         WritableMap advertising = Arguments.createMap();
 
         try {
-            map.putString("name", device.getName());
+            String name = getSafeDeviceName();
+            map.putString("name", name);
             map.putString("id", device.getAddress()); // mac address
             map.putInt("rssi", advertisingRSSI);
 
-            String name = device.getName();
             if (name != null)
                 advertising.putString("localName", name);
 
@@ -211,6 +213,23 @@ public class Peripheral extends BluetoothGattCallback {
         return map;
     }
 
+    @Nullable
+    protected String getSafeDeviceName() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            Context context = bleManager != null ? bleManager.getReactContext() : null;
+            if (context == null) {
+                return null;
+            }
+
+            if (ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT)
+                    != PackageManager.PERMISSION_GRANTED) {
+                return null;
+            }
+        }
+
+        return device.getName();
+    }
+
     public WritableMap asWritableMap(BluetoothGatt gatt) {
 
         WritableMap map = asWritableMap();
@@ -219,13 +238,13 @@ public class Peripheral extends BluetoothGattCallback {
         WritableArray characteristicsArray = Arguments.createArray();
 
         if (connected && gatt != null) {
-            for (Iterator<BluetoothGattService> it = gatt.getServices().iterator(); it.hasNext();) {
+            for (Iterator<BluetoothGattService> it = gatt.getServices().iterator(); it.hasNext(); ) {
                 BluetoothGattService service = it.next();
                 WritableMap serviceMap = Arguments.createMap();
                 serviceMap.putString("uuid", UUIDHelper.uuidToString(service.getUuid()));
 
                 for (Iterator<BluetoothGattCharacteristic> itCharacteristic = service.getCharacteristics()
-                        .iterator(); itCharacteristic.hasNext();) {
+                        .iterator(); itCharacteristic.hasNext(); ) {
                     BluetoothGattCharacteristic characteristic = itCharacteristic.next();
                     WritableMap characteristicsMap = Arguments.createMap();
 
@@ -297,15 +316,12 @@ public class Peripheral extends BluetoothGattCallback {
                 for (Callback retrieveServicesCallback : retrieveServicesCallbacks) {
                     retrieveServicesCallback.invoke("Error during service retrieval: gatt is null");
                 }
-            }
-            else if (status == BluetoothGatt.GATT_SUCCESS)
-            {
+            } else if (status == BluetoothGatt.GATT_SUCCESS) {
                 for (Callback retrieveServicesCallback : retrieveServicesCallbacks) {
                     WritableMap map = this.asWritableMap(gatt);
                     retrieveServicesCallback.invoke(null, map);
                 }
-            }
-            else {
+            } else {
                 for (Callback retrieveServicesCallback : retrieveServicesCallbacks) {
                     retrieveServicesCallback.invoke("Error during service retrieval.");
                 }
@@ -370,12 +386,20 @@ public class Peripheral extends BluetoothGattCallback {
         connected = false;
         clearBuffers();
     }
+
     @Override
     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);
 
+        // We immediately update the internal connection status
+        if (newState == BluetoothProfile.STATE_CONNECTED && status == BluetoothGatt.GATT_SUCCESS) {
+            connected = true;
+        } else if (newState == BluetoothProfile.STATE_DISCONNECTED || status != BluetoothGatt.GATT_SUCCESS) {
+            connected = false;
+        }
+
         mainHandler.post(() -> {
             gatt = gatta;
 
@@ -385,8 +409,6 @@ public class Peripheral extends BluetoothGattCallback {
 
             connecting = false;
             if (newState == BluetoothProfile.STATE_CONNECTED && status == BluetoothGatt.GATT_SUCCESS) {
-                connected = true;
-
                 sendConnectionEvent(device, status);
 
                 Log.d(BleManager.LOG_TAG, "Connected to: " + device.getAddress());
@@ -420,7 +442,7 @@ public class Peripheral extends BluetoothGattCallback {
         advertisingDataBytes = data;
     }
 
-    //////
+    /// ///
 
     @Override
     public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
@@ -456,7 +478,7 @@ public class Peripheral extends BluetoothGattCallback {
                         return;
                     }
                 }
-                
+
                 WritableMap map = Arguments.createMap();
                 map.putString("peripheral", device.getAddress());
                 map.putString("characteristic", charString);
@@ -480,6 +502,7 @@ public class Peripheral extends BluetoothGattCallback {
             onCharacteristicRead(gatt, characteristic, characteristic.getValue(), status);
         }
     }
+
     @Override
     public void onCharacteristicRead(@NonNull final BluetoothGatt gatt,
                                      @NonNull final BluetoothGattCharacteristic characteristic,
@@ -517,27 +540,28 @@ public class Peripheral extends BluetoothGattCallback {
         super.onCharacteristicWrite(gatt, characteristic, status);
 
         mainHandler.post(() -> {
-            if (writeQueue.size() > 0) {
-                byte[] data = writeQueue.get(0);
-                writeQueue.remove(0);
-                doWrite(characteristic, data, null);
-            } 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;
-                }
-                for (Callback writeCallback : writeCallbacks) {
-                    writeCallback.invoke("Error writing " + characteristic.getUuid() + " status=" + status, null);
-                }
-                writeCallbacks.clear();
-            } else if (!writeCallbacks.isEmpty()) {
-                for (Callback writeCallback : writeCallbacks) {
-                    writeCallback.invoke();
+            if (!writeQueue.isEmpty()) {
+                byte[] data = writeQueue.poll();
+                doWrite(characteristic, data);
+            } 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;
+                    }
+                    for (Callback writeCallback : writeCallbacks) {
+                        writeCallback.invoke("Error writing " + characteristic.getUuid() + " status=" + status, null);
+                    }
+                    writeCallbacks.clear();
+                } else if (!writeCallbacks.isEmpty()) {
+                    for (Callback writeCallback : writeCallbacks) {
+                        writeCallback.invoke();
+                    }
+                    writeCallbacks.clear();
                 }
-                writeCallbacks.clear();
+                completedCommand();
             }
-            completedCommand();
         });
     }
 
@@ -699,7 +723,7 @@ public class Peripheral extends BluetoothGattCallback {
             // Then write to descriptor
             registerNotifyCallbacks.addLast(callback);
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                result &=  BluetoothStatusCodes.SUCCESS == gatt.writeDescriptor(descriptor, finalValue);
+                result &= BluetoothStatusCodes.SUCCESS == gatt.writeDescriptor(descriptor, finalValue);
             } else {
                 descriptor.setValue(finalValue);
                 result &= gatt.writeDescriptor(descriptor);
@@ -752,7 +776,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
@@ -810,7 +834,7 @@ public class Peripheral extends BluetoothGattCallback {
     }
 
     public void readDescriptor(UUID serviceUUID, UUID characteristicUUID, UUID descriptorUUID,
-            final Callback callback) {
+                               final Callback callback) {
         enqueue(() -> {
             if (!isConnected() || gatt == null) {
                 callback.invoke("Device is not connected", null);
@@ -893,9 +917,8 @@ public class Peripheral extends BluetoothGattCallback {
                     writeCallback.invoke("writeDescriptor failed for descriptor: " + descriptor.getUuid(), null);
                 }
                 writeDescriptorCallbacks.clear();
+                completedCommand();
             }
-
-            completedCommand();
         });
     }
 
@@ -939,14 +962,6 @@ public class Peripheral extends BluetoothGattCallback {
                 return;
             }
 
-            // Check if we still have a valid gatt object
-            if (gatt == null) {
-                Log.d(BleManager.LOG_TAG, "Error, gatt is null. Fill all callbacks with an error");
-                errorAndClearAllCallbacks("Gatt is null");
-                resetQueuesAndBuffers();
-                return;
-            }
-
             // Execute the next command in the queue
             commandQueueBusy = true;
             mainHandler.post(new Runnable() {
@@ -1019,7 +1034,12 @@ public class Peripheral extends BluetoothGattCallback {
                 return;
             } else {
                 this.retrieveServicesCallbacks.addLast(callback);
-                gatt.discoverServices();
+                boolean started = gatt.discoverServices();
+                if (!started) {
+                    this.retrieveServicesCallbacks.removeLastOccurrence(callback);
+                    callback.invoke("Failed to start service discovery", null);
+                    completedCommand();
+                }
             }
         });
     }
@@ -1029,7 +1049,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;
@@ -1051,7 +1071,7 @@ public class Peripheral extends BluetoothGattCallback {
     }
 
     private BluetoothGattCharacteristic findCharacteristic(BluetoothGattService service,
-                                                                   UUID characteristicUUID) {
+                                                           UUID characteristicUUID) {
 
         if (service != null) {
             return service.getCharacteristic(characteristicUUID);
@@ -1060,30 +1080,39 @@ public class Peripheral extends BluetoothGattCallback {
         return null;
     }
 
-    public boolean doWrite(final BluetoothGattCharacteristic characteristic, byte[] data, final Callback callback) {
+    private void doWrite(final BluetoothGattCharacteristic characteristic, final byte[] data) {
+        characteristic.setValue(data);
+        if (!gatt.writeCharacteristic(characteristic)) {
+            // write without response, caller will handle the callback
+            for (Callback writeCallback : writeCallbacks) {
+                writeCallback.invoke("Write failed", null);
+            }
+            writeCallbacks.clear();
+            completedCommand();
+        }
+    }
+
+    private boolean enqueueWrite(final BluetoothGattCharacteristic characteristic, byte[] data, final Callback callback) {
         final byte[] copyOfData = copyOf(data);
-        return enqueue(new Runnable() {
-            @Override
-            public void run() {
-                characteristic.setValue(copyOfData);
-                if (characteristic.getWriteType() == BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
-                        && callback != null) {
-                    writeCallbacks.addLast(callback);
-                }
-                if (!gatt.writeCharacteristic(characteristic)) {
-                    // write without response, caller will handle the callback
-                    for (Callback writeCallback : writeCallbacks) {
-                        writeCallback.invoke("Write failed", null);
-                    }
-                    writeCallbacks.clear();
-                    completedCommand();
+        final boolean withResponse = characteristic.getWriteType() == BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT;
+        if (withResponse && callback != null) {
+            writeCallbacks.addLast(callback);
+        }
+        return enqueue(() -> {
+            if (!isConnected() || gatt == null) {
+                if (withResponse && callback != null) {
+                    writeCallbacks.removeLastOccurrence(callback);
+                    callback.invoke("Device is not connected", null);
                 }
+                completedCommand();
+                return;
             }
+            doWrite(characteristic, copyOfData);
         });
     }
 
     public void write(UUID serviceUUID, UUID characteristicUUID, byte[] data, Integer maxByteSize,
-            Integer queueSleepTime, Callback callback, int writeType) {
+                      Integer queueSleepTime, Callback callback, int writeType) {
         enqueue(() -> {
             if (!isConnected() || gatt == null) {
                 callback.invoke("Device is not connected", null);
@@ -1104,12 +1133,15 @@ public class Peripheral extends BluetoothGattCallback {
             characteristic.setWriteType(writeType);
 
             if (data.length <= maxByteSize) {
-                if (!doWrite(characteristic, data, callback)) {
-                    callback.invoke("Write failed");
-                } else {
-                    if (BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE == writeType) {
-                        callback.invoke();
+                if (!enqueueWrite(characteristic, data, callback)) {
+                    if (BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT == writeType) {
+                        writeCallbacks.removeLastOccurrence(callback);
                     }
+                    callback.invoke("Write failed");
+                    completedCommand();
+                    return;
+                } else if (BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE == writeType) {
+                    callback.invoke();
                 }
             } else {
                 int dataLength = data.length;
@@ -1134,21 +1166,24 @@ public class Peripheral extends BluetoothGattCallback {
 
                 if (BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT == writeType) {
                     writeQueue.addAll(splittedMessage);
-                    if (!doWrite(characteristic, firstMessage, callback)) {
+                    if (!enqueueWrite(characteristic, firstMessage, callback)) {
                         writeQueue.clear();
+                        writeCallbacks.remove(callback);
                         callback.invoke("Write failed");
+                        completedCommand();
+                        return;
                     }
                 } else {
                     try {
                         boolean writeError = false;
-                        if (!doWrite(characteristic, firstMessage, callback)) {
+                        if (!enqueueWrite(characteristic, firstMessage, callback)) {
                             writeError = true;
                             callback.invoke("Write failed");
                         }
                         if (!writeError) {
                             Thread.sleep(queueSleepTime);
                             for (byte[] message : splittedMessage) {
-                                if (!doWrite(characteristic, message, callback)) {
+                                if (!enqueueWrite(characteristic, message, callback)) {
                                     writeError = true;
                                     callback.invoke("Write failed");
                                     break;
@@ -1159,8 +1194,14 @@ public class Peripheral extends BluetoothGattCallback {
                                 callback.invoke();
                             }
                         }
+                        if (writeError) {
+                            completedCommand();
+                            return;
+                        }
                     } catch (InterruptedException e) {
                         callback.invoke("Error during writing");
+                        completedCommand();
+                        return;
                     }
                 }
             }
@@ -1234,7 +1275,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;
@@ -1242,9 +1283,9 @@ public class Peripheral extends BluetoothGattCallback {
                 writeProperty = BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE;
             }
 
-           if (service == null) {
-               throw new Exception("Service is null.");
-           }
+            if (service == null) {
+                throw new Exception("Service is null.");
+            }
             List<BluetoothGattCharacteristic> characteristics = service.getCharacteristics();
             for (BluetoothGattCharacteristic characteristic : characteristics) {
                 if ((characteristic.getProperties() & writeProperty) != 0

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

@@ -36,7 +36,7 @@ public abstract class ScanManager {
 
     public abstract void stopScan(Callback callback);
 
-    public abstract void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options, Callback callback);
+    public abstract void scan(ReadableMap options, Callback callback);
 
     public abstract boolean isScanning();
 

package/dist/cjs/NativeBleManager.d.ts

@@ -9,40 +9,41 @@ import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
  */
 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;
+    isStarted(callback: (error: CallbackError, started: boolean) => void): void;
+    scan(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;
+    readRSSI(peripheralUUID: string, callback: (error: CallbackError, rssi: number) => void): void;
+    readDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, callback: (error: CallbackError, data: number[]) => void): void;
+    writeDescriptor(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, data: Object[], callback: (error: CallbackError) => void): void;
+    getDiscoveredPeripherals(callback: (error: CallbackError, 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;
-    startNotificationWithBuffer(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, bufferLength: number, callback: (error: string | null) => 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;
+    write(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: Object[], maxByteSize: number, callback: (error: CallbackError) => void): void;
+    writeWithoutResponse(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, message: Object[], maxByteSize: number, queueSleepTime: number, callback: (error: CallbackError) => void): void;
+    read(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: CallbackError, data: number[]) => void): void;
+    startNotificationWithBuffer(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, bufferLength: number, callback: (error: CallbackError) => void): void;
+    startNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: CallbackError) => void): void;
+    stopNotification(peripheralUUID: string, serviceUUID: string, characteristicUUID: string, callback: (error: CallbackError) => void): void;
+    getConnectedPeripherals(serviceUUIDStrings: string[], callback: (error: CallbackError, 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;
+    isScanning(callback: (error: CallbackError, status: boolean) => void): void;
+    getMaximumWriteValueLengthForWithoutResponse(peripheralUUID: string, callback: (error: CallbackError, max: number) => void): void;
+    getMaximumWriteValueLengthForWithResponse(deviceUUID: string, callback: (error: CallbackError, max: number) => void): void;
+    enableBluetooth(callback: (error: CallbackError) => void): void;
+    getBondedPeripherals(callback: (error: CallbackError, result: Peripheral[] | null) => void): void;
+    createBond(peripheralUUID: string, devicePin: string, callback: (error: CallbackError) => void): void;
+    removeBond(peripheralUUID: string, callback: (error: CallbackError) => void): void;
+    removePeripheral(peripheralUUID: string, callback: (error: CallbackError) => void): void;
+    requestMTU(peripheralUUID: string, mtu: number, callback: (error: CallbackError, mtu: number) => void): void;
+    requestConnectionPriority(peripheralUUID: string, connectionPriority: number, callback: (error: CallbackError, status: boolean) => void): void;
+    refreshCache(peripheralUUID: string, callback: (error: CallbackError, 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;
+    getAssociatedPeripherals(callback: (error: CallbackError, peripherals: Peripheral[] | null) => void): void;
+    removeAssociatedPeripheral(peripheralUUID: string, callback: (error: CallbackError) => void): void;
     supportsCompanion(callback: (supports: boolean) => void): void;
-    companionScan(serviceUUIDs: string[], option: Object, callback: (error: string | null, peripheral: Peripheral | null) => void): void;
+    companionScan(serviceUUIDs: string[], option: Object, callback: (error: CallbackError, peripheral: Peripheral | null) => void): void;
     /**
      * Supported events.
      */

package/dist/cjs/NativeBleManager.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// oxlint-disable no-wrapper-object-types
 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

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

package/dist/cjs/index.d.ts

@@ -104,6 +104,11 @@ declare class BleManager {
     stopNotification(peripheralId: string, serviceUUID: string, characteristicUUID: string): Promise<void>;
     checkState(): Promise<BleState>;
     start(options?: StartOptions): Promise<void>;
+    /**
+     * Check if the BLE manager has been started.
+     * @returns boolean promise indicating if the manager is started.
+     */
+    isStarted(): Promise<boolean>;
     /**
      *
      * @param serviceUUIDs
@@ -112,7 +117,7 @@ declare class BleManager {
      * @param scanningOptions optional map of properties to fine-tune scan behavior, see DOCS.
      * @returns
      */
-    scan(serviceUUIDs: string[], seconds: number, allowDuplicates?: boolean, scanningOptions?: ScanOptions): Promise<void>;
+    scan(scanningOptions?: ScanOptions): Promise<void>;
     stopScan(): Promise<void>;
     /**
      * [Android only] triggers an ENABLE_REQUEST intent to the end-user to enable bluetooth.

package/dist/cjs/index.js

@@ -318,6 +318,22 @@ class BleManager {
             });
         });
     }
+    /**
+     * Check if the BLE manager has been started.
+     * @returns boolean promise indicating if the manager is started.
+     */
+    isStarted() {
+        return new Promise((fulfill, reject) => {
+            BleManagerModule.isStarted((error, started) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    fulfill(started);
+                }
+            });
+        });
+    }
     /**
      *
      * @param serviceUUIDs
@@ -326,10 +342,16 @@ class BleManager {
      * @param scanningOptions optional map of properties to fine-tune scan behavior, see DOCS.
      * @returns
      */
-    scan(serviceUUIDs, seconds, allowDuplicates, scanningOptions = {}) {
+    scan(scanningOptions = {}) {
         return new Promise((fulfill, reject) => {
-            if (allowDuplicates == null) {
-                allowDuplicates = false;
+            if (scanningOptions.serviceUUIDs == null) {
+                scanningOptions.serviceUUIDs = [];
+            }
+            if (scanningOptions.seconds == null) {
+                scanningOptions.seconds = 0;
+            }
+            if (scanningOptions.allowDuplicates == null) {
+                scanningOptions.allowDuplicates = false;
             }
             // (ANDROID) Match as many advertisement per filter as hw could allow
             // depends on current capability and availability of the resources in hw.
@@ -367,7 +389,7 @@ class BleManager {
                     ];
                 }
             }
-            BleManagerModule.scan(serviceUUIDs, seconds, allowDuplicates, scanningOptions, (error) => {
+            BleManagerModule.scan(scanningOptions, (error) => {
                 if (error) {
                     reject(error);
                 }