react-native-ble-manager 12.4.3 → 12.4.5

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

@@ -460,6 +460,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             peripheral.registerNotify(UUIDHelper.uuidFromString(serviceUUID),
@@ -475,6 +484,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             if (peripheral.isConnected()) {
@@ -494,6 +512,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             if (peripheral.isConnected()) {
@@ -514,6 +541,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             if (peripheral.isConnected()) {
@@ -539,6 +575,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             if (peripheral.isConnected()) {
@@ -563,6 +608,15 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID and characteristicUUID required.");
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID);
+            return;
+        }
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral != null) {
             if (peripheral.isConnected()) {
@@ -582,6 +636,19 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID, CharacteristicUUID and descriptorUUID required.", null);
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID, null);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID, null);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(descriptorUUID)) {
+            callback.invoke("Invalid descriptor UUID format: " + descriptorUUID, null);
+            return;
+        }
 
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral == null) {
@@ -604,6 +671,19 @@ public class BleManager extends NativeBleManagerSpec {
             callback.invoke("ServiceUUID, CharacteristicUUID and descriptorUUID required.", null);
             return;
         }
+        // Validate UUID formats to prevent crash
+        if (!UUIDHelper.isValidBLEUUID(serviceUUID)) {
+            callback.invoke("Invalid service UUID format: " + serviceUUID, null);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(characteristicUUID)) {
+            callback.invoke("Invalid characteristic UUID format: " + characteristicUUID, null);
+            return;
+        }
+        if (!UUIDHelper.isValidBLEUUID(descriptorUUID)) {
+            callback.invoke("Invalid descriptor UUID format: " + descriptorUUID, null);
+            return;
+        }
 
         Peripheral peripheral = peripherals.get(deviceUUID);
         if (peripheral == null) {

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

@@ -109,9 +109,17 @@ public class CompanionScanner {
         AssociationRequest.Builder builder = new AssociationRequest.Builder()
                 .setSingleDevice(options.hasKey("single") && options.getBoolean("single")) ;
 
+        int validUUIDCount = 0;
         for (int i = 0; i < serviceUUIDs.size(); i++) {
-            final ParcelUuid uuid = new ParcelUuid(UUIDHelper.uuidFromString(serviceUUIDs.getString(i)));
+            String uuidString = serviceUUIDs.getString(i);
+            // Validate UUID format to prevent crash
+            if (!UUIDHelper.isValidBLEUUID(uuidString)) {
+                Log.w(LOG_TAG, "Warning: Invalid UUID format in scan options: " + uuidString + ", skipping");
+                continue;
+            }
+            final ParcelUuid uuid = new ParcelUuid(UUIDHelper.uuidFromString(uuidString));
             Log.d(LOG_TAG, "Filter service: " + uuid);
+            validUUIDCount++;
 
             builder = builder
                     // Add LE filter.
@@ -119,6 +127,12 @@ public class CompanionScanner {
                             .setScanFilter(new ScanFilter.Builder().setServiceUuid(uuid).build())
                             .build());
         }
+        
+        // If serviceUUIDs were provided but none were valid, return error
+        if (serviceUUIDs.size() > 0 && validUUIDCount == 0) {
+            callback.invoke("Invalid UUID format in serviceUUIDs: all UUIDs are invalid");
+            return;
+        }
 
         AssociationRequest pairingRequest = builder.build();
         if (scanCallback != null) {

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

@@ -104,10 +104,23 @@ public class DefaultScanManager extends ScanManager {
 
         ReadableArray serviceUUIDs = options.getArray("serviceUUIDs");
         if (serviceUUIDs != null && serviceUUIDs.size() > 0) {
+            int validUUIDCount = 0;
             for (int i = 0; i < serviceUUIDs.size(); i++) {
-                ScanFilter filter = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(UUIDHelper.uuidFromString(Objects.requireNonNull(serviceUUIDs.getString(i))))).build();
+                String uuidString = Objects.requireNonNull(serviceUUIDs.getString(i));
+                // Validate UUID format to prevent crash
+                if (!UUIDHelper.isValidBLEUUID(uuidString)) {
+                    Log.w(BleManager.LOG_TAG, "Warning: Invalid UUID format in scan options: " + uuidString + ", skipping");
+                    continue;
+                }
+                ScanFilter filter = new ScanFilter.Builder().setServiceUuid(new ParcelUuid(UUIDHelper.uuidFromString(uuidString))).build();
                 filters.add(filter);
-                Log.d(BleManager.LOG_TAG, "Filter service: " + serviceUUIDs.getString(i));
+                validUUIDCount++;
+                Log.d(BleManager.LOG_TAG, "Filter service: " + uuidString);
+            }
+            // If serviceUUIDs were provided but none were valid, return error
+            if (validUUIDCount == 0) {
+                callback.invoke("Invalid UUID format in serviceUUIDs: all UUIDs are invalid");
+                return;
             }
         }
 

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

@@ -1099,15 +1099,34 @@ public class Peripheral extends BluetoothGattCallback {
             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);
+            try {
+                 if (!isConnected() || gatt == null) {
+                     if (withResponse && callback != null) {
+                         if (writeCallbacks.removeLastOccurrence(callback)) {
+                             try {
+                                 callback.invoke("Device is not connected", null);
+                             } catch (Exception callbackException) {
+                                 Log.e(BleManager.LOG_TAG, "Error invoking write callback for disconnected device", callbackException);
+                             }
+                         }
+                     }
+                     completedCommand();
+                     return;
+                 }
+                 doWrite(characteristic, copyOfData);
+             } catch (Exception e) {
+                 Log.e(BleManager.LOG_TAG, "Error in enqueueWrite lambda", e);
+                 if (withResponse && callback != null) {
+                     if (writeCallbacks.removeLastOccurrence(callback)) {
+                         try {
+                             callback.invoke("Write failed: " + e.getMessage(), null);
+                         } catch (Exception callbackException) {
+                             Log.e(BleManager.LOG_TAG, "Error invoking write callback", callbackException);
+                         }
+                     }
+                 }
+                 completedCommand();
+             }
         });
     }
 

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

@@ -9,6 +9,27 @@ public class UUIDHelper {
 	// base UUID used to build 128 bit Bluetooth UUIDs
 	public static final String UUID_BASE = "0000XXXX-0000-1000-8000-00805f9b34fb";
 
+	// Validate BLE UUID format (16-bit or 128-bit)
+	// Returns true if the string is a valid BLE UUID format
+	public static boolean isValidBLEUUID(String uuidString) {
+		if (uuidString == null || uuidString.isEmpty()) {
+			return false;
+		}
+
+		// Validate 16-bit UUID (4 hex characters)
+		if (uuidString.length() == 4) {
+			return uuidString.matches("[0-9A-Fa-f]{4}");
+		}
+
+		// Validate 128-bit UUID (standard UUID format)
+		try {
+			UUID.fromString(uuidString);
+			return true;
+		} catch (IllegalArgumentException e) {
+			return false;
+		}
+	}
+
 	// handle 16 and 128 bit UUIDs
 	public static UUID uuidFromString(String uuid) {