@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/src/main/java/com/glassly/bluetoothsdk/DeviceStore.kt

@@ -0,0 +1,360 @@
+package com.glassly.bluetoothsdk
+
+import android.os.Handler
+import android.os.Looper
+import com.glassly.bluetoothsdk.utils.DeviceTypes
+import com.glassly.bluetoothsdk.utils.ConnTypes
+import com.glassly.bluetoothsdk.utils.MicMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+
+/** Centralized observable state store for glasses and Bluetooth SDK settings */
+object DeviceStore {
+
+    val store = ObservableStore()
+
+    /**
+     * [BluetoothSdkModule] applies batched `update("bluetooth", map)` key-by-key. Post to Main so the store has
+     * the latest value before BLE. Height and depth schedule independently so Nex sends one protobuf per change.
+     */
+    private val dashboardBleHandler = Handler(Looper.getMainLooper())
+    private var pendingDashboardHeightRunnable: Runnable? = null
+    private var pendingDashboardDepthRunnable: Runnable? = null
+
+    /** Same equality rule as [ObservableStore.set] — avoids BLE side effects on no-op applies. */
+    private fun observableStoreWouldHaveSkipped(oldValue: Any?, newValue: Any): Boolean {
+        if (oldValue == null) return false
+        return JSONObject(mapOf("v" to oldValue)).toString() ==
+                JSONObject(mapOf("v" to newValue)).toString()
+    }
+
+    private fun scheduleDashboardHeightToGlasses() {
+        pendingDashboardHeightRunnable?.let { dashboardBleHandler.removeCallbacks(it) }
+        val r = Runnable {
+            pendingDashboardHeightRunnable = null
+            val h = (store.get("bluetooth", "dashboard_height") as? Number)?.toInt() ?: 4
+            DeviceManager.getInstance().sgc?.setDashboardHeightOnly(h)
+        }
+        pendingDashboardHeightRunnable = r
+        dashboardBleHandler.post(r)
+    }
+
+    private fun scheduleDashboardDepthToGlasses() {
+        pendingDashboardDepthRunnable?.let { dashboardBleHandler.removeCallbacks(it) }
+        val r = Runnable {
+            pendingDashboardDepthRunnable = null
+            val d = (store.get("bluetooth", "dashboard_depth") as? Number)?.toInt() ?: 2
+            DeviceManager.getInstance().sgc?.setDashboardDepthOnly(d)
+        }
+        pendingDashboardDepthRunnable = r
+        dashboardBleHandler.post(r)
+    }
+
+    init {
+        // SETTINGS are snake_case
+        // CORE STATE is camelCase
+
+        // GLASSES STATE:
+        store.set("glasses", "batteryLevel", -1)
+        store.set("glasses", "charging", false)
+        store.set("glasses", "fullyBooted", false)
+        store.set("glasses", "connected", false)
+        store.set("glasses", "connectionState", ConnTypes.DISCONNECTED)
+        store.set("glasses", "deviceModel", "")
+        store.set("glasses", "firmwareVersion", "")
+        store.set("glasses", "hotspotOtaVersion", 0)
+        store.set("glasses", "micEnabled", false)
+        store.set("glasses", "voiceActivityDetectionEnabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
+        store.set("glasses", "bluetoothClassicConnected", false)
+        store.set("glasses", "caseRemoved", true)
+        store.set("glasses", "caseOpen", true)
+        store.set("glasses", "caseCharging", false)
+        store.set("glasses", "caseBatteryLevel", -1)
+        store.set("glasses", "headUp", false)
+        store.set("glasses", "bluetoothMacAddress", "")
+        store.set("glasses", "wifiMacAddress", "")
+        store.set("glasses", "leftMacAddress", "")
+        store.set("glasses", "rightMacAddress", "")
+        store.set("glasses", "macAddress", "")
+        store.set("glasses", "serialNumber", "")
+        store.set("glasses", "style", "")
+        store.set("glasses", "color", "")
+        store.set("glasses", "wifiSsid", "")
+        store.set("glasses", "wifiConnected", false)
+        store.set("glasses", "wifiLocalIp", "")
+        store.set("glasses", "hotspotEnabled", false)
+        store.set("glasses", "hotspotSsid", "")
+        store.set("glasses", "hotspotPassword", "")
+        store.set("glasses", "hotspotGatewayIp", "")
+        store.set("glasses", "bluetoothName", "")
+        store.set("glasses", "signalStrength", -1)
+        store.set("glasses", "signalStrengthUpdatedAt", 0L)
+        store.set("glasses", "controllerConnected", false)
+        store.set("glasses", "controllerFullyBooted", false)
+        store.set("glasses", "controllerMacAddress", "")
+        store.set("glasses", "controllerBatteryLevel", -1)
+        store.set("glasses", "controllerSignalStrength", -1)
+        store.set("glasses", "ringSignalStrength", -1)
+
+        // CORE STATE:
+        store.set("bluetooth", "systemMicUnavailable", false)
+        store.set("bluetooth", "searching", false)
+        store.set("bluetooth", "searchingController", false)
+        store.set("bluetooth", "micEnabled", false)
+        store.set("bluetooth", "currentMic", "")
+        store.set("bluetooth", "searchResults", emptyList<Any>())
+        store.set("bluetooth", "wifiScanResults", emptyList<Any>())
+        store.set("bluetooth", "micRanking", MicMap.map["auto"]!!)
+        store.set("bluetooth", "lastLog", mutableListOf<String>())
+
+        // CORE SETTINGS:
+        store.set("bluetooth", "default_wearable", "")
+        store.set("bluetooth", "pending_wearable", "")
+        store.set("bluetooth", "device_name", "")
+        store.set("bluetooth", "device_address", "")
+        store.set("bluetooth", "default_controller", "")
+        store.set("bluetooth", "pending_controller", "")
+        store.set("bluetooth", "controller_device_name", "")
+        store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "preferred_mic", "auto")
+        store.set("bluetooth", "sensing_enabled", true)
+        store.set("bluetooth", "power_saving_mode", false)
+        store.set("bluetooth", "brightness", 50)
+        store.set("bluetooth", "auto_brightness", true)
+        store.set("bluetooth", "dashboard_height", 4)
+        store.set("bluetooth", "dashboard_depth", 2)
+        store.set("bluetooth", "head_up_angle", 30)
+        store.set("bluetooth", "imu_enabled", false)
+        store.set("bluetooth", "contextual_dashboard", true)
+        store.set("bluetooth", "gallery_mode", true)
+        store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
+        store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
+        store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "button_photo_size", "max")
+        store.set("bluetooth", "button_max_recording_time", 10)
+        store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
+        store.set("bluetooth", "button_video_width", 1280)
+        store.set("bluetooth", "button_video_height", 720)
+        store.set("bluetooth", "button_video_fps", 30)
+        store.set("bluetooth", "preferred_mic", "auto")
+        store.set("bluetooth", "lc3_frame_size", 60)
+        store.set("bluetooth", "auth_email", "")
+        store.set("bluetooth", "core_token", "")
+        store.set("bluetooth", "should_send_pcm", false)
+        store.set("bluetooth", "should_send_lc3", false)
+        store.set("bluetooth", "should_send_transcript", false)
+        store.set("bluetooth", "use_native_dashboard", false)
+        // Mentra Nex feature flags (off by default; toggled from Nex Developer Settings):
+        store.set("bluetooth", "nex_chinese_captions", false)
+        store.set("bluetooth", "nex_lc3_audio_playback", false)
+    }
+
+    fun get(category: String, key: String): Any? {
+        return store.get(category, key)
+    }
+
+    fun set(category: String, key: String, value: Any) {
+        store.set(category, key, value)
+    }
+
+    /** Apply changes with side effects */
+    fun apply(category: String, key: String, value: Any) {
+        val oldValue = store.get(category, key)
+        store.set(category, key, value)
+        if (observableStoreWouldHaveSkipped(oldValue, value)) {
+            return
+        }
+
+        // Trigger hardware updates based on setting changes
+        when (category to key) {
+            "glasses" to "fullyBooted" -> {
+                if (value is Boolean) {
+                    if (value) {
+                        DeviceManager.getInstance().handleDeviceReady()
+                    } else {
+                        DeviceManager.getInstance().handleDeviceDisconnected()
+                    }
+                    // we shouldn't call store.set in this function as this is only intended for side-effects, not driving state updates
+                }
+            }
+            "glasses" to "controllerFullyBooted" -> {
+                if (value is Boolean) {
+                    if (value) {
+                        DeviceManager.getInstance().handleControllerReady()
+                    } else {
+                        DeviceManager.getInstance().handleControllerDisconnected()
+                    }
+                }
+            }
+            "glasses" to "controllerMacAddress" -> {
+                if (value is String && value.isNotEmpty()) {
+                    CoroutineScope(Dispatchers.Main).launch {
+                        // give the glasses some extra time to finish booting:
+                        delay(1000)
+                        DeviceManager.getInstance().sgc?.connectController()
+                    }
+                }
+            }
+            "glasses" to "headUp" -> {
+                if (value is Boolean) {
+                    DeviceManager.getInstance().sendCurrentState()
+                    Bridge.sendHeadUp(value)
+                }
+            }
+
+            // BLUETOOTH:
+            "bluetooth" to "brightness" -> {
+                val b = (value as? Number)?.toInt()  ?: 50
+                val auto = (store.get("bluetooth", "auto_brightness") as? Boolean) ?: true
+                CoroutineScope(Dispatchers.Main).launch {
+                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
+                    DeviceManager.getInstance().sgc?.sendTextWall("Set brightness to $b%")
+                    delay(800) // 0.8 seconds
+                    DeviceManager.getInstance().sgc?.clearDisplay()
+                }
+            }
+            "bluetooth" to "auto_brightness" -> {
+                val b = (store.get("bluetooth", "brightness") as? Int) ?: 50
+                val auto = (value as? Boolean) ?: true
+                val autoBrightnessChanged = (oldValue as? Boolean) != auto
+                CoroutineScope(Dispatchers.Main).launch {
+                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
+                    if (autoBrightnessChanged) {
+                        DeviceManager.getInstance()
+                                .sgc
+                                ?.sendTextWall(
+                                        if (auto) "Enabled auto brightness"
+                                        else "Disabled auto brightness"
+                                )
+                        delay(800) // 0.8 seconds
+                        DeviceManager.getInstance().sgc?.clearDisplay()
+                    }
+                }
+            }
+            "bluetooth" to "cfw_scene_renderer" -> {
+                val enabled = value as? Boolean
+                if (enabled != null && (oldValue as? Boolean) != enabled) {
+                    CoroutineScope(Dispatchers.Main).launch {
+                        DeviceManager.getInstance().sgc?.cfwSceneRendererToggled(enabled)
+                    }
+                }
+            }
+            "bluetooth" to "dashboard_height" -> {
+                scheduleDashboardHeightToGlasses()
+            }
+            "bluetooth" to "dashboard_depth" -> {
+                scheduleDashboardDepthToGlasses()
+            }
+            "bluetooth" to "head_up_angle" -> {
+                (value as? Int)?.let { angle ->
+                    DeviceManager.getInstance().sgc?.setHeadUpAngle(angle)
+                }
+            }
+            "bluetooth" to "imu_enabled" -> {
+                (value as? Boolean)?.let { enabled ->
+                    CoroutineScope(Dispatchers.Main).launch {
+                        DeviceManager.getInstance().sgc?.setImuEnabled(enabled)
+                    }
+                }
+            }
+            "bluetooth" to "menu_apps" -> {
+                @Suppress("UNCHECKED_CAST")
+                (value as? List<Map<String, Any>>)?.let { items ->
+                    DeviceManager.getInstance().sgc?.setDashboardMenu(items)
+                }
+            }
+            // `core` category is normalized to `bluetooth` before reaching this switch.
+            "bluetooth" to "calendar_events" -> {
+                @Suppress("UNCHECKED_CAST")
+                (value as? List<Map<String, Any>>)?.let { events ->
+                    DeviceManager.getInstance().sgc?.sendCalendarEvents(events)
+                }
+            }
+            "bluetooth" to "metric_system",
+            "bluetooth" to "twelve_hour_time" -> {
+                DeviceManager.getInstance().sgc?.sendDashboardDisplaySettings()
+            }
+            "bluetooth" to "gallery_mode" -> {
+                DeviceManager.getInstance().sgc?.sendGalleryMode()
+            }
+            "bluetooth" to "voice_activity_detection_enabled" -> {
+                DeviceManager.getInstance().sgc?.sendVoiceActivityDetectionSetting()
+            }
+            "bluetooth" to "loudness_gate_enabled" -> {
+                DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
+            }
+            "bluetooth" to "nex_lc3_audio_playback" -> {
+                (value as? Boolean)?.let { enabled ->
+                    Bridge.log("DeviceStore: nex_lc3_audio_playback changed to $enabled")
+                    DeviceManager.getInstance().sgc?.applyNexAudioPlaybackSetting()
+                }
+            }
+            "bluetooth" to "screen_disabled" -> {
+                (value as? Boolean)?.let { disabled ->
+                    if (disabled) {
+                        DeviceManager.getInstance().sgc?.exit()
+                    } else {
+                        DeviceManager.getInstance().sgc?.clearDisplay()
+                    }
+                }
+            }
+            "bluetooth" to "button_photo_size" -> {
+                DeviceManager.getInstance().sgc?.sendButtonPhotoSettings()
+            }
+            "bluetooth" to "button_max_recording_time" -> {
+                DeviceManager.getInstance().sgc?.sendButtonMaxRecordingTime()
+            }
+            "bluetooth" to "camera_fov" -> {
+                DeviceManager.getInstance().sgc?.sendCameraFovSetting()
+            }
+            "bluetooth" to "button_video_settings" -> {
+                DeviceManager.getInstance().sgc?.sendButtonVideoRecordingSettings()
+            }
+            // Legacy scalar keys remain supported for older hosts. New code should write the
+            // canonical button_video_settings object so width/height/fps update atomically.
+            "bluetooth" to "button_video_width",
+            "bluetooth" to "button_video_height",
+            "bluetooth" to "button_video_fps" -> {
+                DeviceManager.getInstance().sgc?.sendButtonVideoRecordingSettings()
+            }
+            "bluetooth" to "preferred_mic" -> {
+                (value as? String)?.let { mic ->
+                    apply("bluetooth", "micRanking", MicMap.map[mic] ?: MicMap.map["auto"]!!)
+                    DeviceManager.getInstance().setMicState()
+                }
+            }
+            "bluetooth" to "local_stt_fallback_active" -> {
+                (value as? Boolean)?.let { active ->
+                    Bridge.log("DeviceStore: local_stt_fallback_active changed to $active")
+                    DeviceManager.getInstance().setMicState()
+                }
+            }
+            "bluetooth" to "should_send_pcm" -> {
+                (value as? Boolean)?.let { pcm ->
+                    DeviceManager.getInstance().setMicState()
+                }
+            }
+            "bluetooth" to "should_send_lc3" -> {
+                (value as? Boolean)?.let { lc3 ->
+                    DeviceManager.getInstance().setMicState()
+                }
+            }
+            "bluetooth" to "should_send_transcript" -> {
+                (value as? Boolean)?.let { transcript ->
+                    DeviceManager.getInstance().setMicState()
+                }
+            }
+            "bluetooth" to "default_wearable" -> {
+                (value as? String)?.let { wearable ->
+                    Bridge.saveSetting("default_wearable", wearable)
+                    if (wearable.contains(DeviceTypes.SIMULATED)) {
+                        DeviceManager.getInstance().initSGC(wearable)
+                    }
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/glassly/bluetoothsdk/GeneratedChangelogCatalog.kt

@@ -0,0 +1,8 @@
+package com.glassly.bluetoothsdk
+
+/** Generated from /changelogs. Do not edit directly. */
+internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
+    listOf(
+        ReleaseChangelog(version = "3.1.0", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- GlasslyOS, Glassly Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+        ReleaseChangelog(version = "0.1.0", markdown = "First coordinated Glassly release: the app, Glassly Engine, and the Bluetooth SDK now ship one shared release version.\n\n- The Glassly App, Glassly Engine, and the Bluetooth SDK are versioned and published together.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+    )

package/android/src/main/java/com/glassly/bluetoothsdk/GeneratedReleaseMetadata.kt

@@ -0,0 +1,11 @@
+package com.glassly.bluetoothsdk
+
+/** Generated by release CI. Do not edit in a release checkout. */
+internal object GeneratedReleaseMetadata {
+    const val FAMILY_BASE_VERSION: String = "0.1.0"
+    const val RELEASE_IDENTITY: String = "0.1.0-dev.26"
+    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.26"
+    const val SOURCE_COMMIT: String = "b63f66924c61de31540b5093d05ff036c756ed74"
+    const val OTA_MANIFEST_URL: String = null
+    const val OTA_MANIFEST_SHA256: String = null
+}