Skip to content

A rootless Android app that boots Alpine Linux: run containers (Podman/Docker/LXC) and GUI desktop apps.

Add persistent VM storage, port forwarding, and Termux terminal integration

ExTv35c2321cfcf6
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 8d4375b..d3a9396 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -116,6 +116,10 @@ dependencies {
// DataStore (app settings)
implementation(libs.androidx.datastore.preferences)
+ // Termux terminal emulator & view
+ implementation(libs.termux.terminal.emulator)
+ implementation(libs.termux.terminal.view)
+
// Testing
testImplementation(libs.junit)
androidTestImplementation(libs.androidx.junit)
diff --git a/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt b/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt
new file mode 100644
index 0000000..1078ea4
--- /dev/null
+++ b/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt
@@ -0,0 +1,83 @@
+/*
+ * Podroid - Rootless Podman for Android
+ * Copyright (C) 2024 Podroid contributors
+ *
+ * Persists port forwarding rules in DataStore.
+ */
+package com.excp.podroid.data.repository
+
+import android.content.Context
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringSetPreferencesKey
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * A single port forwarding rule.
+ * @param hostPort Port on the Android device
+ * @param guestPort Port inside the VM
+ * @param protocol "tcp" or "udp"
+ */
+data class PortForwardRule(
+ val hostPort: Int,
+ val guestPort: Int,
+ val protocol: String = "tcp",
+) {
+ fun serialize(): String = "$protocol:$hostPort:$guestPort"
+
+ companion object {
+ fun deserialize(s: String): PortForwardRule? {
+ val parts = s.split(":")
+ if (parts.size != 3) return null
+ val proto = parts[0]
+ val host = parts[1].toIntOrNull() ?: return null
+ val guest = parts[2].toIntOrNull() ?: return null
+ return PortForwardRule(host, guest, proto)
+ }
+ }
+}
+
+@Singleton
+class PortForwardRepository @Inject constructor(
+ @ApplicationContext private val context: Context,
+) {
+ companion object {
+ private val KEY_PORT_FORWARDS = stringSetPreferencesKey("port_forwards")
+ }
+
+ val rules: Flow<List<PortForwardRule>> = context.dataStore.data
+ .map { prefs ->
+ prefs[KEY_PORT_FORWARDS]
+ ?.mapNotNull { PortForwardRule.deserialize(it) }
+ ?: emptyList()
+ }
+
+ suspend fun addRule(rule: PortForwardRule) {
+ context.dataStore.edit { prefs ->
+ val current = prefs[KEY_PORT_FORWARDS]?.toMutableSet() ?: mutableSetOf()
+ current.add(rule.serialize())
+ prefs[KEY_PORT_FORWARDS] = current
+ }
+ }
+
+ suspend fun removeRule(rule: PortForwardRule) {
+ context.dataStore.edit { prefs ->
+ val current = prefs[KEY_PORT_FORWARDS]?.toMutableSet() ?: return@edit
+ current.remove(rule.serialize())
+ prefs[KEY_PORT_FORWARDS] = current
+ }
+ }
+
+ suspend fun getRulesSnapshot(): List<PortForwardRule> {
+ var result: List<PortForwardRule> = emptyList()
+ context.dataStore.edit { prefs ->
+ result = prefs[KEY_PORT_FORWARDS]
+ ?.mapNotNull { PortForwardRule.deserialize(it) }
+ ?: emptyList()
+ }
+ return result
+ }
+}
diff --git a/app/src/main/java/com/excp/podroid/data/repository/SettingsRepository.kt b/app/src/main/java/com/excp/podroid/data/repository/SettingsRepository.kt
index 3a3e593..14a5412 100644
--- a/app/src/main/java/com/excp/podroid/data/repository/SettingsRepository.kt
+++ b/app/src/main/java/com/excp/podroid/data/repository/SettingsRepository.kt
@@ -18,7 +18,7 @@ import kotlinx.coroutines.flow.map
import javax.inject.Inject
import javax.inject.Singleton
-private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
+internal val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
@Singleton
class SettingsRepository @Inject constructor(
diff --git a/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt b/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt
index 0e25ab5..ad04d76 100644
--- a/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt
+++ b/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt
@@ -3,12 +3,14 @@
* Copyright (C) 2024 Podroid contributors
*
* QEMU configuration for Podroid (Podman on Android).
- * Uses initrd approach for fast, stateless Alpine Linux VM.
+ * Uses initrd approach with persistent overlay for Alpine Linux VM.
*/
package com.excp.podroid.engine
import android.content.Context
import android.util.Log
+import com.excp.podroid.data.repository.PortForwardRepository
+import com.excp.podroid.data.repository.PortForwardRule
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
@@ -22,21 +24,38 @@ import javax.inject.Singleton
@Singleton
class PodroidQemu @Inject constructor(
@ApplicationContext private val context: Context,
+ private val portForwardRepository: PortForwardRepository,
) {
private val _state = MutableStateFlow<VmState>(VmState.Idle)
val state: StateFlow<VmState> = _state.asStateFlow()
- /** Accumulated serial console output */
+ /** Accumulated serial console output (for fallback / logging) */
private val _consoleText = MutableStateFlow("")
val consoleText: StateFlow<String> = _consoleText.asStateFlow()
- private var process: Process? = null
+ var process: Process? = null
+ private set
/** Stream to write to VM serial console (QEMU stdin) */
var consoleOutput: OutputStream? = null
private set
+ /**
+ * Callback for raw console output bytes. When set, each chunk read from
+ * QEMU stdout is forwarded here (used by QemuTerminalSession).
+ */
+ var onConsoleOutput: ((ByteArray, Int) -> Unit)? = null
+
+ /** QMP client for runtime VM management */
+ val qmpClient: QmpClient by lazy {
+ QmpClient("${context.filesDir.absolutePath}/qmp.sock")
+ }
+
fun start() {
+ start(emptyList())
+ }
+
+ fun start(portForwards: List<PortForwardRule>) {
if (_state.value is VmState.Starting || _state.value is VmState.Running) {
Log.w(TAG, "start() called while VM is in state ${_state.value}, ignoring")
return
@@ -51,7 +70,7 @@ class PodroidQemu @Inject constructor(
_consoleText.value = ""
try {
- val cmd = buildCommand(qemuExe)
+ val cmd = buildCommand(qemuExe, portForwards)
Log.d(TAG, "Launching: ${cmd.joinToString(" ")}")
val nativeDir = context.applicationInfo.nativeLibraryDir
@@ -66,7 +85,7 @@ class PodroidQemu @Inject constructor(
consoleOutput = process!!.outputStream
Log.d(TAG, "Process started")
- // Read serial console output (stdout), accumulate in StateFlow, and write to log file
+ // Read serial console output (stdout), log to file, and forward to listeners
val logFile = File(context.filesDir, "console.log")
logFile.delete()
Thread({
@@ -77,10 +96,12 @@ class PodroidQemu @Inject constructor(
while (true) {
val n = input.read(buf)
if (n < 0) break
- val text = String(buf, 0, n)
- _consoleText.value += text
- logOut.write(buf, 0, n)
+ val chunk = buf.copyOf(n)
+ _consoleText.value += String(chunk)
+ logOut.write(chunk, 0, n)
logOut.flush()
+ // Forward to terminal session if attached
+ onConsoleOutput?.invoke(chunk, n)
}
logOut.close()
} catch (e: Exception) {
@@ -136,17 +157,29 @@ class PodroidQemu @Inject constructor(
}
fun stop() {
+ // Send sync via serial console for graceful shutdown
+ try {
+ consoleOutput?.let { out ->
+ out.write("sync\n".toByteArray())
+ out.flush()
+ Thread.sleep(500)
+ }
+ } catch (e: Exception) {
+ Log.d(TAG, "Failed to send sync: ${e.message}")
+ }
+
process?.destroy()
- try { Thread.sleep(500) } catch (_: Exception) {}
+ try { Thread.sleep(1000) } catch (_: Exception) {}
if (process?.isAlive == true) {
process?.destroyForcibly()
}
process = null
consoleOutput = null
+ onConsoleOutput = null
_state.value = VmState.Stopped
}
- private fun buildCommand(qemuExe: File): List<String> {
+ private fun buildCommand(qemuExe: File, portForwards: List<PortForwardRule>): List<String> {
val args = mutableListOf<String>()
// Machine & CPU
@@ -174,15 +207,21 @@ class PodroidQemu @Inject constructor(
Log.w(TAG, "Initrd not found!")
}
- // Storage (Persistent Containers)
+ // Storage (Persistent)
val storagePath = File(context.filesDir, "storage.img")
if (storagePath.exists()) {
args += "-device"; args += "virtio-blk-pci,drive=drive1"
args += "-drive"; args += "file=${storagePath.absolutePath},if=none,id=drive1,format=raw"
}
- // Network — match Termux QEMU networking pattern (simple user netdev)
- args += "-netdev"; args += "user,id=net0"
+ // Network with port forwarding
+ val netdevArg = buildString {
+ append("user,id=net0")
+ for (rule in portForwards) {
+ append(",hostfwd=${rule.protocol}::${rule.hostPort}-:${rule.guestPort}")
+ }
+ }
+ args += "-netdev"; args += netdevArg
args += "-device"; args += "virtio-net,netdev=net0"
// Serial console via stdio — bidirectional through process stdin/stdout
@@ -191,7 +230,7 @@ class PodroidQemu @Inject constructor(
// Display (headless)
args += "-display"; args += "none"
- // QMP socket for management
+ // QMP socket for management (port forwarding, VM control)
args += "-qmp"
args += "unix:${context.filesDir.absolutePath}/qmp.sock,server,nowait"
diff --git a/app/src/main/java/com/excp/podroid/engine/QmpClient.kt b/app/src/main/java/com/excp/podroid/engine/QmpClient.kt
new file mode 100644
index 0000000..a647b7f
--- /dev/null
+++ b/app/src/main/java/com/excp/podroid/engine/QmpClient.kt
@@ -0,0 +1,94 @@
+/*
+ * Podroid - Rootless Podman for Android
+ * Copyright (C) 2024 Podroid contributors
+ *
+ * Minimal QMP (QEMU Machine Protocol) client for runtime VM management.
+ * Used for adding/removing port forwards while the VM is running.
+ */
+package com.excp.podroid.engine
+
+import android.net.LocalSocket
+import android.net.LocalSocketAddress
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+
+class QmpClient(private val socketPath: String) {
+
+ companion object {
+ private const val TAG = "QmpClient"
+ }
+
+ /**
+ * Execute a QMP command and return the response.
+ * Each call opens a new connection (QMP is stateless per-connection after capabilities).
+ */
+ suspend fun execute(command: String, arguments: JSONObject? = null): Result<JSONObject> =
+ withContext(Dispatchers.IO) {
+ try {
+ val socket = LocalSocket()
+ socket.connect(
+ LocalSocketAddress(socketPath, LocalSocketAddress.Namespace.FILESYSTEM)
+ )
+
+ val reader = BufferedReader(InputStreamReader(socket.inputStream))
+ val writer = OutputStreamWriter(socket.outputStream)
+
+ // Read QMP greeting
+ val greeting = reader.readLine()
+ Log.d(TAG, "QMP greeting: $greeting")
+
+ // Send qmp_capabilities to enter command mode
+ writer.write("{\"execute\":\"qmp_capabilities\"}\n")
+ writer.flush()
+ val capResponse = reader.readLine()
+ Log.d(TAG, "Capabilities response: $capResponse")
+
+ // Send the actual command
+ val cmd = JSONObject().apply {
+ put("execute", command)
+ if (arguments != null) put("arguments", arguments)
+ }
+ writer.write(cmd.toString() + "\n")
+ writer.flush()
+
+ val response = reader.readLine()
+ Log.d(TAG, "Command response: $response")
+
+ socket.close()
+ Result.success(JSONObject(response ?: "{}"))
+ } catch (e: Exception) {
+ Log.e(TAG, "QMP command failed: $command", e)
+ Result.failure(e)
+ }
+ }
+
+ /**
+ * Add a port forward rule at runtime via QEMU monitor.
+ * @param hostPort Port on the Android host
+ * @param guestPort Port inside the VM
+ * @param protocol "tcp" or "udp"
+ */
+ suspend fun addPortForward(hostPort: Int, guestPort: Int, protocol: String = "tcp"): Result<JSONObject> {
+ val monitorCmd = "hostfwd_add net0 ${protocol}::${hostPort}-:${guestPort}"
+ return execute(
+ "human-monitor-command",
+ JSONObject().put("command-line", monitorCmd)
+ )
+ }
+
+ /**
+ * Remove a port forward rule at runtime via QEMU monitor.
+ */
+ suspend fun removePortForward(hostPort: Int, protocol: String = "tcp"): Result<JSONObject> {
+ val monitorCmd = "hostfwd_remove net0 ${protocol}::${hostPort}"
+ return execute(
+ "human-monitor-command",
+ JSONObject().put("command-line", monitorCmd)
+ )
+ }
+}
diff --git a/app/src/main/java/com/excp/podroid/service/PodroidService.kt b/app/src/main/java/com/excp/podroid/service/PodroidService.kt
index dd9e67f..40808e9 100644
--- a/app/src/main/java/com/excp/podroid/service/PodroidService.kt
+++ b/app/src/main/java/com/excp/podroid/service/PodroidService.kt
@@ -18,6 +18,7 @@ import android.util.Log
import androidx.core.app.NotificationCompat
import com.excp.podroid.MainActivity
import com.excp.podroid.R
+import com.excp.podroid.data.repository.PortForwardRepository
import com.excp.podroid.engine.PodroidQemu
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.*
@@ -27,6 +28,7 @@ import javax.inject.Inject
class PodroidService : Service() {
@Inject lateinit var podroidQemu: PodroidQemu
+ @Inject lateinit var portForwardRepository: PortForwardRepository
private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
private var launchJob: Job? = null
@@ -63,7 +65,8 @@ class PodroidService : Service() {
withContext(Dispatchers.IO) {
try {
- podroidQemu.start()
+ val rules = portForwardRepository.getRulesSnapshot()
+ podroidQemu.start(rules)
} catch (e: Exception) {
Log.e(TAG, "QEMU failed to start", e)
}
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
index 00df451..c4683cf 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
@@ -6,6 +6,7 @@
*/
package com.excp.podroid.ui.screens.settings
+import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
@@ -13,26 +14,42 @@ 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.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
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.Delete
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilledTonalButton
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
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.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.excp.podroid.data.repository.PortForwardRule
+import com.excp.podroid.engine.VmState
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -41,6 +58,9 @@ fun SettingsScreen(
viewModel: SettingsViewModel = hiltViewModel(),
) {
val darkTheme by viewModel.darkTheme.collectAsStateWithLifecycle(false)
+ val portForwardRules by viewModel.portForwardRules.collectAsStateWithLifecycle()
+ val vmState by viewModel.vmState.collectAsStateWithLifecycle()
+ var showAddDialog by remember { mutableStateOf(false) }
Scaffold(
topBar = {
@@ -74,6 +94,55 @@ fun SettingsScreen(
Spacer(Modifier.height(16.dp))
+ // Port Forwarding Section
+ SettingsSectionHeader("Port Forwarding")
+
+ Text(
+ text = "Forward ports from the VM to your Android device. " +
+ "Changes apply immediately if the VM is running.",
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ modifier = Modifier.padding(bottom = 8.dp),
+ )
+
+ if (portForwardRules.isEmpty()) {
+ Text(
+ text = "No port forwards configured",
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ modifier = Modifier.padding(vertical = 8.dp),
+ )
+ } else {
+ portForwardRules.forEach { rule ->
+ PortForwardRuleRow(
+ rule = rule,
+ onDelete = { viewModel.removePortForward(rule) },
+ )
+ }
+ }
+
+ Spacer(Modifier.height(8.dp))
+
+ FilledTonalButton(
+ onClick = { showAddDialog = true },
+ modifier = Modifier.fillMaxWidth(),
+ ) {
+ Icon(Icons.Default.Add, contentDescription = null)
+ Spacer(Modifier.width(8.dp))
+ Text("Add Port Forward")
+ }
+
+ if (vmState is VmState.Running) {
+ Text(
+ text = "VM is running - changes apply immediately via QMP",
+ style = MaterialTheme.typography.labelSmall,
+ color = MaterialTheme.colorScheme.primary,
+ modifier = Modifier.padding(top = 4.dp),
+ )
+ }
+
+ Spacer(Modifier.height(16.dp))
+
SettingsSectionHeader("About")
SettingsInfoRow("Version", "1.0.0")
@@ -81,11 +150,122 @@ fun SettingsScreen(
SettingsInfoRow("Guest", "AArch64 (ARM64)")
SettingsInfoRow("Distro", "Alpine Linux")
SettingsInfoRow("Container", "Podman")
- SettingsInfoRow("Terminal", "ttyd")
+ SettingsInfoRow("Storage", "Persistent (overlay)")
Spacer(Modifier.height(32.dp))
}
}
+
+ if (showAddDialog) {
+ AddPortForwardDialog(
+ onDismiss = { showAddDialog = false },
+ onAdd = { hostPort, guestPort, protocol ->
+ viewModel.addPortForward(hostPort, guestPort, protocol)
+ showAddDialog = false
+ },
+ )
+ }
+}
+
+@Composable
+private fun PortForwardRuleRow(
+ rule: PortForwardRule,
+ onDelete: () -> Unit,
+) {
+ Card(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(vertical = 4.dp),
+ colors = CardDefaults.cardColors(
+ containerColor = MaterialTheme.colorScheme.surfaceVariant,
+ ),
+ ) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 16.dp, vertical = 8.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ Column(modifier = Modifier.weight(1f)) {
+ Text(
+ text = "Host :${rule.hostPort} -> VM :${rule.guestPort}",
+ style = MaterialTheme.typography.bodyMedium,
+ )
+ Text(
+ text = rule.protocol.uppercase(),
+ style = MaterialTheme.typography.labelSmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ }
+ IconButton(onClick = onDelete) {
+ Icon(
+ Icons.Default.Delete,
+ contentDescription = "Remove",
+ tint = MaterialTheme.colorScheme.error,
+ )
+ }
+ }
+ }
+}
+
+@Composable
+private fun AddPortForwardDialog(
+ onDismiss: () -> Unit,
+ onAdd: (hostPort: Int, guestPort: Int, protocol: String) -> Unit,
+) {
+ var hostPort by remember { mutableStateOf("") }
+ var guestPort by remember { mutableStateOf("") }
+ var error by remember { mutableStateOf<String?>(null) }
+
+ AlertDialog(
+ onDismissRequest = onDismiss,
+ title = { Text("Add Port Forward") },
+ text = {
+ Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+ OutlinedTextField(
+ value = hostPort,
+ onValueChange = { hostPort = it; error = null },
+ label = { Text("Host port (Android)") },
+ keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+ singleLine = true,
+ modifier = Modifier.fillMaxWidth(),
+ )
+ OutlinedTextField(
+ value = guestPort,
+ onValueChange = { guestPort = it; error = null },
+ label = { Text("VM port") },
+ keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+ singleLine = true,
+ modifier = Modifier.fillMaxWidth(),
+ )
+ if (error != null) {
+ Text(
+ text = error!!,
+ color = MaterialTheme.colorScheme.error,
+ style = MaterialTheme.typography.bodySmall,
+ )
+ }
+ }
+ },
+ confirmButton = {
+ TextButton(onClick = {
+ val hp = hostPort.toIntOrNull()
+ val gp = guestPort.toIntOrNull()
+ if (hp == null || gp == null || hp !in 1..65535 || gp !in 1..65535) {
+ error = "Enter valid ports (1-65535)"
+ return@TextButton
+ }
+ onAdd(hp, gp, "tcp")
+ }) {
+ Text("Add")
+ }
+ },
+ dismissButton = {
+ TextButton(onClick = onDismiss) {
+ Text("Cancel")
+ }
+ },
+ )
}
@Composable
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
index 5e8141c..682863b 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
@@ -8,17 +8,56 @@ package com.excp.podroid.ui.screens.settings
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
+import com.excp.podroid.data.repository.PortForwardRepository
+import com.excp.podroid.data.repository.PortForwardRule
import com.excp.podroid.data.repository.SettingsRepository
+import com.excp.podroid.engine.PodroidQemu
+import com.excp.podroid.engine.VmState
import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class SettingsViewModel @Inject constructor(
- private val settingsRepo: SettingsRepository,
+ private val settingsRepository: SettingsRepository,
+ private val portForwardRepository: PortForwardRepository,
+ private val podroidQemu: PodroidQemu,
) : ViewModel() {
- val darkTheme = settingsRepo.darkTheme
+ val darkTheme: Flow<Boolean> = settingsRepository.darkTheme
- fun setDarkTheme(v: Boolean) = viewModelScope.launch { settingsRepo.setDarkTheme(v) }
+ val portForwardRules: StateFlow<List<PortForwardRule>> = portForwardRepository.rules
+ .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
+
+ val vmState: StateFlow<VmState> = podroidQemu.state
+ .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), VmState.Idle)
+
+ fun setDarkTheme(value: Boolean) {
+ viewModelScope.launch { settingsRepository.setDarkTheme(value) }
+ }
+
+ fun addPortForward(hostPort: Int, guestPort: Int, protocol: String = "tcp") {
+ val rule = PortForwardRule(hostPort, guestPort, protocol)
+ viewModelScope.launch {
+ portForwardRepository.addRule(rule)
+ // If VM is running, apply immediately via QMP
+ if (podroidQemu.state.value is VmState.Running) {
+ podroidQemu.qmpClient.addPortForward(hostPort, guestPort, protocol)
+ }
+ }
+ }
+
+ fun removePortForward(rule: PortForwardRule) {
+ viewModelScope.launch {
+ portForwardRepository.removeRule(rule)
+ // If VM is running, remove immediately via QMP
+ if (podroidQemu.state.value is VmState.Running) {
+ podroidQemu.qmpClient.removePortForward(rule.hostPort, rule.protocol)
+ }
+ }
+ }
}
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalScreen.kt b/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalScreen.kt
index e34097d..ddab8c2 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalScreen.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalScreen.kt
@@ -2,57 +2,58 @@
* Podroid - Rootless Podman for Android
* Copyright (C) 2024 Podroid contributors
*
- * Serial console terminal screen.
+ * Terminal screen using Termux TerminalView for full VT100/xterm emulation.
*/
package com.excp.podroid.ui.screens.terminal
import android.app.Activity
+import android.graphics.Typeface
import android.view.WindowManager
import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+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.WindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.navigationBars
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.ArrowBack
-import androidx.compose.material.icons.filled.Send
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
+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.draw.clip
import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.font.FontWeight
+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.lifecycle.viewmodel.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.excp.podroid.engine.VmState
+import com.termux.view.TerminalView
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -60,29 +61,19 @@ fun TerminalScreen(
onNavigateBack: () -> Unit,
viewModel: TerminalViewModel = hiltViewModel(),
) {
- val terminalText by viewModel.terminalText.collectAsStateWithLifecycle()
- val scrollState = rememberScrollState()
- var inputText by remember { mutableStateOf("") }
-
- // Detect keyboard height to trigger re-scroll
- val imeHeight = WindowInsets.ime.getBottom(LocalDensity.current)
+ val context = LocalContext.current
+ val vmState by viewModel.vmState.collectAsState()
- val sendCommand = {
- viewModel.sendInput(inputText + "\n")
- inputText = ""
- }
+ val isVmRunning = vmState is VmState.Running
- // Ensure soft input resizes the layout
- val context = LocalContext.current
+ // Keep screen on and adjust for soft keyboard
DisposableEffect(Unit) {
val activity = context as? Activity
+ activity?.window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
activity?.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
- onDispose {}
- }
-
- // Auto-scroll to bottom when text changes OR keyboard appears/disappears
- LaunchedEffect(terminalText, imeHeight) {
- scrollState.animateScrollTo(scrollState.maxValue)
+ onDispose {
+ activity?.window?.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+ }
}
Column(
@@ -94,65 +85,151 @@ fun TerminalScreen(
) {
// Top bar
TopAppBar(
- title = { Text("Terminal") },
+ title = { Text("Terminal", color = Color.White) },
navigationIcon = {
IconButton(onClick = onNavigateBack) {
- Icon(Icons.Default.ArrowBack, contentDescription = "Back")
+ Icon(
+ Icons.AutoMirrored.Filled.ArrowBack,
+ contentDescription = "Back",
+ tint = Color.White,
+ )
}
},
+ colors = TopAppBarDefaults.topAppBarColors(
+ containerColor = Color(0xFF1A1A1A),
+ ),
)
- // Terminal output area
- Box(
- modifier = Modifier
- .weight(1f)
- .fillMaxWidth()
- .background(Color.Black)
- .verticalScroll(scrollState)
- .padding(8.dp)
- ) {
- Text(
- text = if (terminalText.isEmpty()) "Waiting for VM to boot..." else terminalText,
- color = if (terminalText.isEmpty()) Color.Gray else Color.Green,
- fontFamily = FontFamily.Monospace,
- fontSize = 12.sp,
- lineHeight = 16.sp,
- )
- }
+ // Termux TerminalView
+ if (!isVmRunning) {
+ Box(
+ modifier = Modifier
+ .weight(1f)
+ .fillMaxWidth(),
+ contentAlignment = Alignment.Center
+ ) {
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ Text(
+ text = "VM Not Running",
+ color = Color.Red,
+ fontSize = 18.sp,
+ fontWeight = FontWeight.Bold
+ )
+ Text(
+ text = "Start the VM from Home screen first",
+ color = Color.Gray,
+ fontSize = 14.sp,
+ modifier = Modifier.padding(top = 8.dp)
+ )
+ }
+ }
+ } else {
+ AndroidView(
+ factory = { ctx ->
+ TerminalView(ctx, null).apply {
+ setTextSize(24)
+ setTypeface(Typeface.MONOSPACE)
+ keepScreenOn = true
+ isFocusable = true
+ isFocusableInTouchMode = true
+
+ // Create session wired to QEMU I/O (no host binaries)
+ viewModel.createSession()
+ viewModel.attachView(this)
+ setTerminalViewClient(viewModel.viewClient)
+
+ // Set session and emulator directly on the view
+ // (avoid attachSession which calls JNI.setPtyWindowSize)
+ val session = viewModel.session!!
+ mTermSession = session
+ mEmulator = session.emulator
+
+ // Request focus so keyboard works
+ requestFocus()
- // Input bar
- Row(
- modifier = Modifier
- .fillMaxWidth()
- .background(Color(0xFF1A1A1A))
- .padding(8.dp),
- verticalAlignment = Alignment.CenterVertically,
- ) {
- BasicTextField(
- value = inputText,
- onValueChange = { inputText = it },
+ // Resize emulator to match view after layout
+ post {
+ if (width > 0 && height > 0 && mRenderer != null) {
+ try {
+ val rendererClass = mRenderer.javaClass
+ val fw = rendererClass.getDeclaredField("mFontWidth").apply { isAccessible = true }.getFloat(mRenderer)
+ val fls = rendererClass.getDeclaredField("mFontLineSpacing").apply { isAccessible = true }.getInt(mRenderer)
+ val flsa = rendererClass.getDeclaredField("mFontLineSpacingAndAscent").apply { isAccessible = true }.getInt(mRenderer)
+ val cols = (width / fw).toInt().coerceAtLeast(4)
+ val rows = ((height - flsa) / fls).coerceAtLeast(4)
+ session.emulator?.resize(cols, rows)
+ onScreenUpdated()
+ } catch (_: Exception) {}
+ }
+ }
+ }
+ },
modifier = Modifier
.weight(1f)
- .height(40.dp)
- .background(Color(0xFF2A2A2A))
- .padding(horizontal = 12.dp, vertical = 8.dp),
- textStyle = TextStyle(
- color = Color.White,
- fontFamily = FontFamily.Monospace,
- fontSize = 14.sp,
- ),
- cursorBrush = SolidColor(Color.White),
- singleLine = true,
- keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),
- keyboardActions = KeyboardActions(onSend = { sendCommand() }),
+ .fillMaxWidth(),
)
- IconButton(onClick = { sendCommand() }) {
- Icon(
- Icons.Default.Send,
- contentDescription = "Send",
- tint = Color.White,
- )
- }
}
+
+ // Extra keys row
+ ExtraKeysRow(
+ onKey = { viewModel.sendExtraKey(it) },
+ ctrlActive = viewModel.extraCtrl,
+ altActive = viewModel.extraAlt,
+ )
}
}
+
+@Composable
+private fun ExtraKeysRow(
+ onKey: (String) -> Unit,
+ ctrlActive: Boolean,
+ altActive: Boolean,
+) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .background(Color(0xFF1A1A1A))
+ .horizontalScroll(rememberScrollState())
+ .padding(horizontal = 4.dp, vertical = 4.dp),
+ horizontalArrangement = Arrangement.spacedBy(3.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ ExtraKey("ESC", onKey)
+ ExtraKey("TAB", onKey)
+ ExtraKey("CTRL", onKey, active = ctrlActive)
+ ExtraKey("\u2190", onKey, sendKey = "LEFT") // ←
+ ExtraKey("\u2191", onKey, sendKey = "UP") // ↑
+ ExtraKey("\u2193", onKey, sendKey = "DOWN") // ↓
+ ExtraKey("\u2192", onKey, sendKey = "RIGHT") // →
+ ExtraKey("ALT", onKey, active = altActive)
+ ExtraKey("-", onKey)
+ ExtraKey("/", onKey)
+ ExtraKey("|", onKey)
+ ExtraKey("HOME", onKey)
+ ExtraKey("END", onKey)
+ ExtraKey("PGUP", onKey)
+ ExtraKey("PGDN", onKey)
+ }
+}
+
+@Composable
+private fun ExtraKey(
+ label: String,
+ onKey: (String) -> Unit,
+ sendKey: String = label,
+ active: Boolean = false,
+) {
+ Text(
+ text = label,
+ color = if (active) Color.Black else Color(0xFFCCCCCC),
+ fontSize = 12.sp,
+ fontWeight = FontWeight.Medium,
+ fontFamily = FontFamily.Monospace,
+ textAlign = TextAlign.Center,
+ modifier = Modifier
+ .clip(RoundedCornerShape(4.dp))
+ .background(if (active) Color(0xFF4FC3F7) else Color(0xFF333333))
+ .clickable { onKey(sendKey) }
+ .padding(horizontal = 10.dp, vertical = 8.dp),
+ )
+}
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalViewModel.kt b/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalViewModel.kt
index 0127bc1..475b523 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalViewModel.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/terminal/TerminalViewModel.kt
@@ -1,40 +1,329 @@
/*
* Podroid - Rootless Podman for Android
* Copyright (C) 2024 Podroid contributors
+ *
+ * No host binaries used — TerminalSession is created but its subprocess
+ * is bypassed via reflection. Keyboard I/O goes to QEMU serial console.
*/
package com.excp.podroid.ui.screens.terminal
+import android.content.Context
+import android.system.Os
import android.util.Log
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
+import android.view.KeyEvent
+import android.view.MotionEvent
import com.excp.podroid.engine.PodroidQemu
+import com.excp.podroid.engine.VmState
+import com.termux.terminal.TerminalEmulator
+import com.termux.terminal.TerminalSession
+import com.termux.terminal.TerminalSessionClient
+import com.termux.view.TerminalView
+import com.termux.view.TerminalViewClient
import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
+import dagger.hilt.android.qualifiers.ApplicationContext
+import androidx.lifecycle.ViewModel
import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.launch
+import java.io.OutputStream
import javax.inject.Inject
@HiltViewModel
class TerminalViewModel @Inject constructor(
+ @ApplicationContext private val context: Context,
private val qemu: PodroidQemu,
) : ViewModel() {
- /** Console output text — directly from PodroidQemu singleton */
- val terminalText: StateFlow<String> = qemu.consoleText
+ val vmState: StateFlow<VmState> = qemu.state
+
+ private var terminalView: TerminalView? = null
+ private var emulator: TerminalEmulator? = null
+ private var qemuStdin: OutputStream? = null
+ private var attached = false
+ var session: TerminalSession? = null
+ private set
+
+ var extraCtrl = false
+ var extraAlt = false
- fun sendInput(text: String) {
- val output = qemu.consoleOutput ?: run {
- Log.w(TAG, "consoleOutput is null, VM not running")
- return
+ val sessionClient = object : TerminalSessionClient {
+ override fun onTextChanged(changedSession: TerminalSession) {
+ terminalView?.onScreenUpdated()
}
- viewModelScope.launch(Dispatchers.IO) {
- try {
- output.write(text.toByteArray())
- output.flush()
- } catch (e: Exception) {
- Log.e(TAG, "Failed to send input", e)
+ override fun onTitleChanged(changedSession: TerminalSession) {}
+ override fun onSessionFinished(finishedSession: TerminalSession) {}
+ override fun onCopyTextToClipboard(session: TerminalSession, text: String?) {}
+ override fun onPasteTextFromClipboard(session: TerminalSession?) {}
+ override fun onBell(session: TerminalSession) {}
+ override fun onColorsChanged(session: TerminalSession) {}
+ override fun onTerminalCursorStateChange(state: Boolean) {}
+ override fun getTerminalCursorStyle(): Int = 0
+ override fun logError(tag: String?, message: String?) { Log.e(tag ?: TAG, message ?: "") }
+ override fun logWarn(tag: String?, message: String?) { Log.w(tag ?: TAG, message ?: "") }
+ override fun logInfo(tag: String?, message: String?) { Log.i(tag ?: TAG, message ?: "") }
+ override fun logDebug(tag: String?, message: String?) { Log.d(tag ?: TAG, message ?: "") }
+ override fun logVerbose(tag: String?, message: String?) { Log.v(tag ?: TAG, message ?: "") }
+ override fun logStackTraceWithMessage(tag: String?, message: String?, e: Exception?) {
+ Log.e(tag ?: TAG, message, e)
+ }
+ override fun logStackTrace(tag: String?, e: Exception?) {
+ Log.e(tag ?: TAG, "Stack trace", e)
+ }
+ }
+
+ val viewClient = object : TerminalViewClient {
+ override fun onScale(scale: Float): Float = scale
+ override fun onSingleTapUp(e: MotionEvent?) {
+ terminalView?.let { view ->
+ val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE)
+ as android.view.inputmethod.InputMethodManager
+ imm.showSoftInput(view, 0)
+ }
+ }
+ override fun shouldBackButtonBeMappedToEscape(): Boolean = false
+ override fun shouldEnforceCharBasedInput(): Boolean = true
+ override fun shouldUseCtrlSpaceWorkaround(): Boolean = false
+ override fun isTerminalViewSelected(): Boolean = true
+ override fun copyModeChanged(copyMode: Boolean) {}
+ override fun onKeyDown(keyCode: Int, e: KeyEvent?, session: TerminalSession?): Boolean = false
+ override fun onKeyUp(keyCode: Int, e: KeyEvent?): Boolean {
+ // Reset Ctrl/Alt toggles after a key is processed
+ if (extraCtrl || extraAlt) {
+ extraCtrl = false
+ extraAlt = false
+ }
+ return false
+ }
+ override fun onLongPress(event: MotionEvent?): Boolean = false
+ override fun readControlKey(): Boolean = extraCtrl
+ override fun readAltKey(): Boolean = extraAlt
+ override fun readShiftKey(): Boolean = false
+ override fun readFnKey(): Boolean = false
+ override fun onCodePoint(codePoint: Int, ctrlDown: Boolean, session: TerminalSession?): Boolean {
+ // If CTRL extra key is active, send the control character directly
+ if (extraCtrl && codePoint in 64..127) {
+ // Ctrl+A=1, Ctrl+B=2, ..., Ctrl+Z=26, etc.
+ val ctrlByte = (codePoint and 0x1f).toByte()
+ try {
+ qemuStdin?.write(byteArrayOf(ctrlByte))
+ qemuStdin?.flush()
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send ctrl key", e)
+ }
+ extraCtrl = false
+ extraAlt = false
+ return true // consumed
+ }
+ if (extraCtrl && codePoint in 96..122) {
+ // lowercase ctrl+a through ctrl+z
+ val ctrlByte = (codePoint - 96).toByte()
+ try {
+ qemuStdin?.write(byteArrayOf(ctrlByte))
+ qemuStdin?.flush()
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send ctrl key", e)
+ }
+ extraCtrl = false
+ extraAlt = false
+ return true
}
+ return false
}
+ override fun onEmulatorSet() {}
+ override fun logError(tag: String?, message: String?) { Log.e(tag ?: TAG, message ?: "") }
+ override fun logWarn(tag: String?, message: String?) { Log.w(tag ?: TAG, message ?: "") }
+ override fun logInfo(tag: String?, message: String?) { Log.i(tag ?: TAG, message ?: "") }
+ override fun logDebug(tag: String?, message: String?) { Log.d(tag ?: TAG, message ?: "") }
+ override fun logVerbose(tag: String?, message: String?) { Log.v(tag ?: TAG, message ?: "") }
+ override fun logStackTraceWithMessage(tag: String?, message: String?, e: Exception?) {
+ Log.e(tag ?: TAG, message, e)
+ }
+ override fun logStackTrace(tag: String?, e: Exception?) {
+ Log.e(tag ?: TAG, "Stack trace", e)
+ }
+ }
+
+ fun attachView(view: TerminalView) {
+ terminalView = view
+ }
+
+ /**
+ * Create a TerminalSession wired to QEMU I/O instead of a local subprocess.
+ *
+ * We create a real pipe fd so JNI.setPtyWindowSize() doesn't crash,
+ * inject our emulator via reflection, and drain the session's keyboard
+ * queue to forward input to QEMU stdin.
+ */
+ fun createSession() {
+ if (attached) return
+ attached = true
+
+ qemuStdin = qemu.consoleOutput
+
+ // Create session — constructor just stores fields, no subprocess started
+ val sess = TerminalSession(
+ "/dev/null",
+ context.filesDir.absolutePath,
+ emptyArray(),
+ emptyArray(),
+ 2000,
+ sessionClient,
+ )
+ session = sess
+
+ // Create emulator that sends keyboard output to QEMU stdin
+ val qemuOutput = object : com.termux.terminal.TerminalOutput() {
+ override fun write(data: ByteArray, offset: Int, count: Int) {
+ try {
+ qemuStdin?.let {
+ it.write(data, offset, count)
+ it.flush()
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to write to QEMU", e)
+ }
+ }
+ override fun titleChanged(oldTitle: String?, newTitle: String?) {}
+ override fun onCopyTextToClipboard(text: String?) {}
+ override fun onPasteTextFromClipboard() {}
+ override fun onBell() {}
+ override fun onColorsChanged() {}
+ }
+
+ val emu = TerminalEmulator(qemuOutput, 80, 24, 2000, sessionClient)
+ emulator = emu
+
+ // Create a real pipe so JNI.setPtyWindowSize() gets a valid fd
+ // (ioctl will fail with ENOTTY but won't crash)
+ var pipeFd = -1
+ try {
+ val fds = Os.pipe()
+ // Get raw int fd via reflection (FileDescriptor doesn't expose it directly)
+ val fdIntField = java.io.FileDescriptor::class.java.getDeclaredField("descriptor")
+ fdIntField.isAccessible = true
+ pipeFd = fdIntField.getInt(fds[1])
+ Os.close(fds[0]) // close read end
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to create pipe: ${e.message}")
+ }
+
+ // Inject our emulator and fake pid into session via reflection
+ try {
+ val cls = TerminalSession::class.java
+
+ val emulatorField = cls.getDeclaredField("mEmulator")
+ emulatorField.isAccessible = true
+ emulatorField.set(sess, emu)
+
+ val pidField = cls.getDeclaredField("mShellPid")
+ pidField.isAccessible = true
+ pidField.setInt(sess, 1)
+
+ val fdField = cls.getDeclaredField("mTerminalFileDescriptor")
+ fdField.isAccessible = true
+ fdField.setInt(sess, pipeFd)
+
+ Log.d(TAG, "Session reflection setup OK, pipeFd=$pipeFd")
+ } catch (e: Exception) {
+ Log.e(TAG, "Reflection setup failed", e)
+ }
+
+ // Thread to drain keyboard input from session's queue → QEMU stdin
+ try {
+ val queueField = TerminalSession::class.java.getDeclaredField("mTerminalToProcessIOQueue")
+ queueField.isAccessible = true
+ val queue = queueField.get(sess)!!
+
+ val readMethod = queue.javaClass.getDeclaredMethod(
+ "read", ByteArray::class.java, Boolean::class.javaPrimitiveType
+ )
+ readMethod.isAccessible = true
+
+ Thread({
+ val buf = ByteArray(4096)
+ try {
+ while (true) {
+ val n = readMethod.invoke(queue, buf, true) as Int
+ if (n > 0) {
+ if (extraCtrl) {
+ // Apply Ctrl modifier: a-z → 1-26, A-Z → 1-26
+ val out = ByteArray(n)
+ for (i in 0 until n) {
+ val b = buf[i].toInt() and 0xFF
+ out[i] = if (b in 0x40..0x7F) (b and 0x1F).toByte() else buf[i]
+ }
+ qemuStdin?.write(out, 0, n)
+ extraCtrl = false
+ extraAlt = false
+ } else {
+ qemuStdin?.write(buf, 0, n)
+ }
+ qemuStdin?.flush()
+ }
+ }
+ } catch (e: Exception) {
+ Log.d(TAG, "Keyboard→QEMU thread ended: ${e.message}")
+ }
+ }, "keyboard-to-qemu").apply {
+ isDaemon = true
+ start()
+ }
+ Log.d(TAG, "Keyboard→QEMU thread started")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to start keyboard→QEMU thread", e)
+ }
+
+ // QEMU output → feed to emulator
+ qemu.onConsoleOutput = { data, len ->
+ emu.append(data, len)
+ terminalView?.post { terminalView?.onScreenUpdated() }
+ }
+
+ // Feed buffered output
+ val existing = qemu.consoleText.value
+ if (existing.isNotEmpty()) {
+ val bytes = existing.toByteArray()
+ emu.append(bytes, bytes.size)
+ }
+ }
+
+ fun sendExtraKey(key: String) {
+ when (key) {
+ "CTRL" -> { extraCtrl = !extraCtrl; return }
+ "ALT" -> { extraAlt = !extraAlt; return }
+ }
+ val bytes = when (key) {
+ "ESC" -> byteArrayOf(27)
+ "TAB" -> byteArrayOf(9)
+ "UP" -> "\u001b[A".toByteArray()
+ "DOWN" -> "\u001b[B".toByteArray()
+ "LEFT" -> "\u001b[D".toByteArray()
+ "RIGHT" -> "\u001b[C".toByteArray()
+ "HOME" -> "\u001b[H".toByteArray()
+ "END" -> "\u001b[F".toByteArray()
+ "PGUP" -> "\u001b[5~".toByteArray()
+ "PGDN" -> "\u001b[6~".toByteArray()
+ "-" -> "-".toByteArray()
+ "|" -> "|".toByteArray()
+ "/" -> "/".toByteArray()
+ else -> return
+ }
+ try {
+ qemuStdin?.write(bytes)
+ qemuStdin?.flush()
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send extra key", e)
+ }
+ extraCtrl = false
+ extraAlt = false
+ }
+
+ override fun onCleared() {
+ super.onCleared()
+ qemu.onConsoleOutput = null
+ emulator = null
+ terminalView = null
+ qemuStdin = null
+ session = null
+ attached = false
}
companion object {
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 75f8a09..c29487b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -28,6 +28,9 @@ coroutines = "1.9.0"
# DataStore
datastore = "1.1.4"
+# Termux terminal
+termux = "v0.118.1"
+
# Testing
junit = "4.13.2"
junitVersion = "1.2.1"
@@ -73,6 +76,10 @@ kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-
# DataStore
androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "datastore" }
+# Termux terminal
+termux-terminal-emulator = { group = "com.github.termux.termux-app", name = "terminal-emulator", version.ref = "termux" }
+termux-terminal-view = { group = "com.github.termux.termux-app", name = "terminal-view", version.ref = "termux" }
+
# Testing
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
diff --git a/init-podroid b/init-podroid
index ca8ae20..102cff2 100644
--- a/init-podroid
+++ b/init-podroid
@@ -1,7 +1,11 @@
#!/bin/sh
-# Podroid init — optimized for Android QEMU VM + Podman
+# Podroid init — persistent Alpine Linux VM with Podman
+# Uses overlayfs on persistent storage so ALL changes survive reboots.
# Serial console (ttyAMA0) is the primary interface.
+# ── Phase 2: Main init (running inside persistent overlay) ──
+if [ "$1" = "--main" ]; then
+
# ── Core filesystems ──
mount -t proc proc /proc -o noexec,nosuid,nodev
mount -t sysfs sys /sys -o noexec,nosuid,nodev
@@ -16,7 +20,6 @@ mount -t tmpfs tmpfs /run -o noexec,nosuid,nodev,mode=0755
# ── cgroup2 (required by podman/crun) ──
mkdir -p /sys/fs/cgroup
mount -t cgroup2 cgroup2 /sys/fs/cgroup 2>/dev/null
-# Enable all available controllers for root
if [ -f /sys/fs/cgroup/cgroup.subtree_control ]; then
for ctrl in cpuset cpu io memory hugetlb pids rdma misc; do
echo "+$ctrl" > /sys/fs/cgroup/cgroup.subtree_control 2>/dev/null
@@ -38,10 +41,8 @@ hostname podroid
KVER=$(uname -r)
if [ -d "/lib/modules/$KVER" ]; then
depmod -a 2>/dev/null
- # Virtio devices
modprobe virtio_net 2>/dev/null
modprobe virtio_blk 2>/dev/null
- # Container essentials
modprobe fuse 2>/dev/null
modprobe tun 2>/dev/null
modprobe veth 2>/dev/null
@@ -88,53 +89,34 @@ sysctl -qw net.bridge.bridge-nf-call-iptables=1 2>/dev/null
sysctl -qw net.bridge.bridge-nf-call-ip6tables=1 2>/dev/null
sysctl -qw net.ipv4.ping_group_range="0 2147483647" 2>/dev/null
sysctl -qw kernel.unprivileged_userns_clone=1 2>/dev/null
-# Increase inotify for podman
sysctl -qw fs.inotify.max_user_instances=256 2>/dev/null
sysctl -qw fs.inotify.max_user_watches=65536 2>/dev/null
-# ── Persistent storage ──
-for dev in /dev/vda /dev/vdb; do
- [ -b "$dev" ] || continue
- mount -t ext4 -o rw,noatime "$dev" /var/lib/containers 2>/dev/null || {
- echo "[init] Formatting $dev..."
- mkfs.ext4 -q -F "$dev" 2>/dev/null
- mount -t ext4 -o rw,noatime "$dev" /var/lib/containers 2>/dev/null
- }
- # Ensure storage subdirs exist on persistent disk
- mkdir -p /var/lib/containers/storage
- break
-done
-
-# ── User/group config ──
-echo "root:100000:65536" > /etc/subuid
-echo "root:100000:65536" > /etc/subgid
+# ── User/group config (only if not already customized) ──
+[ -f /etc/subuid ] || echo "root:100000:65536" > /etc/subuid
+[ -f /etc/subgid ] || echo "root:100000:65536" > /etc/subgid
-# ── Podman configuration (optimized for QEMU on Android) ──
-mkdir -p /etc/containers
+# ── Podman configuration (only write defaults on first boot) ──
+if [ ! -f /etc/containers/containers.conf ]; then
+ mkdir -p /etc/containers
-cat > /etc/containers/containers.conf <<'CONF'
+ cat > /etc/containers/containers.conf <<'CONF'
[containers]
-# Use cgroup2 + crun
cgroups = "enabled"
default_sysctls = []
-# Dont need userns inside VM (we are already root)
userns = "host"
[engine]
-# crun is lighter than runc
runtime = "crun"
-# No pivot_root in initramfs
no_pivot_root = true
-# Use slirp4netns for rootless networking
network_cmd = "/usr/bin/slirp4netns"
-# Events logger
events_logger = "file"
[network]
network_backend = "netavark"
CONF
-cat > /etc/containers/storage.conf <<'CONF'
+ cat > /etc/containers/storage.conf <<'CONF'
[storage]
driver = "overlay"
runroot = "/run/containers/storage"
@@ -144,16 +126,19 @@ graphroot = "/var/lib/containers/storage"
mount_program = "/usr/bin/fuse-overlayfs"
CONF
-cat > /etc/containers/registries.conf <<'CONF'
+ cat > /etc/containers/registries.conf <<'CONF'
unqualified-search-registries = ["docker.io", "quay.io"]
CONF
+fi
-# ── crun config — disable pivot_root ──
-mkdir -p /etc/crun
-cat > /etc/crun/crun.conf <<'CONF'
+# ── crun config ──
+if [ ! -f /etc/crun/crun.conf ]; then
+ mkdir -p /etc/crun
+ cat > /etc/crun/crun.conf <<'CONF'
[global]
no-pivot = true
CONF
+fi
# ── Environment ──
export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
@@ -164,17 +149,32 @@ export CONTAINERS_CONF=/etc/containers/containers.conf
export CONTAINERS_STORAGE_CONF=/etc/containers/storage.conf
export CONTAINERS_REGISTRIES_CONF=/etc/containers/registries.conf
-# ── Silence kernel messages on console ──
+# ── Console settings ──
dmesg -n 1 2>/dev/null
+# ── Graceful shutdown handler ──
+shutdown_handler() {
+ echo ""
+ echo "[init] Shutting down..."
+ sync
+ # Stop all running containers gracefully
+ podman stop -a -t 5 2>/dev/null
+ sync
+ echo "[init] Goodbye."
+}
+trap shutdown_handler TERM INT HUP
+
# ── Banner ──
IP=$(ip addr show "$NETIF" 2>/dev/null | grep 'inet ' | awk '{print $2}' | cut -d'/' -f1)
+PERSISTENT="yes"
+[ -f /mnt/persist/.overlay-active ] || PERSISTENT="no (running from initramfs)"
echo ""
echo "=========================================="
echo " Podroid - Alpine Linux + Podman"
echo "=========================================="
-echo " IP: ${IP:-no network}"
-echo " DNS: 8.8.8.8"
+echo " IP: ${IP:-no network}"
+echo " DNS: 8.8.8.8"
+echo " Persistent: ${PERSISTENT}"
echo ""
# Quick connectivity check (background, don't block boot)
@@ -190,9 +190,99 @@ echo " Ready! Try: podman run --rm alpine echo hello"
echo ""
# ── Shell ──
+
+# Create a profile for the login shell
+cat > /etc/profile <<'PROF'
+export HOME=/root
+export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+export TERM=linux
+export PODMAN_IGNORE_CGROUPSV1_WARNING=1
+export CONTAINERS_CONF=/etc/containers/containers.conf
+export CONTAINERS_STORAGE_CONF=/etc/containers/storage.conf
+export CONTAINERS_REGISTRIES_CONF=/etc/containers/registries.conf
cd /root
+PROF
+
+# Set root shell and create passwd entry if missing
+grep -q '^root:' /etc/passwd 2>/dev/null || echo "root:x:0:0:root:/root:/bin/sh" > /etc/passwd
+
+# Use getty to spawn a proper login shell on the serial console.
+# getty sets up the controlling TTY correctly, enabling job control + Ctrl+C.
while true; do
- printf "podroid:~# "
- read -r cmd || continue
- [ -n "$cmd" ] && eval "$cmd" 2>&1
+ /sbin/getty -n -l /bin/sh 0 ttyAMA0 linux
+ sleep 1
done
+fi
+
+# ══════════════════════════════════════════════════════════════
+# Phase 1: Early init — mount persistent storage and overlay
+# ══════════════════════════════════════════════════════════════
+
+# Minimal filesystems needed to find and mount the disk
+mount -t proc proc /proc -o noexec,nosuid,nodev
+mount -t sysfs sys /sys -o noexec,nosuid,nodev
+mount -t devtmpfs devtmpfs /dev -o exec,nosuid,mode=0755,size=2M 2>/dev/null || \
+ mount -t tmpfs tmpfs /dev -o exec,nosuid,mode=0755,size=2M
+
+# Load virtio_blk early so the persistent disk is visible
+KVER=$(uname -r)
+if [ -d "/lib/modules/$KVER" ]; then
+ depmod -a 2>/dev/null
+ modprobe virtio_blk 2>/dev/null
+fi
+
+# Silence kernel during setup
+echo 1 > /proc/sys/kernel/printk 2>/dev/null
+
+# ── Find and mount persistent storage ──
+mkdir -p /mnt/persist
+PERSIST_DEV=""
+for dev in /dev/vda /dev/vdb; do
+ [ -b "$dev" ] || continue
+ PERSIST_DEV="$dev"
+ break
+done
+
+OVERLAY_OK=false
+if [ -n "$PERSIST_DEV" ]; then
+ mount -t ext4 -o rw,noatime "$PERSIST_DEV" /mnt/persist 2>/dev/null || {
+ echo "[init] Formatting $PERSIST_DEV for persistent storage..."
+ /bin/busybox --install -s 2>/dev/null
+ mkfs.ext4 -q -F "$PERSIST_DEV" 2>/dev/null
+ mount -t ext4 -o rw,noatime "$PERSIST_DEV" /mnt/persist 2>/dev/null
+ }
+
+ if mountpoint -q /mnt/persist 2>/dev/null; then
+ # Create overlay directories on persistent disk
+ mkdir -p /mnt/persist/upper /mnt/persist/work /mnt/overlay
+
+ # Mount overlay: lower=initramfs, upper=persistent disk
+ mount -t overlay overlay \
+ -o lowerdir=/,upperdir=/mnt/persist/upper,workdir=/mnt/persist/work \
+ /mnt/overlay 2>/dev/null
+
+ if mountpoint -q /mnt/overlay 2>/dev/null; then
+ # Bind the persistent disk into the overlay for direct access
+ mkdir -p /mnt/overlay/mnt/persist
+ mount --bind /mnt/persist /mnt/overlay/mnt/persist
+
+ # Mark overlay as active
+ touch /mnt/persist/.overlay-active
+
+ # Unmount early mounts (will be re-created in phase 2)
+ umount /dev 2>/dev/null
+ umount /sys 2>/dev/null
+ umount /proc 2>/dev/null
+
+ # Enter overlay and run main init
+ exec chroot /mnt/overlay /init --main
+ fi
+ fi
+fi
+
+# ── Fallback: no persistent storage, run directly ──
+echo "[init] WARNING: No persistent storage — changes will be lost on reboot!"
+umount /dev 2>/dev/null
+umount /sys 2>/dev/null
+umount /proc 2>/dev/null
+exec /init --main
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 2921c15..8a5341b 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -19,6 +19,7 @@ dependencyResolutionManagement {
repositories {
google()
mavenCentral()
+ maven { url = uri("https://jitpack.io") }
}
}