@mentra/bluetooth-sdk 0.1.19 → 0.1.21-beta.0

package/android/src/main/java/com/mentra/bluetoothsdk/MentraLocalNetworkModule.kt

@@ -0,0 +1,333 @@
+package com.mentra.bluetoothsdk
+
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.net.wifi.WifiNetworkSpecifier
+import android.os.Build
+import android.util.Base64
+import android.util.Log
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+
+/** MentraOS-internal transport for glasses-local traffic without process network binding. */
+class MentraLocalNetworkModule : Module() {
+    private companion object {
+        const val TAG = "MentraLocalNetwork"
+    }
+
+    private val lock = Any()
+    private val executor = Executors.newCachedThreadPool()
+    private val activeConnections = ConcurrentHashMap<String, HttpURLConnection>()
+    private var localNetwork: Network? = null
+    private var networkCallback: ConnectivityManager.NetworkCallback? = null
+    private var pendingConnectPromise: Promise? = null
+
+    override fun definition() = ModuleDefinition {
+        Name("MentraLocalNetwork")
+        Events("downloadProgress", "networkLost")
+
+        AsyncFunction("connect") { ssid: String, password: String, promise: Promise ->
+            connect(ssid, password, promise)
+        }
+
+        AsyncFunction("request") {
+            requestId: String,
+            url: String,
+            method: String,
+            headers: Map<String, String>,
+            body: String?,
+            timeoutMs: Int,
+            promise: Promise ->
+            executor.execute { performRequest(requestId, url, method, headers, body, timeoutMs, promise) }
+        }
+
+        AsyncFunction("download") {
+            requestId: String,
+            url: String,
+            destination: String,
+            headers: Map<String, String>,
+            connectionTimeoutMs: Int,
+            readTimeoutMs: Int,
+            promise: Promise ->
+            executor.execute {
+                performDownload(
+                    requestId,
+                    url,
+                    destination,
+                    headers,
+                    connectionTimeoutMs,
+                    readTimeoutMs,
+                    promise,
+                )
+            }
+        }
+
+        AsyncFunction("cancel") { requestId: String -> cancel(requestId) }
+        AsyncFunction("disconnect") { disconnect() }
+
+        OnDestroy { disconnect() }
+    }
+
+    private fun connectivityManager(): ConnectivityManager =
+        requireNotNull(appContext.reactContext?.getSystemService(ConnectivityManager::class.java)) {
+            "ConnectivityManager is unavailable"
+        }
+
+    private fun connect(ssid: String, password: String, promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            promise.reject("ERR_UNSUPPORTED_ANDROID", "Scoped local WiFi requires Android 10 or newer", null)
+            return
+        }
+
+        disconnect()
+        val manager = connectivityManager()
+        val specifier =
+            WifiNetworkSpecifier.Builder()
+                .setSsid(ssid)
+                .setWpa2Passphrase(password)
+                .build()
+        val request =
+            NetworkRequest.Builder()
+                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+                .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                .setNetworkSpecifier(specifier)
+                .build()
+
+        val callback =
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) {
+                    val connectPromise: Promise?
+                    synchronized(lock) {
+                        if (networkCallback !== this) {
+                            Log.d(TAG, "Ignoring onAvailable from a stale network request")
+                            return
+                        }
+                        localNetwork = network
+                        connectPromise = pendingConnectPromise
+                        pendingConnectPromise = null
+                    }
+                    Log.i(
+                        TAG,
+                        "Captured glasses WiFi network=$network processBoundNetwork=${manager.boundNetworkForProcess}",
+                    )
+                    connectPromise?.resolve(mapOf("connected" to true, "ssid" to ssid))
+                }
+
+                override fun onUnavailable() {
+                    synchronized(lock) {
+                        if (networkCallback !== this) {
+                            Log.d(TAG, "Ignoring onUnavailable from a stale network request")
+                            return
+                        }
+                    }
+                    rejectPendingConnect("ERR_LOCAL_WIFI_UNAVAILABLE", "Could not connect to $ssid")
+                    clearNetworkCallback(this)
+                }
+
+                override fun onLost(network: Network) {
+                    synchronized(lock) {
+                        if (networkCallback !== this || localNetwork != network) {
+                            Log.d(TAG, "Ignoring onLost from a stale network request")
+                            return
+                        }
+                        localNetwork = null
+                    }
+                    cancelAll()
+                    clearNetworkCallback(this)
+                    sendEvent("networkLost", mapOf("ssid" to ssid))
+                }
+            }
+
+        synchronized(lock) {
+            pendingConnectPromise = promise
+            networkCallback = callback
+        }
+        try {
+            manager.requestNetwork(request, callback, 30_000)
+        } catch (error: Exception) {
+            clearNetworkCallback(callback)
+            rejectPendingConnect("ERR_LOCAL_WIFI_REQUEST", error.message ?: "Local WiFi request failed", error)
+        }
+    }
+
+    private fun performRequest(
+        requestId: String,
+        url: String,
+        method: String,
+        headers: Map<String, String>,
+        body: String?,
+        timeoutMs: Int,
+        promise: Promise,
+    ) {
+        var connection: HttpURLConnection? = null
+        try {
+            connection = openConnection(requestId, url)
+            connection.requestMethod = method
+            connection.connectTimeout = timeoutMs
+            connection.readTimeout = timeoutMs
+            headers.forEach(connection::setRequestProperty)
+            if (body != null) {
+                connection.doOutput = true
+                connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+            }
+            val status = connection.responseCode
+            val stream = if (status >= 400) connection.errorStream else connection.inputStream
+            val bytes = stream?.use { it.readBytes() } ?: ByteArray(0)
+            promise.resolve(
+                mapOf(
+                    "status" to status,
+                    "headers" to responseHeaders(connection),
+                    "bodyBase64" to Base64.encodeToString(bytes, Base64.NO_WRAP),
+                ),
+            )
+        } catch (error: Exception) {
+            promise.reject("ERR_LOCAL_HTTP", error.message ?: "Local HTTP request failed", error)
+        } finally {
+            activeConnections.remove(requestId)
+            connection?.disconnect()
+        }
+    }
+
+    private fun performDownload(
+        requestId: String,
+        url: String,
+        destination: String,
+        headers: Map<String, String>,
+        connectionTimeoutMs: Int,
+        readTimeoutMs: Int,
+        promise: Promise,
+    ) {
+        var connection: HttpURLConnection? = null
+        try {
+            connection = openConnection(requestId, url)
+            connection.requestMethod = "GET"
+            connection.connectTimeout = connectionTimeoutMs
+            connection.readTimeout = readTimeoutMs
+            headers.forEach(connection::setRequestProperty)
+            val status = connection.responseCode
+            if (status !in 200..299) throw IllegalStateException("HTTP $status")
+            val contentLength = connection.contentLengthLong
+            val responseHeaders = responseHeaders(connection)
+
+            // Match RNFS's begin callback contract before the first response byte. Gallery
+            // resumable downloads need the real status and Content-Range to validate segments.
+            sendEvent(
+                "downloadProgress",
+                mapOf(
+                    "requestId" to requestId,
+                    "bytesWritten" to 0L,
+                    "contentLength" to contentLength,
+                    "statusCode" to status,
+                    "headers" to responseHeaders,
+                ),
+            )
+
+            val destinationFile = File(destination)
+            destinationFile.parentFile?.mkdirs()
+            var bytesWritten = 0L
+            connection.inputStream.use { input ->
+                FileOutputStream(destinationFile, false).use { output ->
+                    val buffer = ByteArray(64 * 1024)
+                    while (true) {
+                        val count = input.read(buffer)
+                        if (count < 0) break
+                        output.write(buffer, 0, count)
+                        bytesWritten += count
+                        sendEvent(
+                            "downloadProgress",
+                            mapOf(
+                                "requestId" to requestId,
+                                "bytesWritten" to bytesWritten,
+                                "contentLength" to contentLength,
+                            ),
+                        )
+                    }
+                }
+            }
+            promise.resolve(
+                mapOf(
+                    "statusCode" to status,
+                    "bytesWritten" to bytesWritten,
+                    "headers" to responseHeaders,
+                ),
+            )
+        } catch (error: Exception) {
+            promise.reject("ERR_LOCAL_DOWNLOAD", error.message ?: "Local download failed", error)
+        } finally {
+            activeConnections.remove(requestId)
+            connection?.disconnect()
+        }
+    }
+
+    private fun openConnection(requestId: String, url: String): HttpURLConnection {
+        val network = synchronized(lock) { localNetwork }
+            ?: throw IllegalStateException("Local WiFi is not connected")
+        val connection = network.openConnection(URL(url)) as HttpURLConnection
+        activeConnections[requestId] = connection
+        return connection
+    }
+
+    private fun responseHeaders(connection: HttpURLConnection): Map<String, String> =
+        connection.headerFields
+            .filterKeys { it != null }
+            .mapValues { (_, values) -> values.joinToString(", ") }
+
+    private fun cancel(requestId: String) {
+        activeConnections.remove(requestId)?.disconnect()
+    }
+
+    private fun cancelAll() {
+        activeConnections.keys.toList().forEach(::cancel)
+    }
+
+    private fun disconnect() {
+        cancelAll()
+        val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
+        val callback: ConnectivityManager.NetworkCallback?
+        synchronized(lock) {
+            callback = networkCallback
+            networkCallback = null
+            localNetwork = null
+        }
+        if (callback != null && manager != null) {
+            try {
+                manager.unregisterNetworkCallback(callback)
+            } catch (_: IllegalArgumentException) {
+                // Already unregistered by the platform.
+            }
+        }
+        rejectPendingConnect("ERR_LOCAL_WIFI_CANCELLED", "Local WiFi connection cancelled")
+    }
+
+    private fun clearNetworkCallback(callback: ConnectivityManager.NetworkCallback) {
+        val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
+        synchronized(lock) {
+            if (networkCallback == callback) networkCallback = null
+        }
+        if (manager != null) {
+            try {
+                manager.unregisterNetworkCallback(callback)
+            } catch (_: IllegalArgumentException) {
+                // Callback was not registered or has already been removed.
+            }
+        }
+    }
+
+    private fun rejectPendingConnect(code: String, message: String, cause: Throwable? = null) {
+        val promise: Promise?
+        synchronized(lock) {
+            promise = pendingConnectPromise
+            pendingConnectPromise = null
+        }
+        promise?.reject(code, message, cause)
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/camera/CameraModels.kt

@@ -167,6 +167,17 @@ data class CameraFovResult(
     }
 }
 
+enum class PhotoMode(val value: String) {
+    PHOTO("photo"),
+    TEXT("text");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): PhotoMode =
+            values().firstOrNull { it.value == value } ?: PHOTO
+    }
+}
+
 data class PhotoRequest @JvmOverloads constructor(
     val requestId: String = generatedCameraRequestId("photo"),
     val size: PhotoSize,
@@ -188,6 +199,9 @@ data class PhotoRequest @JvmOverloads constructor(
     val ispDigitalGain: Int? = null,
     val ispAnalogGain: String? = null,
     val resetCaptureTuning: Boolean? = null,
+    val mode: PhotoMode = PhotoMode.PHOTO,
+    /** `ble` skips direct upload; `auto` tries Wi-Fi with BLE fallback. */
+    val transferMethod: String = "auto",
 ) {
     companion object {
         /** Mirrors iOS `BluetoothSdkModule` defaults for keys omitted from the JS bridge. */
@@ -225,6 +239,8 @@ data class PhotoRequest @JvmOverloads constructor(
                 compress = PhotoCompression.fromValue(stringValue(values, "compress") ?: "none"),
                 save = boolValue(values, "save", "saveToGallery") ?: false,
                 sound = boolValue(values, "sound") ?: true,
+                mode = PhotoMode.fromValue(stringValue(values, "mode")),
+                transferMethod = if (stringValue(values, "transferMethod") == "ble") "ble" else "auto",
                 exposureTimeNs = exposureTimeNs,
                 iso = iso,
                 aeExposureDivisor = aeDivisor,

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G1.kt

@@ -1773,7 +1773,7 @@ class G1 : SGCManager() {
         return ""
     }
 
-    override fun requestWifiScan() {
+    override fun requestWifiScan(scanId: String?) {
 
     }
 
@@ -2841,7 +2841,7 @@ class G1 : SGCManager() {
     private fun chunkTextForTransmission(text: String?): List<ByteArray> {
         // Handle empty or whitespace-only text by sending at least a space
         // This ensures the display gets updated/cleared properly
-        val textToSend = if (text == null || text.trim().isEmpty()) " " else text
+        val textToSend = if (text == null || text.trim().isEmpty()) " " else sanitizeG1DisplayText(text)
         val textBytes = textToSend.toByteArray(StandardCharsets.UTF_8)
         val totalChunks = Math.ceil(textBytes.size.toDouble() / MAX_CHUNK_SIZE).toInt()
 

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G1TextSanitizer.kt

@@ -0,0 +1,38 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import java.text.Normalizer
+
+private val G1_COMBINING_MARKS = Regex("\\p{M}+")
+
+/**
+ * Converts text to the base Latin glyphs available in the Even Realities G1 firmware.
+ *
+ * G1 does not ship glyphs for combining diacritics. Normalize at the device boundary so
+ * miniapps can retain the real text everywhere else and newer glasses receive it unchanged.
+ */
+internal fun sanitizeG1DisplayText(text: String): String {
+    val expanded = buildString(text.length) {
+        text.forEach { character ->
+            when (character) {
+                'Đ', 'Ð' -> append('D')
+                'đ', 'ð' -> append('d')
+                'Ł' -> append('L')
+                'ł' -> append('l')
+                'Ø' -> append('O')
+                'ø' -> append('o')
+                'Æ' -> append("AE")
+                'æ' -> append("ae")
+                'Œ' -> append("OE")
+                'œ' -> append("oe")
+                'ẞ' -> append("SS")
+                'ß' -> append("ss")
+                'Þ' -> append("TH")
+                'þ' -> append("th")
+                else -> append(character)
+            }
+        }
+    }
+
+    return Normalizer.normalize(expanded, Normalizer.Form.NFD)
+        .replace(G1_COMBINING_MARKS, "")
+}

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G2.kt

@@ -575,16 +575,18 @@ private object DevSettingsProto {
     /// TimeSync submessage: f1 = (Unix seconds + TZ offset seconds) as Int32, no TZ field.
     /// Firmware appears to ignore the TZ field, so we pre-shift the timestamp itself
     /// to make UTC interpretation read as local. Empirically confirmed via probe variants in dbg1().
-    fun timeSync(magicRandom: Int): ByteArray {
+    fun timeSync(
+        magicRandom: Int,
+        timestampMs: Long = System.currentTimeMillis()
+    ): ByteArray {
         val w = ProtobufWriter()
         w.writeInt32Field(1, DevCfgCommandId.TIME_SYNC.value)
         w.writeInt32Field(2, magicRandom)
 
         val tsW = ProtobufWriter()
-        val nowMs = System.currentTimeMillis()
-        val nowSec = nowMs / 1000
-        val tzSec = (TimeZone.getDefault().getOffset(nowMs) / 1000).toLong()
-        tsW.writeInt32Field(1, (nowSec + tzSec).toInt())
+        val timestampSec = timestampMs / 1000
+        val tzSec = (TimeZone.getDefault().getOffset(timestampMs) / 1000).toLong()
+        tsW.writeInt32Field(1, (timestampSec + tzSec).toInt())
         w.writeMessageField(128, tsW.toByteArray())
         return w.toByteArray()
     }
@@ -1707,7 +1709,7 @@ class G2 : SGCManager() {
                 payload = payload,
                 reserveFlag = true
             )
-        sendToGlasses(packets)
+        sendToGlasses(packets, left = true, right = true)
     }
 
     // ---------- Authentication Sequence ----------
@@ -1732,7 +1734,7 @@ class G2 : SGCManager() {
 
         delay(200)
         val timeSync = DevSettingsProto.timeSync(sendManager.nextMagicRandom())
-        sendDevSettingsCommand(timeSync)
+        sendDevSettingsCommand(timeSync, left = true, right = true)
 
         // Skip onboarding on connect
         delay(200)
@@ -3763,7 +3765,12 @@ class G2 : SGCManager() {
     /// time-zone travel, or a long sleep where the glasses' clock has drifted.
     fun syncTime() {
         Bridge.log("G2: syncTime()")
-        val msg = DevSettingsProto.timeSync(sendManager.nextMagicRandom())
+        sendSetSystemTime(System.currentTimeMillis())
+    }
+
+    override fun sendSetSystemTime(timestampMs: Long) {
+        Bridge.log("G2: sendSetSystemTime()")
+        val msg = DevSettingsProto.timeSync(sendManager.nextMagicRandom(), timestampMs)
         sendDevSettingsCommand(msg, left = true, right = true)
     }
 
@@ -3782,7 +3789,7 @@ class G2 : SGCManager() {
 
     // ---------- SGCManager: Network (G2 has no WiFi) ----------
 
-    override fun requestWifiScan() {}
+    override fun requestWifiScan(scanId: String?) {}
     override fun sendWifiCredentials(ssid: String, password: String) {}
     override fun forgetWifiNetwork(ssid: String) {}
     override fun sendHotspotState(enabled: Boolean) {}

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/Mach1.kt

@@ -350,7 +350,7 @@ class Mach1 : SGCManager() {
         destroy()
     }
 
-    override fun requestWifiScan() {
+    override fun requestWifiScan(scanId: String?) {
 
     }