A rootless Android app that boots Alpine Linux: run containers (Podman/Docker/LXC) and GUI desktop apps.
x11: add extra-keys row matching the terminal's vocabulary
ExTv26663b216a6b
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/x11/X11Screen.kt b/app/src/main/java/com/excp/podroid/ui/screens/x11/X11Screen.ktindex 945a2f5..df812e7 100644--- a/app/src/main/java/com/excp/podroid/ui/screens/x11/X11Screen.kt+++ b/app/src/main/java/com/excp/podroid/ui/screens/x11/X11Screen.kt@@ -10,11 +10,21 @@ import android.view.MotionEventimport android.view.SurfaceHolderimport android.view.SurfaceViewimport androidx.compose.foundation.background+import androidx.compose.foundation.clickable+import androidx.compose.foundation.gestures.awaitEachGesture+import androidx.compose.foundation.gestures.awaitFirstDown+import androidx.compose.foundation.gestures.waitForUpOrCancellation+import androidx.compose.foundation.horizontalScroll+import androidx.compose.foundation.layout.Arrangementimport androidx.compose.foundation.layout.Boximport androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Rowimport androidx.compose.foundation.layout.fillMaxSize+import androidx.compose.foundation.layout.fillMaxWidthimport androidx.compose.foundation.layout.paddingimport androidx.compose.foundation.layout.size+import androidx.compose.foundation.rememberScrollState+import androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.foundation.text.BasicTextFieldimport androidx.compose.foundation.text.KeyboardActionsimport androidx.compose.foundation.text.KeyboardOptions@@ -39,6 +49,7 @@ import androidx.compose.ui.Alignmentimport androidx.compose.ui.ExperimentalComposeUiApiimport androidx.compose.ui.Modifierimport androidx.compose.ui.draw.alpha+import androidx.compose.ui.draw.clipimport androidx.compose.ui.focus.FocusRequesterimport androidx.compose.ui.focus.focusRequesterimport androidx.compose.ui.graphics.Color@@ -47,18 +58,23 @@ import androidx.compose.ui.input.key.KeyEventTypeimport androidx.compose.ui.input.key.keyimport androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.input.key.type+import androidx.compose.ui.input.pointer.pointerInputimport androidx.compose.ui.input.pointer.pointerInteropFilterimport androidx.compose.ui.platform.LocalSoftwareKeyboardController+import androidx.compose.ui.text.font.FontFamily+import androidx.compose.ui.text.font.FontWeightimport androidx.compose.ui.text.input.ImeActionimport androidx.compose.ui.text.input.TextFieldValue+import androidx.compose.ui.text.style.TextAlignimport androidx.compose.ui.unit.dp+import androidx.compose.ui.unit.spimport androidx.compose.ui.viewinterop.AndroidViewimport androidx.hilt.navigation.compose.hiltViewModelimport androidx.lifecycle.compose.collectAsStateWithLifecycleimport com.excp.podroid.x11.X11Constants+import kotlinx.coroutines.delay-// X11 keysyms for keys that don't appear as printable characters in-// onValueChange diffs. ASCII keys (0x20–0x7E) double as their own keysyms.+// X11 keysyms used outside the label table.private const val XK_BackSpace = 0xFF08private const val XK_Tab = 0xFF09private const val XK_Return = 0xFF0D@@ -67,11 +83,46 @@ private const val XK_Left = 0xFF51private const val XK_Up = 0xFF52private const val XK_Right = 0xFF53private const val XK_Down = 0xFF54+private const val XK_Control_L = 0xFFE3+private const val XK_Alt_L = 0xFFE9++/**+ * Maps the human-readable label used by [X11ExtraKeysRow] (matching the+ * terminal's ExtraKeysRow vocabulary) to an X11 keysym. Returns null for+ * pure modifier labels (CTRL/ALT) — those are handled as toggles.+ */+private fun labelToKeysym(label: String): Int? = when (label) {+ "ESC" -> XK_Escape+ "TAB" -> XK_Tab+ "LEFT" -> XK_Left+ "RIGHT" -> XK_Right+ "UP" -> XK_Up+ "DOWN" -> XK_Down+ "HOME" -> 0xFF50+ "END" -> 0xFF57+ "PGUP" -> 0xFF55+ "PGDN" -> 0xFF56+ "F1" -> 0xFFBE+ "F2" -> 0xFFBF+ "F3" -> 0xFFC0+ "F4" -> 0xFFC1+ "F5" -> 0xFFC2+ "F6" -> 0xFFC3+ "F7" -> 0xFFC4+ "F8" -> 0xFFC5+ "F9" -> 0xFFC6+ "F10" -> 0xFFC7+ "F11" -> 0xFFC8+ "F12" -> 0xFFC9+ "-" -> 0x2D+ "/" -> 0x2F+ "|" -> 0x7C+ else -> null // CTRL / ALT handled by toggles+}@OptIn(ExperimentalMaterial3Api::class,ExperimentalComposeUiApi::class,- androidx.compose.ui.ExperimentalComposeUiApi::class,)@Composablefun X11Screen(@@ -88,14 +139,11 @@ fun X11Screen(Bitmap.createBitmap(X11Constants.FB_WIDTH, X11Constants.FB_HEIGHT, Bitmap.Config.ARGB_8888)}- // SurfaceView size in pixels — captured in surfaceChanged.var svWidth by remember { mutableStateOf(1) }var svHeight by remember { mutableStateOf(1) }- // Letterbox / pillarbox destination rect inside the SurfaceView, recomputed- // whenever the view size changes. Pinned to the TOP (dY = 0) so the soft- // keyboard never overlaps the framebuffer — the black bar lives below.- // Horizontally still centered (pillarbox) in landscape orientation.+ // Letterbox / pillarbox dst rect, pinned to top so the soft keyboard+ // (and the extra-keys row) live in the empty bottom strip.val (dstX, dstY, dstW, dstH) = remember(svWidth, svHeight) {val fbW = X11Constants.FB_WIDTH.toFloat()val fbH = X11Constants.FB_HEIGHT.toFloat()@@ -109,13 +157,36 @@ fun X11Screen(IntArray4(dX, dY, dW, dH)}- // Hidden text field for soft-keyboard input. We give it focus when the- // keyboard icon is tapped; the IME shows; typed characters arrive via- // onValueChange and are forwarded to the VM as X11 KeyPress/KeyRelease.val focusRequester = remember { FocusRequester() }val keyboardController = LocalSoftwareKeyboardController.currentvar imeBuf by remember { mutableStateOf(TextFieldValue("")) }+ // Sticky modifier state — tap CTRL once, the next key is sent with+ // Control_L held; the modifier auto-clears after that one keypress+ // (one-shot semantics, matches Termux convention).+ var ctrlActive by remember { mutableStateOf(false) }+ var altActive by remember { mutableStateOf(false) }++ fun sendWithModifiers(keysym: Int) {+ if (ctrlActive) viewModel.sendKey(XK_Control_L, down = true)+ if (altActive) viewModel.sendKey(XK_Alt_L, down = true)+ viewModel.sendKey(keysym, down = true)+ viewModel.sendKey(keysym, down = false)+ if (altActive) viewModel.sendKey(XK_Alt_L, down = false)+ if (ctrlActive) viewModel.sendKey(XK_Control_L, down = false)+ // One-shot: clear modifiers after one press.+ ctrlActive = false+ altActive = false+ }++ fun onExtraKey(label: String) {+ when (label) {+ "CTRL" -> ctrlActive = !ctrlActive+ "ALT" -> altActive = !altActive+ else -> labelToKeysym(label)?.let(::sendWithModifiers)+ }+ }+Column(modifier = Modifier.fillMaxSize().background(Color.Black)) {TopAppBar(title = { Text("X11") },@@ -141,10 +212,10 @@ fun X11Screen(},)- Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {- when (val state = connection) {- X11ConnectionState.Connecting,- X11ConnectionState.Disconnected -> {+ when (val state = connection) {+ X11ConnectionState.Connecting,+ X11ConnectionState.Disconnected -> {+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {CircularProgressIndicator(color = MaterialTheme.colorScheme.primary)Text("Connecting to X11 server...",@@ -152,115 +223,214 @@ fun X11Screen(color = Color.White,)}- is X11ConnectionState.Failed -> {+ }+ is X11ConnectionState.Failed -> {+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {Text("X11 server not ready — VM still booting?\n${state.message}",color = MaterialTheme.colorScheme.error,)}- X11ConnectionState.Connected -> {- AndroidView(- modifier = Modifier- .fillMaxSize()- .pointerInteropFilter { ev ->- // Map raw touch (in SurfaceView space) into the- // letterboxed destination rect, then into the- // 1280x720 framebuffer. Taps in the black bars- // become coords clamped to the FB edge — feels- // OK in practice (mouse moves to nearest edge).- val w = dstW.coerceAtLeast(1)- val h = dstH.coerceAtLeast(1)- val sx = ((ev.x - dstX) / w * X11Constants.FB_WIDTH)- .toInt().coerceIn(0, X11Constants.FB_WIDTH - 1)- val sy = ((ev.y - dstY) / h * X11Constants.FB_HEIGHT)- .toInt().coerceIn(0, X11Constants.FB_HEIGHT - 1)- val mask = when (ev.actionMasked) {- MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE -> 1- else -> 0- }- viewModel.sendPointer(sx, sy, mask)- true- },- factory = { ctx ->- SurfaceView(ctx).apply {- holder.addCallback(object : SurfaceHolder.Callback {- override fun surfaceCreated(h: SurfaceHolder) {}- override fun surfaceChanged(h: SurfaceHolder, f: Int, w: Int, hh: Int) {- svWidth = w- svHeight = hh- }- override fun surfaceDestroyed(h: SurfaceHolder) {}- })+ }+ X11ConnectionState.Connected -> {+ AndroidView(+ modifier = Modifier+ .weight(1f)+ .fillMaxWidth()+ .pointerInteropFilter { ev ->+ val w = dstW.coerceAtLeast(1)+ val h = dstH.coerceAtLeast(1)+ val sx = ((ev.x - dstX) / w * X11Constants.FB_WIDTH)+ .toInt().coerceIn(0, X11Constants.FB_WIDTH - 1)+ val sy = ((ev.y - dstY) / h * X11Constants.FB_HEIGHT)+ .toInt().coerceIn(0, X11Constants.FB_HEIGHT - 1)+ val mask = when (ev.actionMasked) {+ MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE -> 1+ else -> 0}+ viewModel.sendPointer(sx, sy, mask)+ true},- update = { sv ->- // Re-blit on every frameCounter tick.- @Suppress("UNUSED_EXPRESSION")- frameCount- bitmap.setPixels(- viewModel.framebuffer, 0,- X11Constants.FB_WIDTH,- 0, 0,- X11Constants.FB_WIDTH, X11Constants.FB_HEIGHT,- )- val holder = sv.holder- val canvas = holder.lockCanvas() ?: return@AndroidView- try {- canvas.drawColor(android.graphics.Color.BLACK)- val dst = Rect(dstX, dstY, dstX + dstW, dstY + dstH)- canvas.drawBitmap(bitmap, null, dst, null)- } finally {- holder.unlockCanvasAndPost(canvas)+ factory = { ctx ->+ SurfaceView(ctx).apply {+ holder.addCallback(object : SurfaceHolder.Callback {+ override fun surfaceCreated(h: SurfaceHolder) {}+ override fun surfaceChanged(h: SurfaceHolder, f: Int, w: Int, hh: Int) {+ svWidth = w+ svHeight = hh+ }+ override fun surfaceDestroyed(h: SurfaceHolder) {}+ })+ }+ },+ update = { sv ->+ @Suppress("UNUSED_EXPRESSION")+ frameCount+ bitmap.setPixels(+ viewModel.framebuffer, 0,+ X11Constants.FB_WIDTH,+ 0, 0,+ X11Constants.FB_WIDTH, X11Constants.FB_HEIGHT,+ )+ val holder = sv.holder+ val canvas = holder.lockCanvas() ?: return@AndroidView+ try {+ canvas.drawColor(android.graphics.Color.BLACK)+ val dst = Rect(dstX, dstY, dstX + dstW, dstY + dstH)+ canvas.drawBitmap(bitmap, null, dst, null)+ } finally {+ holder.unlockCanvasAndPost(canvas)+ }+ },+ )++ X11ExtraKeysRow(+ onKey = ::onExtraKey,+ ctrlActive = ctrlActive,+ altActive = altActive,+ )++ // Hidden IME hook (must stay in the layout while connected so+ // the requestFocus/show sequence has a target).+ BasicTextField(+ value = imeBuf,+ onValueChange = { new ->+ forwardImeDiff(imeBuf.text, new.text, viewModel)+ imeBuf = TextFieldValue("")+ },+ keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),+ keyboardActions = KeyboardActions(+ onSend = {+ viewModel.sendKey(XK_Return, down = true)+ viewModel.sendKey(XK_Return, down = false)+ },+ ),+ modifier = Modifier+ .size(1.dp)+ .alpha(0f)+ .focusRequester(focusRequester)+ .onPreviewKeyEvent { ev ->+ if (ev.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false+ val keysym = when (ev.key) {+ Key.Backspace -> XK_BackSpace+ Key.Enter,+ Key.NumPadEnter -> XK_Return+ Key.Tab -> XK_Tab+ Key.Escape -> XK_Escape+ Key.DirectionLeft -> XK_Left+ Key.DirectionRight -> XK_Right+ Key.DirectionUp -> XK_Up+ Key.DirectionDown -> XK_Down+ else -> return@onPreviewKeyEvent false}+ viewModel.sendKey(keysym, down = true)+ viewModel.sendKey(keysym, down = false)+ true},- )+ )+ }+ }+ }+}- // Off-screen IME hook. 1.dp + alpha 0 keeps it invisible- // but still focusable so the soft keyboard targets it.- BasicTextField(- value = imeBuf,- onValueChange = { new ->- forwardImeDiff(imeBuf.text, new.text, viewModel)- // Reset to empty so the buffer doesn't grow.- imeBuf = TextFieldValue("")- },- keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),- keyboardActions = KeyboardActions(- onSend = {- viewModel.sendKey(XK_Return, down = true)- viewModel.sendKey(XK_Return, down = false)- },- ),- modifier = Modifier- .size(1.dp)- .alpha(0f)- .focusRequester(focusRequester)- .onPreviewKeyEvent { ev ->- // Hardware-key intercept for special keys the- // soft keyboard sends as KeyEvents (arrows,- // backspace on some IMEs, escape, tab).- if (ev.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false- val keysym = when (ev.key) {- Key.Backspace -> XK_BackSpace- Key.Enter,- Key.NumPadEnter -> XK_Return- Key.Tab -> XK_Tab- Key.Escape -> XK_Escape- Key.DirectionLeft -> XK_Left- Key.DirectionRight -> XK_Right- Key.DirectionUp -> XK_Up- Key.DirectionDown -> XK_Down- else -> return@onPreviewKeyEvent false- }- viewModel.sendKey(keysym, down = true)- viewModel.sendKey(keysym, down = false)- true- },- )+/**+ * Same vocabulary as the terminal's ExtraKeysRow so muscle memory carries+ * over: ESC, TAB, CTRL, arrows, ALT, punctuation, HOME/END, PGUP/PGDN, F1–F12.+ * CTRL and ALT are sticky one-shot modifiers (highlighted while active).+ */+@Composable+private fun X11ExtraKeysRow(+ onKey: (String) -> Unit,+ ctrlActive: Boolean,+ altActive: Boolean,+) {+ Row(+ modifier = Modifier+ .fillMaxWidth()+ .background(MaterialTheme.colorScheme.surfaceVariant)+ .horizontalScroll(rememberScrollState())+ .padding(horizontal = 4.dp, vertical = 4.dp),+ horizontalArrangement = Arrangement.spacedBy(3.dp),+ verticalAlignment = Alignment.CenterVertically,+ ) {+ X11KeyButton("ESC", onKey)+ X11KeyButton("TAB", onKey)+ X11KeyButton("CTRL", onKey, isActive = ctrlActive)+ X11KeyButton("←", onKey, sendKey = "LEFT", repeatable = true)+ X11KeyButton("↑", onKey, sendKey = "UP", repeatable = true)+ X11KeyButton("↓", onKey, sendKey = "DOWN", repeatable = true)+ X11KeyButton("→", onKey, sendKey = "RIGHT", repeatable = true)+ X11KeyButton("ALT", onKey, isActive = altActive)+ X11KeyButton("-", onKey)+ X11KeyButton("/", onKey)+ X11KeyButton("|", onKey)+ X11KeyButton("HOME", onKey)+ X11KeyButton("END", onKey)+ X11KeyButton("PGUP", onKey)+ X11KeyButton("PGDN", onKey)+ X11KeyButton("F1", onKey)+ X11KeyButton("F2", onKey)+ X11KeyButton("F3", onKey)+ X11KeyButton("F4", onKey)+ X11KeyButton("F5", onKey)+ X11KeyButton("F6", onKey)+ X11KeyButton("F7", onKey)+ X11KeyButton("F8", onKey)+ X11KeyButton("F9", onKey)+ X11KeyButton("F10", onKey)+ X11KeyButton("F11", onKey)+ X11KeyButton("F12", onKey)+ }+}++@Composable+private fun X11KeyButton(+ label: String,+ onKey: (String) -> Unit,+ sendKey: String = label,+ isActive: Boolean = false,+ repeatable: Boolean = false,+) {+ var pressed by remember { mutableStateOf(false) }+ LaunchedEffect(pressed, sendKey, repeatable) {+ if (!repeatable || !pressed) return@LaunchedEffect+ delay(400L)+ var interval = 70L+ while (pressed) {+ onKey(sendKey)+ delay(interval)+ if (interval > 30L) interval -= 3L+ }+ }+ val tapModifier = if (repeatable) {+ Modifier.pointerInput(sendKey) {+ awaitEachGesture {+ awaitFirstDown(requireUnconsumed = false)+ onKey(sendKey)+ pressed = true+ try {+ waitForUpOrCancellation()+ } finally {+ pressed = false}}}+ } else {+ Modifier.clickable { onKey(sendKey) }}+ Text(+ text = label,+ color = if (isActive) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurface,+ fontSize = 12.sp,+ fontWeight = FontWeight.Medium,+ fontFamily = FontFamily.Monospace,+ textAlign = TextAlign.Center,+ modifier = Modifier+ .clip(RoundedCornerShape(4.dp))+ .background(if (isActive) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surface)+ .then(tapModifier)+ .padding(horizontal = 10.dp, vertical = 8.dp),+ )}/**@@ -270,14 +440,12 @@ fun X11Screen(*/private fun forwardImeDiff(old: String, new: String, vm: X11ViewModel) {if (new.length > old.length) {- // Inserted text — send each char as keysym = code.new.substring(old.length).forEach { ch ->val keysym = ch.codevm.sendKey(keysym, down = true)vm.sendKey(keysym, down = false)}} else if (new.length < old.length) {- // Soft delete — fire that many backspaces.repeat(old.length - new.length) {vm.sendKey(XK_BackSpace, down = true)vm.sendKey(XK_BackSpace, down = false)@@ -285,5 +453,4 @@ private fun forwardImeDiff(old: String, new: String, vm: X11ViewModel) {}}-// Tiny helper so the dst rect destructure reads cleanly.private data class IntArray4(val a: Int, val b: Int, val c: Int, val d: Int)