@mentra/bluetooth-sdk 0.1.21-beta.5 → 3.1.0-dev.7

package/android/src/main/java/com/mentra/bluetoothsdk/otaserver/MentraOtaServerModule.kt

@@ -0,0 +1,120 @@
+package com.mentra.bluetoothsdk.otaserver
+
+import android.util.Log
+import com.mentra.bluetoothsdk.net.LocalIpv4
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+
+/**
+ * Expo surface for the hotspot-served OTA file server (OS-1676).
+ *
+ * JS hands over the rewritten manifest body and a map of sha256 -> local file path, and gets
+ * back the base URL the glasses should be pointed at via ota_start. The optional host
+ * argument lets the caller pass the authoritative scoped-network address (from
+ * MentraLocalNetwork's LinkProperties); otherwise interface scanning is used.
+ */
+class MentraOtaServerModule : Module() {
+  private var otaServer: LocalOtaServer? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("MentraOtaServer")
+
+    AsyncFunction("startOtaServer") { manifestJson: String, artifactPaths: Map<String, String>, host: String? ->
+      startOtaServer(manifestJson, artifactPaths, host)
+    }
+
+    AsyncFunction("stopOtaServer") {
+      stopOtaServerInternal()
+    }
+
+    // API parity with iOS. Android hotspot OTA obtains the authoritative address
+    // directly from the scoped Network and does not call this fallback.
+    AsyncFunction("waitForWifiAddress") { _: String, _: Int ->
+      LocalIpv4.bestLocalIpv4Address()
+        ?: throw IllegalStateException("No Wi-Fi/LAN IPv4 address found for this phone.")
+    }
+
+    OnDestroy {
+      closeOtaServerInternal()
+    }
+  }
+
+  @Synchronized
+  private fun startOtaServer(
+    manifestJson: String,
+    artifactPaths: Map<String, String>,
+    hostOverride: String?,
+  ): Map<String, Any> {
+    val artifacts = artifactPaths.mapValues { (_, path) ->
+      File(path.removePrefix("file://"))
+    }
+    artifacts.forEach { (key, file) ->
+      if (!file.isFile) {
+        throw IllegalArgumentException("Artifact $key not found at ${file.absolutePath}")
+      }
+    }
+
+    val server = otaServer ?: LocalOtaServer(
+      onLog = { message -> emitStatus(message) },
+    ).also {
+      otaServer = it
+    }
+    server.configure(manifestJson, artifacts)
+
+    val host = hostOverride?.takeIf { it.isNotBlank() }
+      ?: LocalIpv4.bestLocalIpv4Address()
+      ?: throw IllegalStateException("No Wi-Fi/LAN IPv4 address found for this phone.")
+
+    server.activePort?.let { activePort ->
+      emitStatus("OTA server ready at http://$host:$activePort/version.json")
+      return serverResult(host, activePort)
+    }
+
+    var lastError: Throwable? = null
+    for (port in OTA_PORTS) {
+      try {
+        val actualPort = server.start(host, port)
+        emitStatus("OTA server ready at http://$host:$actualPort/version.json")
+        return serverResult(host, actualPort)
+      } catch (error: Throwable) {
+        lastError = error
+        emitStatus("Port $port unavailable: ${error.message ?: error::class.java.simpleName}")
+      }
+    }
+
+    throw IllegalStateException(
+      "Could not start OTA server: ${lastError?.message ?: "all ports unavailable"}",
+    )
+  }
+
+  @Synchronized
+  private fun stopOtaServerInternal() {
+    otaServer?.stop()
+    emitStatus("OTA server stopped")
+  }
+
+  @Synchronized
+  private fun closeOtaServerInternal() {
+    otaServer?.close()
+    otaServer = null
+  }
+
+  private fun emitStatus(message: String) {
+    Log.d(TAG, message)
+  }
+
+  private fun serverResult(host: String, port: Int): Map<String, Any> {
+    return mapOf(
+      "baseUrl" to "http://$host:$port",
+      "manifestUrl" to "http://$host:$port/version.json",
+      "host" to host,
+      "port" to port,
+    )
+  }
+
+  private companion object {
+    const val TAG = "MentraOtaServer"
+    val OTA_PORTS = listOf(8791, 8792, 8793, 8794)
+  }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/photoreceiver/MentraPhotoReceiverModule.kt

@@ -4,11 +4,10 @@ import android.content.Context
 import android.net.Uri
 import android.util.Log
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
+import com.mentra.bluetoothsdk.net.LocalIpv4
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import java.net.Inet4Address
-import java.net.NetworkInterface
 
 class MentraPhotoReceiverModule : Module() {
   private var photoUploadServer: LocalPhotoUploadServer? = null
@@ -45,7 +44,7 @@ class MentraPhotoReceiverModule : Module() {
       photoUploadServer = it
     }
 
-    val host = bestLocalIpv4Address()
+    val host = LocalIpv4.bestLocalIpv4Address()
       ?: throw IllegalStateException("No Wi-Fi/LAN IPv4 address found for this phone.")
 
     server.activePort?.let { activePort ->
@@ -128,39 +127,6 @@ class MentraPhotoReceiverModule : Module() {
       ?: throw Exceptions.ReactContextLost()
   }
 
-  private fun bestLocalIpv4Address(): String? {
-    val wifiPrivateCandidates = mutableListOf<Inet4Address>()
-    val wifiCandidates = mutableListOf<Inet4Address>()
-    val privateCandidates = mutableListOf<Inet4Address>()
-    val otherCandidates = mutableListOf<Inet4Address>()
-    val interfaces = NetworkInterface.getNetworkInterfaces()?.toList().orEmpty()
-    for (networkInterface in interfaces) {
-      if (!networkInterface.isUp || networkInterface.isLoopback) {
-        continue
-      }
-      val addresses = networkInterface.inetAddresses.toList()
-        .filterIsInstance<Inet4Address>()
-        .filter { address ->
-          !address.isLoopbackAddress &&
-            !address.isLinkLocalAddress
-        }
-      if (isWifiInterface(networkInterface.name)) {
-        wifiPrivateCandidates += addresses.filter { isPrivateIpv4(it.hostAddress.orEmpty()) }
-        wifiCandidates += addresses
-      } else {
-        privateCandidates += addresses.filter { isPrivateIpv4(it.hostAddress.orEmpty()) }
-        otherCandidates += addresses
-      }
-    }
-
-    return (
-      wifiPrivateCandidates.firstOrNull() ?:
-        wifiCandidates.firstOrNull() ?:
-        privateCandidates.firstOrNull() ?:
-        otherCandidates.firstOrNull()
-      )?.hostAddress
-  }
-
   private fun receiverEndpoint(host: String, port: Int): ReceiverEndpoint {
     return ReceiverEndpoint(
       uploadUrl = "http://$host:$port/upload",
@@ -177,19 +143,6 @@ class MentraPhotoReceiverModule : Module() {
     )
   }
 
-  private fun isWifiInterface(name: String): Boolean {
-    return name.startsWith("wlan") ||
-      name.startsWith("p2p") ||
-      name.startsWith("ap") ||
-      name.startsWith("swlan")
-  }
-
-  private fun isPrivateIpv4(host: String): Boolean {
-    return host.startsWith("192.168.") ||
-      host.startsWith("10.") ||
-      host.matches(Regex("^172\\.(1[6-9]|2[0-9]|3[0-1])\\..*"))
-  }
-
   private companion object {
     const val TAG = "MentraPhotoReceiver"
     val PHOTO_PORTS = listOf(8787, 8788, 8789, 8790)

package/android/src/main/java/com/mentra/bluetoothsdk/services/Foreground.kt

@@ -20,6 +20,35 @@ class ForegroundService : Service() {
         const val NOTIFICATION_ID = 1001
         const val ACTION_REFRESH_TYPES =
                 "com.mentra.bluetoothsdk.services.action.REFRESH_FOREGROUND_SERVICE_TYPES"
+
+        internal fun bootstrapServiceType(): Int =
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+
+        internal fun preferredServiceType(
+                hasConnectedDeviceAccess: Boolean,
+                hasMicrophoneAccess: Boolean,
+                hasLocationAccess: Boolean,
+                includeMediaPlayback: Boolean = true,
+        ): Int {
+            var serviceType = 0
+
+            if (includeMediaPlayback) {
+                serviceType =
+                        serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+            }
+            if (hasConnectedDeviceAccess) {
+                serviceType =
+                        serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
+            }
+            if (hasMicrophoneAccess) {
+                serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+            }
+            if (hasLocationAccess) {
+                serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
+            }
+
+            return if (serviceType == 0) bootstrapServiceType() else serviceType
+        }
     }
 
     private var locationTypeRequested = false
@@ -28,7 +57,11 @@ class ForegroundService : Service() {
         super.onCreate()
         Bridge.log("ForegroundService: onCreate() called")
         BleTraceLogger.logLifecycle(this, "ForegroundService", "service_create")
-        startForegroundWithAutoDetectedType()
+        // Enter the foreground immediately with a type that has no runtime
+        // prerequisites. onStartCommand() replaces this bootstrap type with the
+        // eligible long-running types, deliberately omitting dataSync so Android 15's
+        // six-hour dataSync timer no longer applies.
+        startForegroundWithType(bootstrapServiceType())
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -50,8 +83,10 @@ class ForegroundService : Service() {
     }
 
     private fun startForegroundWithAutoDetectedType() {
-        val serviceType = detectServiceType()
+        startForegroundWithType(detectServiceType())
+    }
 
+    private fun startForegroundWithType(serviceType: Int) {
         createNotificationChannel()
 
         val notification =
@@ -65,7 +100,7 @@ class ForegroundService : Service() {
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             Bridge.log(
-                    "ForegroundService: Starting with auto-detected type: ${getServiceTypeName(serviceType)}"
+                    "ForegroundService: Starting with type: ${getServiceTypeName(serviceType)}"
             )
             startForeground(NOTIFICATION_ID, notification, serviceType)
         } else {
@@ -79,14 +114,11 @@ class ForegroundService : Service() {
             return 0 // No service types before Android Q
         }
 
-        var serviceType = 0
-
         // Audio prompts can be initiated by glasses while the host Activity is
         // backgrounded. mediaPlayback has no runtime prerequisite, so keep it
         // active on the existing Mentra service for the entire connected
         // session rather than trying to launch a second service after a wake
         // phrase arrives.
-        serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
         Bridge.log("ForegroundService: Added mediaPlayback (supports background audio)")
 
         // Check Bluetooth permissions
@@ -106,28 +138,32 @@ class ForegroundService : Service() {
                     }
                 }
 
-        // Check CHANGE_NETWORK_STATE permission - this is a "normal" permission that is
-        // auto-granted at install time, but we check it defensively in case this changes.
-        // This permission can satisfy the connectedDevice FGS requirement without needing
-        // BLUETOOTH_CONNECT, which is a "dangerous" permission that users can deny.
-        val hasNetworkStatePermission =
+        // These normal permissions satisfy the connectedDevice FGS prerequisite without
+        // waiting for a runtime Bluetooth grant. CHANGE_WIFI_STATE is declared by the SDK;
+        // CHANGE_NETWORK_STATE is also accepted when a host app already declares it.
+        val hasConnectedDeviceManifestPermission =
                 ContextCompat.checkSelfPermission(
                         this,
                         android.Manifest.permission.CHANGE_NETWORK_STATE
-                ) == PackageManager.PERMISSION_GRANTED
+                ) == PackageManager.PERMISSION_GRANTED ||
+                        ContextCompat.checkSelfPermission(
+                                this,
+                                android.Manifest.permission.CHANGE_WIFI_STATE
+                        ) == PackageManager.PERMISSION_GRANTED
 
-        // Use connectedDevice if we have EITHER Bluetooth OR network state permission.
-        // This avoids falling back to dataSync (which has a 6-hour timeout on Android 14+)
+        // Use connectedDevice if we have either Bluetooth or a qualifying normal permission.
+        // This avoids falling back to dataSync (which has a six-hour timeout on Android 15+)
         // when users deny Bluetooth permissions.
-        if (hasBluetoothPermission || hasNetworkStatePermission) {
-            serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
+        val hasConnectedDeviceAccess =
+                hasBluetoothPermission || hasConnectedDeviceManifestPermission
+        if (hasConnectedDeviceAccess) {
             if (hasBluetoothPermission) {
                 Bridge.log("ForegroundService: Added connectedDevice (has Bluetooth permission)")
             } else {
-                Bridge.log("ForegroundService: Added connectedDevice (has CHANGE_NETWORK_STATE permission)")
+                Bridge.log("ForegroundService: Added connectedDevice (has network control permission)")
             }
         } else {
-            Bridge.log("ForegroundService: No Bluetooth or network state permission for connectedDevice")
+            Bridge.log("ForegroundService: No qualifying permission for connectedDevice")
         }
 
         // Check microphone permission
@@ -136,7 +172,6 @@ class ForegroundService : Service() {
                         PackageManager.PERMISSION_GRANTED
 
         if (hasMicPermission) {
-            serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
             Bridge.log("ForegroundService: Added microphone (has RECORD_AUDIO permission)")
         } else {
             Bridge.log("ForegroundService: No microphone permission")
@@ -154,8 +189,8 @@ class ForegroundService : Service() {
         val locationManager = getSystemService(LocationManager::class.java)
         val isLocationEnabled = locationManager?.isLocationEnabled == true
 
-        if (locationTypeRequested && hasLocationPermission && isLocationEnabled) {
-            serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
+        val hasLocationAccess = locationTypeRequested && hasLocationPermission && isLocationEnabled
+        if (hasLocationAccess) {
             Bridge.log("ForegroundService: Added location (has foreground location permission)")
         } else {
             Bridge.log(
@@ -164,15 +199,11 @@ class ForegroundService : Service() {
             )
         }
 
-        // Only use dataSync as absolute last resort fallback if no other types were added.
-        // WARNING: dataSync has a 6-hour timeout on Android 14+ which will crash the app.
-        // This should rarely happen since CHANGE_NETWORK_STATE is a normal permission.
-        if (serviceType == 0) {
-            serviceType = ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
-            Bridge.log("ForegroundService: WARNING - Using dataSync as fallback (6-hour timeout on Android 14+)")
-        }
-
-        return serviceType
+        return preferredServiceType(
+                hasConnectedDeviceAccess = hasConnectedDeviceAccess,
+                hasMicrophoneAccess = hasMicPermission,
+                hasLocationAccess = hasLocationAccess,
+        )
     }
 
     private fun getNotificationText(serviceType: Int): String {