react-native-ble-manager 12.4.4 → 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/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) {
 

package/ios/Helper.swift

@@ -274,6 +274,24 @@ class Helper {
         return nil  // Characteristic not found on this service
     }
 
+    // Validate BLE UUID format (16-bit or 128-bit)
+    // Returns true if the string is a valid BLE UUID format
+    static func isValidBLEUUID(_ uuidString: String) -> Bool {
+        // Check for empty string
+        if uuidString.isEmpty {
+            return false
+        }
+        
+        // Validate 16-bit UUID (4 hex characters)
+        let hexCharacterSet = CharacterSet(charactersIn: "0123456789ABCDEFabcdef")
+        let isValid16Bit = uuidString.count == 4 && uuidString.rangeOfCharacter(from: hexCharacterSet.inverted) == nil
+        
+        // Validate 128-bit UUID (standard UUID format)
+        let isValid128Bit = UUID(uuidString: uuidString) != nil
+        
+        return isValid16Bit || isValid128Bit
+    }
+
 }
 
 class Peripheral: Hashable {

package/ios/SwiftBleManager.swift

@@ -191,6 +191,21 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
         prop: CBCharacteristicProperties,
         callback: @escaping RCTResponseSenderBlock
     ) -> BLECommandContext? {
+        // Validate UUID formats to prevent CBUUID(string:) crash
+        guard Helper.isValidBLEUUID(serviceUUIDString) else {
+            let error = "Invalid service UUID format: \(serviceUUIDString)"
+            NSLog(error)
+            callback([error])
+            return nil
+        }
+        
+        guard Helper.isValidBLEUUID(characteristicUUIDString) else {
+            let error = "Invalid characteristic UUID format: \(characteristicUUIDString)"
+            NSLog(error)
+            callback([error])
+            return nil
+        }
+        
         let serviceUUID = CBUUID(string: serviceUUIDString)
         let characteristicUUID = CBUUID(string: characteristicUUIDString)
 
@@ -363,7 +378,21 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
         if let serviceUUIDStrings = scanningOptions["serviceUUIDs"]
             as? [String]
         {
-            serviceUUIDs = serviceUUIDStrings.map { CBUUID(string: $0) }
+            // Validate UUID formats to prevent CBUUID(string:) crash
+            for uuidString in serviceUUIDStrings {
+                if Helper.isValidBLEUUID(uuidString) {
+                    serviceUUIDs.append(CBUUID(string: uuidString))
+                } else {
+                    NSLog("Warning: Invalid UUID format in scan options: \(uuidString), skipping")
+                }
+            }
+            // If serviceUUIDs were provided but none were valid, return error
+            if !serviceUUIDStrings.isEmpty && serviceUUIDs.isEmpty {
+                let error = "Invalid UUID format in serviceUUIDs: all UUIDs are invalid"
+                NSLog(error)
+                callback([error])
+                return
+            }
         }
 
         var options: [String: Any]?
@@ -528,8 +557,14 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
 
             var uuids: [CBUUID] = []
             for string in services {
-                let uuid = CBUUID(string: string)
-                uuids.append(uuid)
+                // Validate UUID format to prevent CBUUID(string:) crash
+                guard Helper.isValidBLEUUID(string) else {
+                    let error = "Invalid service UUID format: \(string)"
+                    NSLog(error)
+                    callback([error])
+                    return
+                }
+                uuids.append(CBUUID(string: string))
             }
 
             if !uuids.isEmpty {
@@ -587,6 +622,14 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
         let peripheral = context.peripheral
         let characteristic = context.characteristic
 
+        // Validate UUID format to prevent CBUUID(string:) crash
+        guard Helper.isValidBLEUUID(descriptorUUID) else {
+            let error = "Invalid descriptor UUID format: \(descriptorUUID)"
+            NSLog(error)
+            callback([error])
+            return
+        }
+
         guard
             let descriptor = Helper.findDescriptor(
                 fromUUID: CBUUID(string: descriptorUUID),
@@ -642,6 +685,14 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
         let peripheral = context.peripheral
         let characteristic = context.characteristic
 
+        // Validate UUID format to prevent CBUUID(string:) crash
+        guard Helper.isValidBLEUUID(descriptorUUID) else {
+            let error = "Invalid descriptor UUID format: \(descriptorUUID)"
+            NSLog(error)
+            callback([error])
+            return
+        }
+
         guard
             let descriptor = Helper.findDescriptor(
                 fromUUID: CBUUID(string: descriptorUUID),
@@ -696,6 +747,15 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
         var serviceUUIDs: [CBUUID] = []
 
         for uuidString in serviceUUIDStrings {
+            // Validate BLE UUID format to prevent CBUUID(string:) crash
+            guard Helper.isValidBLEUUID(uuidString) else {
+                let error = uuidString.isEmpty ? "Invalid UUID: empty string" : "Invalid UUID format: \(uuidString)"
+                NSLog(error)
+                callback([error])
+                return
+            }
+            
+            // Create CBUUID only with validated UUID string (prevents crash)
             serviceUUIDs.append(CBUUID(string: uuidString))
         }
 
@@ -1397,6 +1457,11 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
     ) {
         if let error = error {
             NSLog("Error: \(error)")
+            invokeAndClearDictionary(
+                &retrieveServicesCallbacks,
+                withKey: peripheral.uuidAsString(),
+                usingParameters: [error.localizedDescription]
+            )
             return
         }
         if SwiftBleManager.verboseLogging {
@@ -1440,21 +1505,44 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
     ) {
         if let error = error {
             NSLog("Error: \(error)")
-            return
         }
         if SwiftBleManager.verboseLogging {
             NSLog("Characteristics For Service Discover")
         }
 
+        let peripheralUUIDString = peripheral.uuidAsString()
+        let characteristics = (error == nil) ? (service.characteristics ?? []) : []
+
+        if characteristics.isEmpty {
+            if var servicesLatch = retrieveServicesLatches[peripheralUUIDString] {
+                servicesLatch.remove(service)
+                retrieveServicesLatches[peripheralUUIDString] = servicesLatch
+
+                if servicesLatch.isEmpty {
+                    if let peripheral = peripherals[peripheralUUIDString] {
+                        invokeAndClearDictionary(
+                            &retrieveServicesCallbacks,
+                            withKey: peripheralUUIDString,
+                            usingParameters: [
+                                NSNull(), peripheral.servicesInfo(),
+                            ]
+                        )
+                    }
+                    retrieveServicesLatches.removeValue(
+                        forKey: peripheralUUIDString
+                    )
+                }
+            }
+            return
+        }
+
         var characteristicsForService = Set<CBCharacteristic>()
-        characteristicsForService.formUnion(service.characteristics ?? [])
+        characteristicsForService.formUnion(characteristics)
         characteristicsLatches[service.uuid.uuidString] =
             characteristicsForService
 
-        if let characteristics = service.characteristics {
-            for characteristic in characteristics {
-                peripheral.discoverDescriptors(for: characteristic)
-            }
+        for characteristic in characteristics {
+            peripheral.discoverDescriptors(for: characteristic)
         }
     }
 
@@ -1465,7 +1553,6 @@ public class SwiftBleManager: NSObject, CBCentralManagerDelegate,
     ) {
         if let error = error {
             NSLog("Error: \(error)")
-            return
         }
         let peripheralUUIDString: String = peripheral.uuidAsString()
         let serviceUUIDString: String =

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-ble-manager",
-    "version": "12.4.4",
+    "version": "12.4.5",
     "description": "A BLE module for react native.",
     "homepage": "https://innoveit.github.io/react-native-ble-manager/",
     "repository": {