Skip to content

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.kt
index 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.MotionEvent
import android.view.SurfaceHolder
import android.view.SurfaceView
import 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.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
@@ -39,6 +49,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
@@ -47,18 +58,23 @@ import androidx.compose.ui.input.key.KeyEventType
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.input.pointer.pointerInteropFilter
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.TextFieldValue
+import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import 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 = 0xFF08
private const val XK_Tab = 0xFF09
private const val XK_Return = 0xFF0D
@@ -67,11 +83,46 @@ private const val XK_Left = 0xFF51
private const val XK_Up = 0xFF52
private const val XK_Right = 0xFF53
private 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,
)
@Composable
fun 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.current
var 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.code
vm.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)