@capacitor-community/bluetooth-le 8.0.0 → 8.0.2

package/ios/Sources/BluetoothLe/ScanFilters.swift

@@ -0,0 +1,114 @@
+import Foundation
+import CoreBluetooth
+
+struct ManufacturerDataFilter {
+    let companyIdentifier: UInt16
+    let dataPrefix: Data?
+    let mask: Data?
+}
+
+struct ServiceDataFilter {
+    let serviceUuid: CBUUID
+    let dataPrefix: Data?
+    let mask: Data?
+}
+
+class ScanFilterUtils {
+
+    static func passesManufacturerDataFilter(_ advertisementData: [String: Any], filters: [ManufacturerDataFilter]?) -> Bool {
+        guard let filters = filters, !filters.isEmpty else {
+            return true  // No filters means everything passes
+        }
+
+        guard let manufacturerData = advertisementData[CBAdvertisementDataManufacturerDataKey] as? Data,
+              manufacturerData.count >= 2 else {
+            return false  // If there's no valid manufacturer data, fail
+        }
+
+        let companyIdentifier = manufacturerData.prefix(2).withUnsafeBytes {
+            $0.load(as: UInt16.self).littleEndian // Manufacturer ID is little-endian
+        }
+
+        let payload = Data(manufacturerData.dropFirst(2))
+
+        for filter in filters {
+            if filter.companyIdentifier != companyIdentifier {
+                continue  // Skip if company ID does not match
+            }
+
+            if let dataPrefix = filter.dataPrefix {
+                if payload.count < dataPrefix.count {
+                    continue // Payload too short, does not match
+                }
+
+                if let mask = filter.mask {
+                    // Validate that mask length matches dataPrefix length
+                    if mask.count != dataPrefix.count {
+                        continue // Skip this filter if mask length is invalid
+                    }
+                    var matches = true
+                    for i in 0..<dataPrefix.count {
+                        if (payload[i] & mask[i]) != (dataPrefix[i] & mask[i]) {
+                            matches = false
+                            break
+                        }
+                    }
+                    if matches {
+                        return true
+                    }
+                } else if payload.starts(with: dataPrefix) {
+                    return true
+                }
+            } else {
+                return true // Company ID matched, and no dataPrefix required
+            }
+        }
+
+        return false  // If none matched, return false
+    }
+
+    static func passesServiceDataFilter(_ advertisementData: [String: Any], filters: [ServiceDataFilter]?) -> Bool {
+        guard let filters = filters, !filters.isEmpty else {
+            return true  // No filters means everything passes
+        }
+
+        guard let serviceDataDict = advertisementData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] else {
+            return false  // If there's no service data, fail
+        }
+
+        for filter in filters {
+            guard let serviceData = serviceDataDict[filter.serviceUuid] else {
+                continue  // Skip if service UUID does not match
+            }
+
+            if let dataPrefix = filter.dataPrefix {
+                if serviceData.count < dataPrefix.count {
+                    continue // Service data too short, does not match
+                }
+
+                if let mask = filter.mask {
+                    // Validate that mask length matches dataPrefix length
+                    if mask.count != dataPrefix.count {
+                        continue // Skip this filter if mask length is invalid
+                    }
+                    var matches = true
+                    for i in 0..<dataPrefix.count {
+                        if (serviceData[i] & mask[i]) != (dataPrefix[i] & mask[i]) {
+                            matches = false
+                            break
+                        }
+                    }
+                    if matches {
+                        return true
+                    }
+                } else if serviceData.starts(with: dataPrefix) {
+                    return true
+                }
+            } else {
+                return true // Service UUID matched, and no dataPrefix required
+            }
+        }
+
+        return false  // If none matched, return false
+    }
+}

package/ios/Sources/BluetoothLe/ThreadSafeDictionary.swift

@@ -1,15 +1,61 @@
-import Foundation
-
-class ThreadSafeDictionary<K: Hashable, T> {
-    private var dictionary: [K: T] = [:]
-    private let queue = DispatchQueue(label: "threadSafeDictionaryQueue", attributes: .concurrent)
-
-    subscript(key: K) -> T? {
-        get {
-            return queue.sync { dictionary[key] }
-        }
-        set {
-            queue.async(flags: .barrier) { self.dictionary[key] = newValue }
-        }
-    }
-}
+import Foundation
+
+class ThreadSafeDictionary<K: Hashable, T> {
+    private var dictionary: [K: T] = [:]
+    private let queue = DispatchQueue(label: "threadSafeDictionaryQueue", attributes: .concurrent)
+
+    subscript(key: K) -> T? {
+        get {
+            return queue.sync { dictionary[key] }
+        }
+        set {
+            queue.async(flags: .barrier) { self.dictionary[key] = newValue }
+        }
+    }
+
+    func removeValue(forKey key: K) -> T? {
+        return queue.sync(flags: .barrier) {
+            return dictionary.removeValue(forKey: key)
+        }
+    }
+
+    var count: Int {
+        return queue.sync { dictionary.count }
+    }
+
+    func removeAll() {
+        queue.async(flags: .barrier) {
+            self.dictionary.removeAll()
+        }
+    }
+
+    /// Atomically gets existing value or inserts and returns new value
+    /// The create closure is only called if the key doesn't exist
+    /// Returns tuple of (value, wasInserted) where wasInserted indicates if a new value was created
+    func getOrInsert(key: K, create: () -> T) -> (value: T, wasInserted: Bool) {
+        return queue.sync(flags: .barrier) {
+            if let existing = dictionary[key] {
+                return (existing, false)
+            }
+            let newValue = create()
+            dictionary[key] = newValue
+            return (newValue, true)
+        }
+    }
+
+    /// Atomically gets existing value (calling update on it) or inserts new value
+    /// The create closure is only called if the key doesn't exist
+    /// The update closure is called on existing values before returning
+    /// Returns tuple of (value, wasInserted) where wasInserted indicates if a new value was created
+    func getOrInsert(key: K, create: () -> T, update: (T) -> Void) -> (value: T, wasInserted: Bool) {
+        return queue.sync(flags: .barrier) {
+            if let existing = dictionary[key] {
+                update(existing)
+                return (existing, false)
+            }
+            let newValue = create()
+            dictionary[key] = newValue
+            return (newValue, true)
+        }
+    }
+}

package/ios/Tests/BluetoothLeTests/ConversionTests.swift

@@ -1,55 +1,55 @@
-import Foundation
-import CoreBluetooth
-import XCTest
-@testable import BluetoothLe
-
-class ConversionTests: XCTestCase {
-
-    func testDataToString() throws {
-        let input = Data([0xA1, 0x2E, 0x38, 0xD4, 0x89, 0xC3])
-        let output = dataToString(input)
-        XCTAssertEqual(output, "a12e38d489c3")
-    }
-
-    func testStringToData() throws {
-        let input = "a12e38d489c3"
-        let output = stringToData(input)
-        let expected = Data([0xA1, 0x2E, 0x38, 0xD4, 0x89, 0xC3])
-        for (index, byte) in output.enumerated() {
-            XCTAssertEqual(byte, expected[index])
-        }
-    }
-
-    func testEmptyStringToData() throws {
-        let input = ""
-        let output = stringToData(input)
-        XCTAssertEqual(output, Data([]))
-    }
-
-    func testCbuuidToString() throws {
-        XCTAssertEqual(cbuuidToString(CBUUID(string: "180D")), "0000180d-0000-1000-8000-00805f9b34fb")
-        XCTAssertEqual(cbuuidToString(CBUUID(string: "AAAA180D")), "aaaa180d-0000-1000-8000-00805f9b34fb")
-        XCTAssertEqual(cbuuidToString(CBUUID(string: "fb005c80-02e7-f387-1cad-8acd2d8df0c8")), "fb005c80-02e7-f387-1cad-8acd2d8df0c8")
-    }
-
-    func testCbuuidToStringUppercase() throws {
-        XCTAssertEqual(cbuuidToStringUppercase(CBUUID(string: "180D")), "0000180D-0000-1000-8000-00805F9B34FB")
-        XCTAssertEqual(cbuuidToStringUppercase(CBUUID(string: "fb005c80-02e7-f387-1cad-8acd2d8df0c8")), "FB005C80-02E7-F387-1CAD-8ACD2D8DF0C8")
-    }
-
-    func testOptionalStringConversion() throws {
-        let str: String? = "180D"
-        XCTAssertEqual("\(str)", "Optional(\"180D\")")
-        XCTAssertEqual("\(str!)", "180D")
-    }
-
-    func testDescriptorValueToString() throws {
-        XCTAssertEqual(descriptorValueToString("Hello"), "48656c6c6f")
-        XCTAssertEqual(descriptorValueToString(Data([0, 5, 255])), "0005ff")
-        XCTAssertEqual(descriptorValueToString(UInt16(258)), "0201")
-        XCTAssertEqual(descriptorValueToString(UInt16(1)), "0100")
-        XCTAssertEqual(descriptorValueToString(NSNumber(1)), "0100")
-        XCTAssertEqual(descriptorValueToString(0), "")
-    }
-
-}
+import Foundation
+import CoreBluetooth
+import XCTest
+@testable import BluetoothLe
+
+class ConversionTests: XCTestCase {
+
+    func testDataToString() throws {
+        let input = Data([0xA1, 0x2E, 0x38, 0xD4, 0x89, 0xC3])
+        let output = dataToString(input)
+        XCTAssertEqual(output, "a12e38d489c3")
+    }
+
+    func testStringToData() throws {
+        let input = "a12e38d489c3"
+        let output = stringToData(input)
+        let expected = Data([0xA1, 0x2E, 0x38, 0xD4, 0x89, 0xC3])
+        for (index, byte) in output.enumerated() {
+            XCTAssertEqual(byte, expected[index])
+        }
+    }
+
+    func testEmptyStringToData() throws {
+        let input = ""
+        let output = stringToData(input)
+        XCTAssertEqual(output, Data([]))
+    }
+
+    func testCbuuidToString() throws {
+        XCTAssertEqual(cbuuidToString(CBUUID(string: "180D")), "0000180d-0000-1000-8000-00805f9b34fb")
+        XCTAssertEqual(cbuuidToString(CBUUID(string: "AAAA180D")), "aaaa180d-0000-1000-8000-00805f9b34fb")
+        XCTAssertEqual(cbuuidToString(CBUUID(string: "fb005c80-02e7-f387-1cad-8acd2d8df0c8")), "fb005c80-02e7-f387-1cad-8acd2d8df0c8")
+    }
+
+    func testCbuuidToStringUppercase() throws {
+        XCTAssertEqual(cbuuidToStringUppercase(CBUUID(string: "180D")), "0000180D-0000-1000-8000-00805F9B34FB")
+        XCTAssertEqual(cbuuidToStringUppercase(CBUUID(string: "fb005c80-02e7-f387-1cad-8acd2d8df0c8")), "FB005C80-02E7-F387-1CAD-8ACD2D8DF0C8")
+    }
+
+    func testOptionalStringConversion() throws {
+        let str: String? = "180D"
+        XCTAssertEqual("\(str)", "Optional(\"180D\")")
+        XCTAssertEqual("\(str!)", "180D")
+    }
+
+    func testDescriptorValueToString() throws {
+        XCTAssertEqual(descriptorValueToString("Hello"), "48656c6c6f")
+        XCTAssertEqual(descriptorValueToString(Data([0, 5, 255])), "0005ff")
+        XCTAssertEqual(descriptorValueToString(UInt16(258)), "0201")
+        XCTAssertEqual(descriptorValueToString(UInt16(1)), "0100")
+        XCTAssertEqual(descriptorValueToString(NSNumber(1)), "0100")
+        XCTAssertEqual(descriptorValueToString(0), "")
+    }
+
+}

package/ios/Tests/BluetoothLeTests/PluginTests.swift

@@ -1,27 +1,27 @@
-import XCTest
-import Capacitor
-@testable import BluetoothLe
-
-class PluginTests: XCTestCase {
-
-    func testEcho() {
-        // This is an example of a functional test case for a plugin.
-        // Use XCTAssert and related functions to verify your tests produce the correct results.
-
-        let value = "Hello, World!"
-        XCTAssertEqual(1, 1)
-
-        //        let plugin = MyPlugin()
-        //
-        //        let call = CAPPluginCall(callbackId: "test", options: [
-        //            "value": value
-        //        ], success: { (result, _) in
-        //            let resultValue = result!.data["value"] as? String
-        //            XCTAssertEqual(value, resultValue)
-        //        }, error: { (_) in
-        //            XCTFail("Error shouldn't have been called")
-        //        })
-        //
-        //        plugin.echo(call!)
-    }
-}
+import XCTest
+import Capacitor
+@testable import BluetoothLe
+
+class PluginTests: XCTestCase {
+
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let value = "Hello, World!"
+        XCTAssertEqual(1, 1)
+
+        //        let plugin = MyPlugin()
+        //
+        //        let call = CAPPluginCall(callbackId: "test", options: [
+        //            "value": value
+        //        ], success: { (result, _) in
+        //            let resultValue = result!.data["value"] as? String
+        //            XCTAssertEqual(value, resultValue)
+        //        }, error: { (_) in
+        //            XCTFail("Error shouldn't have been called")
+        //        })
+        //
+        //        plugin.echo(call!)
+    }
+}

package/ios/Tests/BluetoothLeTests/ScanFiltersTests.swift

@@ -0,0 +1,153 @@
+import XCTest
+import CoreBluetooth
+@testable import BluetoothLe
+
+class ScanFiltersTests: XCTestCase {
+
+    // MARK: - Manufacturer Data Filter Tests
+
+    func testManufacturerDataFilter_InvalidMaskLength() {
+        // Test that when mask.count != dataPrefix.count, the filter is skipped
+        // and returns false (no match)
+
+        // Create manufacturer data: 2 bytes company ID + 4 bytes payload
+        var manufacturerData = Data()
+        manufacturerData.append(contentsOf: [0x4C, 0x00]) // Apple company ID (0x004C in little-endian)
+        manufacturerData.append(contentsOf: [0x01, 0x02, 0x03, 0x04]) // 4 bytes payload
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataManufacturerDataKey: manufacturerData
+        ]
+
+        // Create filter with dataPrefix of 4 bytes but mask of only 2 bytes
+        // This should be skipped due to invalid mask length
+        let dataPrefix = Data([0x01, 0x02, 0x03, 0x04]) // 4 bytes
+        let mask = Data([0xFF, 0xFF]) // Only 2 bytes - invalid!
+
+        let filter = ManufacturerDataFilter(
+            companyIdentifier: 0x004C,
+            dataPrefix: dataPrefix,
+            mask: mask
+        )
+
+        // Should return false because the filter is skipped due to invalid mask
+        let result = ScanFilterUtils.passesManufacturerDataFilter(advertisementData, filters: [filter])
+        XCTAssertFalse(result, "Should return false when mask length doesn't match dataPrefix length")
+    }
+
+    func testManufacturerDataFilter_ValidMaskLength() {
+        // Test the valid case where mask and dataPrefix have the same length
+        var manufacturerData = Data()
+        manufacturerData.append(contentsOf: [0x4C, 0x00]) // Apple company ID
+        manufacturerData.append(contentsOf: [0x01, 0x02, 0x03, 0x04])
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataManufacturerDataKey: manufacturerData
+        ]
+
+        // Mask and dataPrefix have the same length - should work correctly
+        let dataPrefix = Data([0x01, 0x02, 0x03, 0x04])
+        let mask = Data([0xFF, 0xFF, 0xFF, 0xFF]) // Same length as dataPrefix
+
+        let filter = ManufacturerDataFilter(
+            companyIdentifier: 0x004C,
+            dataPrefix: dataPrefix,
+            mask: mask
+        )
+
+        let result = ScanFilterUtils.passesManufacturerDataFilter(advertisementData, filters: [filter])
+        XCTAssertTrue(result, "Should match when mask and dataPrefix have same length")
+    }
+
+    func testManufacturerDataFilter_NoMask() {
+        // Test without a mask - should use simple prefix matching
+        var manufacturerData = Data()
+        manufacturerData.append(contentsOf: [0x4C, 0x00])
+        manufacturerData.append(contentsOf: [0x01, 0x02, 0x03, 0x04])
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataManufacturerDataKey: manufacturerData
+        ]
+
+        let dataPrefix = Data([0x01, 0x02])
+        let filter = ManufacturerDataFilter(
+            companyIdentifier: 0x004C,
+            dataPrefix: dataPrefix,
+            mask: nil // No mask
+        )
+
+        let result = ScanFilterUtils.passesManufacturerDataFilter(advertisementData, filters: [filter])
+        XCTAssertTrue(result, "Should match with prefix matching when no mask is provided")
+    }
+
+    // MARK: - Service Data Filter Tests
+
+    func testServiceDataFilter_InvalidMaskLength() {
+        // Test that when mask.count != dataPrefix.count, the filter is skipped
+        // and returns false (no match)
+
+        let serviceUUID = CBUUID(string: "1234")
+        let serviceData = Data([0x01, 0x02, 0x03, 0x04]) // 4 bytes
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataServiceDataKey: [serviceUUID: serviceData]
+        ]
+
+        // Create filter with dataPrefix of 4 bytes but mask of only 2 bytes
+        // This should be skipped due to invalid mask length
+        let dataPrefix = Data([0x01, 0x02, 0x03, 0x04]) // 4 bytes
+        let mask = Data([0xFF, 0xFF]) // Only 2 bytes - invalid!
+
+        let filter = ServiceDataFilter(
+            serviceUuid: serviceUUID,
+            dataPrefix: dataPrefix,
+            mask: mask
+        )
+
+        // Should return false because the filter is skipped due to invalid mask
+        let result = ScanFilterUtils.passesServiceDataFilter(advertisementData, filters: [filter])
+        XCTAssertFalse(result, "Should return false when mask length doesn't match dataPrefix length")
+    }
+
+    func testServiceDataFilter_ValidMaskLength() {
+        // Test the valid case where mask and dataPrefix have the same length
+        let serviceUUID = CBUUID(string: "1234")
+        let serviceData = Data([0x01, 0x02, 0x03, 0x04])
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataServiceDataKey: [serviceUUID: serviceData]
+        ]
+
+        let dataPrefix = Data([0x01, 0x02, 0x03, 0x04])
+        let mask = Data([0xFF, 0xFF, 0xFF, 0xFF]) // Same length
+
+        let filter = ServiceDataFilter(
+            serviceUuid: serviceUUID,
+            dataPrefix: dataPrefix,
+            mask: mask
+        )
+
+        let result = ScanFilterUtils.passesServiceDataFilter(advertisementData, filters: [filter])
+        XCTAssertTrue(result, "Should match when mask and dataPrefix have same length")
+    }
+
+    func testServiceDataFilter_NoMask() {
+        // Test without a mask
+        let serviceUUID = CBUUID(string: "1234")
+        let serviceData = Data([0x01, 0x02, 0x03, 0x04])
+
+        let advertisementData: [String: Any] = [
+            CBAdvertisementDataServiceDataKey: [serviceUUID: serviceData]
+        ]
+
+        let dataPrefix = Data([0x01, 0x02])
+        let filter = ServiceDataFilter(
+            serviceUuid: serviceUUID,
+            dataPrefix: dataPrefix,
+            mask: nil
+        )
+
+        let result = ScanFilterUtils.passesServiceDataFilter(advertisementData, filters: [filter])
+        XCTAssertTrue(result, "Should match with prefix matching when no mask is provided")
+    }
+}