From 2fc97a70806e8494d37d73ec85ac5282ff60bcba Mon Sep 17 00:00:00 2001
From: Guy Dupont <dupontgu@gmail.com>
Date: Wed, 15 Jul 2026 16:56:04 -0400
Subject: [PATCH 1/9] allow key event forwarding to server, update emulator to
 demo, accompanying shared UI

---
 .../thelightphone/plugin/ManifestGenerator.kt |   1 +
 .../com/thelightphone/sdk/LightActivity.kt    | 111 +++++++++++++---
 .../com/thelightphone/sdk/LightScreen.kt      |  19 ++-
 .../sdk/LightServiceConnection.kt             |  61 +++++++--
 .../com/thelightphone/sdk/LightViewModel.kt   |   3 +-
 .../sdk/emulator/EmulatorApplication.kt       |  46 ++++++-
 .../sdk/emulator/EmulatorDeviceKeyHandler.kt  | 122 ++++++++++++++++++
 .../sdk/emulator/EmulatorNavController.kt     |  22 ++++
 .../sdk/emulator/EmulatorSettings.kt          | 119 +++++++++++++----
 .../sdk/emulator/LightAudioManager.kt         | 106 +++++++++++++++
 .../sdk/emulator/MainActivity.kt              | 105 +++++++++------
 .../sdk/server/LightSdkServer.kt              |  22 ++++
 .../sdk/server/LightSdkService.kt             |  15 ++-
 .../sdk/shared/LightDeviceKeys.kt             |  11 ++
 .../thelightphone/sdk/shared/LightResult.kt   |   4 +-
 .../sdk/shared/LightServiceMethod.kt          |  23 ++++
 .../thelightphone/sdk/ui/LightKeyHandler.kt   |  15 +++
 .../thelightphone/sdk/ui/LightModalManager.kt |  95 ++++++++++++++
 .../thelightphone/sdk/ui/LightProgressBar.kt  | 103 +++++++++++++++
 19 files changed, 898 insertions(+), 105 deletions(-)
 create mode 100644 sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
 create mode 100644 sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorNavController.kt
 create mode 100644 sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/LightAudioManager.kt
 create mode 100644 sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
 create mode 100644 sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightKeyHandler.kt
 create mode 100644 sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
 create mode 100644 sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt

diff --git a/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt b/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
index 17757462..45ac8c03 100644
--- a/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
+++ b/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
@@ -39,6 +39,7 @@ object ManifestGenerator {
         appendLine("""            android:value="${xmlAttr(metadata.serverPackage)}" />""")
         appendLine("""        <activity""")
         appendLine("""            android:name="com.thelightphone.sdk.LightActivity"""")
+        appendLine("""            android:launchMode="singleTask"""")
         metadata.orientation?.let {
             appendLine("""            android:screenOrientation="${xmlAttr(it)}"""")
         }
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
index b8411bd7..1eabde85 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
@@ -2,6 +2,7 @@ package com.thelightphone.sdk
 
 import android.content.Context
 import android.os.Bundle
+import android.view.KeyEvent
 import android.view.WindowManager
 import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedCallback
@@ -12,10 +13,10 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Modifier
-import androidx.lifecycle.ViewModelStoreOwner
-import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
@@ -23,6 +24,12 @@ import androidx.core.view.WindowInsetsControllerCompat
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.preferencesDataStore
+import androidx.lifecycle.ViewModelStoreOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
+import com.thelightphone.sdk.shared.LightServiceMethod
+import com.thelightphone.sdk.ui.LightModalManager
+import kotlinx.coroutines.launch
 import java.io.File
 
 private class BackStackEntry<T>(
@@ -88,25 +95,30 @@ class LightActivity internal constructor() : ComponentActivity() {
 
         setContent {
             androidx.compose.runtime.LaunchedEffect(Unit) { contentReady = true }
-            val screen = currentScreen.value?.screen
-            if (screen != null) {
-                Column(modifier = Modifier.fillMaxSize()) {
-                    Box(
-                        modifier = Modifier
-                            .weight(1f)
-                            .fillMaxWidth(),
-                    ) {
-                        val content: @Composable () -> Unit = { screen.Content() }
-                        if (screen is ViewModelStoreOwner) {
-                            CompositionLocalProvider(
-                                LocalViewModelStoreOwner provides screen,
-                                content = content,
-                            )
-                        } else {
-                            content()
+            Box(modifier = Modifier.fillMaxSize()) {
+                val screen = currentScreen.value?.screen
+                if (screen != null) {
+                    Column(modifier = Modifier.fillMaxSize()) {
+                        Box(
+                            modifier = Modifier
+                                .weight(1f)
+                                .fillMaxWidth(),
+                        ) {
+                            val content: @Composable () -> Unit = { screen.Content() }
+                            if (screen is ViewModelStoreOwner) {
+                                CompositionLocalProvider(
+                                    LocalViewModelStoreOwner provides screen,
+                                    content = content,
+                                )
+                            } else {
+                                content()
+                            }
                         }
                     }
                 }
+                // Transient modals draw on top of the current screen.
+                val activeModal by LightModalManager.activeModal.collectAsState()
+                activeModal?.Content()
             }
         }
 
@@ -120,6 +132,69 @@ class LightActivity internal constructor() : ComponentActivity() {
         )
     }
 
+    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            return super.onKeyDown(keyCode, event)
+        }
+        if (currentScreen.value?.screen?.onKeyDown(keyCode, event) == true) {
+            return true
+        }
+        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyDown, keyCode, event)
+        return true
+    }
+
+    override fun onKeyMultiple(
+        keyCode: Int,
+        repeatCount: Int,
+        event: KeyEvent?
+    ): Boolean {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            return super.onKeyMultiple(keyCode, repeatCount, event)
+        }
+        if (event != null && currentScreen.value?.screen?.onKeyMultiple(keyCode, repeatCount, event) == true) {
+            return true
+        }
+        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyMultiple, keyCode, event)
+        return true
+    }
+
+    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            return super.onKeyUp(keyCode, event)
+        }
+        if (event != null && currentScreen.value?.screen?.onKeyUp(keyCode, event) == true) {
+            return true
+        }
+        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyUp, keyCode, event)
+        return true
+    }
+
+    private fun forwardKeyEventToServer(
+        eventType: LightServiceMethod.DeviceKeyEvent.EventType,
+        keyCode: Int,
+        event: KeyEvent?,
+    ) {
+        val action = event?.action ?: when (eventType) {
+            LightServiceMethod.DeviceKeyEvent.EventType.KeyDown -> KeyEvent.ACTION_DOWN
+            LightServiceMethod.DeviceKeyEvent.EventType.KeyUp -> KeyEvent.ACTION_UP
+            LightServiceMethod.DeviceKeyEvent.EventType.KeyMultiple -> KeyEvent.ACTION_MULTIPLE
+        }
+        lifecycleScope.launch {
+            callRemoteServiceMethod(
+                LightServiceMethod.DeviceKeyEvent,
+                LightServiceMethod.DeviceKeyEvent.Request(
+                    eventType = eventType,
+                    keyCode = keyCode,
+                    repeatCount = event?.repeatCount,
+                    action = action,
+                    characters = event?.characters,
+                    unicodeChar = event?.unicodeChar ?: 0,
+                    componentToRelaunch = componentName.flattenToString()
+                )
+            )
+        }
+    }
+
     override fun onPause() {
         super.onPause()
         currentScreen.value?.screen?.notifyAppPause()
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightScreen.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightScreen.kt
index 898f8197..020198d2 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightScreen.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightScreen.kt
@@ -1,16 +1,15 @@
 package com.thelightphone.sdk
 
+import android.view.KeyEvent
 import androidx.compose.runtime.Composable
-import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.core.Preferences
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.ViewModelStore
 import androidx.lifecycle.ViewModelStoreOwner
-import java.io.File
-import kotlin.text.clear
+import com.thelightphone.sdk.ui.LightKeyHandler
 
-abstract class SimpleLightScreen<ResultType>(sealedActivity: SealedLightActivity) {
+abstract class SimpleLightScreen<ResultType>(sealedActivity: SealedLightActivity) :
+    LightKeyHandler {
     internal val activity = sealedActivity.activity
     internal var result: ResultType? = null
     protected val lightContext = SealedLightContext(sealedActivity.activity)
@@ -92,4 +91,14 @@ abstract class LightScreen<ResultType, VM : LightViewModel<ResultType>>(
             super.goBack(result)
         }
     }
+
+    override fun onKeyDown(keyCode: Int, event: KeyEvent) = viewModel.onKeyDown(keyCode, event)
+
+    override fun onKeyUp(keyCode: Int, event: KeyEvent)= viewModel.onKeyUp(keyCode, event)
+
+    override fun onKeyMultiple(
+        keyCode: Int,
+        repeatCount: Int,
+        event: KeyEvent
+    ) = viewModel.onKeyMultiple(keyCode, repeatCount, event)
 }
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
index c3feca9e..57b9ee3c 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
@@ -27,15 +27,21 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
 private const val TAG = "LightServiceConnection"
+private const val DEFAULT_TOKEN = "no_auth"
 
 internal object LightServiceConnection : ServiceConnection {
 
     private var serviceBinder: IBinder? = null
     private var bound = false
     private var binderReady = CompletableDeferred<IBinder>()
-    private var token: String? = null
+    private var token: String = DEFAULT_TOKEN
+    // Retained so we can rebind ourselves if the binding dies. applicationContext, so no leak.
+    private var appContext: Context? = null
+    private var serverPackage: String? = null
 
     fun bind(context: Context, serverPackage: String) {
+        appContext = context.applicationContext
+        this.serverPackage = serverPackage
         if (bound) return
         val intent = Intent(LightConstants.ACTION_BIND_SDK_SERVICE).apply {
             setPackage(serverPackage)
@@ -46,12 +52,20 @@ internal object LightServiceConnection : ServiceConnection {
         }
     }
 
+    /** Forget the cached token so the next [ensureToken] re-authenticates with the server. */
+    fun clearToken() {
+        token = DEFAULT_TOKEN
+    }
+
+    private fun resetConnection() {
+        serviceBinder = null
+        clearToken()
+        binderReady = CompletableDeferred()
+    }
+
     fun unbind(context: Context) {
         if (!bound) return
-        try {
-            context.unbindService(this)
-        } catch (_: IllegalArgumentException) {
-        }
+        runCatching { context.unbindService(this) }
         bound = false
         serviceBinder = null
     }
@@ -91,6 +105,8 @@ internal object LightServiceConnection : ServiceConnection {
     override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
         Log.i(TAG, "Connected to LightSdkService")
         serviceBinder = binder
+        // force re-auth if re-connected
+        clearToken()
         if (binder != null) {
             binderReady.complete(binder)
         }
@@ -98,15 +114,29 @@ internal object LightServiceConnection : ServiceConnection {
 
     override fun onServiceDisconnected(name: ComponentName?) {
         Log.w(TAG, "Disconnected from LightSdkService")
-        serviceBinder = null
-        token = null
-        binderReady = CompletableDeferred()
+        resetConnection()
+    }
+
+    override fun onBindingDied(name: ComponentName?) {
+        Log.w(TAG, "Binding to LightSdkService died, rebinding")
+        resetConnection()
+        // BIND_AUTO_CREATE does not recover a dead binding on its own; unbind and rebind.
+        val ctx = appContext ?: return
+        val pkg = serverPackage ?: return
+        runCatching { ctx.unbindService(this) }
+            .onFailure { Log.w(TAG, "Failed to unbind service", it) }
+        bound = false
+        bind(ctx, pkg)
+    }
+
+    override fun onNullBinding(name: ComponentName?) {
+        Log.e(TAG, "LightSdkService returned a null binding")
     }
 
     suspend fun awaitBinder(): IBinder = binderReady.await()
 
     fun ensureToken(): Boolean {
-        if (token != null) return true
+        if (token != DEFAULT_TOKEN) return true
         return when (val result = request(
             LightServiceMethod.GetToken.id,
             LightServiceMethod.GetToken.encodeRequest(Unit)
@@ -138,7 +168,18 @@ suspend fun <TRequest, TResponse> callRemoteServiceMethod(
     if (bound != true) {
         return@withContext LightResult.Error(LightResult.ErrorCode.Unknown, "Unable to bind to server")
     }
-    when (val result = LightServiceConnection.request(method.id, method.encodeRequest(body))) {
+    val encoded = method.encodeRequest(body)
+    var result = LightServiceConnection.request(method.id, encoded)
+    if (result is LightResult.Error && result.code == LightResult.ErrorCode.InvalidToken) {
+        // The server no longer recognizes our token (e.g. it restarted and lost its token
+        // store). Drop it, re-authenticate, and retry the request exactly once. GetToken is
+        // gated by caller verification rather than the token, so this cannot loop.
+        Log.i(TAG, "Token rejected calling remote method, re-auth + retry")
+        LightServiceConnection.clearToken()
+        LightServiceConnection.ensureToken()
+        result = LightServiceConnection.request(method.id, encoded)
+    }
+    when (result) {
         is LightResult.Success -> LightResult.Success(method.decodeResponse(result.data))
         is LightResult.Error -> result
     }
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightViewModel.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightViewModel.kt
index 1b7d2c6b..977944ac 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightViewModel.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightViewModel.kt
@@ -1,8 +1,9 @@
 package com.thelightphone.sdk
 
 import androidx.lifecycle.ViewModel
+import com.thelightphone.sdk.ui.LightKeyHandler
 
-abstract class LightViewModel<T> : ViewModel() {
+abstract class LightViewModel<T> : ViewModel(), LightKeyHandler {
     open fun onScreenShow(screen: SimpleLightScreen<T>) {}
     open fun onScreenHide(screen: SimpleLightScreen<T>) {}
     open fun onAppPause() {}
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
index 07663c31..a1fb0cc8 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
@@ -1,7 +1,9 @@
 package com.thelightphone.sdk.emulator
 
 import android.app.Application
+import android.content.ComponentName
 import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.content.pm.Signature
 import android.util.Log
@@ -10,6 +12,8 @@ import com.thelightphone.sdk.server.ClientCertType
 import com.thelightphone.sdk.server.DefaultLightSdkServerSettings
 import com.thelightphone.sdk.server.LightSdkServer
 import com.thelightphone.sdk.shared.LightResult
+import com.thelightphone.sdk.shared.LightServiceMethod
+import com.thelightphone.sdk.ui.LightModalManager
 import java.security.MessageDigest
 
 // SHA-256 fingerprint of sdk/keys/lightsdk-dev.jks (alias: lightsdk-dev).
@@ -17,10 +21,14 @@ private const val LIGHTSDK_DEV_CERT_SHA256 =
     "B9C33E29B0CCAD2BFF11ACAB55F65A3C517EF4BC92CD9C77785366FA353D5F28"
 
 class EmulatorApplication : Application() {
+    val lightAudioManager by lazy { LightAudioManager(this) }
+    val deviceKeyHandler by lazy { EmulatorDeviceKeyHandler(lightAudioManager) }
+
     override fun onCreate() {
         super.onCreate()
         val mollySocketUriString = BuildConfig.MOLLYSOCKET_URI
         val settings = DefaultLightSdkServerSettings(this)
+
         with(LightSdkServer) {
             registerLockReceiver(MainActivity::class.java, settings)
             customServiceMethodResolver = { callingId, methodId, payload ->
@@ -41,10 +49,45 @@ class EmulatorApplication : Application() {
             }
             provideSdkSettings = { settings }
             permissionActivity = LightSdkPermissionActivity::class.java
+            rootActivity = MainActivity::class.java
+            onDeviceKeyEvent = { _, request -> handleDeviceKeyEvent(request) }
         }
 
         EmulatorHttpServer(this).start()
     }
+
+    private fun handleDeviceKeyEvent(request: LightServiceMethod.DeviceKeyEvent.Request) {
+        deviceKeyHandler.onDeviceKeyEventRequest(request)?.let { modal ->
+            // when the server is done handling the key press, server should re-launch the component that was foregrounded
+            // at the time of key event
+            fun relaunchSender() {
+                val componentToRelaunch =
+                    request.componentToRelaunch?.let(ComponentName::unflattenFromString)
+                startActivity(
+                    Intent().setComponent(componentToRelaunch)
+                        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                )
+                EmulatorNavController.navigateTo(Nav.Toolbox)
+            }
+
+            val keyModal = DeviceKeyModal(
+                modal,
+                onMoreClick = {
+                    EmulatorNavController.navigateTo(Nav.Settings(backButtonOverride = ::relaunchSender))
+                },
+                onExpired = { relaunchSender() }
+            )
+            // show the modal, and then pull this app into focus over the client
+            LightModalManager.show(keyModal)
+            foregroundApp()
+        }
+    }
+
+    private fun foregroundApp() {
+        val intent = Intent(this.applicationContext, MainActivity::class.java)
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        startActivity(intent)
+    }
 }
 
 // For the emulator, any apk built with LIGHTSDK_DEV_CERT_SHA256 is considered signed by Light
@@ -63,7 +106,8 @@ private fun Context.checkLightSdkCert(callingPackage: String): ClientCertType {
     }
     val md = MessageDigest.getInstance("SHA-256")
     val matches = signers.any { sig ->
-        md.digest(sig.toByteArray()).toHexString().equals(LIGHTSDK_DEV_CERT_SHA256, ignoreCase = true)
+        md.digest(sig.toByteArray()).toHexString()
+            .equals(LIGHTSDK_DEV_CERT_SHA256, ignoreCase = true)
     }
     return if (matches) ClientCertType.LightSdkSignedUnverified else ClientCertType.Unknown
 }
\ No newline at end of file
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
new file mode 100644
index 00000000..964c0a55
--- /dev/null
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
@@ -0,0 +1,122 @@
+package com.thelightphone.sdk.emulator
+
+import android.util.Log
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import com.thelightphone.sdk.shared.LightKeys
+import com.thelightphone.sdk.shared.LightServiceMethod
+import com.thelightphone.sdk.ui.LightIcon
+import com.thelightphone.sdk.ui.LightIcons
+import com.thelightphone.sdk.ui.LightModal
+import com.thelightphone.sdk.ui.LightProgressBar
+import com.thelightphone.sdk.ui.LightText
+import com.thelightphone.sdk.ui.LightTextVariant
+import com.thelightphone.sdk.ui.LightTheme
+import com.thelightphone.sdk.ui.LightThemeController
+import com.thelightphone.sdk.ui.gridUnitsAsDp
+import com.thelightphone.sdk.ui.lightClickable
+import kotlinx.coroutines.CompletableDeferred
+
+class EmulatorDeviceKeyHandler(private val audioManager: LightAudioManager) {
+
+    companion object {
+        private const val TAG = "EmulatorDeviceKeyHandler"
+    }
+
+    fun onDeviceKeyEventRequest(request: LightServiceMethod.DeviceKeyEvent.Request): AudioModal? {
+        if (request.eventType != LightServiceMethod.DeviceKeyEvent.EventType.KeyDown) return null
+        return when (request.keyCode) {
+            LightKeys.VOLUME_UP -> audioManager.stepUp()
+            LightKeys.VOLUME_DOWN -> audioManager.stepDown()
+            else -> {
+                Log.d(TAG, "Unhandled keyCode: ${request.keyCode}")
+                null
+            }
+        }
+    }
+}
+
+class DeviceKeyModal(
+    private val audioModal: AudioModal,
+    private val onMoreClick: () -> Unit,
+    override val onExpired: () -> Unit
+) : LightModal {
+    private val dismissDeferred = CompletableDeferred<Unit>()
+
+    override fun dismiss() { dismissDeferred.complete(Unit) }
+    override suspend fun awaitDismiss() { dismissDeferred.await() }
+
+    @Composable
+    override fun Content() {
+        val themeColors by LightThemeController.colors.collectAsState()
+        val label = when (audioModal.type) {
+            ModalType.RingerVol -> "ringer"
+            ModalType.CallVol -> "call volume"
+            ModalType.AlarmVol -> "alarm"
+            ModalType.MediaVol -> "volume"
+            ModalType.Silent -> "silent"
+            ModalType.VibrateOnly -> "vibrate only"
+        }
+        LightTheme(themeColors) {
+            Surface {
+                Column(
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(horizontal = 3.5f.gridUnitsAsDp())
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        modifier = Modifier.weight(1f)
+                    ) {
+                        Spacer(Modifier.height(10.5f.gridUnitsAsDp()))
+                        LightText(label, variant = LightTextVariant.Subtitle)
+                        if (audioModal.type == ModalType.Silent) {
+                            Spacer(Modifier.height(2f.gridUnitsAsDp()))
+                            LightIcon(LightIcons.SPEAKER_MUTED)
+                        } else {
+                            Spacer(Modifier.height(2.5f.gridUnitsAsDp()))
+                            LightProgressBar(themeColors, audioModal.value)
+                        }
+                    }
+                    LightText(
+                        text = ". . .",
+                        variant = LightTextVariant.Copy,
+                        modifier = Modifier.lightClickable {
+                            dismiss()
+                            onMoreClick()
+                        }
+                    )
+                    Spacer(Modifier.height(1f.gridUnitsAsDp()))
+                }
+            }
+        }
+    }
+}
+
+@Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
+@Composable
+fun DeviceKeyModalPreview() {
+    var audioModal by remember { mutableStateOf(AudioModal(ModalType.RingerVol, 0.4f)) }
+    fun toggle() {
+        audioModal = if (audioModal.type == ModalType.RingerVol) {
+            AudioModal(ModalType.Silent, 0.0f)
+        } else {
+            AudioModal(ModalType.RingerVol, 0.4f)
+        }
+    }
+    DeviceKeyModal(audioModal, onExpired = {}, onMoreClick = ::toggle).Content()
+}
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorNavController.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorNavController.kt
new file mode 100644
index 00000000..19e2cc16
--- /dev/null
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorNavController.kt
@@ -0,0 +1,22 @@
+package com.thelightphone.sdk.emulator
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+sealed interface Nav {
+    data object LockScreen : Nav
+    data object Toolbox : Nav
+    class Settings(
+        val startingScreen: EmulatorSettingsNav = EmulatorSettingsNav.Root,
+        val backButtonOverride: (() -> Unit)? = null
+    ) : Nav
+}
+
+object EmulatorNavController {
+    private val _currentNav = MutableStateFlow<Nav>(Nav.LockScreen)
+    val currentNav = _currentNav.asStateFlow()
+
+    fun navigateTo(nav: Nav) {
+        _currentNav.value = nav
+    }
+}
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
index 2887ef03..31c4cfa8 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
@@ -5,17 +5,22 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material3.Surface
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import com.thelightphone.sdk.ui.LightTouchableProgressBar
 import com.thelightphone.sdk.server.ClientFilterLevel
 import com.thelightphone.sdk.server.ForceFocusLevel
 import com.thelightphone.sdk.server.LightSdkServerSettings
 import com.thelightphone.sdk.shared.LightServiceMethod
 import com.thelightphone.sdk.ui.*
 import com.thelightphone.sdk.ui.LightBarButton.LightIcon
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 
-private enum class EmulatorSettingsNav {
-    Root, FilterLevel, Keyboard, ForceFocus
+enum class EmulatorSettingsNav {
+    Root, FilterLevel, Keyboard, ForceFocus, Notifications
 }
 
 val ClientFilterLevel.label: String
@@ -34,8 +39,17 @@ val ForceFocusLevel.label: String
     }
 
 @Composable
-fun EmulatorSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit) {
-    var nav by remember { mutableStateOf(EmulatorSettingsNav.Root) }
+fun EmulatorSettings(
+    settings: LightSdkServerSettings,
+    emulatorSettingsAudio: EmulatorSettingsAudio,
+    startingNav: Nav.Settings,
+    onRootBackPressed: () -> Unit,
+) {
+    var nav by remember { mutableStateOf(startingNav.startingScreen) }
+    val subscreenBackPressed = startingNav.backButtonOverride ?: {
+        nav = EmulatorSettingsNav.Root
+    }
+    val rowPadding = Modifier.padding(1f.gridUnitsAsDp())
     Surface(Modifier.fillMaxSize()) {
         when (nav) {
             EmulatorSettingsNav.Root -> {
@@ -43,7 +57,7 @@ fun EmulatorSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit
                     LightTopBar(
                         leftButton = LightIcon(
                             icon = LightIcons.BACK,
-                            onClick = onBackPressed
+                            onClick = startingNav.backButtonOverride ?: onRootBackPressed
                         ),
                         center = LightTopBarCenter.Text("Settings"),
                         modifier = Modifier.padding(bottom = 1f.gridUnitsAsDp()),
@@ -52,13 +66,13 @@ fun EmulatorSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit
                         Modifier
                             .fillMaxWidth()
                             .clickable { nav = EmulatorSettingsNav.FilterLevel }
-                            .padding(16.dp)
+                            .then(rowPadding)
                     ) {
                         Column {
                             LightText("Allowed Tools", variant = LightTextVariant.Superfine)
                             LightText(
                                 settings.clientFilterLevel.label,
-                                variant = LightTextVariant.Subheading
+                                variant = LightTextVariant.Copy
                             )
                         }
                     }
@@ -66,13 +80,13 @@ fun EmulatorSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit
                         Modifier
                             .fillMaxWidth()
                             .clickable { nav = EmulatorSettingsNav.ForceFocus }
-                            .padding(16.dp)
+                            .then(rowPadding)
                     ) {
                         Column {
                             LightText("Force Focus", variant = LightTextVariant.Superfine)
                             LightText(
                                 settings.forceFocusLevel.label,
-                                variant = LightTextVariant.Subheading
+                                variant = LightTextVariant.Copy
                             )
                         }
                     }
@@ -80,28 +94,47 @@ fun EmulatorSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit
                         Modifier
                             .fillMaxWidth()
                             .clickable { nav = EmulatorSettingsNav.Keyboard }
-                            .padding(16.dp)
+                            .then(rowPadding)
                     ) {
                         Column {
                             LightText(
                                 "Keyboard Settings",
-                                variant = LightTextVariant.Subheading
+                                variant = LightTextVariant.Copy
                             )
                         }
                     }
+                    Row(
+                        Modifier
+                            .fillMaxWidth()
+                            .clickable { nav = EmulatorSettingsNav.Notifications }
+                            .then(rowPadding)
+                    ) {
+                        Column {
+                            LightText("Notifications", variant = LightTextVariant.Copy)
+                        }
+                    }
                 }
             }
 
-            EmulatorSettingsNav.FilterLevel -> ClientFilterLevelSettings(settings) {
-                nav = EmulatorSettingsNav.Root
-            }
+            EmulatorSettingsNav.FilterLevel -> ClientFilterLevelSettings(
+                settings,
+                subscreenBackPressed
+            )
 
-            EmulatorSettingsNav.ForceFocus -> ForceFocusLevelSettings(settings) {
-                nav = EmulatorSettingsNav.Root
-            }
+            EmulatorSettingsNav.ForceFocus -> ForceFocusLevelSettings(
+                settings,
+                subscreenBackPressed
+            )
+
+            EmulatorSettingsNav.Keyboard -> KeyboardSettings(settings, subscreenBackPressed)
 
-            EmulatorSettingsNav.Keyboard -> KeyboardSettings(settings) {
-                nav = EmulatorSettingsNav.Root
+            EmulatorSettingsNav.Notifications -> {
+                val volume by emulatorSettingsAudio.ringerVolume.collectAsState()
+                NotificationSettings(
+                    volume = volume,
+                    onVolumeChange = emulatorSettingsAudio::setRingerVolume,
+                    onBackPressed = subscreenBackPressed,
+                )
             }
         }
     }
@@ -112,7 +145,7 @@ fun ClientFilterLevelSettings(settings: LightSdkServerSettings, onBackPressed: (
     Surface(Modifier.fillMaxSize()) {
         Column(Modifier.fillMaxSize()) {
             LightTopBar(
-                leftButton = LightBarButton.LightIcon(
+                leftButton = LightIcon(
                     icon = LightIcons.BACK,
                     onClick = onBackPressed
                 ),
@@ -171,6 +204,32 @@ fun ForceFocusLevelSettings(settings: LightSdkServerSettings, onBackPressed: ()
     }
 }
 
+@Composable
+fun NotificationSettings(
+    volume: Float,
+    onVolumeChange: (Float) -> Unit,
+    onBackPressed: () -> Unit,
+) {
+    val themeColors = LightThemeController.colors.collectAsState().value
+    Surface(Modifier.fillMaxSize()) {
+        Column(Modifier.fillMaxSize()) {
+            LightTopBar(
+                leftButton = LightIcon(icon = LightIcons.BACK, onClick = onBackPressed),
+                center = LightTopBarCenter.Text("Notifications"),
+                modifier = Modifier.padding(bottom = 1f.gridUnitsAsDp()),
+            )
+            Column(Modifier.padding(horizontal = 3.5f.gridUnitsAsDp())) {
+                LightText("Ringer volume", variant = LightTextVariant.Superfine)
+                LightTouchableProgressBar(
+                    colors = themeColors,
+                    progress = volume,
+                    onValueChange = onVolumeChange,
+                )
+            }
+        }
+    }
+}
+
 @Composable
 fun KeyboardSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit) {
     var keyboardOptions by remember { mutableStateOf(settings.keyboardOptions) }
@@ -219,18 +278,34 @@ fun KeyboardSettings(settings: LightSdkServerSettings, onBackPressed: () -> Unit
     }
 }
 
+interface EmulatorSettingsAudio {
+    fun setRingerVolume(normalized: Float)
+    val ringerVolume: StateFlow<Float>
+}
+
 @Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
 @Composable
 fun EmulatorSettingsPreview() {
     val settings = object : LightSdkServerSettings {
         override var clientFilterLevel: ClientFilterLevel = ClientFilterLevel.AllowAllApks
         override var keyboardOptions: LightServiceMethod.GetKeyboardOptions.Response =
-            LightServiceMethod.GetKeyboardOptions.Response(null, true, true)
+            LightServiceMethod.GetKeyboardOptions.Response(null,
+                displayVoice = true,
+                enableKeyAnimation = true
+            )
         override var userPreferences: LightServiceMethod.GetUserPreferences.Response =
             LightServiceMethod.GetUserPreferences.Response(hapticsEnabled = true)
         override var forceFocusLevel: ForceFocusLevel = ForceFocusLevel.Always
     }
+    val emulatorAudioWrapper = object : EmulatorSettingsAudio {
+        private val currentVolume = MutableStateFlow(0.5f)
+        override fun setRingerVolume(normalized: Float) {
+            currentVolume.value = normalized
+        }
+
+        override val ringerVolume: StateFlow<Float> = currentVolume.asStateFlow()
+    }
     LightTheme {
-        EmulatorSettings(settings) { }
+        EmulatorSettings(settings, emulatorAudioWrapper, Nav.Settings()) { }
     }
 }
\ No newline at end of file
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/LightAudioManager.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/LightAudioManager.kt
new file mode 100644
index 00000000..12460421
--- /dev/null
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/LightAudioManager.kt
@@ -0,0 +1,106 @@
+package com.thelightphone.sdk.emulator
+
+import android.content.Context
+import android.media.AudioManager
+import android.os.VibrationEffect
+import android.os.VibratorManager
+import android.util.Log
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlin.math.roundToInt
+
+enum class ModalType {
+    RingerVol, CallVol, AlarmVol, MediaVol, Silent, VibrateOnly
+}
+
+data class AudioModal(val type: ModalType, val value: Float)
+
+class LightAudioManager(private val context: Context) {
+
+    companion object {
+        private const val TAG = "LightAudioManager"
+        private const val RING_STREAM = AudioManager.STREAM_RING
+    }
+
+    private val am get() = context.getSystemService(AudioManager::class.java)
+
+    private val _ringerVolume = MutableStateFlow(currentNormalizedVolume())
+    val ringerVolume: StateFlow<Float> = _ringerVolume.asStateFlow()
+
+    // Ladder, low → high: silent, vibrate-only, audible 1..max
+    fun stepUp(): AudioModal {
+        val modal = when (am.ringerMode) {
+            AudioManager.RINGER_MODE_SILENT -> setVibrateOnly()
+            AudioManager.RINGER_MODE_VIBRATE -> setAudible(1)
+            else -> {
+                val current = am.getStreamVolume(RING_STREAM)
+                val max = am.getStreamMaxVolume(RING_STREAM)
+                setAudible((current + 1).coerceAtMost(max))
+            }
+        }
+        _ringerVolume.value = currentNormalizedVolume()
+        return modal
+    }
+
+    fun stepDown(): AudioModal {
+        val modal = when (am.ringerMode) {
+            AudioManager.RINGER_MODE_SILENT -> currentModal()
+            AudioManager.RINGER_MODE_VIBRATE -> setSilent()
+            else -> {
+                val current = am.getStreamVolume(RING_STREAM)
+                if (current <= 1) setVibrateOnly() else setAudible(current - 1)
+            }
+        }
+        _ringerVolume.value = currentNormalizedVolume()
+        return modal
+    }
+
+    fun setRingerVolume(normalized: Float) {
+        val max = am.getStreamMaxVolume(RING_STREAM).coerceAtLeast(1)
+        val volume = (normalized * max).roundToInt().coerceIn(1, max)
+        runCatchingRinger { am.setStreamVolume(RING_STREAM, volume, 0) }
+        _ringerVolume.value = currentNormalizedVolume()
+    }
+
+    private fun setAudible(volume: Int): AudioModal {
+        runCatchingRinger { am.setStreamVolume(RING_STREAM, volume, 0) }
+        val max = am.getStreamMaxVolume(RING_STREAM).coerceAtLeast(1)
+        return AudioModal(ModalType.RingerVol, volume.toFloat() / max)
+    }
+
+    private fun setVibrateOnly(): AudioModal {
+        runCatchingRinger { am.ringerMode = AudioManager.RINGER_MODE_VIBRATE }
+        vibrateTick()
+        return AudioModal(ModalType.VibrateOnly, 0f)
+    }
+
+    private fun setSilent(): AudioModal {
+        runCatchingRinger { am.ringerMode = AudioManager.RINGER_MODE_SILENT }
+        return AudioModal(ModalType.Silent, 0f)
+    }
+
+    private fun currentModal(): AudioModal = when (am.ringerMode) {
+        AudioManager.RINGER_MODE_SILENT -> AudioModal(ModalType.Silent, 0f)
+        AudioManager.RINGER_MODE_VIBRATE -> AudioModal(ModalType.VibrateOnly, 0f)
+        else -> AudioModal(ModalType.RingerVol, currentNormalizedVolume())
+    }
+
+    private fun currentNormalizedVolume(): Float {
+        val max = am.getStreamMaxVolume(RING_STREAM).coerceAtLeast(1)
+        return am.getStreamVolume(RING_STREAM).toFloat() / max
+    }
+
+    private fun vibrateTick() {
+        context.getSystemService(VibratorManager::class.java).defaultVibrator
+            .vibrate(VibrationEffect.createOneShot(50, VibrationEffect.DEFAULT_AMPLITUDE))
+    }
+
+    private inline fun runCatchingRinger(block: () -> Unit) {
+        try {
+            block()
+        } catch (e: SecurityException) {
+            Log.w(TAG, "Ringer change denied — grant notification policy access to this app", e)
+        }
+    }
+}
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
index 3cfd75af..767c3d5b 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
@@ -3,6 +3,7 @@ package com.thelightphone.sdk.emulator
 import android.content.Intent
 import android.os.Bundle
 import android.util.Log
+import android.view.KeyEvent
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -24,19 +25,19 @@ import androidx.core.view.WindowInsetsControllerCompat
 import com.thelightphone.sdk.server.LightSdkServer
 import com.thelightphone.sdk.server.LightSdkServer.queryEnabledClients
 import com.thelightphone.sdk.server.LightSdkServer.runningAsSystemApp
+import com.thelightphone.sdk.server.LightSdkServerSettings
+import com.thelightphone.sdk.shared.LightKeys.VOLUME_UP
+import com.thelightphone.sdk.shared.LightServiceMethod
 import com.thelightphone.sdk.ui.*
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import java.time.LocalTime
 import java.time.format.DateTimeFormatter
 
 class MainActivity : ComponentActivity() {
 
-    enum class Nav {
-        LockScreen, Toolbox, Settings
-    }
-
-    private val currentNavFlow = MutableStateFlow(Nav.LockScreen)
+    val lightAudioManager get() = (application as EmulatorApplication).lightAudioManager
 
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge()
@@ -54,42 +55,65 @@ class MainActivity : ComponentActivity() {
         val serverSettings = LightSdkServer.provideSdkSettings(this)
         setContent {
             val themeColors by LightThemeController.colors.collectAsState()
-            val currentNav by currentNavFlow.collectAsState()
             LightTheme(colors = themeColors) {
-                when (currentNav) {
-                    Nav.LockScreen -> {
-                        LightLockscreen {
-                            currentNavFlow.value = Nav.Toolbox
-                        }
-                    }
-                    Nav.Toolbox -> {
-                        ToolList(
-                            fetchExternalTools = {
-                                queryEnabledClients(serverSettings).map {
-                                    val appInfo = it.packageInfo.applicationInfo!!
-                                    val label =
-                                        packageManager.getApplicationLabel(appInfo).toString()
-                                    ExternalTool(label, it.packageInfo.packageName)
-                                }
-                            }, launchPackage = {
-                                packageManager.getLaunchIntentForPackage(it)?.let { intent ->
-                                    intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
-                                    val options =
-                                        android.app.ActivityOptions.makeCustomAnimation(this, 0, 0)
-                                    startActivity(intent, options.toBundle())
-                                }
-                            }, launchDefaultTool = {
-                                when (it) {
-                                    DefaultTool.Settings -> currentNavFlow.value = Nav.Settings
-                                }
-                            })
-                    }
+                Box(Modifier.fillMaxSize()) {
+                    PrimaryUI(serverSettings, lightAudioManager)
+                    val modal by LightModalManager.activeModal.collectAsState()
+                    modal?.Content()
+                }
+            }
+        }
+    }
 
-                    Nav.Settings -> {
-                        EmulatorSettings(serverSettings) {
-                            currentNavFlow.value = Nav.Toolbox
+    @Composable
+    private fun PrimaryUI(
+        serverSettings: LightSdkServerSettings,
+        lightAudioManager: LightAudioManager
+    ) {
+        val currentNav by EmulatorNavController.currentNav.collectAsState()
+        when (val navSnapshot = currentNav) {
+            Nav.LockScreen -> {
+                LightLockscreen {
+                    EmulatorNavController.navigateTo(Nav.Toolbox)
+                }
+            }
+
+            Nav.Toolbox -> {
+                ToolList(
+                    fetchExternalTools = {
+                        queryEnabledClients(serverSettings).map {
+                            val appInfo = it.packageInfo.applicationInfo!!
+                            val label =
+                                packageManager.getApplicationLabel(appInfo).toString()
+                            ExternalTool(label, it.packageInfo.packageName)
                         }
-                    }
+                    }, launchPackage = {
+                        packageManager.getLaunchIntentForPackage(it)?.let { intent ->
+                            intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+                            val options =
+                                android.app.ActivityOptions.makeCustomAnimation(
+                                    this@MainActivity,
+                                    0,
+                                    0
+                                )
+                            startActivity(intent, options.toBundle())
+                        }
+                    }, launchDefaultTool = {
+                        when (it) {
+                            DefaultTool.Settings -> EmulatorNavController.navigateTo(Nav.Settings())
+                        }
+                    })
+            }
+
+            is Nav.Settings -> {
+                val emulatorSettingsAudio = object : EmulatorSettingsAudio {
+                    override fun setRingerVolume(normalized: Float) =
+                        lightAudioManager.setRingerVolume(normalized)
+
+                    override val ringerVolume: StateFlow<Float> = lightAudioManager.ringerVolume
+                }
+                EmulatorSettings(serverSettings, emulatorSettingsAudio, navSnapshot) {
+                    EmulatorNavController.navigateTo(Nav.Toolbox)
                 }
             }
         }
@@ -97,9 +121,10 @@ class MainActivity : ComponentActivity() {
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
-        val screenTurnedOff = intent.extras?.getBoolean(LightSdkServer.SCREEN_OFF_FLAG, false) == true
+        val screenTurnedOff =
+            intent.extras?.getBoolean(LightSdkServer.SCREEN_OFF_FLAG, false) == true
         if (screenTurnedOff) {
-            currentNavFlow.value = Nav.LockScreen
+            EmulatorNavController.navigateTo(Nav.LockScreen)
         }
     }
 }
diff --git a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
index c86cf2cf..879a84ae 100644
--- a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
+++ b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
@@ -3,6 +3,7 @@ package com.thelightphone.sdk.server
 import android.Manifest
 import android.app.Activity
 import android.content.BroadcastReceiver
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
@@ -14,6 +15,7 @@ import android.os.UserHandle
 import android.util.Log
 import com.thelightphone.sdk.shared.LightConstants
 import com.thelightphone.sdk.shared.LightResult
+import com.thelightphone.sdk.shared.LightServiceMethod
 
 
 data class InstalledClient(
@@ -145,6 +147,21 @@ object LightSdkServer {
             LightResult.Error(LightResult.ErrorCode.Unknown, "unknown method: $methodId")
         }
 
+    /**
+     * Handle a hardware key event forwarded from a client whose current screen did not consume
+     * it.
+     *
+     * Settable from enclosing application!! May be run on any thread
+     */
+    var onDeviceKeyEvent: (callingUid: Int, event: LightServiceMethod.DeviceKeyEvent.Request) -> Unit =
+        { _, event ->
+            Log.w(TAG, "Unhandled device key event: $event")
+        }
+
+    var foregroundSelfWithCallback: (componentToReturnTo: ComponentName) -> Unit = {
+        Log.e(TAG, "Server wants to foreground itself but does not know how!")
+    }
+
     /**
      * Given an apk's package name, determine if it's been built with the Light SDK and/or promoted by Light
      *
@@ -167,8 +184,13 @@ object LightSdkServer {
         ).contains(permissionName)
     }
 
+    /**
+     * Activity to launch when allowing user to grant permission via server app
+     */
     var permissionActivity: Class<out Activity>? = null
 
+    var rootActivity: Class<out Activity>? = null
+
 
     var grantPermission: (context: Context, packageName: String, permission: String) -> Result<Unit> =
         { context, packageName, permission ->
diff --git a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkService.kt b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkService.kt
index 6d039f38..ceb8cb71 100644
--- a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkService.kt
+++ b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkService.kt
@@ -81,7 +81,7 @@ class LightSdkService : Service() {
                             Log.w(TAG, "Rejected request with invalid token from uid=$callingUid")
                             reply?.apply {
                                 writeNoException()
-                                writeInt(LightResult.ErrorCode.NoPermission.ordinal)
+                                writeInt(LightResult.ErrorCode.InvalidToken.ordinal)
                                 writeString("invalid token")
                             }
                             return true
@@ -198,11 +198,6 @@ class LightSdkService : Service() {
                         "Server has not defined a component to allow permission acceptance."
                     )
                 } else {
-                    startActivity(
-                        Intent(this@LightSdkService, component).apply {
-                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                        }
-                    )
                     val componentName =
                         ComponentName(
                             this@LightSdkService,
@@ -225,6 +220,14 @@ class LightSdkService : Service() {
                 )
             }
 
+            LightServiceMethod.DeviceKeyEvent -> {
+                val request = LightServiceMethod.DeviceKeyEvent.decodeRequest(payload!!)
+                LightSdkServer.onDeviceKeyEvent(callingUid, request)
+                LightResult.Success(
+                    LightServiceMethod.DeviceKeyEvent.encodeResponse(Unit)
+                )
+            }
+
             null -> {
                 // The app that wraps this server may be able to handle custom methods
                 LightSdkServer.customServiceMethodResolver.invoke(callingUid, methodId, payload)
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
new file mode 100644
index 00000000..160c5039
--- /dev/null
+++ b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
@@ -0,0 +1,11 @@
+package com.thelightphone.sdk.shared
+
+object LightKeys {
+    const val VOLUME_UP = 24
+    const val VOLUME_DOWN = 25
+    const val SHUTTER_PRESSED = 27
+    const val SHUTTER_HALF_PRESSED = 80
+    const val ROTARY_BUTTON_PRESS: Int = 319
+    const val ROTARY_TURN_UP: Int = 317
+    const val ROTARY_TURN_DOWN: Int = 318
+}
\ No newline at end of file
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightResult.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightResult.kt
index 96f30803..cdb62461 100644
--- a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightResult.kt
+++ b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightResult.kt
@@ -2,8 +2,8 @@ package com.thelightphone.sdk.shared
 
 sealed interface LightResult<out T> {
     enum class ErrorCode {
-        // DO NOT REORDER/REMOVE
-        Unknown, Removed, InvalidParameters, NoPermission;
+        // DO NOT REORDER/REMOVE — ordinals are sent over the binder wire. Append new codes only.
+        Unknown, Removed, InvalidParameters, NoPermission, InvalidToken;
     }
     data class Success<T>(val data: T) : LightResult<T>
     data class Error(val code: ErrorCode, val extra: String? = null) : LightResult<Nothing>
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
index 21fb4016..f6a1938b 100644
--- a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
+++ b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
@@ -110,6 +110,28 @@ sealed interface LightServiceMethod<TRequest, TResponse> {
         @Serializable
         data class Response(val componentName: String)
     }
+
+    object DeviceKeyEvent : LightServiceMethod<DeviceKeyEvent.Request, Unit> {
+        enum class EventType {
+            KeyUp, KeyDown, KeyMultiple
+        }
+        override val id = "DeviceKeyEvent"
+        override val requestSerializer = serializer<Request>()
+        override val responseSerializer = serializer<Unit>()
+
+        @Serializable
+        data class Request(
+            val eventType: EventType,
+            val keyCode: Int,
+            val repeatCount: Int?,
+            val action: Int,
+            val characters: String?,
+            val unicodeChar: Int,
+            // if this key event will trigger the server to take over the screen
+            // optionally pass the flattened component to re-launch when it is done
+            val componentToRelaunch: String?,
+        )
+    }
 }
 
 // TODO we're gonna forget to add manually, maybe use reflection?
@@ -120,4 +142,5 @@ val allMethods: Map<String, LightServiceMethod<*, *>> = listOf(
     LightServiceMethod.GetKeyboardOptions,
     LightServiceMethod.GetPermission,
     LightServiceMethod.RequestPermissionComponent,
+    LightServiceMethod.DeviceKeyEvent,
 ).associateBy { it.id }
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightKeyHandler.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightKeyHandler.kt
new file mode 100644
index 00000000..2c2be66c
--- /dev/null
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightKeyHandler.kt
@@ -0,0 +1,15 @@
+package com.thelightphone.sdk.ui
+
+import android.view.KeyEvent
+
+interface LightKeyHandler {
+    fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean = false
+
+    fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean = false
+
+    fun onKeyMultiple(
+        keyCode: Int,
+        repeatCount: Int,
+        event: KeyEvent
+    ): Boolean = false
+}
\ No newline at end of file
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
new file mode 100644
index 00000000..6003b68f
--- /dev/null
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
@@ -0,0 +1,95 @@
+package com.thelightphone.sdk.ui
+
+import androidx.compose.runtime.Composable
+import com.thelightphone.sdk.ui.LightModalManager.DEFAULT_DURATION
+import com.thelightphone.sdk.ui.LightModalManager.show
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * A transient overlay drawn on top of the current screen..
+ * Implementations own their own appearance and positioning.
+ */
+interface LightModal {
+    @Composable
+    fun Content()
+
+    // called if the modal timed out (not manually dismissed)
+    val onExpired: () -> Unit
+
+    /**
+     * Signal that this modal was manually dismissed (e.g. user navigated away, button pressed).
+     * The manager will clear the modal immediately without invoking [onExpired].
+     */
+    fun dismiss()
+
+    /**
+     * Called by the manager to race this modal's manual dismissal against the timeout.
+     * Should suspend until [dismiss] is called.
+     */
+    suspend fun awaitDismiss()
+}
+
+/**
+ * Process-wide bus for transient modals. Any SDK code can [show] a modal;
+ *
+ * At most one modal is active at a time — showing a new one immediately replaces the
+ * current one. The active modal auto-dismisses after [DEFAULT_DURATION] unless it is
+ * replaced first.
+ */
+object LightModalManager {
+
+    val DEFAULT_DURATION: Duration = 2.seconds
+
+    // Dispatchers.Main.immediate so state/timer changes are ordered on the UI thread even
+    // when show() is called from a background thread (e.g. a service callback).
+    private val scope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
+
+    private val _activeModal = MutableStateFlow<LightModal?>(null)
+    val activeModal: StateFlow<LightModal?> = _activeModal.asStateFlow()
+
+    private var dismissJob: Job? = null
+
+    /** Show [modal] over the UI, replacing any current modal and restarting the dismiss timer. */
+    @Synchronized
+    fun show(modal: LightModal, duration: Duration = DEFAULT_DURATION) {
+        dismissJob?.cancel()
+        _activeModal.value = modal
+        dismissJob = scope.launch {
+            // null return means the timeout elapsed; non-null means modal dismissed itself first.
+            val timedOut = withTimeoutOrNull(duration) {
+                modal.awaitDismiss()
+                false
+            } ?: true
+            _activeModal.update {
+                if (modal == it) {
+                    if (timedOut) {
+                        modal.onExpired()
+                        delay(100)
+                    }
+                    null
+                } else it
+            }
+        }
+    }
+
+    /** Immediately dismiss the active modal, if any. */
+    @Synchronized
+    fun dismiss() {
+        dismissJob?.cancel()
+        dismissJob = null
+        _activeModal.value = null
+    }
+}
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
new file mode 100644
index 00000000..f7796c91
--- /dev/null
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
@@ -0,0 +1,103 @@
+package com.thelightphone.sdk.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.gestures.drag
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.tooling.preview.Preview
+
+@Composable
+fun LightProgressBar(colors: LightColors, progress: Float) {
+    Box(contentAlignment = Alignment.CenterStart) {
+        Box(
+            Modifier
+                .fillMaxWidth()
+                .height(0.1f.gridUnitsAsDp())
+                .background(colors.content)
+        )
+        Box(
+            Modifier
+                .fillMaxWidth(progress.coerceIn(0f, 1f))
+                .height(0.5f.gridUnitsAsDp())
+                .background(colors.content)
+        )
+    }
+}
+
+@Composable
+fun LightTouchableProgressBar(
+    colors: LightColors,
+    progress: Float,
+    onValueChange: (Float) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val density = LocalDensity.current
+    val currentOnValueChange by rememberUpdatedState(onValueChange)
+
+    BoxWithConstraints(
+        contentAlignment = Alignment.Center,
+        modifier = modifier.height(3f.gridUnitsAsDp()),
+    ) {
+        val trackWidthPx = with(density) { maxWidth.toPx() }
+
+        fun xToProgress(xPx: Float) = (xPx / trackWidthPx).coerceIn(0f, 1f)
+
+        LightProgressBar(colors, progress)
+
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .pointerInput(Unit) {
+                    awaitEachGesture {
+                        val down = awaitFirstDown()
+                        down.consume()
+                        currentOnValueChange(xToProgress(down.position.x))
+                        drag(down.id) { change ->
+                            change.consume()
+                            currentOnValueChange(xToProgress(change.position.x))
+                        }
+                    }
+                }
+                .pointerInput(Unit) {
+                    detectTapGestures { offset ->
+                        currentOnValueChange(xToProgress(offset.x))
+                    }
+                }
+        )
+    }
+}
+
+@Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
+@Composable
+fun LightProgressBarPreview() {
+    val colors = LightThemeColors.Dark
+    var progress by remember { mutableFloatStateOf(0.4f) }
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier
+            .fillMaxSize()
+            .background(colors.background)
+            .padding(horizontal = 3.5f.gridUnitsAsDp())
+    ) {
+        Box(Modifier.fillMaxWidth()) {
+            LightTouchableProgressBar(colors, progress, onValueChange = { progress = it })
+        }
+    }
+}
\ No newline at end of file

From fd4ec83470382b5160097d6d65a846e6c3676714 Mon Sep 17 00:00:00 2001
From: Guy Dupont <dupontgu@gmail.com>
Date: Fri, 17 Jul 2026 09:50:36 -0400
Subject: [PATCH 2/9] pull in latest keyboard, text editor fixes

---
 gradle/libs.versions.toml                     |   2 +-
 .../com/thelightphone/sdk/LightActivity.kt    | 108 ++++++++++--------
 .../thelightphone/sdk/LightKeyboardManager.kt |   5 +-
 .../sdk/LightServiceConnection.kt             |   7 +-
 .../sdk/emulator/EmulatorApplication.kt       |   8 +-
 .../sdk/emulator/EmulatorDeviceKeyHandler.kt  |  13 ++-
 .../sdk/emulator/MainActivity.kt              |  34 ++++--
 .../sdk/shared/LightDeviceKeys.kt             |  11 --
 .../sdk/shared/LightServiceMethod.kt          |   7 +-
 .../sdk/shared/LightServiceMethodTest.kt      |  40 +++++++
 .../thelightphone/sdk/ui/LightModalManager.kt |   8 +-
 .../sdk/ui/LightTextInputEditor.kt            |  27 ++---
 .../ui/keyboard/LightEmbeddedLp3Keyboard.kt   |   5 +-
 .../ui/keyboard/TextInputKeyboardCallback.kt  |  10 +-
 14 files changed, 176 insertions(+), 109 deletions(-)
 delete mode 100644 sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
 create mode 100644 sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightServiceMethodTest.kt

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 39e5439f..5178687d 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -40,7 +40,7 @@ ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
 ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
-light-keyboard = { module = "com.thelightphone.lp3keyboard:ui", version = "0.0.11"}
+light-keyboard = { module = "com.thelightphone.lp3keyboard:ui", version = "0.0.16"}
 androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }
 androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }
 androidx-camera-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax" }
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
index 1eabde85..6fd3689b 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
@@ -11,7 +11,6 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
@@ -24,18 +23,31 @@ import androidx.core.view.WindowInsetsControllerCompat
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.preferencesDataStore
+import androidx.lifecycle.ViewModelStore
 import androidx.lifecycle.ViewModelStoreOwner
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
+import com.thelightphone.lp3Keyboard.ui.LightDeviceKeys
 import com.thelightphone.sdk.shared.LightServiceMethod
 import com.thelightphone.sdk.ui.LightModalManager
 import kotlinx.coroutines.launch
 import java.io.File
 
+private class ScreenViewModelStoreOwner : ViewModelStoreOwner {
+    override val viewModelStore = ViewModelStore()
+}
+
 private class BackStackEntry<T>(
     val screen: SimpleLightScreen<T>,
     val callback: ((T) -> Unit)? = null,
 ) {
+    // SimpleLightScreens that aren't already a ViewModelStoreOwner (LightScreen) still need a
+    // store scoped to this specific navigation instance, so composables inside them that call
+    // viewModel() don't resolve against the long-lived Activity store and get a stale ViewModel
+    // handed back on a later, unrelated navigation to a screen with the same viewModel() key.
+    val viewModelStoreOwner: ViewModelStoreOwner =
+        screen as? ViewModelStoreOwner ?: ScreenViewModelStoreOwner()
+
     fun deliverResult() {
         val result = screen.result ?: return
         callback?.invoke(result)
@@ -62,6 +74,7 @@ class LightActivity internal constructor() : ComponentActivity() {
         val popped = current.screen
         popped.notifyWillHide()
         popped.destroy()
+        current.viewModelStoreOwner.viewModelStore.clear()
         backStack.removeAt(backStack.lastIndex)
         if (backStack.isEmpty()) {
             finish()
@@ -96,23 +109,18 @@ class LightActivity internal constructor() : ComponentActivity() {
         setContent {
             androidx.compose.runtime.LaunchedEffect(Unit) { contentReady = true }
             Box(modifier = Modifier.fillMaxSize()) {
-                val screen = currentScreen.value?.screen
-                if (screen != null) {
+                val entry = currentScreen.value
+                if (entry != null) {
                     Column(modifier = Modifier.fillMaxSize()) {
                         Box(
                             modifier = Modifier
                                 .weight(1f)
                                 .fillMaxWidth(),
                         ) {
-                            val content: @Composable () -> Unit = { screen.Content() }
-                            if (screen is ViewModelStoreOwner) {
-                                CompositionLocalProvider(
-                                    LocalViewModelStoreOwner provides screen,
-                                    content = content,
-                                )
-                            } else {
-                                content()
-                            }
+                            CompositionLocalProvider(
+                                LocalViewModelStoreOwner provides entry.viewModelStoreOwner,
+                                content = { entry.screen.Content() },
+                            )
                         }
                     }
                 }
@@ -132,63 +140,69 @@ class LightActivity internal constructor() : ComponentActivity() {
         )
     }
 
+    private val Int.isSystemKeyCode: Boolean
+        get() = (this == KeyEvent.KEYCODE_BACK || this == KeyEvent.KEYCODE_HOME)
+
     override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
-            return super.onKeyDown(keyCode, event)
+        // don't do anything with android keys
+        // back button override handled elsewhere and home button won't get dispatched to external tools
+        return if (keyCode.isSystemKeyCode) {
+            super.onKeyDown(keyCode, event)
+        } else if (currentScreen.value?.screen?.onKeyDown(keyCode, event) == true) {
+            // let the active screen handle the button if it wants to
+            true
+        } else if (LightDeviceKeys.mapping.containsKey(keyCode)) {
+            // otherwise see if the server wants to use it
+            forwardKeyEventToServer(keyCode, event)
+            true
+        } else {
+            false
         }
-        if (currentScreen.value?.screen?.onKeyDown(keyCode, event) == true) {
-            return true
-        }
-        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyDown, keyCode, event)
-        return true
     }
 
     override fun onKeyMultiple(
         keyCode: Int,
         repeatCount: Int,
-        event: KeyEvent?
+        event: KeyEvent
     ): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
-            return super.onKeyMultiple(keyCode, repeatCount, event)
-        }
-        if (event != null && currentScreen.value?.screen?.onKeyMultiple(keyCode, repeatCount, event) == true) {
-            return true
+        return if (keyCode.isSystemKeyCode) {
+            super.onKeyMultiple(keyCode, repeatCount, event)
+        } else if (currentScreen.value?.screen?.onKeyMultiple(keyCode, repeatCount, event) == true) {
+            true
+        } else if (LightDeviceKeys.mapping.containsKey(keyCode)) {
+            forwardKeyEventToServer(keyCode, event)
+            true
+        } else {
+            false
         }
-        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyMultiple, keyCode, event)
-        return true
     }
 
-    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
-            return super.onKeyUp(keyCode, event)
+    override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
+        return if (keyCode.isSystemKeyCode) {
+            super.onKeyDown(keyCode, event)
+        } else if (currentScreen.value?.screen?.onKeyUp(keyCode, event) == true) {
+            true
+        } else if (LightDeviceKeys.mapping.containsKey(keyCode)) {
+            forwardKeyEventToServer(keyCode, event)
+            true
+        } else {
+            false
         }
-        if (event != null && currentScreen.value?.screen?.onKeyUp(keyCode, event) == true) {
-            return true
-        }
-        forwardKeyEventToServer(LightServiceMethod.DeviceKeyEvent.EventType.KeyUp, keyCode, event)
-        return true
     }
 
     private fun forwardKeyEventToServer(
-        eventType: LightServiceMethod.DeviceKeyEvent.EventType,
         keyCode: Int,
-        event: KeyEvent?,
+        event: KeyEvent,
     ) {
-        val action = event?.action ?: when (eventType) {
-            LightServiceMethod.DeviceKeyEvent.EventType.KeyDown -> KeyEvent.ACTION_DOWN
-            LightServiceMethod.DeviceKeyEvent.EventType.KeyUp -> KeyEvent.ACTION_UP
-            LightServiceMethod.DeviceKeyEvent.EventType.KeyMultiple -> KeyEvent.ACTION_MULTIPLE
-        }
         lifecycleScope.launch {
             callRemoteServiceMethod(
                 LightServiceMethod.DeviceKeyEvent,
                 LightServiceMethod.DeviceKeyEvent.Request(
-                    eventType = eventType,
                     keyCode = keyCode,
-                    repeatCount = event?.repeatCount,
-                    action = action,
-                    characters = event?.characters,
-                    unicodeChar = event?.unicodeChar ?: 0,
+                    repeatCount = event.repeatCount,
+                    action = event.action,
+                    characters = event.characters,
+                    unicodeChar = event.unicodeChar,
                     componentToRelaunch = componentName.flattenToString()
                 )
             )
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
index 5338b1ef..49d1c610 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
@@ -7,8 +7,8 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import com.thelightphone.lp3Keyboard.ui.KeyboardOptions
-import com.thelightphone.lp3Keyboard.ui.defaultEmojis
 import com.thelightphone.lp3Keyboard.ui.parseEmojiString
+import com.thelightphone.lp3Keyboard.ui.viewmodel.defaultEmojis
 import com.thelightphone.sdk.shared.LightServiceMethod
 import com.thelightphone.sdk.shared.error
 import com.thelightphone.sdk.shared.getOrNull
@@ -40,7 +40,8 @@ suspend fun refreshKeyboardOptions(): KeyboardOptions? {
         // not using currently - may want to move into LayoutOptions in Lp3Keyboard source
         displayReturn = true,
         displayVoice = result.displayVoice,
-        enableKeyAnimation = result.enableKeyAnimation
+        enableKeyAnimation = result.enableKeyAnimation,
+        swipeEnabled = false
     )
 }
 
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
index 57b9ee3c..d4f57503 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightServiceConnection.kt
@@ -105,7 +105,7 @@ internal object LightServiceConnection : ServiceConnection {
     override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
         Log.i(TAG, "Connected to LightSdkService")
         serviceBinder = binder
-        // force re-auth if re-connected
+        // force re-auth if re-connected, token is likely invalid server-side now
         clearToken()
         if (binder != null) {
             binderReady.complete(binder)
@@ -120,7 +120,6 @@ internal object LightServiceConnection : ServiceConnection {
     override fun onBindingDied(name: ComponentName?) {
         Log.w(TAG, "Binding to LightSdkService died, rebinding")
         resetConnection()
-        // BIND_AUTO_CREATE does not recover a dead binding on its own; unbind and rebind.
         val ctx = appContext ?: return
         val pkg = serverPackage ?: return
         runCatching { ctx.unbindService(this) }
@@ -171,9 +170,7 @@ suspend fun <TRequest, TResponse> callRemoteServiceMethod(
     val encoded = method.encodeRequest(body)
     var result = LightServiceConnection.request(method.id, encoded)
     if (result is LightResult.Error && result.code == LightResult.ErrorCode.InvalidToken) {
-        // The server no longer recognizes our token (e.g. it restarted and lost its token
-        // store). Drop it, re-authenticate, and retry the request exactly once. GetToken is
-        // gated by caller verification rather than the token, so this cannot loop.
+        // Case where the app is "allowed", but the token is no longer valid, allow one retry
         Log.i(TAG, "Token rejected calling remote method, re-auth + retry")
         LightServiceConnection.clearToken()
         LightServiceConnection.ensureToken()
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
index a1fb0cc8..8301ba3f 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
@@ -58,8 +58,8 @@ class EmulatorApplication : Application() {
 
     private fun handleDeviceKeyEvent(request: LightServiceMethod.DeviceKeyEvent.Request) {
         deviceKeyHandler.onDeviceKeyEventRequest(request)?.let { modal ->
-            // when the server is done handling the key press, server should re-launch the component that was foregrounded
-            // at the time of key event
+            // when the server is done handling the key press, server should re-foreground
+            // the app that sent it, if desired
             fun relaunchSender() {
                 val componentToRelaunch =
                     request.componentToRelaunch?.let(ComponentName::unflattenFromString)
@@ -79,11 +79,11 @@ class EmulatorApplication : Application() {
             )
             // show the modal, and then pull this app into focus over the client
             LightModalManager.show(keyModal)
-            foregroundApp()
+            foregroundEmulator()
         }
     }
 
-    private fun foregroundApp() {
+    private fun foregroundEmulator() {
         val intent = Intent(this.applicationContext, MainActivity::class.java)
             .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         startActivity(intent)
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
index 964c0a55..448ea5f1 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorDeviceKeyHandler.kt
@@ -1,6 +1,7 @@
 package com.thelightphone.sdk.emulator
 
 import android.util.Log
+import android.view.KeyEvent.ACTION_DOWN
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -16,7 +17,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
-import com.thelightphone.sdk.shared.LightKeys
+import com.thelightphone.lp3Keyboard.ui.LightDeviceKeys
 import com.thelightphone.sdk.shared.LightServiceMethod
 import com.thelightphone.sdk.ui.LightIcon
 import com.thelightphone.sdk.ui.LightIcons
@@ -37,10 +38,10 @@ class EmulatorDeviceKeyHandler(private val audioManager: LightAudioManager) {
     }
 
     fun onDeviceKeyEventRequest(request: LightServiceMethod.DeviceKeyEvent.Request): AudioModal? {
-        if (request.eventType != LightServiceMethod.DeviceKeyEvent.EventType.KeyDown) return null
-        return when (request.keyCode) {
-            LightKeys.VOLUME_UP -> audioManager.stepUp()
-            LightKeys.VOLUME_DOWN -> audioManager.stepDown()
+        if (request.action != ACTION_DOWN) return null
+        return when (LightDeviceKeys.mapping[request.keyCode]) {
+            LightDeviceKeys.VolumeUp -> audioManager.stepUp()
+            LightDeviceKeys.VolumeDown -> audioManager.stepDown()
             else -> {
                 Log.d(TAG, "Unhandled keyCode: ${request.keyCode}")
                 null
@@ -49,6 +50,8 @@ class EmulatorDeviceKeyHandler(private val audioManager: LightAudioManager) {
     }
 }
 
+// Modeled after LightOS volume rocker modal
+// In ideal world, this will be used directly in LightOS
 class DeviceKeyModal(
     private val audioModal: AudioModal,
     private val onMoreClick: () -> Unit,
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
index 767c3d5b..30840047 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/MainActivity.kt
@@ -3,7 +3,6 @@ package com.thelightphone.sdk.emulator
 import android.content.Intent
 import android.os.Bundle
 import android.util.Log
-import android.view.KeyEvent
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -11,9 +10,25 @@ import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.Orientation
 import androidx.compose.foundation.gestures.draggable
 import androidx.compose.foundation.gestures.rememberDraggableState
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
 import androidx.compose.material3.Surface
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.BiasAlignment
 import androidx.compose.ui.Modifier
@@ -26,11 +41,16 @@ import com.thelightphone.sdk.server.LightSdkServer
 import com.thelightphone.sdk.server.LightSdkServer.queryEnabledClients
 import com.thelightphone.sdk.server.LightSdkServer.runningAsSystemApp
 import com.thelightphone.sdk.server.LightSdkServerSettings
-import com.thelightphone.sdk.shared.LightKeys.VOLUME_UP
-import com.thelightphone.sdk.shared.LightServiceMethod
-import com.thelightphone.sdk.ui.*
+import com.thelightphone.sdk.ui.LightIcon
+import com.thelightphone.sdk.ui.LightIcons
+import com.thelightphone.sdk.ui.LightModalManager
+import com.thelightphone.sdk.ui.LightText
+import com.thelightphone.sdk.ui.LightTextVariant
+import com.thelightphone.sdk.ui.LightTheme
+import com.thelightphone.sdk.ui.LightThemeColors
+import com.thelightphone.sdk.ui.LightThemeController
+import com.thelightphone.sdk.ui.gridUnitsAsDp
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import java.time.LocalTime
 import java.time.format.DateTimeFormatter
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
deleted file mode 100644
index 160c5039..00000000
--- a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightDeviceKeys.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.thelightphone.sdk.shared
-
-object LightKeys {
-    const val VOLUME_UP = 24
-    const val VOLUME_DOWN = 25
-    const val SHUTTER_PRESSED = 27
-    const val SHUTTER_HALF_PRESSED = 80
-    const val ROTARY_BUTTON_PRESS: Int = 319
-    const val ROTARY_TURN_UP: Int = 317
-    const val ROTARY_TURN_DOWN: Int = 318
-}
\ No newline at end of file
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
index f6a1938b..413a0641 100644
--- a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
+++ b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
@@ -112,19 +112,15 @@ sealed interface LightServiceMethod<TRequest, TResponse> {
     }
 
     object DeviceKeyEvent : LightServiceMethod<DeviceKeyEvent.Request, Unit> {
-        enum class EventType {
-            KeyUp, KeyDown, KeyMultiple
-        }
         override val id = "DeviceKeyEvent"
         override val requestSerializer = serializer<Request>()
         override val responseSerializer = serializer<Unit>()
 
         @Serializable
         data class Request(
-            val eventType: EventType,
             val keyCode: Int,
             val repeatCount: Int?,
-            val action: Int,
+            val action: Int, // Android KeyEvent actions
             val characters: String?,
             val unicodeChar: Int,
             // if this key event will trigger the server to take over the screen
@@ -143,4 +139,5 @@ val allMethods: Map<String, LightServiceMethod<*, *>> = listOf(
     LightServiceMethod.GetPermission,
     LightServiceMethod.RequestPermissionComponent,
     LightServiceMethod.DeviceKeyEvent,
+    LightServiceMethod.GetUserPreferences,
 ).associateBy { it.id }
diff --git a/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightServiceMethodTest.kt b/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightServiceMethodTest.kt
new file mode 100644
index 00000000..953cfa25
--- /dev/null
+++ b/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightServiceMethodTest.kt
@@ -0,0 +1,40 @@
+package com.thelightphone.sdk.shared
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class LightServiceMethodTest {
+
+    private val allDeclared: List<LightServiceMethod<*, *>> by lazy {
+        LightServiceMethod::class.java.declaredClasses
+            .filter { LightServiceMethod::class.java.isAssignableFrom(it) }
+            .mapNotNull { clazz ->
+                runCatching {
+                    clazz.getDeclaredField("INSTANCE").get(null) as LightServiceMethod<*, *>
+                }.getOrNull()
+            }
+    }
+
+    @Test
+    fun noDuplicateIds() {
+        val duplicates = allDeclared
+            .groupBy { it.id }
+            .filter { it.value.size > 1 }
+            .keys
+        assertTrue(duplicates.isEmpty(), "Duplicate LightServiceMethod ids: $duplicates")
+    }
+
+    @Test
+    fun allMethodsIsComplete() {
+        val missing = allDeclared.filter { it.id !in allMethods }
+        assertTrue(missing.isEmpty(), "Methods missing from allMethods: ${missing.map { it.id }}")
+    }
+
+    @Test
+    fun allMethodsHasNoExtras() {
+        val declared = allDeclared.map { it.id }.toSet()
+        val extras = allMethods.keys.filter { it !in declared }
+        assertEquals(emptyList(), extras, "allMethods contains unknown ids: $extras")
+    }
+}
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
index 6003b68f..863e7c64 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightModalManager.kt
@@ -20,7 +20,7 @@ import kotlin.time.Duration.Companion.seconds
 
 /**
  * A transient overlay drawn on top of the current screen..
- * Implementations own their own appearance and positioning.
+ * Implementations own their own appearance
  */
 interface LightModal {
     @Composable
@@ -43,9 +43,9 @@ interface LightModal {
 }
 
 /**
- * Process-wide bus for transient modals. Any SDK code can [show] a modal;
+ * Show/dismiss transient modal overlays
  *
- * At most one modal is active at a time — showing a new one immediately replaces the
+ * At most one modal is active at a time, showing a new one immediately replaces the
  * current one. The active modal auto-dismisses after [DEFAULT_DURATION] unless it is
  * replaced first.
  */
@@ -68,7 +68,7 @@ object LightModalManager {
         dismissJob?.cancel()
         _activeModal.value = modal
         dismissJob = scope.launch {
-            // null return means the timeout elapsed; non-null means modal dismissed itself first.
+            // null return means the timeout elapsed, non-null means modal dismissed itself first.
             val timedOut = withTimeoutOrNull(duration) {
                 modal.awaitDismiss()
                 false
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightTextInputEditor.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightTextInputEditor.kt
index 02e711a8..ce6647db 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightTextInputEditor.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightTextInputEditor.kt
@@ -10,7 +10,6 @@ import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.material3.Surface
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -31,6 +30,10 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.thelightphone.lp3Keyboard.ui.*
+import com.thelightphone.lp3Keyboard.ui.viewmodel.EnQwertyLp3KeyboardViewModel
+import com.thelightphone.lp3Keyboard.ui.viewmodel.Lp3KeyboardViewModel
+import com.thelightphone.lp3Keyboard.ui.viewmodel.Lp3RepeatableKeyboardCallback
+import com.thelightphone.lp3Keyboard.ui.viewmodel.defaultEmojis
 import com.thelightphone.sdk.ui.keyboard.LightEmbeddedLp3Keyboard
 import com.thelightphone.sdk.ui.keyboard.TextInputKeyboardCallback
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -51,7 +54,7 @@ fun LightTextInputEditor(
     submitIcon: LightIconConfiguration? = null,
     showBackButton: Boolean = true,
     singleLine: Boolean = false,
-    editorKey: Any = title,
+    editorKey: Any = remember { Any() },
 ) {
     val currentOnSubmit by rememberUpdatedState(onSubmit)
     val keyboardCallback = remember(state, singleLine) {
@@ -62,7 +65,7 @@ fun LightTextInputEditor(
         )
     }
 
-    val keyboardViewModel: Lp3KeyboardViewModel = viewModel<DefaultLp3KeyboardViewModel>(
+    val keyboardViewModel: Lp3KeyboardViewModel<*> = viewModel<EnQwertyLp3KeyboardViewModel<*>>(
         key = "LightTextInputEditor-$editorKey",
         factory = factory(keyboardCallback, keyboardOptionsFlow),
     )
@@ -94,7 +97,7 @@ fun LightTextInputEditor(
     state: TextFieldState,
     onSubmit: (CharSequence) -> Unit,
     onBack: () -> Unit,
-    viewModel: Lp3KeyboardViewModel,
+    viewModel: Lp3KeyboardViewModel<*>,
     modifier: Modifier = Modifier,
     submitLabel: String = "SUBMIT",
     submitIcon: LightIconConfiguration? = null,
@@ -186,13 +189,13 @@ fun LightTextInputEditor(
 
             LightBottomBar(
                 items = listOf(
-                    when (val icon = submitIcon) {
+                    when (submitIcon) {
                         null -> LightBarButton.Text(
                             text = submitLabel,
                             onClick = { onSubmit(state.text) },
                         )
                         else -> LightBarButton.LightIcon(
-                            icon = icon,
+                            icon = submitIcon,
                             onClick = { onSubmit(state.text) },
                             contentDescription = submitLabel,
                         )
@@ -210,16 +213,13 @@ private fun factory(
     object : ViewModelProvider.Factory {
         @Suppress("UNCHECKED_CAST")
         override fun <T : ViewModel> create(modelClass: Class<T>): T {
-            return DefaultLp3KeyboardViewModel(
+            return EnQwertyLp3KeyboardViewModel<Unit>(
                 callback,
                 keyboardOptionsFlow = keyboardOptionsFlow,
                 optionsForLayout = {
-                    val showCloseButton = when (it) {
-                        EmojiLayout, is ExtendedCharKeyboard -> true
-                        CapsLockedLayout, LowerCaseLayout, NumberLayout, SymbolsLayout, UpperCaseLayout -> false
-                    }
+                    val showCloseButton = !it.isRootLayout
                     LayoutOptions(showCloseButton)
-                }
+                },
             ) as T
         }
 
@@ -255,5 +255,6 @@ fun defaultKeyboardOptions() = KeyboardOptions(
     defaultEmojis,
     displayReturn = true,
     displayVoice = true,
-    enableKeyAnimation = true
+    enableKeyAnimation = true,
+    swipeEnabled = false
 )
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/LightEmbeddedLp3Keyboard.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/LightEmbeddedLp3Keyboard.kt
index ec48468c..085d7d8b 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/LightEmbeddedLp3Keyboard.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/LightEmbeddedLp3Keyboard.kt
@@ -12,14 +12,14 @@ import androidx.compose.ui.unit.dp
 import com.thelightphone.lp3Keyboard.ui.DarkKeyboardColors
 import com.thelightphone.lp3Keyboard.ui.LightKeyboardColors
 import com.thelightphone.lp3Keyboard.ui.Lp3KeyboardTheme
-import com.thelightphone.lp3Keyboard.ui.Lp3KeyboardViewModel
 import com.thelightphone.lp3Keyboard.ui.LocalKeyboardColors
 import com.thelightphone.lp3Keyboard.ui.Lp3KeyboardWrapper
+import com.thelightphone.lp3Keyboard.ui.viewmodel.Lp3KeyboardViewModel
 import com.thelightphone.sdk.ui.LightThemeColors
 import com.thelightphone.sdk.ui.LightThemeTokens
 
 @Composable
-fun LightEmbeddedLp3Keyboard(viewModel: Lp3KeyboardViewModel) {
+fun LightEmbeddedLp3Keyboard(viewModel: Lp3KeyboardViewModel<*>) {
     val layout by viewModel.layoutFlow.collectAsState()
     val keyboardOptions by viewModel.keyboardOptionsFlow.collectAsState()
     val layoutOptions by viewModel.layoutOptionsFlow.collectAsState()
@@ -42,6 +42,7 @@ fun LightEmbeddedLp3Keyboard(viewModel: Lp3KeyboardViewModel) {
                 keyboardOptions = keyboardOptions,
                 layoutOptions = layoutOptions,
                 callback = viewModel,
+                swipeCallback = null
             )
         }
     }
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/TextInputKeyboardCallback.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/TextInputKeyboardCallback.kt
index 1865340f..e06c9d89 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/TextInputKeyboardCallback.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/keyboard/TextInputKeyboardCallback.kt
@@ -3,8 +3,8 @@ package com.thelightphone.sdk.ui.keyboard
 import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.foundation.text.input.delete
 import androidx.compose.ui.text.TextRange
-import com.thelightphone.lp3Keyboard.ui.Lp3RepeatableKeyboardCallback
 import com.thelightphone.lp3Keyboard.ui.SpecialKey
+import com.thelightphone.lp3Keyboard.ui.viewmodel.Lp3RepeatableKeyboardCallback
 
 internal class TextInputKeyboardCallback(
     private val state: TextFieldState,
@@ -46,14 +46,18 @@ internal class TextInputKeyboardCallback(
         insertCodePoint(code)
     }
 
-    override fun onSpecialKeyRepeated(key: SpecialKey) {
-        if (key == SpecialKey.Space) insertAtCursor(" ")
+    override fun onSpecialKeyRepeated(specialKey: SpecialKey) {
+        if (specialKey == SpecialKey.Space) insertAtCursor(" ")
     }
 
     private fun insertCodePoint(code: Int) {
         insertAtCursor(buildString { appendCodePoint(code) })
     }
 
+    override fun onSubmitWord(word: CharSequence) {
+        insertAtCursor(word.toString())
+    }
+
     private fun insertAtCursor(text: String) {
         state.edit {
             val start = selection.min

From 5a16119a34fc1128ee2767f2b0ca8c153b69ef2c Mon Sep 17 00:00:00 2001
From: Guy Dupont <dupontgu@gmail.com>
Date: Mon, 20 Jul 2026 14:19:11 -0400
Subject: [PATCH 3/9] add progress bar to ui demo

---
 .../thelightphone/uidemo/UiDemoHomeScreen.kt  |  7 +++
 .../uidemo/UiDemoProgressBarScreen.kt         | 56 +++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt

diff --git a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
index 909f6701..db3c6cbc 100644
--- a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
+++ b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
@@ -113,6 +113,13 @@ class UiDemoHomeScreen(sealedActivity: SealedLightActivity) :
                                 .lightClickable { LightThemeController.toggle() }
                                 .padding(vertical = 0.75f.gridUnitsAsDp()),
                         )
+                        LightText(
+                            text = "PROGRESS BAR",
+                            variant = LightTextVariant.Copy,
+                            modifier = Modifier
+                                .lightClickable { navigateTo(::UiDemoProgressBarScreen) }
+                                .padding(vertical = 0.75f.gridUnitsAsDp()),
+                        )
                     }
                 }
 
diff --git a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt
new file mode 100644
index 00000000..94b90d1a
--- /dev/null
+++ b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt
@@ -0,0 +1,56 @@
+package com.thelightphone.uidemo
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment.Companion.CenterHorizontally
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.thelightphone.sdk.SealedLightActivity
+import com.thelightphone.sdk.SimpleLightScreen
+import com.thelightphone.sdk.ui.LightText
+import com.thelightphone.sdk.ui.LightTextVariant
+import com.thelightphone.sdk.ui.LightTheme
+import com.thelightphone.sdk.ui.LightThemeController
+import com.thelightphone.sdk.ui.LightTouchableProgressBar
+import com.thelightphone.sdk.ui.gridUnitsAsDp
+import java.util.Locale
+
+class UiDemoProgressBarScreen(sealedActivity: SealedLightActivity) :
+    SimpleLightScreen<Unit>(sealedActivity) {
+
+    @Composable
+    override fun Content() = ContentInner()
+}
+
+@Composable
+private fun ContentInner() {
+    val themeColors by LightThemeController.colors.collectAsState()
+    var progress by remember { mutableStateOf(0.5f) }
+    LightTheme(colors = themeColors) {
+        Column(
+            horizontalAlignment = CenterHorizontally,
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(2f.gridUnitsAsDp())
+        ) {
+            LightText("%.2f".format(Locale.ROOT, progress), variant = LightTextVariant.Copy)
+            LightTouchableProgressBar(themeColors, progress, onValueChange = { progress = it })
+        }
+    }
+}
+
+@Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
+@Composable
+fun UiDemoProgressBarScreen() {
+    ContentInner()
+}

From 62baa93d09e68cf3b767cb0c285b99f644c2b49f Mon Sep 17 00:00:00 2001
From: Guy Dupont <dupontgu@gmail.com>
Date: Wed, 22 Jul 2026 14:32:24 -0400
Subject: [PATCH 4/9] pr fixes

---
 .../thelightphone/plugin/ManifestGenerator.kt | 81 ++++++++++---------
 .../thelightphone/sdk/LightKeyboardManager.kt |  2 +-
 .../sdk/emulator/EmulatorSettings.kt          |  5 +-
 .../sdk/server/LightSdkServerSettings.kt      |  2 +
 .../sdk/shared/LightServiceMethod.kt          |  3 +-
 .../sdk/shared/LightResultTest.kt             | 20 +++++
 6 files changed, 69 insertions(+), 44 deletions(-)
 create mode 100644 sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightResultTest.kt

diff --git a/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt b/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
index 45ac8c03..e9af9d08 100644
--- a/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
+++ b/plugin/src/main/kotlin/com/thelightphone/plugin/ManifestGenerator.kt
@@ -29,45 +29,48 @@ object ManifestGenerator {
         for (feature in features) {
             appendLine("""    <uses-feature android:name="${xmlAttr(feature)}" android:required="false" />""")
         }
-        appendLine("""    <application""")
-        appendLine("""        android:name="com.thelightphone.sdk.LightSdkApplication"""")
-        appendLine("""        android:label="${xmlAttr(metadata.label)}"""")
-        appendLine("""        android:supportsRtl="true"""")
-        appendLine("""        android:theme="@style/LightSdk.Theme.Splash">""")
-        appendLine("""        <meta-data""")
-        appendLine("""            android:name="com.thelightphone.sdk.LIGHT_SERVER_PACKAGE"""")
-        appendLine("""            android:value="${xmlAttr(metadata.serverPackage)}" />""")
-        appendLine("""        <activity""")
-        appendLine("""            android:name="com.thelightphone.sdk.LightActivity"""")
-        appendLine("""            android:launchMode="singleTask"""")
-        metadata.orientation?.let {
-            appendLine("""            android:screenOrientation="${xmlAttr(it)}"""")
-        }
-        appendLine("""            android:exported="true">""")
-        appendLine("""            <intent-filter>""")
-        appendLine("""                <action android:name="android.intent.action.MAIN" />""")
-        appendLine("""                <category android:name="android.intent.category.LAUNCHER" />""")
-        appendLine("""            </intent-filter>""")
-        appendLine("""        </activity>""")
-        appendLine("""        <receiver""")
-        appendLine("""            android:name="com.thelightphone.sdk.LightSdkReceiver"""")
-        appendLine("""            android:enabled="true"""")
-        appendLine("""            android:exported="true"""")
-        appendLine("""            android:permission="normal">""")
-        appendLine("""            <intent-filter>""")
-        appendLine("""                <action android:name="com.thelightphone.sdk.ACTION_SDK_MARKER" />""")
-        appendLine("""            </intent-filter>""")
-        appendLine("""            <meta-data""")
-        appendLine("""                android:name="com.thelightphone.sdk.SDK_VERSION"""")
-        appendLine("""                android:value="${'$'}{sdkVersion}" />""")
-        appendLine("""        </receiver>""")
-        appendLine("""    </application>""")
-        appendLine("""    <queries>""")
-        appendLine("""        <intent>""")
-        appendLine("""            <action android:name="com.thelightphone.sdk.ACTION_SDK_MARKER" />""")
-        appendLine("""        </intent>""")
-        appendLine("""    </queries>""")
-        appendLine("""</manifest>""")
+        val screenOrientation = metadata.orientation?.let {
+            "\n            |            android:screenOrientation=\"${xmlAttr(it)}\""
+        }.orEmpty()
+        appendLine(
+            """
+            |    <application
+            |        android:name="com.thelightphone.sdk.LightSdkApplication"
+            |        android:label="${xmlAttr(metadata.label)}"
+            |        android:supportsRtl="true"
+            |        android:theme="@style/LightSdk.Theme.Splash">
+            |        <meta-data
+            |            android:name="com.thelightphone.sdk.LIGHT_SERVER_PACKAGE"
+            |            android:value="${xmlAttr(metadata.serverPackage)}" />
+            |        <activity
+            |            android:name="com.thelightphone.sdk.LightActivity"
+            |            android:launchMode="singleTask"$screenOrientation
+            |            android:exported="true">
+            |            <intent-filter>
+            |                <action android:name="android.intent.action.MAIN" />
+            |                <category android:name="android.intent.category.LAUNCHER" />
+            |            </intent-filter>
+            |        </activity>
+            |        <receiver
+            |            android:name="com.thelightphone.sdk.LightSdkReceiver"
+            |            android:enabled="true"
+            |            android:exported="true"
+            |            android:permission="normal">
+            |            <intent-filter>
+            |                <action android:name="com.thelightphone.sdk.ACTION_SDK_MARKER" />
+            |            </intent-filter>
+            |            <meta-data
+            |                android:name="com.thelightphone.sdk.SDK_VERSION"
+            |                android:value="${'$'}{sdkVersion}" />
+            |        </receiver>
+            |    </application>
+            |    <queries>
+            |        <intent>
+            |            <action android:name="com.thelightphone.sdk.ACTION_SDK_MARKER" />
+            |        </intent>
+            |    </queries>
+            |</manifest>""".trimMargin()
+        )
     }
 
     private fun xmlAttr(value: String): String = buildString(value.length) {
diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
index 49d1c610..54ac5018 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightKeyboardManager.kt
@@ -41,7 +41,7 @@ suspend fun refreshKeyboardOptions(): KeyboardOptions? {
         displayReturn = true,
         displayVoice = result.displayVoice,
         enableKeyAnimation = result.enableKeyAnimation,
-        swipeEnabled = false
+        swipeEnabled = result.swipeEnabled == true // nullable
     )
 }
 
diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
index 31c4cfa8..ab98cf7f 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorSettings.kt
@@ -5,10 +5,8 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material3.Surface
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import com.thelightphone.sdk.ui.LightTouchableProgressBar
 import com.thelightphone.sdk.server.ClientFilterLevel
 import com.thelightphone.sdk.server.ForceFocusLevel
 import com.thelightphone.sdk.server.LightSdkServerSettings
@@ -291,7 +289,8 @@ fun EmulatorSettingsPreview() {
         override var keyboardOptions: LightServiceMethod.GetKeyboardOptions.Response =
             LightServiceMethod.GetKeyboardOptions.Response(null,
                 displayVoice = true,
-                enableKeyAnimation = true
+                enableKeyAnimation = true,
+                swipeEnabled = true
             )
         override var userPreferences: LightServiceMethod.GetUserPreferences.Response =
             LightServiceMethod.GetUserPreferences.Response(hapticsEnabled = true)
diff --git a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServerSettings.kt b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServerSettings.kt
index e699e708..4e8b3707 100644
--- a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServerSettings.kt
+++ b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServerSettings.kt
@@ -56,6 +56,7 @@ class DefaultLightSdkServerSettings(context: Context) : LightSdkServerSettings {
         private const val KEYBOARD_EMOJIS = "lp3_keyboard_emojis"
         private const val KEYBOARD_SHOW_VOICE = "lp3_keyboard_show_voice"
         private const val KEYBOARD_ENABLE_KEY_ANIMATION = "lp3_keyboard_enable_key_animation"
+        private const val KEYBOARD_ENABLE_SWIPE = "lp3_keyboard_enable_swipe"
     }
 
     private val contentResolver = context.contentResolver
@@ -106,6 +107,7 @@ class DefaultLightSdkServerSettings(context: Context) : LightSdkServerSettings {
             return LightServiceMethod.GetKeyboardOptions.Response(
                 emojisAsString = Settings.System.getString(contentResolver, KEYBOARD_EMOJIS),
                 displayVoice = Settings.System.getInt(contentResolver, KEYBOARD_SHOW_VOICE, 1) == 1,
+                swipeEnabled = Settings.System.getInt(contentResolver, KEYBOARD_ENABLE_SWIPE, 1) == 1,
                 enableKeyAnimation = Settings.System.getInt(
                     contentResolver,
                     KEYBOARD_ENABLE_KEY_ANIMATION,
diff --git a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
index 413a0641..9e6cb154 100644
--- a/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
+++ b/sdk/shared/src/main/kotlin/com/thelightphone/sdk/shared/LightServiceMethod.kt
@@ -69,7 +69,8 @@ sealed interface LightServiceMethod<TRequest, TResponse> {
             // "😅😅😅😅😅😅" -> keyboard will parse out emoji code points
             val emojisAsString: String?,
             val displayVoice: Boolean,
-            val enableKeyAnimation: Boolean
+            val enableKeyAnimation: Boolean,
+            val swipeEnabled: Boolean?
         )
     }
 
diff --git a/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightResultTest.kt b/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightResultTest.kt
new file mode 100644
index 00000000..ddebbc5e
--- /dev/null
+++ b/sdk/shared/src/test/kotlin/com/thelightphone/sdk/shared/LightResultTest.kt
@@ -0,0 +1,20 @@
+package com.thelightphone.sdk.shared
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LightResultTest {
+    @Test
+    fun `ensure error code values have not changed`() {
+        LightResult.ErrorCode.entries.forEach {
+            val expectedOrdinal = when(it) {
+                LightResult.ErrorCode.Unknown -> 0
+                LightResult.ErrorCode.Removed -> 1
+                LightResult.ErrorCode.InvalidParameters -> 2
+                LightResult.ErrorCode.NoPermission -> 3
+                LightResult.ErrorCode.InvalidToken -> 4
+            }
+            assertEquals(expectedOrdinal, it.ordinal, "Ordinal for $it has been changed!")
+        }
+    }
+}
\ No newline at end of file

From 8e60903e94308c3533b0d5e8c74453d3bb9d9334 Mon Sep 17 00:00:00 2001
From: Gustavo Brunoro <brunoro@users.noreply.github.com>
Date: Wed, 22 Jul 2026 18:51:51 -0300
Subject: [PATCH 5/9] fix: remove unnecessary tap gesture listener

drag listener already catches tap events
---
 .../main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt  | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
index f7796c91..2d66c2bf 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
@@ -75,10 +75,6 @@ fun LightTouchableProgressBar(
                         }
                     }
                 }
-                .pointerInput(Unit) {
-                    detectTapGestures { offset ->
-                        currentOnValueChange(xToProgress(offset.x))
-                    }
                 }
         )
     }

From faa5b6f78f295190a4c422289594c8ce23186fe2 Mon Sep 17 00:00:00 2001
From: Gustavo Brunoro <git@hitnail.net>
Date: Wed, 22 Jul 2026 18:58:11 -0300
Subject: [PATCH 6/9] fix: progressbar ui example has back button

---
 .../uidemo/UiDemoProgressBarScreen.kt         | 39 ++++++++++++-------
 .../thelightphone/sdk/ui/LightProgressBar.kt  |  1 -
 2 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt
index 94b90d1a..14b16aeb 100644
--- a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt
+++ b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoProgressBarScreen.kt
@@ -1,10 +1,8 @@
 package com.thelightphone.uidemo
 
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
@@ -14,13 +12,16 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment.Companion.CenterHorizontally
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
 import com.thelightphone.sdk.SealedLightActivity
 import com.thelightphone.sdk.SimpleLightScreen
+import com.thelightphone.sdk.ui.LightBarButton
+import com.thelightphone.sdk.ui.LightIcons
 import com.thelightphone.sdk.ui.LightText
 import com.thelightphone.sdk.ui.LightTextVariant
 import com.thelightphone.sdk.ui.LightTheme
 import com.thelightphone.sdk.ui.LightThemeController
+import com.thelightphone.sdk.ui.LightTopBar
+import com.thelightphone.sdk.ui.LightTopBarCenter
 import com.thelightphone.sdk.ui.LightTouchableProgressBar
 import com.thelightphone.sdk.ui.gridUnitsAsDp
 import java.util.Locale
@@ -29,22 +30,32 @@ class UiDemoProgressBarScreen(sealedActivity: SealedLightActivity) :
     SimpleLightScreen<Unit>(sealedActivity) {
 
     @Composable
-    override fun Content() = ContentInner()
+    override fun Content() = ContentInner(onBack = { goBack() })
 }
 
 @Composable
-private fun ContentInner() {
+private fun ContentInner(onBack: () -> Unit) {
     val themeColors by LightThemeController.colors.collectAsState()
     var progress by remember { mutableStateOf(0.5f) }
     LightTheme(colors = themeColors) {
-        Column(
-            horizontalAlignment = CenterHorizontally,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(2f.gridUnitsAsDp())
-        ) {
-            LightText("%.2f".format(Locale.ROOT, progress), variant = LightTextVariant.Copy)
-            LightTouchableProgressBar(themeColors, progress, onValueChange = { progress = it })
+        Column(modifier = Modifier.fillMaxSize()) {
+            LightTopBar(
+                leftButton = LightBarButton.LightIcon(
+                    icon = LightIcons.BACK,
+                    onClick = onBack,
+                ),
+                center = LightTopBarCenter.Text("Progress Bar"),
+                modifier = Modifier.padding(bottom = 1f.gridUnitsAsDp()),
+            )
+            Column(
+                horizontalAlignment = CenterHorizontally,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(2f.gridUnitsAsDp())
+            ) {
+                LightText("%.2f".format(Locale.ROOT, progress), variant = LightTextVariant.Copy)
+                LightTouchableProgressBar(themeColors, progress, onValueChange = { progress = it })
+            }
         }
     }
 }
@@ -52,5 +63,5 @@ private fun ContentInner() {
 @Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
 @Composable
 fun UiDemoProgressBarScreen() {
-    ContentInner()
+    ContentInner(onBack = {})
 }
diff --git a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
index 2d66c2bf..4c271f14 100644
--- a/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
+++ b/sdk/ui/src/main/kotlin/com/thelightphone/sdk/ui/LightProgressBar.kt
@@ -75,7 +75,6 @@ fun LightTouchableProgressBar(
                         }
                     }
                 }
-                }
         )
     }
 }

From 101eb68a597e0f45ec64149cc8c3a4367fa74fd3 Mon Sep 17 00:00:00 2001
From: Gustavo Brunoro <git@hitnail.net>
Date: Wed, 22 Jul 2026 19:08:21 -0300
Subject: [PATCH 7/9] fix: forward onKeyUp correctly

---
 .../src/main/kotlin/com/thelightphone/sdk/LightActivity.kt      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
index 6fd3689b..f46ece93 100644
--- a/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
+++ b/sdk/client/src/main/kotlin/com/thelightphone/sdk/LightActivity.kt
@@ -179,7 +179,7 @@ class LightActivity internal constructor() : ComponentActivity() {
 
     override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
         return if (keyCode.isSystemKeyCode) {
-            super.onKeyDown(keyCode, event)
+            super.onKeyUp(keyCode, event)
         } else if (currentScreen.value?.screen?.onKeyUp(keyCode, event) == true) {
             true
         } else if (LightDeviceKeys.mapping.containsKey(keyCode)) {

From 52f1e992bd17890627aa7c17cc2894a3f37af2ad Mon Sep 17 00:00:00 2001
From: Gustavo Brunoro <git@hitnail.net>
Date: Wed, 22 Jul 2026 19:17:41 -0300
Subject: [PATCH 8/9] feat: key events UI demo screen

---
 .../thelightphone/uidemo/UiDemoHomeScreen.kt  |  11 +-
 .../uidemo/UiDemoKeyEventsScreen.kt           | 110 ++++++++++++++++++
 2 files changed, 120 insertions(+), 1 deletion(-)
 create mode 100644 examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoKeyEventsScreen.kt

diff --git a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
index db3c6cbc..72f12260 100644
--- a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
+++ b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoHomeScreen.kt
@@ -17,6 +17,7 @@ import com.thelightphone.sdk.InitialScreen
 import com.thelightphone.sdk.SealedLightActivity
 import com.thelightphone.sdk.SimpleLightScreen
 import com.thelightphone.sdk.ui.LightFullscreenModal
+import com.thelightphone.sdk.ui.LightScrollView
 import com.thelightphone.sdk.ui.LightText
 import com.thelightphone.sdk.ui.LightTextVariant
 import com.thelightphone.sdk.ui.LightTheme
@@ -47,8 +48,9 @@ class UiDemoHomeScreen(sealedActivity: SealedLightActivity) :
                         modifier = Modifier.padding(bottom = 1f.gridUnitsAsDp()),
                     )
 
-                    Column(
+                    LightScrollView(
                         modifier = Modifier
+                            .weight(1f)
                             .fillMaxWidth()
                             .padding(horizontal = 1f.gridUnitsAsDp()),
                     ) {
@@ -120,6 +122,13 @@ class UiDemoHomeScreen(sealedActivity: SealedLightActivity) :
                                 .lightClickable { navigateTo(::UiDemoProgressBarScreen) }
                                 .padding(vertical = 0.75f.gridUnitsAsDp()),
                         )
+                        LightText(
+                            text = "KEY EVENTS",
+                            variant = LightTextVariant.Copy,
+                            modifier = Modifier
+                                .lightClickable { navigateTo(::UiDemoKeyEventsScreen) }
+                                .padding(vertical = 0.75f.gridUnitsAsDp()),
+                        )
                     }
                 }
 
diff --git a/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoKeyEventsScreen.kt b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoKeyEventsScreen.kt
new file mode 100644
index 00000000..e7d2b208
--- /dev/null
+++ b/examples/ui-demo/src/main/kotlin/com/thelightphone/uidemo/UiDemoKeyEventsScreen.kt
@@ -0,0 +1,110 @@
+package com.thelightphone.uidemo
+
+import android.view.KeyEvent
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import com.thelightphone.sdk.SealedLightActivity
+import com.thelightphone.sdk.SimpleLightScreen
+import com.thelightphone.sdk.ui.LightBarButton
+import com.thelightphone.sdk.ui.LightIcons
+import com.thelightphone.sdk.ui.LightScrollView
+import com.thelightphone.sdk.ui.LightText
+import com.thelightphone.sdk.ui.LightTextVariant
+import com.thelightphone.sdk.ui.LightTheme
+import com.thelightphone.sdk.ui.LightThemeController
+import com.thelightphone.sdk.ui.LightTopBar
+import com.thelightphone.sdk.ui.LightTopBarCenter
+import com.thelightphone.sdk.ui.gridUnitsAsDp
+
+private const val MAX_EVENTS = 20
+
+class UiDemoKeyEventsScreen(sealedActivity: SealedLightActivity) :
+    SimpleLightScreen<Unit>(sealedActivity) {
+
+    // Newest-first, capped. Mutated from key dispatch (main thread), read by Content().
+    private val events = mutableStateListOf<String>()
+
+    private fun record(type: String, keyCode: Int, event: KeyEvent) {
+        events.add(0, "${KeyEvent.keyCodeToString(keyCode)} ($keyCode) $type " +
+            "action=${event.action} repeat=${event.repeatCount}")
+        if (events.size > MAX_EVENTS) events.removeRange(MAX_EVENTS, events.size)
+    }
+
+    // Return true to consume: keeps this screen self-contained (no server forwarding).
+    // BACK/HOME never arrive here — LightActivity short-circuits them before the screen.
+    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+        record("DOWN", keyCode, event)
+        return true
+    }
+
+    override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
+        record("UP", keyCode, event)
+        return true
+    }
+
+    override fun onKeyMultiple(keyCode: Int, repeatCount: Int, event: KeyEvent): Boolean {
+        record("MULTIPLE", keyCode, event)
+        return true
+    }
+
+    @Composable
+    override fun Content() = ContentInner(events, onBack = { goBack() })
+}
+
+@Composable
+private fun ContentInner(events: List<String>, onBack: () -> Unit) {
+    val themeColors by LightThemeController.colors.collectAsState()
+    LightTheme(colors = themeColors) {
+        Column(modifier = Modifier.fillMaxSize()) {
+            LightTopBar(
+                leftButton = LightBarButton.LightIcon(
+                    icon = LightIcons.BACK,
+                    onClick = onBack,
+                ),
+                center = LightTopBarCenter.Text("Key Events"),
+                modifier = Modifier.padding(bottom = 1f.gridUnitsAsDp()),
+            )
+            if (events.isEmpty()) {
+                LightText(
+                    text = "Press a hardware key…",
+                    variant = LightTextVariant.Copy,
+                    modifier = Modifier.padding(horizontal = 1f.gridUnitsAsDp()),
+                )
+            }
+            LightScrollView(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxWidth()
+                    .padding(horizontal = 1f.gridUnitsAsDp()),
+            ) {
+                events.forEach { line ->
+                    LightText(
+                        text = line,
+                        variant = LightTextVariant.Superfine,
+                        modifier = Modifier.padding(vertical = 0.5f.gridUnitsAsDp()),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Preview(widthDp = 1080 / 3, heightDp = 1240 / 3, showBackground = true)
+@Composable
+fun UiDemoKeyEventsScreenPreview() {
+    ContentInner(
+        events = listOf(
+            "DOWN  KEYCODE_VOLUME_UP (24)  action=0 repeat=0",
+            "UP  KEYCODE_VOLUME_UP (24)  action=1 repeat=0",
+        ),
+        onBack = {},
+    )
+}

From 3fb103ec0706b41c627fd385369f970d5e3341e3 Mon Sep 17 00:00:00 2001
From: Guy Dupont <dupontgu@gmail.com>
Date: Fri, 24 Jul 2026 09:53:42 -0400
Subject: [PATCH 9/9] remove unused field

---
 .../com/thelightphone/sdk/emulator/EmulatorApplication.kt      | 1 -
 .../main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt | 3 ---
 2 files changed, 4 deletions(-)

diff --git a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
index 8301ba3f..3129314e 100644
--- a/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
+++ b/sdk/emulator/src/main/kotlin/com/thelightphone/sdk/emulator/EmulatorApplication.kt
@@ -49,7 +49,6 @@ class EmulatorApplication : Application() {
             }
             provideSdkSettings = { settings }
             permissionActivity = LightSdkPermissionActivity::class.java
-            rootActivity = MainActivity::class.java
             onDeviceKeyEvent = { _, request -> handleDeviceKeyEvent(request) }
         }
 
diff --git a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
index 879a84ae..993b837f 100644
--- a/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
+++ b/sdk/server/src/main/kotlin/com/thelightphone/sdk/server/LightSdkServer.kt
@@ -189,9 +189,6 @@ object LightSdkServer {
      */
     var permissionActivity: Class<out Activity>? = null
 
-    var rootActivity: Class<out Activity>? = null
-
-
     var grantPermission: (context: Context, packageName: String, permission: String) -> Result<Unit> =
         { context, packageName, permission ->
             runCatching {