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.ktsindex 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)+// TestingtestImplementation(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.ktnew file mode 100644index 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.ktindex 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.mapimport javax.inject.Injectimport javax.inject.Singleton-private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")+internal val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")@Singletonclass 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.ktindex 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.engineimport android.content.Contextimport android.util.Log+import com.excp.podroid.data.repository.PortForwardRepository+import com.excp.podroid.data.repository.PortForwardRuleimport dagger.hilt.android.qualifiers.ApplicationContextimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.StateFlow@@ -22,21 +24,38 @@ import javax.inject.Singleton@Singletonclass 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? = nullprivate 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!!.outputStreamLog.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 listenersval 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 = nullconsoleOutput = 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 += netdevArgargs += "-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.ktnew file mode 100644index 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.ktindex 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.Logimport androidx.core.app.NotificationCompatimport com.excp.podroid.MainActivityimport com.excp.podroid.R+import com.excp.podroid.data.repository.PortForwardRepositoryimport com.excp.podroid.engine.PodroidQemuimport dagger.hilt.android.AndroidEntryPointimport kotlinx.coroutines.*@@ -27,6 +28,7 @@ import javax.inject.Injectclass PodroidService : Service() {@Inject lateinit var podroidQemu: PodroidQemu+ @Inject lateinit var portForwardRepository: PortForwardRepositoryprivate 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.ktindex 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.Arrangementimport androidx.compose.foundation.layout.Columnimport androidx.compose.foundation.layout.Rowimport androidx.compose.foundation.layout.Spacer@@ -13,26 +14,42 @@ import androidx.compose.foundation.layout.fillMaxSizeimport androidx.compose.foundation.layout.fillMaxWidthimport androidx.compose.foundation.layout.heightimport androidx.compose.foundation.layout.padding+import androidx.compose.foundation.layout.widthimport androidx.compose.foundation.rememberScrollState+import androidx.compose.foundation.text.KeyboardOptionsimport androidx.compose.foundation.verticalScrollimport androidx.compose.material.icons.Iconsimport 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.CardDefaultsimport androidx.compose.material3.ExperimentalMaterial3Api+import androidx.compose.material3.FilledTonalButtonimport androidx.compose.material3.HorizontalDividerimport androidx.compose.material3.Iconimport androidx.compose.material3.IconButtonimport androidx.compose.material3.MaterialTheme+import androidx.compose.material3.OutlinedTextFieldimport androidx.compose.material3.Scaffoldimport androidx.compose.material3.Switchimport androidx.compose.material3.Text+import androidx.compose.material3.TextButtonimport androidx.compose.material3.TopAppBarimport androidx.compose.runtime.Composableimport androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValueimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifier+import androidx.compose.ui.text.input.KeyboardTypeimport androidx.compose.ui.unit.dpimport androidx.hilt.lifecycle.viewmodel.compose.hiltViewModelimport 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")+ }+ },+ )}@Composablediff --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.ktindex 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.settingsimport androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScope+import com.excp.podroid.data.repository.PortForwardRepository+import com.excp.podroid.data.repository.PortForwardRuleimport com.excp.podroid.data.repository.SettingsRepository+import com.excp.podroid.engine.PodroidQemu+import com.excp.podroid.engine.VmStateimport dagger.hilt.android.lifecycle.HiltViewModel+import kotlinx.coroutines.flow.Flow+import kotlinx.coroutines.flow.SharingStarted+import kotlinx.coroutines.flow.StateFlow+import kotlinx.coroutines.flow.stateInimport kotlinx.coroutines.launchimport javax.inject.Inject@HiltViewModelclass 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.ktindex 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.terminalimport android.app.Activity+import android.graphics.Typefaceimport android.view.WindowManagerimport androidx.compose.foundation.background+import androidx.compose.foundation.clickable+import androidx.compose.foundation.horizontalScroll+import androidx.compose.foundation.layout.Arrangementimport androidx.compose.foundation.layout.Boximport androidx.compose.foundation.layout.Columnimport androidx.compose.foundation.layout.Rowimport androidx.compose.foundation.layout.WindowInsetsimport androidx.compose.foundation.layout.fillMaxSizeimport androidx.compose.foundation.layout.fillMaxWidth-import androidx.compose.foundation.layout.heightimport androidx.compose.foundation.layout.imeimport androidx.compose.foundation.layout.navigationBarsimport androidx.compose.foundation.layout.paddingimport androidx.compose.foundation.layout.windowInsetsPaddingimport 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.RoundedCornerShapeimport 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.ArrowBackimport androidx.compose.material3.ExperimentalMaterial3Apiimport androidx.compose.material3.Iconimport androidx.compose.material3.IconButtonimport androidx.compose.material3.Textimport androidx.compose.material3.TopAppBar+import androidx.compose.material3.TopAppBarDefaultsimport androidx.compose.runtime.Composableimport androidx.compose.runtime.DisposableEffect-import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.collectAsStateimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOfimport androidx.compose.runtime.rememberimport androidx.compose.runtime.setValueimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifier+import androidx.compose.ui.draw.clipimport androidx.compose.ui.graphics.Color-import androidx.compose.ui.graphics.SolidColorimport androidx.compose.ui.platform.LocalContext-import androidx.compose.ui.platform.LocalDensity-import androidx.compose.ui.text.TextStyleimport 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.TextAlignimport androidx.compose.ui.unit.dpimport androidx.compose.ui.unit.sp+import androidx.compose.ui.viewinterop.AndroidViewimport 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 keyboardDisposableEffect(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 barTopAppBar(- 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.ktindex 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.Osimport android.util.Log-import androidx.lifecycle.ViewModel-import androidx.lifecycle.viewModelScope+import android.view.KeyEvent+import android.view.MotionEventimport 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.TerminalViewClientimport dagger.hilt.android.lifecycle.HiltViewModel-import kotlinx.coroutines.Dispatchers+import dagger.hilt.android.qualifiers.ApplicationContext+import androidx.lifecycle.ViewModelimport kotlinx.coroutines.flow.StateFlow-import kotlinx.coroutines.launch+import java.io.OutputStreamimport javax.inject.Inject@HiltViewModelclass 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.tomlindex 75f8a09..c29487b 100644--- a/gradle/libs.versions.toml+++ b/gradle/libs.versions.toml@@ -28,6 +28,9 @@ coroutines = "1.9.0"# DataStoredatastore = "1.1.4"+# Termux terminal+termux = "v0.118.1"+# Testingjunit = "4.13.2"junitVersion = "1.2.1"@@ -73,6 +76,10 @@ kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-# DataStoreandroidx-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" }+# Testingjunit = { 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-podroidindex 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,nodevmount -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/cgroupmount -t cgroup2 cgroup2 /sys/fs/cgroup 2>/dev/null-# Enable all available controllers for rootif [ -f /sys/fs/cgroup/cgroup.subtree_control ]; thenfor ctrl in cpuset cpu io memory hugetlb pids rdma misc; doecho "+$ctrl" > /sys/fs/cgroup/cgroup.subtree_control 2>/dev/null@@ -38,10 +41,8 @@ hostname podroidKVER=$(uname -r)if [ -d "/lib/modules/$KVER" ]; thendepmod -a 2>/dev/null- # Virtio devicesmodprobe virtio_net 2>/dev/nullmodprobe virtio_blk 2>/dev/null- # Container essentialsmodprobe fuse 2>/dev/nullmodprobe tun 2>/dev/nullmodprobe veth 2>/dev/null@@ -88,53 +89,34 @@ sysctl -qw net.bridge.bridge-nf-call-iptables=1 2>/dev/nullsysctl -qw net.bridge.bridge-nf-call-ip6tables=1 2>/dev/nullsysctl -qw net.ipv4.ping_group_range="0 2147483647" 2>/dev/nullsysctl -qw kernel.unprivileged_userns_clone=1 2>/dev/null-# Increase inotify for podmansysctl -qw fs.inotify.max_user_instances=256 2>/dev/nullsysctl -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 + cruncgroups = "enabled"default_sysctls = []-# Dont need userns inside VM (we are already root)userns = "host"[engine]-# crun is lighter than runcruntime = "crun"-# No pivot_root in initramfsno_pivot_root = true-# Use slirp4netns for rootless networkingnetwork_cmd = "/usr/bin/slirp4netns"-# Events loggerevents_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 = trueCONF+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.confexport CONTAINERS_STORAGE_CONF=/etc/containers/storage.confexport 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.confcd /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 1done+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 --maindiff --git a/settings.gradle.kts b/settings.gradle.ktsindex 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") }}}