@glassly/bluetooth-sdk 0.1.0-dev.26

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

@@ -0,0 +1,165 @@
+package com.glassly.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 = "BleTrace"
+    private const val MAX_PAYLOAD_CHARS = 3000
+    private const val K900_TYPE = "k900"
+    private val sensitiveKeyParts =
+        listOf("password", "pass", "token", "secret", "authorization", "auth", "email", "serial")
+
+    @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>) {
+        try {
+            val sanitized = sanitize(JSONObject(payload))
+            Log.i(TAG, format(direction, layer, caller(), type ?: extractType(sanitized), null, sanitized.toString()))
+        } catch (e: Exception) {
+            Log.d(TAG, "BLE trace map logging failed", e)
+        }
+    }
+
+    @JvmStatic
+    fun logLifecycle(
+        context: Context?,
+        component: String,
+        event: String,
+        extra: Map<String, Any?> = emptyMap(),
+    ) {
+        try {
+            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()))
+        } catch (e: Exception) {
+            Log.d(TAG, "BLE trace lifecycle logging failed", e)
+        }
+    }
+
+    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 extractK900Type(cValue)
+            }
+            return extractK900Type(cValue)
+        }
+        return "unknown"
+    }
+
+    private fun extractK900Type(cValue: String): String =
+        if (cValue == "sr_log") "$K900_TYPE:sr_log" else K900_TYPE
+
+    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 sanitizeK900Command(value)
+            }
+        }
+        return when (value) {
+            is JSONObject -> sanitize(value)
+            is JSONArray -> sanitize(value)
+            JSONObject.NULL -> JSONObject.NULL
+            else -> value
+        }
+    }
+
+    private fun sanitizeK900Command(value: String): String =
+        if (value == "sr_log") value else "<non-json C payload>"
+
+    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/glassly/bluetoothsdk/events/BluetoothEvents.kt

@@ -0,0 +1,178 @@
+package com.glassly.bluetoothsdk
+
+data class ButtonPressEvent(
+    val buttonId: String,
+    val pressType: String,
+    val timestamp: Long? = null,
+)
+
+data class TouchEvent(
+    val values: Map<String, Any>,
+) {
+    val deviceModel: String? get() = stringValue(values, "deviceModel")
+    val gestureName: String? get() = stringValue(values, "gestureName")
+    val timestamp: Long? get() = longValue(values, "timestamp")
+    val isSwipe: Boolean get() = gestureName?.contains("swipe", ignoreCase = true) == true
+}
+
+data class SwipeEvent(
+    val values: Map<String, Any>,
+) {
+    val deviceModel: String? get() = stringValue(values, "deviceModel")
+    val gestureName: String? get() = stringValue(values, "gestureName")
+    val timestamp: Long? get() = longValue(values, "timestamp")
+}
+
+data class BatteryStatusEvent(
+    val level: Int?,
+    val charging: Boolean?,
+    val values: Map<String, Any>,
+)
+
+data class VoiceActivityDetectionStatusEvent(
+    val voiceActivityDetectionEnabled: Boolean,
+    val values: Map<String, Any>,
+)
+
+data class SpeakingStatusEvent(
+    val speaking: Boolean,
+    val values: Map<String, Any>,
+)
+
+data class MicHealthEvent(
+    val reason: String,
+    val sequenceGapEvents: Long,
+    val decodeFailures: Long,
+    val lastLc3ReceivedAt: Long?,
+    val lastPcmProducedAt: Long?,
+    val timestamp: Long,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        internal fun fromMap(values: Map<String, Any>): MicHealthEvent =
+            MicHealthEvent(
+                reason = stringValue(values, "reason") ?: "",
+                sequenceGapEvents = longValue(values, "sequenceGapEvents") ?: 0,
+                decodeFailures = longValue(values, "decodeFailures") ?: 0,
+                lastLc3ReceivedAt = longValue(values, "lastLc3ReceivedAt"),
+                lastPcmProducedAt = longValue(values, "lastPcmProducedAt"),
+                timestamp = longValue(values, "timestamp") ?: System.currentTimeMillis(),
+                values = values,
+            )
+    }
+}
+
+data class OtaStartAckEvent(
+    val timestamp: Long?,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        internal fun fromMap(values: Map<String, Any>): OtaStartAckEvent =
+            OtaStartAckEvent(
+                timestamp = longValue(values, "timestamp"),
+                values = values,
+            )
+    }
+}
+
+data class OtaStatusEvent(
+    val sessionId: String,
+    val totalSteps: Int,
+    val currentStep: Int,
+    val stepType: String,
+    val phase: String,
+    val stepPercent: Int,
+    val overallPercent: Int,
+    val status: String,
+    val errorMessage: String?,
+    val glassesTimeMs: Long?,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        internal fun fromMap(values: Map<String, Any>): OtaStatusEvent =
+            OtaStatusEvent(
+                sessionId = stringValue(values, "session_id") ?: "",
+                totalSteps = numberValue(values, "total_steps") ?: 0,
+                currentStep = numberValue(values, "current_step") ?: 0,
+                stepType = stringValue(values, "step_type") ?: "",
+                phase = stringValue(values, "phase") ?: "",
+                stepPercent = numberValue(values, "step_percent") ?: 0,
+                overallPercent = numberValue(values, "overall_percent") ?: 0,
+                status = stringValue(values, "status") ?: "",
+                errorMessage = stringValue(values, "error_message"),
+                glassesTimeMs = longValue(values, "glasses_time_ms"),
+                values = values,
+            )
+    }
+}
+
+data class OtaQueryResult(
+    val values: Map<String, Any>,
+) {
+    val type: String get() = stringValue(values, "type").orEmpty()
+    val status: String? get() = stringValue(values, "status")
+}
+
+data class SettingsAckEvent(
+    val values: Map<String, Any>,
+) {
+    val requestId: String get() = stringValue(values, "requestId").orEmpty()
+    val setting: String get() = stringValue(values, "setting").orEmpty()
+    val status: String get() = stringValue(values, "status") ?: "applied"
+    val timestamp: Long get() = longValue(values, "timestamp") ?: System.currentTimeMillis()
+    val fov: Int? get() = numberValue(values, "fov")
+    val roiPosition: Int? get() = numberValue(values, "roiPosition", "roi_position")
+    val hardwareApplied: Boolean get() = boolValue(values, "hardwareApplied", "hardware_applied") ?: false
+    val errorCode: String? get() = stringValue(values, "errorCode")
+    val errorMessage: String? get() = stringValue(values, "errorMessage")
+}
+
+data class RgbLedControlResponseEvent(
+    val values: Map<String, Any>,
+) {
+    val requestId: String get() = stringValue(values, "requestId").orEmpty()
+    val state: String get() = stringValue(values, "state") ?: "error"
+    val errorCode: String? get() = stringValue(values, "errorCode")
+}
+
+interface BluetoothSdkListener {
+    fun onStateChanged(state: BluetoothState) {}
+    fun onGlassesChanged(glasses: GlassesRuntimeState) {}
+    fun onSdkStateChanged(sdk: PhoneSdkRuntimeState) {}
+    fun onScanChanged(scan: BluetoothScanState) {}
+    fun onDeviceDiscovered(device: Device) {}
+    fun onScanStopped(reason: ScanStopReason) {}
+    fun onButtonPress(event: ButtonPressEvent) {}
+    fun onTouch(event: TouchEvent) {}
+    fun onSwipe(event: SwipeEvent) {}
+    fun onHeadUpChanged(headUp: Boolean) {}
+    fun onVoiceActivityDetectionStatus(event: VoiceActivityDetectionStatusEvent) {}
+    fun onSpeakingStatus(event: SpeakingStatusEvent) {}
+    fun onBatteryStatus(event: BatteryStatusEvent) {}
+    fun onWifiStatusChanged(event: WifiStatusEvent) {}
+    fun onHotspotStatusChanged(event: HotspotStatusEvent) {}
+    fun onHotspotError(event: HotspotErrorEvent) {}
+    fun onGalleryStatus(event: GalleryStatusEvent) {}
+    fun onPhotoResponse(event: PhotoResponseEvent) {}
+    fun onPhotoStatus(event: PhotoStatusEvent) {}
+    fun onCameraStatus(event: CameraStatusEvent) {}
+    fun onVideoRecordingStatus(event: VideoRecordingStatusEvent) {}
+    fun onMediaUpload(event: MediaUploadEvent) {}
+    fun onRgbLedControlResponse(event: RgbLedControlResponseEvent) {}
+    fun onStreamStatus(event: StreamStatusEvent) {}
+    fun onKeepAliveAck(event: KeepAliveAckEvent) {}
+    fun onOtaStartAck(event: OtaStartAckEvent) {}
+    fun onOtaStatus(event: OtaStatusEvent) {}
+    fun onSettingsAck(event: SettingsAckEvent) {}
+    fun onVersionInfo(event: VersionInfoResult) {}
+    fun onMicPcm(event: MicPcmEvent) {}
+    fun onMicLc3(event: MicLc3Event) {}
+    fun onMicHealth(event: MicHealthEvent) {}
+    fun onLocalTranscription(event: LocalTranscriptionEvent) {}
+    fun onDefaultDeviceChanged(device: Device?) {}
+    fun onLog(message: String) {}
+    fun onError(error: BluetoothError) {}
+    fun onRawEvent(eventName: String, values: Map<String, Any>) {}
+}
+
+abstract class BluetoothSdkCallback : BluetoothSdkListener

package/android/src/main/java/com/glassly/bluetoothsdk/internal/MapParsing.kt

@@ -0,0 +1,140 @@
+package com.glassly.bluetoothsdk
+
+internal fun numberValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Int? =
+    keys.firstNotNullOfOrNull { key ->
+        (values[key] as? Number)?.toInt()
+    }
+
+internal fun doubleValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Double? =
+    keys.firstNotNullOfOrNull { key ->
+        (values[key] as? Number)?.toDouble()
+    }
+
+internal fun stringValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): String? =
+    keys.firstNotNullOfOrNull { key ->
+        values[key]?.let { it as? String }
+    }
+
+internal fun boolValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean? =
+    keys.firstNotNullOfOrNull { key ->
+        values[key] as? Boolean
+    }
+
+internal fun longValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Long? =
+    keys.firstNotNullOfOrNull { key ->
+        (values[key] as? Number)?.toLong()
+    }
+
+internal fun hasAnyKey(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean = keys.any(values::containsKey)
+
+internal fun Map<*, *>.stringKeyedMap(): Map<String, Any> =
+    entries.mapNotNull { (key, value) ->
+        val stringKey = key as? String ?: return@mapNotNull null
+        val anyValue = value ?: return@mapNotNull null
+        stringKey to anyValue
+    }.toMap()
+
+internal fun optionalNumberValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Int? =
+    if (hasAnyKey(values, *keys)) {
+        numberValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalLongValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Long? =
+    if (hasAnyKey(values, *keys)) {
+        longValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalStringValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): String? =
+    if (hasAnyKey(values, *keys)) {
+        stringValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalBoolValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean? =
+    if (hasAnyKey(values, *keys)) {
+        boolValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun stringListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<String> = (values[key] as? List<*>)?.mapNotNull { it as? String } ?: emptyList()
+
+internal fun optionalStringListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<String>? =
+    if (values.containsKey(key)) {
+        stringListValue(values, key)
+    } else {
+        null
+    }
+
+internal fun mapListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<Map<String, Any>> =
+    (values[key] as? List<*>)?.mapNotNull(::stringMapValue) ?: emptyList()
+
+internal fun optionalMapListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<Map<String, Any>>? =
+    if (values.containsKey(key)) {
+        mapListValue(values, key)
+    } else {
+        null
+    }
+
+internal fun stringMapValue(value: Any?): Map<String, Any>? =
+    (value as? Map<*, *>)?.entries?.mapNotNull { (key, mapValue) ->
+        val stringKey = key as? String ?: return@mapNotNull null
+        val nonNullValue = mapValue ?: return@mapNotNull null
+        stringKey to nonNullValue
+    }?.toMap()
+
+internal fun MutableMap<String, Any>.putIfNotNull(
+    key: String,
+    value: Any?,
+) {
+    if (value != null) {
+        put(key, value)
+    }
+}

package/android/src/main/java/com/glassly/bluetoothsdk/net/LocalIpv4.kt

@@ -0,0 +1,57 @@
+package com.glassly.bluetoothsdk.net
+
+import java.net.Inet4Address
+import java.net.NetworkInterface
+
+/**
+ * Best-effort local IPv4 discovery for phone-hosted servers the glasses reach over WiFi
+ * (photo upload receiver, hotspot-served OTA). Prefers WiFi-ish interfaces carrying RFC1918
+ * addresses — under a glasses-hotspot session wlan0 holds the 192.168.43.x client address.
+ */
+object LocalIpv4 {
+  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 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])\\..*"))
+  }
+}