@mentra/bluetooth-sdk 0.1.8 → 0.1.10

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

@@ -2,6 +2,8 @@ package com.mentra.bluetoothsdk.photoreceiver
 
 import android.content.Context
 import android.net.Uri
+import android.util.Log
+import com.mentra.bluetoothsdk.debug.BleTraceLogger
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
@@ -29,13 +31,12 @@ class MentraPhotoReceiverModule : Module() {
     }
 
     OnDestroy {
-      stopPhotoReceiverInternal()
+      closePhotoReceiverInternal()
     }
   }
 
+  @Synchronized
   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) },
@@ -44,17 +45,24 @@ class MentraPhotoReceiverModule : Module() {
       photoUploadServer = it
     }
 
+    val host = bestLocalIpv4Address()
+      ?: throw IllegalStateException("No Wi-Fi/LAN IPv4 address found for this phone.")
+
+    server.activePort?.let { activePort ->
+      val endpoint = receiverEndpoint(host, activePort)
+      LocalPhotoReceiverRegistry.register(endpoint.uploadUrl)
+      emitStatus("Photo receiver ready at ${endpoint.uploadUrl}")
+      return receiverResult(endpoint)
+    }
+
     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,
-        )
+        val endpoint = receiverEndpoint(host, actualPort)
+        LocalPhotoReceiverRegistry.register(endpoint.uploadUrl)
+        emitStatus("Photo receiver ready at ${endpoint.uploadUrl}")
+        return receiverResult(endpoint)
       } catch (error: Throwable) {
         lastError = error
         emitStatus("Port $port unavailable: ${error.message ?: error::class.java.simpleName}")
@@ -66,13 +74,35 @@ class MentraPhotoReceiverModule : Module() {
     )
   }
 
+  @Synchronized
   private fun stopPhotoReceiverInternal() {
     photoUploadServer?.stop()
+    LocalPhotoReceiverRegistry.unregister()
     emitStatus("Photo receiver stopped")
   }
 
+  @Synchronized
+  private fun closePhotoReceiverInternal() {
+    photoUploadServer?.close()
+    photoUploadServer = null
+    LocalPhotoReceiverRegistry.unregister()
+  }
+
   private fun handlePhotoUpload(upload: PhotoUpload) {
     val fileUri = Uri.fromFile(upload.photoFile).toString()
+    try {
+      BleTraceLogger.logMap(
+        "phone_to_app",
+        "photo_receiver_event",
+        "photo_upload",
+        mapOf(
+          "requestId" to upload.requestId.orEmpty(),
+          "fileName" to upload.photoFile.name,
+          "byteCount" to upload.byteCount,
+        ),
+      )
+    } catch (_: Throwable) {
+    }
     sendEvent(
       "photoUpload",
       mapOf(
@@ -85,6 +115,7 @@ class MentraPhotoReceiverModule : Module() {
   }
 
   private fun emitStatus(message: String) {
+    Log.d(TAG, message)
     sendEvent(
       "receiverStatus",
       mapOf("message" to message),
@@ -98,23 +129,75 @@ class MentraPhotoReceiverModule : Module() {
   }
 
   private fun bestLocalIpv4Address(): String? {
-    val candidates = mutableListOf<Inet4Address>()
+    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>()
-      candidates += addresses.filterNot { it.isLoopbackAddress || it.isLinkLocalAddress }
+      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 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
+    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",
+      host = host,
+      port = port,
+    )
+  }
+
+  private fun receiverResult(endpoint: ReceiverEndpoint): Map<String, Any> {
+    return mapOf(
+      "uploadUrl" to endpoint.uploadUrl,
+      "host" to endpoint.host,
+      "port" to endpoint.port,
+    )
+  }
+
+  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)
   }
+
+  private data class ReceiverEndpoint(
+    val uploadUrl: String,
+    val host: String,
+    val port: Int,
+  )
 }

package/android/src/main/java/com/mentra/bluetoothsdk/requests/DisplayRequests.kt

@@ -37,3 +37,20 @@ internal data class DashboardMenuItem(
             "packageName" to packageName,
         )
 }
+
+// Mirrors the TS `CalendarEvent` shape: { title, location?, time, endDate }
+// where `endDate` is Unix seconds.
+internal data class CalendarEvent(
+    val title: String,
+    val time: String,
+    val endDate: Long,
+    val location: String? = null,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            put("title", title)
+            put("time", time)
+            put("endDate", endDate)
+            location?.let { put("location", it) }
+        }
+}

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, Integer iso) {
+    public void requestPhoto(String requestId, String appId, String size, String webhookUrl, String authToken, String compress, boolean flash, boolean save, boolean sound, Long exposureTimeNs, Integer iso) {
 
     }
 
@@ -1608,7 +1608,7 @@ public class G1 extends SGCManager {
     }
 
     @Override
-    public boolean displayBitmap(String base64ImageData) {
+    public boolean displayBitmap(String base64ImageData, Integer x, Integer y, Integer width, Integer height) {
         try {
             // Decode base64 to byte array
             byte[] bmpData = android.util.Base64.decode(base64ImageData, android.util.Base64.DEFAULT);