react-native-ble-manager 8.1.0 → 8.4.0

package/BleManager.js

@@ -410,6 +410,10 @@ class BleManager {
       });
     });
   }
+
+  setName(name) {
+    bleManager.setName(name);
+  }
 }
 
 module.exports = new BleManager();

package/README.md

@@ -131,10 +131,12 @@ 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` - corresponding to [`setNumOfMatches`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setNumOfMatches(int)>)
-  - `matchMode` - `Number` - corresponding to [`setMatchMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setMatchMode(int)>)
-  - `scanMode` - `Number` - corresponding to [`setScanMode`](<https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder.html#setScanMode(int)>)
-  - `reportDelay` - `Number` - 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)>)
+  - `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)>)
+  - `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))
 
 **Examples**
 
@@ -662,6 +664,25 @@ BleManager.isPeripheralConnected(
 });
 ```
 
+### setName(name) [Android only]
+
+Create the request to set the name of the bluetooth adapter. (https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#setName(java.lang.String))
+Returns a `Promise` object.
+
+**Examples**
+
+```js
+BleManager.setName("INNOVEIT_CENTRAL")
+  .then(() => {
+    // Success code
+    console.log("Name set successfully");
+  })
+  .catch((error) => {
+    // Failure code
+    console.log("Name could not be set");
+  });
+```
+
 ## Events
 
 ### BleManagerStopScan

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

@@ -481,6 +481,12 @@ class BleManager extends ReactContextBaseJavaModule {
         sendEvent("BleManagerDidUpdateState", map);
     }
 
+    @ReactMethod
+    public void setName(String name) {
+        BluetoothAdapter adapter = getBluetoothAdapter();
+        adapter.setName(name);
+    }
+
     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
@@ -732,4 +738,19 @@ class BleManager extends ReactContextBaseJavaModule {
       // Keep: Required for RN built in Event Emitter Calls.
     }
 
+    @Override
+    public void onCatalystInstanceDestroy() {
+        try {
+            // Disconnect all known peripherals, otherwise android system will think we are still connected
+            // while we have lost the gatt instance
+            disconnectPeripherals();
+        }catch(Exception e) {
+            Log.d(LOG_TAG, "Could not disconnect peripherals", e);
+        }
+
+        if (scanManager != null) {
+            // Stop scan in case one was started to stop events from being emitted after destroy
+            scanManager.stopScan(args -> {});
+        }
+    }
 }

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

@@ -41,7 +41,9 @@ public class LollipopPeripheral extends Peripheral {
 
 			if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
 				// We can check if peripheral is connectable using the scanresult
-				advertising.putBoolean("isConnectable", scanResult.isConnectable());
+				if (this.scanResult != null) {
+					advertising.putBoolean("isConnectable", scanResult.isConnectable());
+				}
 			} else{
 				// We can't check if peripheral is connectable
 				advertising.putBoolean("isConnectable", true);
@@ -82,9 +84,9 @@ public class LollipopPeripheral extends Peripheral {
 		return map;
 	}
 
-	public void updateData(ScanRecord scanRecord) {
-		advertisingData = scanRecord;
-		advertisingDataBytes = scanRecord.getBytes();
+	public void updateData(ScanResult result) {
+		advertisingData = result.getScanRecord();
+		advertisingDataBytes = advertisingData.getBytes();
 	}
 
 

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

@@ -2,6 +2,7 @@ package it.innove;
 
 
 import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.ScanCallback;
 import android.bluetooth.le.ScanFilter;
 import android.bluetooth.le.ScanResult;
@@ -37,6 +38,10 @@ public class LollipopScanManager extends ScanManager {
     public void scan(ReadableArray serviceUUIDs, final int scanSeconds, ReadableMap options,  Callback callback) {
         ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder();
         List<ScanFilter> filters = new ArrayList<>();
+
+        if (options.hasKey("legacy")) {
+            scanSettingsBuilder.setLegacy(options.getBoolean("legacy"));
+        }
         
         if (options.hasKey("scanMode")) {
             scanSettingsBuilder.setScanMode(options.getInt("scanMode"));
@@ -54,6 +59,16 @@ public class LollipopScanManager extends ScanManager {
         if (options.hasKey("reportDelay")) {
             scanSettingsBuilder.setReportDelay(options.getInt("reportDelay"));
         }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && options.hasKey("phy")) {
+            int phy = options.getInt("phy");
+            if (phy == BluetoothDevice.PHY_LE_CODED && getBluetoothAdapter().isLeCodedPhySupported()) {
+                scanSettingsBuilder.setPhy(BluetoothDevice.PHY_LE_CODED);
+            }
+            if (phy == BluetoothDevice.PHY_LE_2M && getBluetoothAdapter().isLe2MPhySupported()) {
+                scanSettingsBuilder.setPhy(BluetoothDevice.PHY_LE_2M);
+            }
+        }
         
         if (serviceUUIDs.size() > 0) {
             for(int i = 0; i < serviceUUIDs.size(); i++){
@@ -112,7 +127,7 @@ public class LollipopScanManager extends ScanManager {
                     if (peripheral == null) {
                         peripheral = new LollipopPeripheral(bleManager.getReactContext(), result);
                     } else {
-                        peripheral.updateData(result.getScanRecord());
+                        peripheral.updateData(result);
                         peripheral.updateRssi(result.getRssi());
                     }
                     bleManager.savePeripheral(peripheral);

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

@@ -3,26 +3,33 @@ package it.innove;
 import java.nio.ByteBuffer;
 
 public class NotifyBufferContainer {
-    public final String key;
-    public final Integer maxCount;
+    public final Integer maxBufferSize;
     private Integer bufferCount;
     public ByteBuffer items;
 
-    public NotifyBufferContainer(String key, Integer count) {
-
-        this.key = key;
-        this.maxCount = count;
+    public NotifyBufferContainer(Integer size) {
+        this.maxBufferSize = size;
         this.resetBuffer();
     }
     public void resetBuffer(){
-        this.bufferCount =0;
-        this.items = ByteBuffer.wrap(new byte[this.maxCount * 20]);
+        this.bufferCount = 0;
+        this.items = ByteBuffer.allocate(this.maxBufferSize);
     }
     public void put(byte[] value){
-        this.bufferCount +=1;
+        this.bufferCount += value.length;
+        if (this.items.remaining() < value.length) {
+            return;
+        }
         this.items.put(value);
     }
-    public Integer size(){
+    public boolean isBufferFull(){
+        return this.bufferCount >= this.maxBufferSize;
+    }
+    public Integer size() {
         return this.bufferCount;
     }
+    @Override 
+    protected void finalize() throws Throwable {
+        this.items = ByteBuffer.allocate(0);
+    }
 }

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

@@ -378,10 +378,10 @@ public class Peripheral extends BluetoothGattCallback {
 			byte[] dataValue = characteristic.getValue();
 			if (buffer != null) {
 				buffer.put(dataValue);
-				// Log.d(BleManager.LOG_TAG, "onCharacteristicChanged-buffering: " +
-				// buffer.size() + " from peripheral: " + device.getAddress());
+				Log.d(BleManager.LOG_TAG, "onCharacteristicChanged-buffering: " +
+				buffer.size() + " from peripheral: " + device.getAddress());
 
-				if (buffer.size().equals(buffer.maxCount)) {
+				if (buffer.isBufferFull()) {
 					Log.d(BleManager.LOG_TAG, "onCharacteristicChanged sending buffered data " + buffer.size());
 
 					// send'm and reset
@@ -581,11 +581,21 @@ public class Peripheral extends BluetoothGattCallback {
 
 	public void registerNotify(UUID serviceUUID, UUID characteristicUUID, Integer buffer, Callback callback) {
 		Log.d(BleManager.LOG_TAG, "registerNotify");
+		if (buffer > 1) {
+			Log.d(BleManager.LOG_TAG, "registerNotify using buffer");
+			String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
+			this.bufferedCharacteristics.put(bufferKey, new NotifyBufferContainer(buffer));
+		}
 		this.setNotify(serviceUUID, characteristicUUID, true, callback);
 	}
 
 	public void removeNotify(UUID serviceUUID, UUID characteristicUUID, Callback callback) {
 		Log.d(BleManager.LOG_TAG, "removeNotify");
+		String bufferKey = this.bufferedCharacteristicsKey(serviceUUID.toString(), characteristicUUID.toString());
+		if (this.bufferedCharacteristics.containsKey(bufferKey)) {
+			NotifyBufferContainer buffer = this.bufferedCharacteristics.get(bufferKey);	
+			this.bufferedCharacteristics.remove(bufferKey);
+		}
 		this.setNotify(serviceUUID, characteristicUUID, false, callback);
 	}
 

package/index.d.ts

@@ -28,6 +28,8 @@ declare module "react-native-ble-manager" {
     matchMode?: number;
     scanMode?: number;
     reportDelay?: number;
+    phy?: number;
+    legacy?: boolean;
   }
 
   export function scan(
@@ -110,7 +112,7 @@ declare module "react-native-ble-manager" {
   // [Android only]
   export function refreshCache(peripheralID: string): Promise<void>;
   // [Android only API 21+]
-  export function requestMTU(peripheralID: string, mtu: number): Promise<void>;
+  export function requestMTU(peripheralID: string, mtu: number): Promise<number>;
 
   export function createBond(
     peripheralID: string,
@@ -120,7 +122,9 @@ declare module "react-native-ble-manager" {
   export function getBondedPeripherals(): Promise<Peripheral[]>;
   export function removePeripheral(peripheralID: string): Promise<void>;
 
-  
+  // [Android only]
+  export function setName(name: string): void;
+
   export interface Service {
     uuid: string;
   }
@@ -147,7 +151,7 @@ declare module "react-native-ble-manager" {
     characteristic: string;
     service: string;
     descriptors?: Descriptor[];
-    
+
   }
 
   export interface PeripheralInfo extends Peripheral {

package/package.json

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