@offline-protocol/mesh-sdk 0.2.1 → 0.2.2

package/android/src/main/java/com/offlineprotocol/BleManager.kt

@@ -698,7 +698,11 @@ class BleManager(
                 }
             }
             
-            bluetoothLeAdvertiser?.startAdvertising(settings, advertiseData, advertiseCallback)
+            // Include scan response with service UUID for iOS compatibility
+            // iOS's CoreBluetooth actively queries for scan responses and has known issues
+            // recognizing 128-bit service UUIDs from Android's main advertisement packet
+            val scanResponse = buildScanResponse()
+            bluetoothLeAdvertiser?.startAdvertising(settings, advertiseData, scanResponse, advertiseCallback)
             
             // Reduced logging
         } catch (e: SecurityException) {
@@ -762,6 +766,21 @@ class BleManager(
             .build()
     }
     
+    /**
+     * Builds the scan response data for BLE advertising.
+     * 
+     * iOS's CoreBluetooth actively queries for scan responses during BLE scanning.
+     * Including the service UUID in the scan response makes Android devices more
+     * reliably visible to iOS devices, which have known issues recognizing 128-bit
+     * service UUIDs from Android's main advertisement packet format.
+     */
+    private fun buildScanResponse(): AdvertiseData {
+        return AdvertiseData.Builder()
+            .setIncludeDeviceName(false)
+            .addServiceUuid(ParcelUuid(SERVICE_UUID))
+            .build()
+    }
+    
     private fun handleScanResult(result: ScanResult) {
         val device = result.device
         val rssi = result.rssi

package/ios/BleManager.swift

@@ -161,6 +161,9 @@ public class BleManager: NSObject, TransportManager {
     private let MAX_CONSECUTIVE_SCAN_RESTARTS = 3
     private let CENTRAL_RESET_BACKOFF: TimeInterval = 45.0
     private let MINIMUM_RSSI_TO_CONNECT: Int16 = -90
+    /// Rate limiting for unknown connectable devices that need GATT verification
+    private var unknownDeviceAttempts: [UUID: Date] = [:]
+    private let UNKNOWN_DEVICE_RATE_LIMIT: TimeInterval = 10.0
 
     // MARK: - Thread helpers
     @inline(__always)
@@ -387,6 +390,7 @@ public class BleManager: NSObject, TransportManager {
         pendingFragments.removeAll()
         pendingOutboundFragments.removeAll()
         lastSeenMeshAdvertisements.removeAll()
+        unknownDeviceAttempts.removeAll()
         pendingAdvertiseRestart?.cancel()
         pendingAdvertiseRestart = nil
         lastAdvertiseRestartAt = nil
@@ -477,8 +481,12 @@ public class BleManager: NSObject, TransportManager {
             scanRestartCount = 0
         }
         
+        // Scan without service UUID filter for iOS ↔ Android interoperability
+        // iOS's scanForPeripherals(withServices:) has known issues recognizing 128-bit
+        // service UUIDs from Android advertisements. Scanning with nil allows us to see
+        // all peripherals and filter in the discovery callback instead.
         central.scanForPeripherals(
-            withServices: [SERVICE_UUID],
+            withServices: nil,
             options: [CBCentralManagerScanOptionAllowDuplicatesKey: true]
         )
         isScanning = true
@@ -1216,6 +1224,9 @@ public class BleManager: NSObject, TransportManager {
 
     private func pruneMeshObservations(now: Date = Date()) {
         lastSeenMeshAdvertisements = lastSeenMeshAdvertisements.filter { now.timeIntervalSince($0.value.timestamp) <= MESH_OBSERVATION_TTL }
+        
+        // Also clean up stale unknown device rate limiting entries
+        unknownDeviceAttempts = unknownDeviceAttempts.filter { now.timeIntervalSince($0.value) <= UNKNOWN_DEVICE_RATE_LIMIT * 3 }
     }
     
     // MARK: - Adaptive Scan Methods
@@ -1319,6 +1330,88 @@ public class BleManager: NSObject, TransportManager {
         
         return normalizedHash < skipProbability
     }
+    
+    // MARK: - Smart Filtering for iOS ↔ Android Interoperability
+    
+    /// Determines if a discovered peripheral should be processed.
+    /// This implements smart filtering since we scan without a service UUID filter
+    /// (required for iOS ↔ Android interoperability).
+    ///
+    /// Accepts:
+    /// - Devices advertising our service UUID (iOS devices)
+    /// - Devices with our service data
+    /// - Previously discovered mesh devices
+    /// - Unknown connectable devices (rate-limited, verified via GATT)
+    private func shouldProcessDiscoveredPeripheral(
+        peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi: Int16,
+        now: Date
+    ) -> Bool {
+        // 1. Check if device is advertising our service UUID
+        if let serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
+            if serviceUUIDs.contains(SERVICE_UUID) {
+                return true
+            }
+        }
+        
+        // 2. Check for our service data (may come from scan response)
+        if let serviceData = advertisementData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] {
+            if serviceData[SERVICE_UUID] != nil {
+                return true
+            }
+        }
+        
+        // 3. Check if this is a previously discovered mesh device
+        if lastSeenMeshAdvertisements[peripheral.identifier] != nil {
+            return true
+        }
+        
+        // 4. Check if we already have this peripheral in our discovered list
+        //    (previously connected or successfully verified via GATT)
+        if discoveredPeripherals[peripheral.identifier] != nil {
+            return true
+        }
+        
+        // 5. Check if we already have a device ID mapping for this peripheral
+        if connections.peripheralDeviceId(for: peripheral.identifier) != nil ||
+           connections.centralDeviceId(for: peripheral.identifier) != nil {
+            return true
+        }
+        
+        // 6. For unknown connectable devices, allow with rate limiting
+        //    These will be verified via GATT service discovery after connection
+        let isConnectable: Bool
+        if #available(iOS 13.0, *) {
+            isConnectable = (advertisementData[CBAdvertisementDataIsConnectable] as? NSNumber)?.boolValue ?? false
+        } else {
+            isConnectable = true
+        }
+        
+        if isConnectable {
+            // Rate limit unknown device connection attempts
+            if let lastAttempt = unknownDeviceAttempts[peripheral.identifier],
+               now.timeIntervalSince(lastAttempt) < UNKNOWN_DEVICE_RATE_LIMIT {
+                return false
+            }
+            
+            // Only process strong signals for unknown devices
+            if rssi >= -75 {
+                unknownDeviceAttempts[peripheral.identifier] = now
+                if logThrottler.shouldLog(key: "unknown_connectable_\(peripheral.identifier.uuidString)", interval: 30) {
+                    print("[BleManager] Allowing unknown connectable device for GATT verification: \(peripheral.identifier) RSSI=\(rssi)")
+                    emitDiagnostic("debug", "Allowing unknown device for GATT verification", context: [
+                        "identifier": peripheral.identifier.uuidString,
+                        "rssi": rssi
+                    ])
+                }
+                return true
+            }
+        }
+        
+        // Filter out all other devices (not our mesh network)
+        return false
+    }
 
     private func identifierForNodeHash(_ nodeHash: UInt64) -> UUID? {
         for (identifier, observation) in lastSeenMeshAdvertisements where observation.advertisement.nodeIdHash == nodeHash {
@@ -1499,6 +1592,20 @@ extension BleManager: CBCentralManagerDelegate {
         // Adaptive scanning: track discoveries for density estimation
         recordDiscoveryForDensity(now: now)
         
+        // Smart filtering for iOS ↔ Android interoperability
+        // Since we scan without a service UUID filter (for Android compatibility),
+        // we need to filter discovered peripherals here instead.
+        let shouldProcess = shouldProcessDiscoveredPeripheral(
+            peripheral: peripheral,
+            advertisementData: advertisementData,
+            rssi: rssiValue,
+            now: now
+        )
+        
+        if !shouldProcess {
+            return
+        }
+        
         // Adaptive scanning: early RSSI filtering in dense networks
         if shouldFilterByRssi(rssiValue) {
             if logThrottler.shouldLog(key: "adaptive_rssi_filter", interval: 10) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offline-protocol/mesh-sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Offline-first mesh networking SDK with intelligent transport switching for React Native",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",