@offline-protocol/mesh-sdk 0.2.0 → 0.2.2

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

@@ -113,6 +113,8 @@ class BleManager(
     private var gattServer: BluetoothGattServer? = null
     private var messageCharacteristic: BluetoothGattCharacteristic? = null
     private var deviceIdCharacteristic: BluetoothGattCharacteristic? = null
+    @Volatile private var isGattServiceReady = false
+    @Volatile private var pendingAdvertiseReason: String? = null
     
     // Connection registry keeps track of client/server links and desired roles.
     private val connections = MeshConnectionRegistry()
@@ -412,6 +414,8 @@ class BleManager(
         // Close GATT server
         gattServer?.close()
         gattServer = null
+        isGattServiceReady = false
+        pendingAdvertiseReason = null
         
         updateState(TransportState.STOPPED)
         protocol.bleStatusChanged(false)
@@ -508,6 +512,9 @@ class BleManager(
     
     private fun setupGattServer() {
         try {
+            // Reset flag - service registration is asynchronous
+            isGattServiceReady = false
+            
             gattServer = bluetoothManager.openGattServer(context, gattServerCallback)
             
             // Create message characteristic (write without response + notify)
@@ -530,10 +537,11 @@ class BleManager(
             service.addCharacteristic(messageCharacteristic)
             service.addCharacteristic(deviceIdCharacteristic)
             
-            // Add service to GATT server
+            // Add service to GATT server (asynchronous - callback in onServiceAdded)
             gattServer?.addService(service)
             
-            Log.i(TAG, "GATT server configured")
+            Log.i(TAG, "GATT server setup initiated, waiting for service registration callback...")
+            emitDiagnostic("info", "GATT server setup initiated")
         } catch (e: SecurityException) {
             Log.e(TAG, "Permission denied while setting up GATT server", e)
             throw e
@@ -644,6 +652,16 @@ class BleManager(
     private fun startAdvertising(reason: String = "manual") {
         if (isAdvertising) return
         
+        // Wait for GATT service to be ready before advertising
+        if (!isGattServiceReady) {
+            pendingAdvertiseReason = reason
+            if (logThrottler.shouldLog("advert_waiting_gatt", intervalMs = 5000)) {
+                Log.i(TAG, "Waiting for GATT service to be ready before advertising (reason: $reason)")
+                emitDiagnostic("info", "Waiting for GATT service registration", mapOf("reason" to reason))
+            }
+            return
+        }
+        
         try {
             val settings = AdvertiseSettings.Builder()
                 .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY)
@@ -680,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) {
@@ -744,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
@@ -1456,6 +1493,33 @@ class BleManager(
     // MARK: - GATT Server Callback
     
     private val gattServerCallback = object : BluetoothGattServerCallback() {
+        override fun onServiceAdded(status: Int, service: BluetoothGattService?) {
+            if (status == BluetoothGatt.GATT_SUCCESS) {
+                Log.i(TAG, "✅ GATT service added successfully: ${service?.uuid}")
+                emitDiagnostic("info", "GATT service registered successfully", mapOf(
+                    "serviceUUID" to (service?.uuid?.toString() ?: "unknown")
+                ))
+                isGattServiceReady = true
+                
+                // Start advertising now that the service is ready
+                val reason = pendingAdvertiseReason
+                if (reason != null) {
+                    pendingAdvertiseReason = null
+                    Log.i(TAG, "📡 Starting deferred advertising after GATT service ready")
+                    mainHandler.post {
+                        startAdvertising("gatt_service_ready")
+                    }
+                }
+            } else {
+                Log.e(TAG, "❌ Error adding GATT service: status=$status")
+                emitDiagnostic("error", "Error adding GATT service", mapOf(
+                    "status" to status,
+                    "serviceUUID" to (service?.uuid?.toString() ?: "unknown")
+                ))
+                isGattServiceReady = false
+            }
+        }
+        
         override fun onConnectionStateChange(device: BluetoothDevice, status: Int, newState: Int) {
             when (newState) {
                 BluetoothProfile.STATE_CONNECTED -> {

package/ios/BleManager.swift

@@ -121,6 +121,8 @@ public class BleManager: NSObject, TransportManager {
     private var isAdvertising = false
     private var centralReady = false
     private var peripheralReady = false
+    private var isGattServiceReady = false
+    private var pendingAdvertiseAfterServiceReady = false
     private var subscribedCentrals: Set<UUID> = []
     private var lastMeshAdvertisement: MeshAdvertisementData?
     
@@ -159,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)
@@ -385,6 +390,7 @@ public class BleManager: NSObject, TransportManager {
         pendingFragments.removeAll()
         pendingOutboundFragments.removeAll()
         lastSeenMeshAdvertisements.removeAll()
+        unknownDeviceAttempts.removeAll()
         pendingAdvertiseRestart?.cancel()
         pendingAdvertiseRestart = nil
         lastAdvertiseRestartAt = nil
@@ -397,6 +403,8 @@ public class BleManager: NSObject, TransportManager {
         
         centralReady = false
         peripheralReady = false
+        isGattServiceReady = false
+        pendingAdvertiseAfterServiceReady = false
         
         updateState(.stopped)
         emitDiagnostic("info", "BLE transport stopped")
@@ -473,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
@@ -705,6 +717,16 @@ public class BleManager: NSObject, TransportManager {
         
         setupGattServer()
         
+        // Wait for GATT service to be ready before advertising
+        guard isGattServiceReady else {
+            pendingAdvertiseAfterServiceReady = true
+            if logThrottler.shouldLog(key: "advert_waiting_gatt", interval: 5) {
+                print("[BleManager] Waiting for GATT service to be ready before advertising (reason: \(reason))")
+                emitDiagnostic("info", "Waiting for GATT service registration", context: ["reason": reason])
+            }
+            return
+        }
+        
         let meshData = meshController.advertisement()
         lastMeshAdvertisement = meshData
         var advertisementData: [String: Any] = [
@@ -763,10 +785,13 @@ public class BleManager: NSObject, TransportManager {
     
     private func setupGattServer() {
         guard let peripheral = peripheralManager else { return }
-        if messageCharacteristic != nil && deviceIdCharacteristic != nil {
+        if messageCharacteristic != nil && deviceIdCharacteristic != nil && isGattServiceReady {
             return
         }
         
+        // Reset flag - service registration is asynchronous
+        isGattServiceReady = false
+        
         // Create message characteristic (write without response + notify)
         messageCharacteristic = CBMutableCharacteristic(
             type: MESSAGE_CHAR_UUID,
@@ -788,10 +813,10 @@ public class BleManager: NSObject, TransportManager {
         let service = CBMutableService(type: SERVICE_UUID, primary: true)
         service.characteristics = [messageCharacteristic!, deviceIdCharacteristic!]
         
-        // Add service to peripheral manager
+        // Add service to peripheral manager (asynchronous - callback in peripheralManager(_:didAdd:error:))
         peripheral.add(service)
-        print("[BleManager] GATT server configured")
-        emitDiagnostic("info", "GATT server configured")
+        print("[BleManager] GATT server setup initiated, waiting for service registration callback...")
+        emitDiagnostic("info", "GATT server setup initiated")
     }
     
     private func startFragmentPolling() {
@@ -1199,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
@@ -1302,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 {
@@ -1482,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) {
@@ -1523,7 +1647,20 @@ extension BleManager: CBCentralManagerDelegate {
         pruneMeshObservations(now: now)
         meshController.observeAdvertisement(meshMetadata, rssi: Int(rssiValue))
 
-        let decision = meshController.shouldInitiateOutbound(metadata: meshMetadata, rssi: Int(rssiValue))
+        // When there's no metadata (iOS/Android advertising without service data),
+        // still try to connect - metadata will be exchanged via GATT after connection
+        let decision: MeshController.MeshDecision
+        if meshMetadata == nil {
+            // No metadata in advertisement - allow basic connection to exchange info via GATT
+            decision = MeshController.MeshDecision(
+                intent: .intraCluster,
+                reason: "no_metadata_in_advert",
+                evictPeerId: nil
+            )
+        } else {
+            decision = meshController.shouldInitiateOutbound(metadata: meshMetadata, rssi: Int(rssiValue))
+        }
+        
         guard decision.intent != .rejected else {
             if logThrottler.shouldLog(key: "mesh_skip_\(peripheral.identifier.uuidString)", interval: 15) {
                 print("[BleManager] Skipping \(peripheral.identifier) due to \(decision.reason)")
@@ -1892,6 +2029,32 @@ extension BleManager: CBPeripheralManagerDelegate {
         }
     }
     
+    public func peripheralManager(_ peripheral: CBPeripheralManager, didAdd service: CBService, error: Error?) {
+        if let error = error {
+            print("[BleManager] ❌ Error adding GATT service: \(error)")
+            emitDiagnostic("error", "Error adding GATT service", context: [
+                "error": error.localizedDescription,
+                "serviceUUID": service.uuid.uuidString
+            ])
+            isGattServiceReady = false
+            return
+        }
+        
+        print("[BleManager] ✅ GATT service added successfully: \(service.uuid)")
+        emitDiagnostic("info", "GATT service registered successfully", context: [
+            "serviceUUID": service.uuid.uuidString
+        ])
+        
+        isGattServiceReady = true
+        
+        // Start advertising now that the service is ready
+        if pendingAdvertiseAfterServiceReady {
+            pendingAdvertiseAfterServiceReady = false
+            print("[BleManager] 📡 Starting deferred advertising after GATT service ready")
+            startAdvertising(reason: "gatt_service_ready")
+        }
+    }
+    
     public func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveWrite requests: [CBATTRequest]) {
         for request in requests {
             print("[BleManager] 📨 GATT WRITE REQUEST from \(request.central.identifier), char: \(request.characteristic.uuid), size: \(request.value?.count ?? 0)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offline-protocol/mesh-sdk",
-  "version": "0.2.0",
+  "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",