@mentra/bluetooth-sdk 0.1.21-beta.3 → 3.1.0-beta.100

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

@@ -0,0 +1,304 @@
+package com.mentra.bluetoothsdk.otaserver
+
+import com.mentra.bluetoothsdk.debug.BleTraceLogger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import java.io.BufferedInputStream
+import java.io.ByteArrayOutputStream
+import java.io.EOFException
+import java.io.File
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.InetSocketAddress
+import java.net.ServerSocket
+import java.net.Socket
+import java.net.SocketException
+import java.nio.charset.StandardCharsets
+import java.util.Locale
+import java.util.concurrent.Semaphore
+import org.json.JSONObject
+
+/**
+ * Static HTTP server for hotspot-served glasses OTA (OS-1676).
+ *
+ * Serves the rewritten OTA manifest at /version.json and pre-downloaded artifacts at
+ * /artifacts/<sha256> to the glasses over the glasses-hotspot link. Same hand-rolled
+ * socket structure as [LocalPhotoUploadServer] —
+ * no third-party HTTP dependency in the SDK.
+ */
+class LocalOtaServer(
+    private val onLog: (String) -> Unit,
+) : AutoCloseable {
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private var serverSocket: ServerSocket? = null
+    private var serverJob: Job? = null
+    private val clientSlots = Semaphore(MAX_ACTIVE_CLIENTS)
+
+    @Volatile
+    private var manifestJson: String = "{}"
+
+    @Volatile
+    private var artifacts: Map<String, File> = emptyMap()
+
+    @Volatile
+    var running: Boolean = false
+        private set
+
+    val activePort: Int?
+        get() = serverSocket
+            ?.takeIf { running && !it.isClosed }
+            ?.localPort
+
+    /** Swap the served manifest and artifact set. Safe while the server is running. */
+    fun configure(manifestJson: String, artifacts: Map<String, File>) {
+        this.manifestJson = manifestJson
+        this.artifacts = artifacts
+    }
+
+    fun start(host: String, port: Int): Int {
+        val activeSocket = serverSocket
+        if (running && activeSocket != null && !activeSocket.isClosed && activeSocket.localPort == port) {
+            onLog("Already listening on $host:${activeSocket.localPort}")
+            return activeSocket.localPort
+        }
+        stop()
+        val socket = ServerSocket()
+        try {
+            socket.reuseAddress = true
+            socket.bind(InetSocketAddress(host, port))
+            serverSocket = socket
+            running = true
+            serverJob = scope.launch {
+                acceptLoop(socket)
+            }
+        } catch (error: Throwable) {
+            try {
+                socket.close()
+            } catch (_: Throwable) {
+            }
+            throw error
+        }
+        onLog("OTA server listening on $host:${socket.localPort}")
+        return socket.localPort
+    }
+
+    fun stop() {
+        running = false
+        serverJob?.cancel()
+        serverJob = null
+        try {
+            serverSocket?.close()
+        } catch (_: Throwable) {
+        }
+        serverSocket = null
+    }
+
+    override fun close() {
+        stop()
+        scope.cancel()
+    }
+
+    private fun acceptLoop(socket: ServerSocket) {
+        while (scope.isActive && !socket.isClosed) {
+            try {
+                val client = socket.accept()
+                if (!clientSlots.tryAcquire()) {
+                    rejectClient(client)
+                    continue
+                }
+                scope.launch {
+                    try {
+                        handleClient(client)
+                    } finally {
+                        clientSlots.release()
+                    }
+                }
+            } catch (error: SocketException) {
+                if (running) onLog("Accept failed: ${error.message}")
+            } catch (error: Throwable) {
+                if (running) onLog("Accept failed: ${error.message ?: error::class.java.simpleName}")
+            }
+        }
+    }
+
+    private fun handleClient(socket: Socket) {
+        socket.use { client ->
+            val requestStartMs = System.currentTimeMillis()
+            client.soTimeout = SOCKET_TIMEOUT_MS
+            val input = BufferedInputStream(client.getInputStream())
+            val output = client.getOutputStream()
+            var request: HttpRequest? = null
+            var status = 0
+            var responseBytes = 0L
+
+            try {
+                val headerText = readHeaders(input).toString(StandardCharsets.ISO_8859_1)
+                request = HttpRequest.parse(headerText)
+                onLog("${request.method} ${request.path} from ${client.inetAddress.hostAddress}")
+
+                if (request.method != "GET") {
+                    status = 405
+                    writeJson(output, status, """{"ok":false,"error":"method_not_allowed"}""")
+                    return
+                }
+
+                when {
+                    request.path == "/version.json" -> {
+                        val body = manifestJson.toByteArray(StandardCharsets.UTF_8)
+                        status = 200
+                        responseBytes = body.size.toLong()
+                        writeBody(output, status, "application/json", body)
+                    }
+                    request.path.startsWith("/artifacts/") -> {
+                        val key = request.path.removePrefix("/artifacts/")
+                        val file = artifacts[key]
+                        if (file == null || !file.isFile) {
+                            status = 404
+                            writeJson(output, status, """{"ok":false,"error":"artifact_not_found"}""")
+                        } else {
+                            status = 200
+                            responseBytes = file.length()
+                            writeFile(output, file)
+                        }
+                    }
+                    else -> {
+                        status = 404
+                        writeJson(output, status, """{"ok":false,"error":"not_found"}""")
+                    }
+                }
+            } catch (error: Throwable) {
+                onLog("request failed: ${error.message ?: error::class.java.simpleName}")
+                if (status == 0) {
+                    status = 500
+                    try {
+                        writeJson(output, status, """{"ok":false,"error":"server_error"}""")
+                    } catch (_: Throwable) {
+                    }
+                }
+            } finally {
+                trace(client, request, status, responseBytes, requestStartMs)
+            }
+        }
+    }
+
+    private fun writeFile(output: OutputStream, file: File) {
+        val fileLength = file.length()
+        output.write("HTTP/1.1 200 OK\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Type: application/octet-stream\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Length: $fileLength\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Connection: close\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+        file.inputStream().use { fileInput ->
+            val buffer = ByteArray(STREAM_CHUNK_BYTES)
+            var remaining = fileLength
+            while (remaining > 0) {
+                val read = fileInput.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
+                if (read <= 0) throw EOFException("artifact truncated while streaming")
+                output.write(buffer, 0, read)
+                remaining -= read
+            }
+        }
+        output.flush()
+    }
+
+    private fun rejectClient(socket: Socket) {
+        socket.use { client ->
+            try {
+                writeJson(client.getOutputStream(), 503, """{"ok":false,"error":"too_many_connections"}""")
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun readHeaders(input: InputStream): ByteArray {
+        val out = ByteArrayOutputStream()
+        val delimiter = byteArrayOf(13, 10, 13, 10)
+        var matched = 0
+        while (true) {
+            val byte = input.read()
+            if (byte == -1) throw EOFException("Socket closed before HTTP headers completed")
+            out.write(byte)
+            matched = if (byte.toByte() == delimiter[matched]) {
+                matched + 1
+            } else if (byte.toByte() == delimiter[0]) {
+                1
+            } else {
+                0
+            }
+            if (matched == delimiter.size) return out.toByteArray()
+            if (out.size() > MAX_HEADER_BYTES) throw IllegalArgumentException("HTTP headers too large")
+        }
+    }
+
+    private fun writeJson(output: OutputStream, status: Int, body: String) {
+        writeBody(output, status, "application/json", body.toByteArray(StandardCharsets.UTF_8))
+    }
+
+    private fun writeBody(
+        output: OutputStream,
+        status: Int,
+        contentType: String,
+        body: ByteArray,
+    ) {
+        val reason = when (status) {
+            200 -> "OK"
+            404 -> "Not Found"
+            405 -> "Method Not Allowed"
+            503 -> "Service Unavailable"
+            else -> "Internal Server Error"
+        }
+        output.write("HTTP/1.1 $status $reason\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Type: $contentType\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Length: ${body.size}\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Connection: close\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write(body)
+        output.flush()
+    }
+
+    private fun trace(
+        client: Socket,
+        request: HttpRequest?,
+        status: Int,
+        responseBytes: Long,
+        startMs: Long,
+    ) {
+        val payload = JSONObject()
+        try {
+            payload.put("type", "ota_server_request")
+            payload.put("remoteHost", client.inetAddress?.hostAddress ?: "")
+            payload.put("method", request?.method ?: "")
+            payload.put("path", request?.path ?: "")
+            payload.put("statusCode", status)
+            payload.put("responseBytes", responseBytes)
+            payload.put("durationMs", System.currentTimeMillis() - startMs)
+            BleTraceLogger.logJson("phone_to_wifi", "wifi_http_output", payload, null)
+        } catch (_: Throwable) {
+        }
+    }
+
+    private data class HttpRequest(
+        val method: String,
+        val path: String,
+    ) {
+        companion object {
+            fun parse(headerText: String): HttpRequest {
+                val lines = headerText.split("\r\n").filter { it.isNotBlank() }
+                val requestParts = lines.firstOrNull()?.split(" ").orEmpty()
+                val method = requestParts.getOrNull(0)?.uppercase(Locale.US).orEmpty()
+                val path = requestParts.getOrNull(1)?.substringBefore("?").orEmpty()
+                return HttpRequest(method, path)
+            }
+        }
+    }
+
+    companion object {
+        private const val MAX_HEADER_BYTES = 64 * 1024
+        private const val MAX_ACTIVE_CLIENTS = 2
+        private const val SOCKET_TIMEOUT_MS = 20_000
+        private const val STREAM_CHUNK_BYTES = 64 * 1024
+    }
+}

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 {