Skip to content

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

fix: resolve AVF fallback reason in current locale

Kybernetria10b6e1103db6
diff --git a/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt b/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt
index e7a9f0b..3c57e51 100644
--- a/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt
+++ b/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt
@@ -15,6 +15,7 @@
package com.excp.podroid.engine
import android.content.Context
+import androidx.annotation.StringRes
import com.excp.podroid.R
import com.excp.podroid.data.repository.PortForwardRepository
import com.excp.podroid.data.repository.PortForwardRule
@@ -94,13 +95,15 @@ class EngineHolder @Inject constructor(
.stateIn(scope, SharingStarted.Eagerly, _currentFlow.value.backendId)
// Non-null only while the current pick is a forced-AVF selection that fell
- // back to QEMU: a short, localized human reason (see FallbackReason /
- // pick()). Updated at the same two points _currentFlow is (publishFirstPick,
- // trySwap) so it always describes the pick that produced the active engine,
- // even on a no-op swap where the engine instance doesn't change but the
- // selection (and therefore the reason) does.
- private val _backendFallback = MutableStateFlow<String?>(null)
- val backendFallback: StateFlow<String?> = _backendFallback.asStateFlow()
+ // back to QEMU: the @StringRes ID of the reason (see FallbackReason /
+ // pick()). Keep the ID unresolved until the UI renders it so a locale
+ // change cannot leave this in-memory state with text from the old locale.
+ // Updated at the same two points _currentFlow is (publishFirstPick, trySwap)
+ // so it always describes the pick that produced the active engine, even on
+ // a no-op swap where the engine instance doesn't change but the selection
+ // (and therefore the reason) does.
+ private val _backendFallback = MutableStateFlow<Int?>(null)
+ val backendFallback: StateFlow<Int?> = _backendFallback.asStateFlow()
/** Last rule set we pushed into the engine, used to compute add/remove diffs. */
@Volatile private var appliedRules: Set<PortForwardRule> = emptySet()
@@ -226,8 +229,11 @@ class EngineHolder @Inject constructor(
}
/** Result of a pick: the chosen engine plus, when a forced-AVF selection
- * fell back to QEMU, a short localized reason for [backendFallback]. */
- private data class PickResult(val engine: VmEngine, val fallbackMessage: String?)
+ * fell back to QEMU, the @StringRes ID of its reason for [backendFallback]. */
+ private data class PickResult(
+ val engine: VmEngine,
+ @StringRes val fallbackReasonResId: Int?,
+ )
private fun pick(sel: EngineSelection): PickResult {
val probe = AvfDiagnostics.probe(context)
@@ -274,23 +280,8 @@ class EngineHolder @Inject constructor(
"customVm=${probe.customVmConfigSupported} " +
"caps=${probe.capabilitiesRaw}(${probe.capabilitiesDecoded}) → ${engine.backendId}"
)
- val fallbackMessage = fallbackReason?.let { fallbackReasonText(it, probe) }
- return PickResult(engine, fallbackMessage)
- }
-
- /** Short, localized reason for [backendFallback], reusing the same
- * prerequisite checks the pick() log above already dumps: feature, then
- * permissions, then service/custom-VM reachability, in that order - the
- * first one that fails is reported. */
- private fun fallbackReasonText(reason: FallbackReason, probe: AvfReport): String {
- val resId = when {
- reason == FallbackReason.PROTECTED_ONLY -> R.string.backend_fallback_reason_protected_only
- !probe.featureSupported -> R.string.backend_fallback_reason_feature
- !probe.managePermissionGranted || !probe.customPermissionGranted ->
- R.string.backend_fallback_reason_permissions
- else -> R.string.backend_fallback_reason_service
- }
- return context.getString(resId)
+ val fallbackReasonResId = fallbackReason?.let { fallbackReasonResId(it, probe) }
+ return PickResult(engine, fallbackReasonResId)
}
/**
@@ -311,7 +302,7 @@ class EngineHolder @Inject constructor(
startedEngine = null
_currentFlow.value = first
}
- _backendFallback.value = result.fallbackMessage
+ _backendFallback.value = result.fallbackReasonResId
}
private suspend fun trySwap(newSel: EngineSelection) {
@@ -331,7 +322,7 @@ class EngineHolder @Inject constructor(
// Update the surfaced reason even on a no-op engine swap: forcing AVF
// on an already-QEMU device changes the selection (and therefore the
// reason) without changing the engine instance.
- _backendFallback.value = result.fallbackMessage
+ _backendFallback.value = result.fallbackReasonResId
val next = result.engine
if (next === currentFlow.value) return
// NOTE: AvfEngine.stop() flips state to Stopped before cleanup() finishes
@@ -448,6 +439,20 @@ class EngineHolder @Inject constructor(
* dedicated branch (a signed pvmfw kernel can never appear later). */
enum class FallbackReason { UNAVAILABLE, PROTECTED_ONLY }
+ /**
+ * Select the localized reason resource for a forced-AVF fallback. The
+ * first failed prerequisite is reported, except protected-only devices
+ * which have their dedicated explanation.
+ */
+ @StringRes
+ internal fun fallbackReasonResId(reason: FallbackReason, probe: AvfReport): Int = when {
+ reason == FallbackReason.PROTECTED_ONLY -> R.string.backend_fallback_reason_protected_only
+ !probe.featureSupported -> R.string.backend_fallback_reason_feature
+ !probe.managePermissionGranted || !probe.customPermissionGranted ->
+ R.string.backend_fallback_reason_permissions
+ else -> R.string.backend_fallback_reason_service
+ }
+
/**
* Pure backend-selection decision, extracted from pick() so it's unit
* testable without a Context or a binder-IPC AVF probe. Mirrors pick()'s
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 a69877b..2ab5112 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
@@ -343,14 +343,19 @@ fun SettingsScreen(
// Annotate, don't disable: the user may grant AVF permissions
// later, so the chip stays selectable while explaining why the
// VM is actually running on QEMU right now.
- if (ui.engineSelection == EngineSelection.AVF && backendFallback != null) {
- Spacer(Modifier.height(PodroidTokens.Spacing.XS))
- Text(
- text = stringResource(R.string.backend_avf_unavailable, backendFallback ?: ""),
- style = MaterialTheme.typography.bodySmall,
- color = MaterialTheme.colorScheme.error,
- modifier = Modifier.padding(horizontal = PodroidTokens.Spacing.MD),
- )
+ if (ui.engineSelection == EngineSelection.AVF) {
+ backendFallback?.let { reasonResId ->
+ Spacer(Modifier.height(PodroidTokens.Spacing.XS))
+ Text(
+ text = stringResource(
+ R.string.backend_avf_unavailable,
+ stringResource(reasonResId),
+ ),
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.error,
+ modifier = Modifier.padding(horizontal = PodroidTokens.Spacing.MD),
+ )
+ }
}
Spacer(Modifier.height(PodroidTokens.Spacing.MD))
AdvancedFieldsBlock(
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 c264adb..f3c221f 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
@@ -328,9 +328,10 @@ class SettingsViewModel @Inject constructor(
*/
val activeBackendIdFlow: StateFlow<String> = engine.backendIdFlow
- /** Non-null when the current pick forced AVF but fell back to QEMU; a
- * short localized reason for the Settings backend caption. See #66. */
- val backendFallback: StateFlow<String?> = engine.backendFallback
+ /** Non-null when the current pick forced AVF but fell back to QEMU; the
+ * @StringRes ID for the Settings backend caption. The screen resolves it
+ * in the current locale. See #66. */
+ val backendFallback: StateFlow<Int?> = engine.backendFallback
private val _exportError = MutableStateFlow<String?>(null)
/** One-shot export failure message; clear after showing with [clearExportError]. */
diff --git a/app/src/test/java/com/excp/podroid/engine/EngineHolderDecideBackendTest.kt b/app/src/test/java/com/excp/podroid/engine/EngineHolderDecideBackendTest.kt
index 3f17f76..e3a70ce 100644
--- a/app/src/test/java/com/excp/podroid/engine/EngineHolderDecideBackendTest.kt
+++ b/app/src/test/java/com/excp/podroid/engine/EngineHolderDecideBackendTest.kt
@@ -4,8 +4,11 @@
*/
package com.excp.podroid.engine
+import com.excp.podroid.R
import com.excp.podroid.engine.EngineHolder.Companion.FallbackReason
import com.excp.podroid.engine.EngineHolder.Companion.decideBackend
+import com.excp.podroid.engine.EngineHolder.Companion.fallbackReasonResId
+import com.excp.podroid.engine.avf.AvfReport
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test
@@ -85,4 +88,64 @@ class EngineHolderDecideBackendTest {
assertEquals("qemu", backendId)
assertEquals(FallbackReason.PROTECTED_ONLY, reason)
}
+
+ @Test
+ fun `protected-only fallback maps to its dedicated resource`() {
+ assertEquals(
+ R.string.backend_fallback_reason_protected_only,
+ fallbackReasonResId(
+ FallbackReason.PROTECTED_ONLY,
+ report(featureSupported = false),
+ ),
+ )
+ }
+
+ @Test
+ fun `unavailable fallback reports the missing feature first`() {
+ assertEquals(
+ R.string.backend_fallback_reason_feature,
+ fallbackReasonResId(
+ FallbackReason.UNAVAILABLE,
+ report(featureSupported = false),
+ ),
+ )
+ }
+
+ @Test
+ fun `unavailable fallback reports missing permissions before service`() {
+ assertEquals(
+ R.string.backend_fallback_reason_permissions,
+ fallbackReasonResId(
+ FallbackReason.UNAVAILABLE,
+ report(managePermissionGranted = false, serviceReachable = false),
+ ),
+ )
+ }
+
+ @Test
+ fun `unavailable fallback reports service when prerequisites are present`() {
+ assertEquals(
+ R.string.backend_fallback_reason_service,
+ fallbackReasonResId(
+ FallbackReason.UNAVAILABLE,
+ report(serviceReachable = false),
+ ),
+ )
+ }
+
+ private fun report(
+ featureSupported: Boolean = true,
+ managePermissionGranted: Boolean = true,
+ customPermissionGranted: Boolean = true,
+ serviceReachable: Boolean = true,
+ ) = AvfReport(
+ featureSupported = featureSupported,
+ managePermissionGranted = managePermissionGranted,
+ customPermissionGranted = customPermissionGranted,
+ virtApexPresent = true,
+ managerClassPresent = true,
+ serviceReachable = serviceReachable,
+ customVmConfigSupported = true,
+ smokeTestResult = null,
+ )
}