@mentra/bluetooth-sdk 0.1.7 → 0.1.8

package/android/src/main/java/com/mentra/bluetoothsdk/debug/BleTraceLogger.kt

@@ -0,0 +1,149 @@
+package com.mentra.bluetoothsdk.debug
+
+import android.content.Context
+import android.os.Build
+import android.os.Process
+import android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+
+object BleTraceLogger {
+    private const val TAG = "MentraBleTrace"
+    private const val MAX_PAYLOAD_CHARS = 3000
+    private val sensitiveKeyParts =
+        listOf("password", "pass", "token", "secret", "authorization", "auth", "email")
+
+    @JvmStatic
+    fun logJson(direction: String, layer: String, payload: JSONObject?, bytes: Int? = null) {
+        if (payload == null) {
+            Log.i(TAG, format(direction, layer, caller(), "null", bytes, "null"))
+            return
+        }
+
+        val sanitized = sanitize(payload)
+        Log.i(TAG, format(direction, layer, caller(), extractType(payload), bytes, sanitized.toString()))
+    }
+
+    @JvmStatic
+    fun logMap(direction: String, layer: String, type: String?, payload: Map<String, Any>) {
+        val sanitized = sanitize(JSONObject(payload))
+        Log.i(TAG, format(direction, layer, caller(), type ?: extractType(sanitized), null, sanitized.toString()))
+    }
+
+    @JvmStatic
+    fun logLifecycle(
+        context: Context?,
+        component: String,
+        event: String,
+        extra: Map<String, Any?> = emptyMap(),
+    ) {
+        val payload = JSONObject()
+        payload.put("event", event)
+        payload.put("component", component)
+        payload.put("pid", Process.myPid())
+        payload.put("model", Build.MODEL)
+        payload.put("sdkInt", Build.VERSION.SDK_INT)
+
+        context?.let {
+            payload.put("package", it.packageName)
+            packageVersion(it)?.let { version -> payload.put("version", version) }
+        }
+
+        extra.forEach { (key, value) -> payload.put(key, value ?: JSONObject.NULL) }
+        Log.i(TAG, format("phone_app", "app_lifecycle", caller(), event, null, sanitize(payload).toString()))
+    }
+
+    private fun format(
+        direction: String,
+        layer: String,
+        source: String,
+        type: String,
+        bytes: Int?,
+        payload: String,
+    ): String {
+        val bytesText = bytes?.let { " bytes=$it" } ?: ""
+        return "BLE_TRACE direction=$direction layer=$layer source=$source type=$type$bytesText payload=${truncate(payload)}"
+    }
+
+    private fun extractType(payload: JSONObject): String {
+        payload.optString("type").takeIf { it.isNotBlank() }?.let { return it }
+        payload.optString("C").takeIf { it.isNotBlank() }?.let { cValue ->
+            try {
+                val inner = JSONObject(cValue)
+                inner.optString("type").takeIf { it.isNotBlank() }?.let { return it }
+            } catch (_: Exception) {
+                return "k900:${cValue.take(40)}"
+            }
+        }
+        return "unknown"
+    }
+
+    private fun sanitize(value: JSONObject): JSONObject {
+        val output = JSONObject()
+        value.keys().forEach { key ->
+            output.put(key, sanitizeValue(key, value.opt(key)))
+        }
+        return output
+    }
+
+    private fun sanitize(value: JSONArray): JSONArray {
+        val output = JSONArray()
+        for (index in 0 until value.length()) {
+            output.put(sanitizeValue(null, value.opt(index)))
+        }
+        return output
+    }
+
+    private fun sanitizeValue(key: String?, value: Any?): Any? {
+        if (key != null && sensitiveKeyParts.any { key.contains(it, ignoreCase = true) }) {
+            return "<redacted>"
+        }
+        if (key == "C" && value is String) {
+            try {
+                return sanitize(JSONObject(value)).toString()
+            } catch (_: Exception) {
+                return truncate(value)
+            }
+        }
+        return when (value) {
+            is JSONObject -> sanitize(value)
+            is JSONArray -> sanitize(value)
+            JSONObject.NULL -> JSONObject.NULL
+            else -> value
+        }
+    }
+
+    private fun caller(): String {
+        val frame =
+            Throwable().stackTrace.firstOrNull {
+                !it.className.contains("BleTraceLogger") &&
+                    !it.className.startsWith("java.lang.") &&
+                    !it.className.startsWith("kotlin.")
+        }
+        return frame?.let {
+            "${it.className.substringAfterLast('.')}.${it.methodName}(${it.fileName}:${it.lineNumber})"
+        } ?: "unknown"
+    }
+
+    private fun packageVersion(context: Context): String? =
+        try {
+            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            val versionCode =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    packageInfo.longVersionCode
+                } else {
+                    @Suppress("DEPRECATION")
+                    packageInfo.versionCode.toLong()
+                }
+            "${packageInfo.versionName ?: "unknown"}+$versionCode"
+        } catch (_: Exception) {
+            null
+        }
+
+    private fun truncate(value: String): String {
+        if (value.length <= MAX_PAYLOAD_CHARS) {
+            return value
+        }
+        return "${value.take(MAX_PAYLOAD_CHARS)}...(truncated ${value.length - MAX_PAYLOAD_CHARS} chars)"
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/events/BluetoothEvents.kt

@@ -58,6 +58,7 @@ interface MentraBluetoothSdkListener {
     fun onHotspotError(event: HotspotErrorEvent) {}
     fun onGalleryStatus(event: GalleryStatusEvent) {}
     fun onPhotoResponse(event: PhotoResponseEvent) {}
+    fun onPhotoStatus(event: PhotoStatusEvent) {}
     fun onStreamStatus(event: StreamStatusEvent) {}
     fun onKeepAliveAck(event: KeepAliveAckEvent) {}
     fun onMicPcm(event: MicPcmEvent) {}

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

@@ -0,0 +1,297 @@
+package com.mentra.bluetoothsdk.photoreceiver
+
+import android.content.Context
+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
+
+data class PhotoUpload(
+    val requestId: String?,
+    val photoFile: File,
+    val byteCount: Int,
+    val fields: Map<String, String>,
+)
+
+class LocalPhotoUploadServer(
+    context: Context,
+    private val onLog: (String) -> Unit,
+    private val onUpload: (PhotoUpload) -> Unit,
+) : AutoCloseable {
+    private val appContext = context.applicationContext
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private var serverSocket: ServerSocket? = null
+    private var serverJob: Job? = null
+    private val uploadDir = File(appContext.cacheDir, "mentra-photo-uploads")
+
+    @Volatile
+    var running: Boolean = false
+        private set
+
+    fun start(port: Int): Int {
+        stop()
+        uploadDir.mkdirs()
+        val socket = ServerSocket()
+        socket.reuseAddress = true
+        socket.bind(InetSocketAddress("0.0.0.0", port))
+        serverSocket = socket
+        running = true
+        serverJob = scope.launch {
+            acceptLoop(socket)
+        }
+        onLog("Listening on 0.0.0.0:${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()
+                scope.launch { handleClient(client) }
+            } 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 ->
+            client.soTimeout = 20_000
+            val input = BufferedInputStream(client.getInputStream())
+            val output = client.getOutputStream()
+            try {
+                val headerBytes = readHeaders(input)
+                val headerText = headerBytes.toString(StandardCharsets.ISO_8859_1)
+                val request = HttpRequest.parse(headerText)
+                onLog("${request.method} ${request.path} from ${client.inetAddress.hostAddress}")
+
+                if (request.method == "GET" && (request.path == "/" || request.path == "/health")) {
+                    writeJson(output, 200, """{"ok":true,"service":"mentra-photo-upload-receiver"}""")
+                    return
+                }
+
+                if (request.method != "POST" || request.path != "/upload") {
+                    writeJson(output, 404, """{"ok":false,"error":"not_found"}""")
+                    return
+                }
+
+                val contentType = request.headers["content-type"].orEmpty()
+                val contentLength = request.headers["content-length"]?.toLongOrNull()
+                if (contentLength == null || contentLength <= 0) {
+                    writeJson(output, 411, """{"ok":false,"error":"content_length_required"}""")
+                    return
+                }
+                if (contentLength > MAX_UPLOAD_BYTES) {
+                    writeJson(output, 413, """{"ok":false,"error":"upload_too_large"}""")
+                    return
+                }
+                if (request.headers["expect"]?.contains("100-continue", ignoreCase = true) == true) {
+                    output.write("HTTP/1.1 100 Continue\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+                    output.flush()
+                }
+
+                onLog("headers contentType=$contentType contentLength=$contentLength userAgent=${request.headers["user-agent"].orEmpty()}")
+                val body = readExact(input, contentLength.toInt())
+                val boundary = multipartBoundary(contentType)
+                if (boundary == null) {
+                    writeJson(output, 400, """{"ok":false,"error":"multipart_boundary_required"}""")
+                    return
+                }
+                val parsed = parseMultipart(body, boundary)
+                val photoBytes = parsed.files["photo"] ?: parsed.files.values.firstOrNull()
+                if (photoBytes == null) {
+                    writeJson(output, 400, """{"ok":false,"error":"photo_field_required"}""")
+                    return
+                }
+
+                val requestId = parsed.fields["requestId"] ?: parsed.fields["request_id"]
+                val file = File(uploadDir, "${safeFilePart(requestId ?: "photo-${System.currentTimeMillis()}")}.jpg")
+                file.writeBytes(photoBytes)
+                onLog("upload fields=${parsed.fields.keys.joinToString(",")} requestId=${requestId.orEmpty()} bytes=${photoBytes.size} saved=${file.absolutePath}")
+                onUpload(
+                    PhotoUpload(
+                        requestId = requestId,
+                        photoFile = file,
+                        byteCount = photoBytes.size,
+                        fields = parsed.fields,
+                    ),
+                )
+                writeJson(output, 200, """{"ok":true,"requestId":"${jsonEscape(requestId.orEmpty())}","bytes":${photoBytes.size}}""")
+            } catch (error: Throwable) {
+                onLog("request failed: ${error.message ?: error::class.java.simpleName}")
+                writeJson(output, 500, """{"ok":false,"error":"${jsonEscape(error.message ?: "server_error")}"}""")
+            }
+        }
+    }
+
+    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 readExact(input: InputStream, length: Int): ByteArray {
+        val body = ByteArray(length)
+        var offset = 0
+        while (offset < length) {
+            val read = input.read(body, offset, length - offset)
+            if (read == -1) throw EOFException("Socket closed after $offset of $length body bytes")
+            offset += read
+        }
+        return body
+    }
+
+    private fun writeJson(output: OutputStream, status: Int, body: String) {
+        val reason = when (status) {
+            200 -> "OK"
+            400 -> "Bad Request"
+            404 -> "Not Found"
+            411 -> "Length Required"
+            413 -> "Payload Too Large"
+            else -> "Internal Server Error"
+        }
+        val bytes = body.toByteArray(StandardCharsets.UTF_8)
+        output.write("HTTP/1.1 $status $reason\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Type: application/json\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Length: ${bytes.size}\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Connection: close\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write(bytes)
+        output.flush()
+    }
+
+    private data class HttpRequest(
+        val method: String,
+        val path: String,
+        val headers: Map<String, 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()
+                val headers = lines.drop(1).mapNotNull { line ->
+                    val separator = line.indexOf(':')
+                    if (separator <= 0) return@mapNotNull null
+                    line.substring(0, separator).lowercase(Locale.US) to line.substring(separator + 1).trim()
+                }.toMap()
+                return HttpRequest(method, path, headers)
+            }
+        }
+    }
+
+    private data class ParsedMultipart(
+        val fields: Map<String, String>,
+        val files: Map<String, ByteArray>,
+    )
+
+    private fun parseMultipart(body: ByteArray, boundary: String): ParsedMultipart {
+        val text = body.toString(StandardCharsets.ISO_8859_1)
+        val marker = "--$boundary"
+        val fields = mutableMapOf<String, String>()
+        val files = mutableMapOf<String, ByteArray>()
+        var cursor = 0
+
+        while (true) {
+            val markerStart = text.indexOf(marker, cursor)
+            if (markerStart < 0) break
+            var partStart = markerStart + marker.length
+            if (text.startsWith("--", partStart)) break
+            if (text.startsWith("\r\n", partStart)) partStart += 2
+
+            val headerEnd = text.indexOf("\r\n\r\n", partStart)
+            if (headerEnd < 0) break
+            val dataStart = headerEnd + 4
+            val nextMarker = text.indexOf("\r\n$marker", dataStart)
+            if (nextMarker < 0) break
+
+            val headerBlock = text.substring(partStart, headerEnd)
+            val disposition = headerBlock.lineSequence()
+                .firstOrNull { it.startsWith("Content-Disposition:", ignoreCase = true) }
+                .orEmpty()
+            val name = Regex("""name="([^"]+)"""").find(disposition)?.groupValues?.get(1)
+            val filename = Regex("""filename="([^"]*)"""").find(disposition)?.groupValues?.get(1)
+            if (name != null) {
+                val bytes = body.copyOfRange(dataStart, nextMarker)
+                if (filename != null) {
+                    files[name] = bytes
+                } else {
+                    fields[name] = bytes.toString(StandardCharsets.UTF_8).trim()
+                }
+            }
+            cursor = nextMarker + 2
+        }
+
+        return ParsedMultipart(fields = fields, files = files)
+    }
+
+    private fun multipartBoundary(contentType: String): String? {
+        return contentType.split(';')
+            .map { it.trim() }
+            .firstOrNull { it.startsWith("boundary=", ignoreCase = true) }
+            ?.substringAfter('=')
+            ?.trim()
+            ?.trim('"')
+            ?.takeIf { it.isNotBlank() }
+    }
+
+    private fun safeFilePart(value: String): String {
+        return value.replace(Regex("[^A-Za-z0-9._-]"), "_").ifBlank { "photo" }
+    }
+
+    private fun jsonEscape(value: String): String {
+        return value.replace("\\", "\\\\").replace("\"", "\\\"")
+    }
+
+    companion object {
+        private const val MAX_HEADER_BYTES = 64 * 1024
+        private const val MAX_UPLOAD_BYTES = 25L * 1024L * 1024L
+    }
+}

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

@@ -0,0 +1,120 @@
+package com.mentra.bluetoothsdk.photoreceiver
+
+import android.content.Context
+import android.net.Uri
+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
+
+  override fun definition() = ModuleDefinition {
+    Name("MentraPhotoReceiver")
+
+    Events("photoUpload", "receiverStatus")
+
+    AsyncFunction("isSupported") {
+      true
+    }
+
+    AsyncFunction("startPhotoReceiver") {
+      startPhotoReceiver()
+    }
+
+    AsyncFunction("stopPhotoReceiver") {
+      stopPhotoReceiverInternal()
+    }
+
+    OnDestroy {
+      stopPhotoReceiverInternal()
+    }
+  }
+
+  private fun startPhotoReceiver(): Map<String, Any> {
+    val host = bestLocalIpv4Address()
+      ?: throw IllegalStateException("No Wi-Fi/LAN IPv4 address found for this phone.")
+    val server = photoUploadServer ?: LocalPhotoUploadServer(
+      context = reactContext(),
+      onLog = { message -> emitStatus(message) },
+      onUpload = ::handlePhotoUpload,
+    ).also {
+      photoUploadServer = it
+    }
+
+    var lastError: Throwable? = null
+    for (port in PHOTO_PORTS) {
+      try {
+        val actualPort = server.start(port)
+        val uploadUrl = "http://$host:$actualPort/upload"
+        emitStatus("Photo receiver ready at $uploadUrl")
+        return mapOf(
+          "uploadUrl" to uploadUrl,
+          "host" to host,
+          "port" to actualPort,
+        )
+      } catch (error: Throwable) {
+        lastError = error
+        emitStatus("Port $port unavailable: ${error.message ?: error::class.java.simpleName}")
+      }
+    }
+
+    throw IllegalStateException(
+      "Could not start phone photo receiver: ${lastError?.message ?: "all ports unavailable"}",
+    )
+  }
+
+  private fun stopPhotoReceiverInternal() {
+    photoUploadServer?.stop()
+    emitStatus("Photo receiver stopped")
+  }
+
+  private fun handlePhotoUpload(upload: PhotoUpload) {
+    val fileUri = Uri.fromFile(upload.photoFile).toString()
+    sendEvent(
+      "photoUpload",
+      mapOf(
+        "requestId" to upload.requestId,
+        "fileUri" to fileUri,
+        "byteCount" to upload.byteCount,
+      ),
+    )
+    emitStatus("Photo uploaded (${upload.byteCount} bytes)")
+  }
+
+  private fun emitStatus(message: String) {
+    sendEvent(
+      "receiverStatus",
+      mapOf("message" to message),
+    )
+  }
+
+  private fun reactContext(): Context {
+    return appContext.reactContext
+      ?: appContext.currentActivity
+      ?: throw Exceptions.ReactContextLost()
+  }
+
+  private fun bestLocalIpv4Address(): String? {
+    val candidates = 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>()
+      candidates += addresses.filterNot { it.isLoopbackAddress || it.isLinkLocalAddress }
+    }
+
+    return candidates.firstOrNull { address ->
+      val host = address.hostAddress.orEmpty()
+      host.startsWith("192.168.") || host.startsWith("10.") || host.matches(Regex("^172\\.(1[6-9]|2[0-9]|3[0-1])\\..*"))
+    }?.hostAddress ?: candidates.firstOrNull()?.hostAddress
+  }
+
+  private companion object {
+    val PHOTO_PORTS = listOf(8787, 8788, 8789, 8790)
+  }
+}

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

@@ -11,6 +11,7 @@ import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.debug.BleTraceLogger
 
 class ForegroundService : Service() {
     companion object {
@@ -21,11 +22,18 @@ class ForegroundService : Service() {
     override fun onCreate() {
         super.onCreate()
         Bridge.log("ForegroundService: onCreate() called")
+        BleTraceLogger.logLifecycle(this, "ForegroundService", "service_create")
         startForegroundWithAutoDetectedType()
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         Bridge.log("ForegroundService: onStartCommand() called")
+        BleTraceLogger.logLifecycle(
+                this,
+                "ForegroundService",
+                "service_start_command",
+                mapOf("action" to intent?.action, "flags" to flags, "startId" to startId)
+        )
         // Re-check permissions in case they changed
         startForegroundWithAutoDetectedType()
         return START_STICKY
@@ -171,5 +179,10 @@ class ForegroundService : Service() {
         }
     }
 
+    override fun onDestroy() {
+        BleTraceLogger.logLifecycle(this, "ForegroundService", "service_destroy")
+        super.onDestroy()
+    }
+
     override fun onBind(intent: Intent?): IBinder? = null
 }

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

@@ -1530,7 +1530,7 @@ public class G1 extends SGCManager {
     }
 
     @Override
-    public void requestPhoto(String requestId, String appId, String size, String webhookUrl, String authToken, String compress, boolean flash, boolean sound, Long exposureTimeNs) {
+    public void requestPhoto(String requestId, String appId, String size, String webhookUrl, String authToken, String compress, boolean flash, boolean sound, Long exposureTimeNs, Integer iso) {
 
     }
 

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

@@ -2362,6 +2362,7 @@ class G2 : SGCManager() {
             flash: Boolean,
             sound: Boolean,
             exposureTimeNs: Long?,
+            iso: Int?,
     ) {
         Bridge.log("G2: requestPhoto - not supported (no camera)")
     }

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

@@ -132,7 +132,7 @@ public class Mach1 extends SGCManager {
     }
 
     @Override
-    public void requestPhoto(@NonNull String requestId, @NonNull String appId, @NonNull String size, @Nullable String webhookUrl, @Nullable String authToken, @Nullable String compress, boolean flash, boolean sound, @Nullable Long exposureTimeNs) {
+    public void requestPhoto(@NonNull String requestId, @NonNull String appId, @NonNull String size, @Nullable String webhookUrl, @Nullable String authToken, @Nullable String compress, boolean flash, boolean sound, @Nullable Long exposureTimeNs, @Nullable Integer iso) {
 
     }