app: add a manual keyboard toggle to the terminal

Tapping the terminal always raised the software keyboard, which is wrong
inside an editor: there a tap places the cursor, so the keyboard covers
half the screen every time you move it. Termux forwards the click to the
running app and our client raises the IME on the same tap, because
GestureAndScaleRecognizer discards what onUp returns and the queued
onSingleTapConfirmed fires regardless.

Guard the IME call in onSingleTapUp behind a new Terminal setting, and
when it is off, float a keyboard button over the terminal that toggles
the IME both ways. Which bottom corner it sits in is a second setting,
so it can be reached one-handed either way.

The setting defaults to on, so nothing changes on upgrade. Hardware
keyboards are unaffected: KEYBOARD_QWERTY never reached showSoftInput,
and 12-key keypads keep activate12KeyInputMethodIfNeeded on tab open.

The button reads dark against the terminal's own black rather than
following the app theme, the deviation DESIGN.md already records for the
virtual keys background directly above it.

Signed-off-by: ravindu644 <droidcasts@protonmail.com>

Author: ravindu644

Android/app/src/main/java/com/droidspaces/app/ui/screen/ContainerTerminalScreen.kt

@@ -10,6 +10,7 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
@@ -20,6 +21,8 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Keyboard
+import androidx.compose.material.icons.filled.KeyboardHide
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
@@ -371,6 +374,13 @@ private fun TerminalTabView(
     // Terminal-only dark mode: renders the terminal page dark even when the rest
     // of the app follows the light theme. Read once at entry; re-enter to apply.
     val terminalDarkTheme = remember { prefsManager.terminalDarkTheme }
+    // When taps no longer raise the keyboard, the button on the terminal is the
+    // only way to get it back, so both are read together at entry.
+    val tapOpensKeyboard = remember { prefsManager.terminalTapKeyboard }
+    val keyboardButtonLeft = remember { prefsManager.terminalKeyboardLeft }
+    // Holds this tab's client so the button acts on the terminal it sits on,
+    // rather than on whichever view TerminalScreenState last saw.
+    var backEnd by remember { mutableStateOf<TerminalBackEnd?>(null) }
     // Termux TerminalColors indices: 256 = default foreground, 257 = background,
     // 258 = cursor. Dark mode uses the classic termux white-on-black scheme:
     // pure white foreground on pure black background.
@@ -392,68 +402,85 @@ private fun TerminalTabView(
     ) {
         Column(modifier = Modifier.fillMaxSize()) {
 
-            AndroidView(
-                factory = { ctx ->
-                    TerminalView(ctx, null).apply {
-                        TerminalScreenState.terminalView = WeakReference(this)
-                        setTextSize(fontSizePx)      // must run first, initializes mRenderer
-                        setTypeface(terminalTypeface) // JetBrains Mono; null = system default
-                        keepScreenOn = true
-                        isFocusableInTouchMode = true
-                        // The renderer only paints cell backgrounds; the full-screen
-                        // default background comes from the View itself.
-                        if (terminalDarkTheme) {
-                            setBackgroundColor(terminalBackground)
-                        }
+            // The button rides inside the terminal's own Box, which is what keeps
+            // it clear of the virtual keys row without hardcoding its height.
+            Box(modifier = Modifier.fillMaxWidth().weight(1f)) {
+                AndroidView(
+                    factory = { ctx ->
+                        TerminalView(ctx, null).apply {
+                            TerminalScreenState.terminalView = WeakReference(this)
+                            setTextSize(fontSizePx)      // must run first, initializes mRenderer
+                            setTypeface(terminalTypeface) // JetBrains Mono; null = system default
+                            keepScreenOn = true
+                            isFocusableInTouchMode = true
+                            // The renderer only paints cell backgrounds; the full-screen
+                            // default background comes from the View itself.
+                            if (terminalDarkTheme) {
+                                setBackgroundColor(terminalBackground)
+                            }
 
-                        if (activity != null) {
-                            val client = TerminalBackEnd(
-                                terminal = this,
-                                activity = activity,
-                                initialFontSizePx = fontSizePx,
-                                onSessionFinished = onSessionFinished,
-                                onFontSizeChanged = { newSize ->
-                                    TerminalSessionService.globalSessionList[tab.id]?.let { info ->
-                                        TerminalSessionService.globalSessionList[tab.id] = info.copy(fontSizePx = newSize)
-                                    }
-                                },
-                            )
-                            val session: TerminalSession =
-                                binder.getSession(tab.id) ?: binder.createSession(
-                                    containerName = containerName,
-                                    client = client,
-                                    containerUser = tab.user,
-                                    sessionId = tab.id,
+                            if (activity != null) {
+                                val client = TerminalBackEnd(
+                                    terminal = this,
+                                    activity = activity,
+                                    initialFontSizePx = fontSizePx,
+                                    onSessionFinished = onSessionFinished,
+                                    onFontSizeChanged = { newSize ->
+                                        TerminalSessionService.globalSessionList[tab.id]?.let { info ->
+                                            TerminalSessionService.globalSessionList[tab.id] = info.copy(fontSizePx = newSize)
+                                        }
+                                    },
                                 )
-                            session.updateTerminalSessionClient(client)
-                            attachSession(session)
-                            setTerminalViewClient(client)
-                        }
+                                val session: TerminalSession =
+                                    binder.getSession(tab.id) ?: binder.createSession(
+                                        containerName = containerName,
+                                        client = client,
+                                        containerUser = tab.user,
+                                        sessionId = tab.id,
+                                    )
+                                session.updateTerminalSessionClient(client)
+                                attachSession(session)
+                                setTerminalViewClient(client)
+                                backEnd = client
+                            }
 
-                        post {
-                            requestFocus()
-                            (mClient as? TerminalBackEnd)?.activate12KeyInputMethodIfNeeded()
-                            mEmulator?.mColors?.mCurrentColors?.apply {
-                                set(256, terminalForeground)
-                                set(258, terminalForeground)
-                                if (terminalDarkTheme) {
-                                    set(257, terminalBackground)
+                            post {
+                                requestFocus()
+                                (mClient as? TerminalBackEnd)?.activate12KeyInputMethodIfNeeded()
+                                mEmulator?.mColors?.mCurrentColors?.apply {
+                                    set(256, terminalForeground)
+                                    set(258, terminalForeground)
+                                    if (terminalDarkTheme) {
+                                        set(257, terminalBackground)
+                                    }
                                 }
                             }
                         }
-                    }
-                },
-                update = { tv ->
-                    if (isVisible) {
-                        // Re-apply before setTextSize: termux renderer resets typeface on size changes
-                        tv.setTypeface(terminalTypeface)
-                        tv.setTextSize(fontSizePx)
-                        tv.onScreenUpdated()
-                        TerminalScreenState.terminalView = WeakReference(tv)
-                    }
-                },
-                modifier = Modifier.fillMaxWidth().weight(1f)
-            )
+                    },
+                    update = { tv ->
+                        if (isVisible) {
+                            // Re-apply before setTextSize: termux renderer resets typeface on size changes
+                            tv.setTypeface(terminalTypeface)
+                            tv.setTextSize(fontSizePx)
+                            tv.onScreenUpdated()
+                            TerminalScreenState.terminalView = WeakReference(tv)
+                        }
+                    },
+                    modifier = Modifier.fillMaxSize()
+                )
+
+                if (!tapOpensKeyboard) {
+                    KeyboardToggleButton(
+                        darkTheme = terminalDarkTheme,
+                        onToggle = { imeVisible ->
+                            if (imeVisible) backEnd?.hideSoftInput() else backEnd?.showSoftInput()
+                        },
+                        modifier = Modifier
+                            .align(if (keyboardButtonLeft) Alignment.BottomStart else Alignment.BottomEnd)
+                            .padding(16.dp)
+                    )
+                }
+            }
 
             AndroidView(
                 factory = { ctx ->
@@ -485,6 +512,47 @@ private fun TerminalTabView(
     }
 }
 
+/**
+ * Manual keyboard control for when taps are handed to the terminal instead. It
+ * toggles, so the same button also puts the keyboard away.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun KeyboardToggleButton(
+    darkTheme: Boolean,
+    onToggle: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val context = LocalContext.current
+    val imeVisible = WindowInsets.isImeVisible
+    // Literals for the same reason virtualKeysBackground above uses them, and the
+    // same decided exception in DESIGN.md: this sits on the terminal's own black,
+    // so it has to read dark even when the app itself is in the light theme.
+    val fill = if (darkTheme) Color(0xFF1A1A1E) else MaterialTheme.colorScheme.surfaceContainerHighest
+    val accent = if (darkTheme) Color.White else MaterialTheme.colorScheme.onSurface
+    val edge = if (darkTheme) Color.White.copy(alpha = 0.15f)
+               else MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.35f)
+
+    Surface(
+        onClick = { onToggle(imeVisible) },
+        modifier = modifier.size(56.dp),
+        shape = RoundedCornerShape(16.dp),
+        // Slightly transparent so it never fully hides a line of output under it
+        color = fill.copy(alpha = 0.9f),
+        border = BorderStroke(1.dp, edge),
+        tonalElevation = 0.dp
+    ) {
+        Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+            Icon(
+                imageVector = if (imeVisible) Icons.Default.KeyboardHide else Icons.Default.Keyboard,
+                contentDescription = context.getString(R.string.terminal_toggle_keyboard),
+                tint = accent,
+                modifier = Modifier.size(28.dp)
+            )
+        }
+    }
+}
+
 @Composable
 private fun UserPickerDialog(
     users: List<String>,

Android/app/src/main/java/com/droidspaces/app/ui/screen/TerminalAppearanceScreen.kt

@@ -1,5 +1,6 @@
 package com.droidspaces.app.ui.screen
 
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -26,7 +27,9 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.filled.ChevronRight
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.automirrored.filled.KeyboardBackspace
 import androidx.compose.material.icons.filled.FontDownload
+import androidx.compose.material.icons.filled.Keyboard
 import androidx.compose.material.icons.filled.FormatSize
 import androidx.compose.material.icons.filled.Terminal
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -89,6 +92,8 @@ fun TerminalAppearanceScreen(onBack: () -> Unit) {
     var terminalDarkTheme by remember { mutableStateOf(prefsManager.terminalDarkTheme) }
     var fontSizePx by remember { mutableFloatStateOf(prefsManager.terminalFontSizePx.toFloat()) }
     var confirmClose by remember { mutableStateOf(prefsManager.terminalConfirmClose) }
+    var tapKeyboard by remember { mutableStateOf(prefsManager.terminalTapKeyboard) }
+    var keyboardLeft by remember { mutableStateOf(prefsManager.terminalKeyboardLeft) }
 
     var selectedFont by remember { mutableStateOf(prefsManager.terminalFontFile) }
     var showFontDialog by remember { mutableStateOf(false) }
@@ -296,17 +301,46 @@ fun TerminalAppearanceScreen(onBack: () -> Unit) {
                 color = cardColor,
                 border = cardBorder
             ) {
-                // Opt-in: guards the X on a terminal tab against fat fingers
-                SwitchItem(
-                    icon = Icons.Default.Close,
-                    title = context.getString(R.string.terminal_confirm_close),
-                    summary = context.getString(R.string.terminal_confirm_close_description),
-                    checked = confirmClose,
-                    onCheckedChange = { checked ->
-                        prefsManager.terminalConfirmClose = checked
-                        confirmClose = checked
+                Column {
+                    // Opt-in: guards the X on a terminal tab against fat fingers
+                    SwitchItem(
+                        icon = Icons.Default.Close,
+                        title = context.getString(R.string.terminal_confirm_close),
+                        summary = context.getString(R.string.terminal_confirm_close_description),
+                        checked = confirmClose,
+                        onCheckedChange = { checked ->
+                            prefsManager.terminalConfirmClose = checked
+                            confirmClose = checked
+                        }
+                    )
+
+                    HorizontalDivider(modifier = Modifier.padding(horizontal = 16.dp), color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.3f))
+
+                    SwitchItem(
+                        icon = Icons.Default.Keyboard,
+                        title = context.getString(R.string.terminal_tap_keyboard),
+                        summary = context.getString(R.string.terminal_tap_keyboard_description),
+                        checked = tapKeyboard,
+                        onCheckedChange = { checked ->
+                            prefsManager.terminalTapKeyboard = checked
+                            tapKeyboard = checked
+                        }
+                    )
+
+                    // Nothing to place while taps still open the keyboard
+                    AnimatedVisibility(visible = !tapKeyboard) {
+                        SwitchItem(
+                            icon = Icons.AutoMirrored.Filled.KeyboardBackspace,
+                            title = context.getString(R.string.terminal_keyboard_left),
+                            summary = context.getString(R.string.terminal_keyboard_left_description),
+                            checked = keyboardLeft,
+                            onCheckedChange = { checked ->
+                                prefsManager.terminalKeyboardLeft = checked
+                                keyboardLeft = checked
+                            }
+                        )
                     }
-                )
+                }
             }
 
             Spacer(modifier = Modifier.height(12.dp))

Android/app/src/main/java/com/droidspaces/app/ui/terminal/TerminalBackEnd.kt

@@ -9,6 +9,7 @@ import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.inputmethod.InputMethodManager
 import com.droidspaces.app.ui.terminal.virtualkeys.SpecialButton
+import com.droidspaces.app.util.PreferencesManager
 import com.termux.terminal.TerminalEmulator
 import com.termux.terminal.TerminalSession
 import com.termux.terminal.TerminalSessionClient
@@ -82,6 +83,9 @@ class TerminalBackEnd(
     }
 
     override fun onSingleTapUp(e: MotionEvent) {
+        // Read live: the setting is changed on another screen while this object
+        // is alive, so a constructor copy would go stale.
+        if (!PreferencesManager.getInstance(activity).terminalTapKeyboard) return
         val keyboard = terminal.resources.configuration.keyboard
         if (keyboard == Configuration.KEYBOARD_NOKEYS ||
             keyboard == Configuration.KEYBOARD_12KEY) {
@@ -131,9 +135,14 @@ class TerminalBackEnd(
         if (terminal.mEmulator != null) terminal.setTerminalCursorBlinkerState(true, true)
     }
 
-    private fun showSoftInput() {
+    internal fun showSoftInput() {
         terminal.requestFocus()
         val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
         imm.showSoftInput(terminal, InputMethodManager.SHOW_IMPLICIT)
     }
+
+    internal fun hideSoftInput() {
+        val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+        imm.hideSoftInputFromWindow(terminal.windowToken, 0)
+    }
 }

Android/app/src/main/java/com/droidspaces/app/util/Constants.kt

@@ -46,6 +46,8 @@ object Constants {
     const val KEY_TERMINAL_FONT_SIZE = "terminal_font_size_px"
     const val KEY_TERMINAL_FONT_FILE = "terminal_font_file"
     const val KEY_TERMINAL_CONFIRM_CLOSE = "terminal_confirm_close"
+    const val KEY_TERMINAL_TAP_KEYBOARD = "terminal_tap_keyboard"
+    const val KEY_TERMINAL_KEYBOARD_LEFT = "terminal_keyboard_button_left"
     const val KEY_APP_LOCALE = "app_locale"
     const val KEY_BACKEND_MODE = "backend_mode"
     const val KEY_DAEMON_MODE_ENABLED = "daemon_mode_enabled"

Android/app/src/main/java/com/droidspaces/app/util/PreferencesManager.kt

@@ -168,6 +168,23 @@ class PreferencesManager private constructor(context: Context) {
             prefs.edit().putBoolean(KEY_TERMINAL_CONFIRM_CLOSE, value).apply()
         }
 
+    // On by default so nothing changes on upgrade. Off hands a tap to whatever
+    // runs in the terminal, which is what an editor wants, and the keyboard
+    // comes from the button on the terminal instead.
+    var terminalTapKeyboard: Boolean
+        get() = prefs.getBoolean(KEY_TERMINAL_TAP_KEYBOARD, true)
+        set(value) {
+            prefs.edit().putBoolean(KEY_TERMINAL_TAP_KEYBOARD, value).apply()
+        }
+
+    // Which bottom corner that button sits in. False is the right, for the
+    // right-handed majority.
+    var terminalKeyboardLeft: Boolean
+        get() = prefs.getBoolean(KEY_TERMINAL_KEYBOARD_LEFT, false)
+        set(value) {
+            prefs.edit().putBoolean(KEY_TERMINAL_KEYBOARD_LEFT, value).apply()
+        }
+
     var isDaemonModeEnabled: Boolean
         get() = prefs.getBoolean(KEY_DAEMON_MODE_ENABLED, false)
         set(value) {
@@ -413,6 +430,8 @@ class PreferencesManager private constructor(context: Context) {
         private const val KEY_TERMINAL_FONT_SIZE = Constants.KEY_TERMINAL_FONT_SIZE
         private const val KEY_TERMINAL_FONT_FILE = Constants.KEY_TERMINAL_FONT_FILE
         private const val KEY_TERMINAL_CONFIRM_CLOSE = Constants.KEY_TERMINAL_CONFIRM_CLOSE
+        private const val KEY_TERMINAL_TAP_KEYBOARD = Constants.KEY_TERMINAL_TAP_KEYBOARD
+        private const val KEY_TERMINAL_KEYBOARD_LEFT = Constants.KEY_TERMINAL_KEYBOARD_LEFT
         const val KEY_THEME_PALETTE = Constants.KEY_THEME_PALETTE
         const val KEY_DAEMON_MODE_ENABLED = Constants.KEY_DAEMON_MODE_ENABLED
         const val KEY_SYMLINK_ENABLED = Constants.KEY_SYMLINK_ENABLED