react-native-ble-manager 12.2.2 → 12.4.0

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

@@ -40,7 +40,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-class BleManager extends NativeBleManagerSpec {
+public class BleManager extends NativeBleManagerSpec {
 
     public static final String LOG_TAG = "RNBleManager";
     private static final int ENABLE_REQUEST = 539;
@@ -282,6 +282,12 @@ class BleManager extends NativeBleManagerSpec {
         Log.d(LOG_TAG, "BleManager initialized");
     }
 
+    @ReactMethod
+    public void isStarted(Callback callback) {
+        Log.d(LOG_TAG, "isStarted");
+        callback.invoke(null, scanManager != null);
+    }
+
     @SuppressLint("MissingPermission")
     @ReactMethod
     public void enableBluetooth(Callback callback) {
@@ -310,7 +316,7 @@ class BleManager extends NativeBleManagerSpec {
     }
 
     @ReactMethod
-    public void scan(ReadableArray serviceUUIDs, double timeoutSeconds, boolean allowDuplicates, ReadableMap scanningOptions,
+    public void scan(ReadableMap scanningOptions,
                      Callback callback) {
         Log.d(LOG_TAG, "scan");
         if (getBluetoothAdapter() == null) {
@@ -333,7 +339,7 @@ class BleManager extends NativeBleManagerSpec {
         }
 
         if (scanManager != null)
-            scanManager.scan(serviceUUIDs, (int) timeoutSeconds, scanningOptions, callback);
+            scanManager.scan(scanningOptions, callback);
     }
 
     @SuppressLint("NewApi") // NOTE: constructor checks the API version.
@@ -448,7 +454,7 @@ class BleManager extends NativeBleManagerSpec {
 
     @ReactMethod
     public void startNotificationWithBuffer(String deviceUUID, String serviceUUID, String characteristicUUID,
-                                           double bufferLength, Callback callback) {
+                                            double bufferLength, Callback callback) {
         Log.d(LOG_TAG, "startNotification");
         if (serviceUUID == null || characteristicUUID == null) {
             callback.invoke("ServiceUUID and characteristicUUID required.");

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

@@ -1,22 +1,23 @@
 package it.innove;
 
+import static it.innove.BleManager.LOG_TAG;
+
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.ScanRecord;
 import android.bluetooth.le.ScanResult;
 import android.os.Build;
 import android.os.ParcelUuid;
 import android.annotation.SuppressLint;
+import android.util.Log;
 import android.util.SparseArray;
 
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 
 import java.nio.ByteBuffer;
 import java.util.Map;
-
+import java.util.Objects;
 
 @SuppressLint("MissingPermission")
 public class DefaultPeripheral extends Peripheral {
@@ -25,7 +26,7 @@ public class DefaultPeripheral extends Peripheral {
     private ScanResult scanResult;
 
     public DefaultPeripheral(BleManager bleManager, ScanResult result) {
-        super(result.getDevice(), result.getRssi(), result.getScanRecord().getBytes(), bleManager);
+        super(result.getDevice(), result.getRssi(), Objects.requireNonNull(result.getScanRecord()).getBytes(), bleManager);
         this.advertisingData = result.getScanRecord();
         this.scanResult = result;
     }
@@ -40,13 +41,17 @@ public class DefaultPeripheral extends Peripheral {
         WritableMap advertising = Arguments.createMap();
 
         try {
-            map.putString("name", device.getName());
+            String name = getSafeDeviceName();
+            if (name == null && scanResult != null && scanResult.getScanRecord() != null) {
+                name = scanResult.getScanRecord().getDeviceName();
+            }
+            map.putString("name", name);
             map.putString("id", device.getAddress()); // mac address
             map.putInt("rssi", advertisingRSSI);
 
             advertising.putMap("rawData", byteArrayToWritableMap(advertisingDataBytes));
 
-            if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                 // We can check if peripheral is connectable using the scanresult
                 if (this.scanResult != null) {
                     advertising.putBoolean("isConnectable", scanResult.isConnectable());
@@ -62,7 +67,7 @@ public class DefaultPeripheral extends Peripheral {
                     advertising.putString("localName", deviceName.replace("\0", ""));
 
                 WritableArray serviceUuids = Arguments.createArray();
-                if (advertisingData.getServiceUuids() != null && advertisingData.getServiceUuids().size() != 0) {
+                if (advertisingData.getServiceUuids() != null && !advertisingData.getServiceUuids().isEmpty()) {
                     for (ParcelUuid uuid : advertisingData.getServiceUuids()) {
                         serviceUuids.pushString(UUIDHelper.uuidToString(uuid.getUuid()));
                     }
@@ -102,7 +107,7 @@ public class DefaultPeripheral extends Peripheral {
 
             map.putMap("advertising", advertising);
         } catch (Exception e) { // this shouldn't happen
-            e.printStackTrace();
+            Log.e(LOG_TAG, "asWritableMap error", e);
         }
 
         return map;
@@ -111,6 +116,6 @@ public class DefaultPeripheral extends Peripheral {
     public void updateData(ScanResult result) {
         scanResult = result;
         advertisingData = result.getScanRecord();
-        advertisingDataBytes = advertisingData.getBytes();
+        advertisingDataBytes = advertisingData != null ? advertisingData.getBytes() : null;
     }
 }

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

@@ -7,19 +7,24 @@ import android.Manifest;
 import android.annotation.SuppressLint;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
-import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.BluetoothLeScanner;
 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.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.ParcelUuid;
 import android.util.Log;
 
 import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
@@ -31,11 +36,20 @@ import com.facebook.react.bridge.WritableMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 
 @SuppressLint("MissingPermission")
 public class DefaultScanManager extends ScanManager {
 
     private boolean isScanning = false;
+    private PendingIntent scanPendingIntent;
+    private BroadcastReceiver scanReceiver;
+    private boolean scanReceiverRegistered = false;
+    private boolean scanningWithIntent = false;
+    private static final String ACTION_SCAN_RESULT = "it.innove.BleManager.ACTION_SCAN_RESULT";
+    private static final String EXTRA_LIST_SCAN_RESULT = "android.bluetooth.le.extra.LIST_SCAN_RESULT";
+    private static final String EXTRA_SCAN_RESULT = "android.bluetooth.le.extra.SCAN_RESULT";
+    private static final String EXTRA_ERROR_CODE = "android.bluetooth.le.extra.ERROR_CODE";
 
     public DefaultScanManager(ReactApplicationContext reactContext, BleManager bleManager) {
         super(reactContext, bleManager);
@@ -47,15 +61,12 @@ public class DefaultScanManager extends ScanManager {
         // update scanSessionId to prevent stopping next scan by running timeout thread
         scanSessionId.incrementAndGet();
 
-        final BluetoothLeScanner scanner = getBluetoothAdapter().getBluetoothLeScanner();
-        if (scanner != null)
-            scanner.stopScan(mScanCallback);
-        isScanning = false;
+        stopActiveScan();
         callback.invoke();
     }
 
     @Override
-    public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options, Callback callback) {
+    public void scan(ReadableMap options, Callback callback) {
         ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder();
         List<ScanFilter> filters = new ArrayList<>();
 
@@ -67,16 +78,14 @@ public class DefaultScanManager extends ScanManager {
             scanSettingsBuilder.setScanMode(options.getInt("scanMode"));
         }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            if (options.hasKey("numberOfMatches")) {
-                scanSettingsBuilder.setNumOfMatches(options.getInt("numberOfMatches"));
-            }
-            if (options.hasKey("matchMode")) {
-                scanSettingsBuilder.setMatchMode(options.getInt("matchMode"));
-            }
-            if (options.hasKey("callbackType")) {
-                scanSettingsBuilder.setCallbackType(options.getInt("callbackType"));
-            }
+        if (options.hasKey("numberOfMatches")) {
+            scanSettingsBuilder.setNumOfMatches(options.getInt("numberOfMatches"));
+        }
+        if (options.hasKey("matchMode")) {
+            scanSettingsBuilder.setMatchMode(options.getInt("matchMode"));
+        }
+        if (options.hasKey("callbackType")) {
+            scanSettingsBuilder.setCallbackType(options.getInt("callbackType"));
         }
 
         if (options.hasKey("reportDelay")) {
@@ -93,9 +102,10 @@ public class DefaultScanManager extends ScanManager {
             }
         }
 
-        if (serviceUUIDs.size() > 0) {
+        ReadableArray serviceUUIDs = options.getArray("serviceUUIDs");
+        if (serviceUUIDs != null && 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();
+                ScanFilter filter = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(UUIDHelper.uuidFromString(Objects.requireNonNull(serviceUUIDs.getString(i))))).build();
                 filters.add(filter);
                 Log.d(BleManager.LOG_TAG, "Filter service: " + serviceUUIDs.getString(i));
             }
@@ -103,11 +113,17 @@ public class DefaultScanManager extends ScanManager {
 
 
         if (options.hasKey("exactAdvertisingName")) {
-            ArrayList<Object> expectedNames = options.getArray("exactAdvertisingName").toArrayList();
-            Log.d(BleManager.LOG_TAG, "Filter on advertising names:" + expectedNames);
-            for (Object name : expectedNames) {
-                ScanFilter filter = new ScanFilter.Builder().setDeviceName(name.toString()).build();
-                filters.add(filter);
+            ReadableArray exactAdvertisingNameArray = options.getArray("exactAdvertisingName");
+            if (exactAdvertisingNameArray == null) {
+                Log.w(BleManager.LOG_TAG, "exactAdvertisingName key present but array is null");
+            }
+            if (exactAdvertisingNameArray != null) {
+                ArrayList<Object> expectedNames = exactAdvertisingNameArray.toArrayList();
+                Log.d(BleManager.LOG_TAG, "Filter on advertising names:" + expectedNames);
+                for (Object name : expectedNames) {
+                    ScanFilter filter = new ScanFilter.Builder().setDeviceName(name.toString()).build();
+                    filters.add(filter);
+                }
             }
         }
 
@@ -154,9 +170,58 @@ public class DefaultScanManager extends ScanManager {
             }
         }
 
-        getBluetoothAdapter().getBluetoothLeScanner().startScan(filters, scanSettingsBuilder.build(), mScanCallback);
+        boolean useScanIntent = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+                && options.hasKey("useScanIntent")
+                && options.getBoolean("useScanIntent");
+
+        if (useScanIntent && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            callback.invoke("useScanIntent requires Android O (API 26) or higher");
+            return;
+        }
+
+        if (isScanning) {
+            scanSessionId.incrementAndGet();
+            stopActiveScan();
+        }
+
+        BluetoothLeScanner scanner = getBluetoothAdapter().getBluetoothLeScanner();
+        if (scanner == null) {
+            callback.invoke("No BLE scanner available");
+            return;
+        }
+
+        try {
+            if (useScanIntent) {
+                Log.i(BleManager.LOG_TAG, "Scan with intent");
+                ensureScanReceiver();
+                Intent intent = new Intent(ACTION_SCAN_RESULT);
+                intent.setPackage(context.getPackageName());
+                int flags = PendingIntent.FLAG_UPDATE_CURRENT;
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    flags |= PendingIntent.FLAG_MUTABLE;
+                }
+                scanPendingIntent = PendingIntent.getBroadcast(context, 0, intent, flags);
+                scanner.startScan(filters, scanSettingsBuilder.build(), scanPendingIntent);
+                scanningWithIntent = true;
+            } else {
+                scanner.startScan(filters, scanSettingsBuilder.build(), mScanCallback);
+                scanningWithIntent = false;
+            }
+        } catch (Exception e) {
+            if (useScanIntent) {
+                if (scanPendingIntent != null) {
+                    scanPendingIntent.cancel();
+                    scanPendingIntent = null;
+                }
+                unregisterScanReceiver();
+            }
+            callback.invoke("Failed to start scan: " + e.getMessage());
+            return;
+        }
+
         isScanning = true;
 
+        long scanSeconds = (long) options.getDouble("seconds");
         if (scanSeconds > 0) {
             Thread thread = new Thread() {
                 private final int currentScanSession = scanSessionId.incrementAndGet();
@@ -165,7 +230,7 @@ public class DefaultScanManager extends ScanManager {
                 public void run() {
 
                     try {
-                        Thread.sleep(scanSeconds * 1000);
+                        Thread.sleep(scanSeconds * 1000L);
                     } catch (InterruptedException ignored) {
                     }
 
@@ -177,9 +242,7 @@ public class DefaultScanManager extends ScanManager {
                             // check current scan session was not stopped
                             if (scanSessionId.intValue() == currentScanSession) {
                                 if (btAdapter.getState() == BluetoothAdapter.STATE_ON) {
-                                    final BluetoothLeScanner scanner = btAdapter.getBluetoothLeScanner();
-                                    if (scanner != null) scanner.stopScan(mScanCallback);
-                                    isScanning = false;
+                                    stopActiveScan();
                                 }
 
                                 WritableMap map = Arguments.createMap();
@@ -269,4 +332,87 @@ public class DefaultScanManager extends ScanManager {
     public void setScanning(boolean scanning) {
         isScanning = scanning;
     }
+
+    private void stopActiveScan() {
+        BluetoothLeScanner scanner = getBluetoothAdapter() != null ? getBluetoothAdapter().getBluetoothLeScanner() : null;
+        if (scanner != null) {
+            try {
+                if (scanningWithIntent && scanPendingIntent != null) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                        scanner.stopScan(scanPendingIntent);
+                    }
+                } else {
+                    scanner.stopScan(mScanCallback);
+                }
+            } catch (IllegalArgumentException | IllegalStateException ignored) {
+                Log.w(BleManager.LOG_TAG, "stopScan ignored error: " + ignored.getMessage());
+            }
+        }
+        if (scanPendingIntent != null) {
+            scanPendingIntent.cancel();
+            scanPendingIntent = null;
+        }
+        unregisterScanReceiver();
+        scanningWithIntent = false;
+        isScanning = false;
+    }
+
+    private void ensureScanReceiver() {
+        if (scanReceiver == null) {
+            scanReceiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    if (!ACTION_SCAN_RESULT.equals(intent.getAction())) {
+                        return;
+                    }
+
+                    if (intent.hasExtra(EXTRA_ERROR_CODE)) {
+                        final int errorCode = intent.getIntExtra(EXTRA_ERROR_CODE, ScanCallback.SCAN_FAILED_INTERNAL_ERROR);
+                        runOnUiThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                stopActiveScan();
+                                WritableMap map = Arguments.createMap();
+                                map.putInt("status", errorCode);
+                                bleManager.emitOnStopScan(map);
+                            }
+                        });
+                        return;
+                    }
+
+                    final ArrayList<ScanResult> results = intent.getParcelableArrayListExtra(EXTRA_LIST_SCAN_RESULT);
+                    final ScanResult singleResult = intent.getParcelableExtra(EXTRA_SCAN_RESULT);
+
+                    runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            if (results != null) {
+                                for (ScanResult result : results) {
+                                    onDiscoveredPeripheral(result);
+                                }
+                            } else if (singleResult != null) {
+                                onDiscoveredPeripheral(singleResult);
+                            }
+                        }
+                    });
+                }
+            };
+        }
+
+        if (!scanReceiverRegistered) {
+            IntentFilter intentFilter = new IntentFilter(ACTION_SCAN_RESULT);
+            ContextCompat.registerReceiver(context, scanReceiver, intentFilter, ContextCompat.RECEIVER_NOT_EXPORTED);
+            scanReceiverRegistered = true;
+        }
+    }
+
+    private void unregisterScanReceiver() {
+        if (scanReceiverRegistered) {
+            try {
+                context.unregisterReceiver(scanReceiver);
+            } catch (IllegalArgumentException ignored) {
+            }
+            scanReceiverRegistered = false;
+        }
+    }
 }