diff options
Diffstat (limited to 'docs')
| -rw-r--r-- | docs/superpowers/plans/2026-11-05-git-dialogs-compose.md | 904 | ||||
| -rw-r--r-- | docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md | 37 |
2 files changed, 925 insertions, 16 deletions
diff --git a/docs/superpowers/plans/2026-11-05-git-dialogs-compose.md b/docs/superpowers/plans/2026-11-05-git-dialogs-compose.md new file mode 100644 index 00000000..e0bd176b --- /dev/null +++ b/docs/superpowers/plans/2026-11-05-git-dialogs-compose.md @@ -0,0 +1,904 @@ +# Git dialogs to Compose Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Remove Material Components and the app's own AppCompat use, moving the last View dialogs and the snackbar to Compose, at minSdk 31. + +**Architecture:** An activity-scoped `Prompts` ViewModel holds pending dialogs and the current snackbar as Compose state; `PromptHost()` draws them at the root of `MainActivity` and `AutofillSaveActivity`. Git code reaches it through `activity.prompts`. Spec: `docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md`. + +**Tech Stack:** Kotlin, Jetpack Compose Material 3, AndroidX Lifecycle, Gradle. No new dependencies. + +Work on `master`. Commits are GPG signed; never disable signing. Do not push until the user asks. Run commands from the repository root. Prefix Gradle with `CI=1` where shown: Kotlin warnings become errors, and lint has `warningsAsErrors`. + +## File structure + +- Create `app/src/main/java/app/passwordstore/ui/prompts/Prompts.kt`: state (`Prompts`, `Prompt`, `Choice`, `Snack`) and drawing (`PromptHost`). +- Create `app/src/test/java/app/passwordstore/ui/prompts/PromptsTest.kt`. +- Delete `app/src/main/java/app/passwordstore/util/autofill/Api26AutofillResponseBuilder.kt`, `app/src/main/res/values-v29/`, `app/src/main/res/layout/git_credential_layout.xml`. +- Everything else is a modification listed per task. + +--- + +### Task 1: minSdk 31 and dead branches + +**Files:** +- Modify: `build-logic/src/main/kotlin/app/passwordstore/gradle/AndroidCommon.kt:23` +- Modify: `app/src/main/java/app/passwordstore/injection/AutofillResponseBuilderModule.kt` +- Modify: `app/src/main/java/app/passwordstore/ui/crypto/CryptoExtensions.kt:54-71` +- Modify: `ui/compose/src/main/kotlin/app/passwordstore/ui/compose/theme/Theme.kt:87` +- Modify: `app/src/test/java/app/passwordstore/util/viewmodel/StrictDomainRegexTest.kt:19` +- Modify: every `SDK_INT` site listed in Step 4, `app/src/main/res/values/arrays.xml`, `app/src/main/res/values/prefs.xml`, `strings.xml` in `values` and 10 locales +- Delete: `Api26AutofillResponseBuilder.kt`, `app/src/main/res/values-v29/` + +- [ ] **Step 1: Raise minSdk** + +In `AndroidCommon.kt`: `defaultConfig.minSdk = 31`. + +- [ ] **Step 2: Drop the Api26 builder** + +`AutofillResponseBuilderModule.kt` body becomes: + +```kotlin + @Provides + @Reusable + fun provideAutofillResponseBuilder(): AutofillResponseBuilder.Factory = + Api30AutofillResponseBuilder.Factory +``` + +Remove the `Build` and `Api26AutofillResponseBuilder` imports, delete `Api26AutofillResponseBuilder.kt`, and remove `@RequiresApi(Build.VERSION_CODES.R)` from `Api30AutofillResponseBuilder.kt:34`. + +- [ ] **Step 3: Simplify the clipboard helper** + +In `CryptoExtensions.kt`: + +```kotlin +/** Copies provided [text] to the clipboard, flagged sensitive. */ +fun FragmentActivity.copyTextToClipboard(text: String?) { + val clipboard = clipboard ?: return + val clip = ClipData.newPlainText("pgp_handler_result_pm", text) + clip.description.extras = + PersistableBundle().apply { putBoolean("android.content.extra.IS_SENSITIVE", true) } + clipboard.setPrimaryClip(clip) +} +``` + +Remove imports that become unused (`Build`, `StringRes`, `snackbar`) if nothing else in the file needs them. + +- [ ] **Step 4: Remove obsolete version checks** + +Rule: a check against `P`, `Q`, `R` or `S` is now always true for `>=` and always false for `<`. Keep the taken branch, delete the other, and delete the condition. Checks against `TIRAMISU` and `UPSIDE_DOWN_CAKE` stay. + +Sites: + +- `app/src/main/java/app/passwordstore/`: `util/services/ClipboardService.kt:124`, `Application.kt:105,109,113,117`, `util/crypto/KeystorePreferences.kt:70,80,94`, `util/autofill/AutofillResponseBuilder.kt:44` (if line numbers moved, grep for `SDK_INT`), `util/services/OreoAutofillService.kt:77`, `util/git/sshj/SshKey.kt:160,201,321`, `util/autofill/AutofillViewUtils.kt:50,59`, `util/auth/BiometricAuthenticator.kt:32`, `ui/autofill/AutofillPublisherChangedActivity.kt:57`, `ui/autofill/AutofillFilterView.kt:77`, `ui/autofill/AutofillDecryptActivity.kt:371`, `ui/settings/ProxyViewModel.kt:23`, `ui/editor/EditorViewModel.kt:171`. +- `autofill-parser/src/main/java/com/github/androidpasswordstore/autofillparser/`: `PublicSuffixListCache.kt:56`, `AutofillHelper.kt:59,89,123`, `FeatureAndTrustDetection.kt:241`. +- `ui/compose/.../Theme.kt:87`: the case becomes `dynamicColor -> {`. + +Note `FeatureAndTrustDetection.kt:241`: `SDK_INT < P` is false, so the whole `||`/`&&` expression must be reduced by hand, not just deleted. At `AutofillHelper.kt:123` the `P` case of the `when` becomes `else`, and any older `else` goes. `KeystorePreferences.kt:80` still returns early on `!strongBox`. + +Then remove the obsolete annotations: + +```bash +grep -rl 'RequiresApi(Build.VERSION_CODES.O)' autofill-parser/src/main | xargs sed -i '/@RequiresApi(Build.VERSION_CODES.O)/d' +``` + +- [ ] **Step 5: Fold `values-v29` into `values`** + +In `app/src/main/res/values/arrays.xml`, the `app_theme_options` third item becomes `@string/pref_app_theme_value_follow_system` and the `app_theme_values` third item becomes `follow_system`. In `values/prefs.xml`, `app_theme_def` becomes `follow_system`. Then: + +```bash +command rm -r app/src/main/res/values-v29 +grep -rl pref_app_theme_value_battery_saver app/src/main/res | xargs sed -i '/pref_app_theme_value_battery_saver/d' +``` + +- [ ] **Step 6: Fix the test below minSdk** + +In `StrictDomainRegexTest.kt` delete `@Config(sdk = [23])` and its import. + +- [ ] **Step 7: Verify** + +Run: `./gradlew spotlessApply && CI=1 ./gradlew spotlessCheck test -PslimTests :app:assembleDebug lint metalavaCheckCompatibilityRelease` + +Expected: BUILD SUCCESSFUL. Lint failures name leftovers: `ObsoleteSdkInt` means a missed check, `UnusedResources` means a string or resource only the deleted code used; delete it, including its translations. If metalava reports an API change in `autofill-parser`, run `./gradlew metalavaGenerateRelease` and include the signature file. + +- [ ] **Step 8: Commit** + +```bash +git add -A +git commit -m "build: raise minSdk to 31 + +The project targets GrapheneOS, which only runs current Android. Android 12 +gives the platform night mode API and removes the fingerprint dialog path that +needs AppCompat. Devices below it stay on 0.2.0. + +Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>" +``` + +--- + +### Task 2: Prompts state + +**Files:** +- Create: `app/src/main/java/app/passwordstore/ui/prompts/Prompts.kt` +- Test: `app/src/test/java/app/passwordstore/ui/prompts/PromptsTest.kt` + +- [ ] **Step 1: Write the failing test** + +```kotlin +/* + * Copyright (C) 2026 Danilo M. <danix@danix.xyz> + * SPDX-License-Identifier: GPL-3.0-only + */ + +package app.passwordstore.ui.prompts + +import androidx.compose.material3.SnackbarDuration +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertSame +import kotlinx.coroutines.CoroutineStart +import kotlinx.coroutines.async +import kotlinx.coroutines.runBlocking + +class PromptsTest { + + private fun Prompts.question() = current as Question + + @Test + fun answerResumesAsk() = runBlocking { + val prompts = Prompts() + val asked = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("t", "m", "ok") } + prompts.answer(prompts.question(), Choice.Other) + assertEquals(Choice.Other, asked.await()) + assertNull(prompts.current) + } + + @Test + fun dismissingAnswersCancel() = runBlocking { + val prompts = Prompts() + val asked = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("t", "m", "ok") } + prompts.cancel(prompts.question()) + assertEquals(Choice.Cancel, asked.await()) + } + + @Test + fun secondAnswerIsIgnored() = runBlocking { + val prompts = Prompts() + val asked = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("t", "m", "ok") } + val question = prompts.question() + prompts.answer(question, Choice.Confirm) + prompts.answer(question, Choice.Cancel) + assertEquals(Choice.Confirm, asked.await()) + } + + @Test + fun cancelledAskRemovesItsDialog() = runBlocking { + val prompts = Prompts() + val asked = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("t", "m", "ok") } + asked.cancel() + assertNull(prompts.current) + } + + @Test + fun promptsShowOneAtATimeInOrder() = runBlocking { + val prompts = Prompts() + val first = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("1", "m", "ok") } + val second = async(start = CoroutineStart.UNDISPATCHED) { prompts.ask("2", "m", "ok") } + assertEquals("1", prompts.question().title) + prompts.answer(prompts.question(), Choice.Confirm) + assertEquals("2", prompts.question().title) + prompts.answer(prompts.question(), Choice.Confirm) + first.await() + second.await() + } + + @Test + fun cancelAllAnswersAPendingCredentialWithNull() { + val prompts = Prompts() + val answers = mutableListOf<CredentialAnswer?>(CredentialAnswer("unset", false)) + prompts.askCredential("m", "h", "r", null) { answers[0] = it } + prompts.cancelAll() + assertNull(answers[0]) + assertNull(prompts.current) + } + + @Test + fun newSnackbarReplacesTheCurrentOne() { + val prompts = Prompts() + val first = prompts.snackbar("one", SnackbarDuration.Indefinite) + val second = prompts.snackbar("two", SnackbarDuration.Short) + assertSame(second, prompts.snack) + // The finished operation dismisses its own snackbar only. + prompts.dismiss(first) + assertSame(second, prompts.snack) + prompts.dismiss(second) + assertNull(prompts.snack) + } +} +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `./gradlew :app:testDebugUnitTest -PslimTests --tests 'app.passwordstore.ui.prompts.PromptsTest'` +Expected: FAIL, compilation error, unresolved reference `Prompts`. + +- [ ] **Step 3: Write the state** + +`app/src/main/java/app/passwordstore/ui/prompts/Prompts.kt`: + +```kotlin +/* + * Copyright (C) 2026 Danilo M. <danix@danix.xyz> + * SPDX-License-Identifier: GPL-3.0-only + */ + +package app.passwordstore.ui.prompts + +import androidx.compose.material3.SnackbarDuration +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.fragment.app.FragmentActivity +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import kotlin.coroutines.resume +import kotlinx.coroutines.suspendCancellableCoroutine + +/** The button that answered a [Question]. Dismissing the dialog answers [Cancel]. */ +enum class Choice { + Confirm, + Other, + Cancel, +} + +/** What the user entered in a [CredentialRequest]. */ +class CredentialAnswer(val text: String, val remember: Boolean) + +/** A dialog waiting for its answer; [cancelled] is the answer to dismissing it. */ +sealed class Prompt<T>(private val cancelled: T, private val deliver: (T) -> Unit) { + internal fun answer(value: T) = deliver(value) + + internal fun cancel() = deliver(cancelled) +} + +class Question( + val title: String, + val message: String, + val confirm: String, + val cancel: String?, + val other: String?, + deliver: (Choice) -> Unit, +) : Prompt<Choice>(Choice.Cancel, deliver) + +class CredentialRequest( + val message: String, + val hint: String, + val remember: String, + val error: String?, + deliver: (CredentialAnswer?) -> Unit, +) : Prompt<CredentialAnswer?>(null, deliver) + +/** A snackbar; each one is a distinct object, so showing the same text again shows it again. */ +class Snack(val message: String, val length: SnackbarDuration) + +/** + * The dialogs and the snackbar of one activity, for code with no composable of its own (git + * operations and store actions), drawn by [PromptHost]. Reach it through [prompts]. + */ +class Prompts : ViewModel() { + + private val queue = mutableStateListOf<Prompt<*>>() + + /** The dialog on screen. The others wait for it to be answered. */ + val current: Prompt<*>? + get() = queue.firstOrNull() + + var snack by mutableStateOf<Snack?>(null) + private set + + /** Shows a dialog and suspends until it is answered. Cancelling the caller closes it. */ + suspend fun ask( + title: String, + message: String, + confirm: String, + cancel: String? = null, + other: String? = null, + ): Choice = suspendCancellableCoroutine { cont -> + val question = Question(title, message, confirm, cancel, other) { cont.resume(it) } + queue += question + cont.invokeOnCancellation { queue.remove(question) } + } + + /** + * Asks for a credential. Not suspending: the SSH thread waits on [deliver], and no cancellation + * reaches it, so this dialog outlives a recreated activity and is drawn again by the new one. + */ + fun askCredential( + message: String, + hint: String, + remember: String, + error: String?, + deliver: (CredentialAnswer?) -> Unit, + ) { + queue += CredentialRequest(message, hint, remember, error, deliver) + } + + /** Answers [prompt], once: a double tap must not resume its caller twice. */ + fun <T> answer(prompt: Prompt<T>, value: T) { + if (queue.remove(prompt)) prompt.answer(value) + } + + fun cancel(prompt: Prompt<*>) { + if (queue.remove(prompt)) prompt.cancel() + } + + fun cancelAll() { + queue.toList().forEach(::cancel) + } + + /** Shows [message] in place of any current snackbar, as the View snackbar did. */ + fun snackbar(message: String, length: SnackbarDuration = SnackbarDuration.Short): Snack = + Snack(message, length).also { snack = it } + + /** Hides [shown], unless another snackbar replaced it. */ + fun dismiss(shown: Snack) { + if (snack === shown) snack = null + } + + override fun onCleared() = cancelAll() +} + +/** The [Prompts] of this activity; it survives recreation. */ +val FragmentActivity.prompts: Prompts + get() = ViewModelProvider(this)[Prompts::class.java] +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `./gradlew :app:testDebugUnitTest -PslimTests --tests 'app.passwordstore.ui.prompts.PromptsTest'` +Expected: PASS, 7 tests. No commit yet: nothing uses the file, Task 3 commits it with its callers. + +--- + +### Task 3: PromptHost and all call sites + +**Files:** +- Modify: `app/src/main/java/app/passwordstore/ui/prompts/Prompts.kt` +- Modify: `ui/main/MainActivity.kt`, `ui/autofill/AutofillSaveActivity.kt` +- Modify: `util/extensions/AndroidExtensions.kt`, `util/git/GitCommandExecutor.kt` +- Modify: `util/git/operation/CredentialFinder.kt`, `util/git/operation/BreakOutOfDetached.kt`, `util/git/operation/GitOperation.kt` +- Modify: `ui/git/base/BaseGitActivity.kt`, `ui/list/StoreActions.kt` +- Modify: `ui/setup/PgpKeysScreen.kt`, `ui/setup/GitServerScreen.kt`, `ui/settings/GitConfigScreen.kt`, `ui/editor/EditorDestination.kt` +- Delete: `app/src/main/res/layout/git_credential_layout.xml` + +Paths without a root are under `app/src/main/java/app/passwordstore/`. + +- [ ] **Step 1: Add `PromptHost` to `Prompts.kt`** + +```kotlin +/** Draws the [Prompts] of [activity]. Place it after the activity's content, inside `APSTheme`. */ +@Composable +fun PromptHost(activity: FragmentActivity) { + val prompts = remember(activity) { activity.prompts } + val snackbars = remember { SnackbarHostState() } + val snack = prompts.snack + // A new snack cancels this effect, which takes the old one off the screen. + LaunchedEffect(snack) { + if (snack != null) { + snackbars.showSnackbar(snack.message, duration = snack.length) + prompts.dismiss(snack) + } + } + Box(Modifier.fillMaxSize().navigationBarsPadding().imePadding(), Alignment.BottomCenter) { + SnackbarHost(snackbars) + } + val prompt = prompts.current + // Keyed: a retry is a new request and starts with an empty field. + key(prompt) { + when (prompt) { + is Question -> QuestionDialog(prompt, prompts) + is CredentialRequest -> CredentialDialog(prompt, prompts) + null -> {} + } + } +} + +@Composable +private fun QuestionDialog(question: Question, prompts: Prompts) { + AlertDialog( + onDismissRequest = { prompts.cancel(question) }, + title = { Text(question.title) }, + text = { Text(question.message) }, + confirmButton = { + TextButton(onClick = { prompts.answer(question, Choice.Confirm) }) { + Text(question.confirm) + } + }, + dismissButton = { + // No Row: the dialog's button area wraps its children when they do not fit. + question.cancel?.let { + TextButton(onClick = { prompts.answer(question, Choice.Cancel) }) { Text(it) } + } + question.other?.let { + TextButton(onClick = { prompts.answer(question, Choice.Other) }) { Text(it) } + } + }, + ) +} + +/** The credential lives only in `remember` and the dialog's window is FLAG_SECURE. */ +@Composable +private fun CredentialDialog(request: CredentialRequest, prompts: Prompts) { + // remember, never rememberSaveable: the credential must not reach saved state. + var text by remember { mutableStateOf("") } + var keep by remember { mutableStateOf(false) } + var revealed by remember { mutableStateOf(false) } + var error by remember { mutableStateOf(request.error) } + val focus = remember { FocusRequester() } + fun submit() = prompts.answer(request, CredentialAnswer(text, keep)) + AlertDialog( + onDismissRequest = { prompts.cancel(request) }, + properties = DialogProperties(securePolicy = SecureFlagPolicy.SecureOn), + title = { Text(stringResource(R.string.passphrase_dialog_title)) }, + text = { + Column { + Text(request.message) + OutlinedTextField( + value = text, + onValueChange = { + text = it + error = null + }, + modifier = Modifier.focusRequester(focus), + label = { Text(request.hint) }, + supportingText = error?.let { { Text(it) } }, + isError = error != null, + trailingIcon = { + IconButton(onClick = { revealed = !revealed }) { + Icon( + painterResource( + if (revealed) composeR.drawable.baseline_visibility_off_24 + else composeR.drawable.baseline_visibility_24 + ), + contentDescription = + stringResource( + if (revealed) R.string.entry_hide_password else R.string.entry_show_password + ), + ) + } + }, + visualTransformation = + if (revealed) VisualTransformation.None else PasswordVisualTransformation(), + singleLine = true, + keyboardOptions = + KeyboardOptions( + autoCorrectEnabled = false, + keyboardType = KeyboardType.Password, + imeAction = ImeAction.Done, + ), + keyboardActions = KeyboardActions(onDone = { submit() }), + ) + Row( + Modifier.toggleable(value = keep, role = Role.Checkbox, onValueChange = { keep = it }), + verticalAlignment = Alignment.CenterVertically, + ) { + Checkbox(checked = keep, onCheckedChange = null) + Text(request.remember) + } + } + LaunchedEffect(Unit) { focus.requestFocus() } + }, + confirmButton = { TextButton(onClick = ::submit) { Text(stringResource(R.string.dialog_ok)) } }, + dismissButton = { + TextButton(onClick = { prompts.cancel(request) }) { + Text(stringResource(R.string.dialog_cancel)) + } + }, + ) +} +``` + +Imports follow `ProxyScreen.kt` (including its `composeR` alias for the `ui:compose` R class) and `EntryDestination.kt`'s `PassphraseDialog`. + +- [ ] **Step 2: Host it** + +`MainActivity.kt`: directly after the `NavHost(...) { ... }` call, still inside `APSTheme { }`, add `PromptHost(this@MainActivity)`. + +`AutofillSaveActivity.kt`: after the `EditorDestination(...)` call inside `APSTheme { }`, add `PromptHost(this@AutofillSaveActivity)`, and change `activity = this` above it only if the compiler needs the label. + +- [ ] **Step 3: Replace the snackbar helper** + +In `AndroidExtensions.kt`: + +```kotlin +/** Shows a snackbar through this activity's [prompts]; it must host a `PromptHost`. */ +fun FragmentActivity.snackbar( + message: String, + length: SnackbarDuration = SnackbarDuration.Short, +): Snack = prompts.snackbar(message, length) +``` + +Remove the `Snackbar` and `View` imports if unused. At every caller replace `Snackbar.LENGTH_LONG` with `SnackbarDuration.Long` and the `com.google.android.material.snackbar.Snackbar` import with `androidx.compose.material3.SnackbarDuration`: `ui/setup/PgpKeysScreen.kt`, `ui/setup/GitServerScreen.kt`, `ui/settings/GitConfigScreen.kt`, `ui/editor/EditorDestination.kt`. + +In `GitCommandExecutor.kt`: + +```kotlin + val running = + activity.snackbar( + message = activity.resources.getString(R.string.git_operation_running), + length = SnackbarDuration.Indefinite, + ) +``` + +and the end of `execute()` becomes `.also { activity.prompts.dismiss(running) }`. + +- [ ] **Step 4: Credential dialog** + +In `CredentialFinder.kt`, replace the whole `if (storedCredential == null) { ... }` branch body, keeping the `else`: + +```kotlin + if (storedCredential == null) { + val resources = callingActivity.resources + callingActivity.prompts.askCredential( + message = resources.getString(messageRes), + hint = resources.getString(hintRes), + remember = resources.getString(rememberRes), + error = if (isRetry) resources.getString(errorRes) else null, + ) { answer -> + if (answer?.remember == true) { + gitOperationPrefs.edit { putString(credentialPref, answer.text) } + } + cont.resume(answer?.text) + } + } else { +``` + +Remove the imports of `SuppressLint`, `LayoutInflater`, `WindowManager`, `doOnTextChanged` and the four Material classes. Delete `app/src/main/res/layout/git_credential_layout.xml`. + +- [ ] **Step 5: Operations** + +`GitOperation.kt`: `open suspend fun preExecute() = true`, and: + +```kotlin + private suspend fun onMissingSshKeyFile() { + val resources = callingActivity.resources + val choice = + callingActivity.prompts.ask( + title = resources.getString(R.string.ssh_preferences_dialog_title), + message = resources.getString(R.string.ssh_preferences_dialog_text), + confirm = resources.getString(R.string.button_label_import), + cancel = resources.getString(R.string.dialog_cancel), + other = resources.getString(R.string.ssh_preferences_dialog_generate), + ) + when (choice) { + Choice.Confirm -> getSshKey(false) + Choice.Other -> getSshKey(true) + // Only closes the dialog: the calling activity is the app's own screen now. + Choice.Cancel -> {} + } + } +``` + +`BreakOutOfDetached.kt`: + +```kotlin + override suspend fun preExecute() = + if (!git.repository.repositoryState.isRebasing && !merging) { + val resources = callingActivity.resources + callingActivity.prompts.ask( + title = resources.getString(R.string.git_abort_and_push_title), + message = resources.getString(R.string.git_break_out_of_detached_unneeded), + confirm = resources.getString(R.string.dialog_ok), + ) + false + } else { + true + } +``` + +`AndroidExtensions.kt:73`: `override suspend fun preExecute(): Boolean {`. + +- [ ] **Step 6: Error dialog** + +`BaseGitActivity.kt`: + +```kotlin + suspend fun promptOnErrorHandler(err: Throwable) { + val error = rootCauseException(err) + if (!isExplicitlyUserInitiatedError(error)) { + gitPrefs.edit { remove(PreferenceKeys.HTTPS_PASSWORD) } + sharedPrefs.edit { remove(PreferenceKeys.SSH_OPENKEYSTORE_KEYID) } + logcat { error.asLog() } + prompts.ask( + title = getString(R.string.jgit_error_dialog_title), + message = ErrorMessages[error], + confirm = getString(R.string.dialog_ok), + ) + } + } +``` + +No caller passes `onPromptDone`. Drop the `withContext` import if unused. + +- [ ] **Step 7: Store actions** + +`StoreActions.kt`, in `moveFile`, replacing the dialog and its `ponytail` comment: + +```kotlin + prompts.ask( + title = getString(R.string.password_move_error_title), + message = getString(R.string.password_move_error_message, source, destination), + confirm = getString(R.string.dialog_ok), + ) +``` + +and `confirm`: + +```kotlin +/** Shows [message] under [title] and suspends until answered; true when confirmed. */ +private suspend fun BaseGitActivity.confirm(title: String, message: String): Boolean = + prompts.ask( + title = title, + message = message, + confirm = getString(R.string.dialog_ok), + cancel = getString(R.string.dialog_cancel), + ) == Choice.Confirm +``` + +Remove `MaterialAlertDialogBuilder`, `resume` and `suspendCancellableCoroutine` imports. `Context` stays for `recordUse` and `moveHistory`. + +- [ ] **Step 8: Verify no Material dialog or snackbar is left** + +Run: `grep -rnE 'MaterialAlertDialog|material\.snackbar|material\.checkbox|material\.textfield' app/src/main` +Expected: no output. + +Run: `./gradlew spotlessApply && CI=1 ./gradlew spotlessCheck test -PslimTests :app:assembleDebug lint` +Expected: BUILD SUCCESSFUL. Delete any string lint reports unused, with its translations. + +- [ ] **Step 9: Commit** + +```bash +git add -A +git commit -m "feat(app): move the git dialogs and the snackbar to Compose + +An activity-scoped Prompts ViewModel holds them, since git operations have no +composable to draw in; PromptHost draws them. The credential dialog's window is +now FLAG_SECURE, and a recreated activity no longer loses it and strands the +SSH thread. + +Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>" +``` + +--- + +### Task 4: AppCompat out of the code + +**Files:** +- Modify: `ui/git/base/BaseGitActivity.kt`, `ui/main/LaunchActivity.kt`, `ui/autofill/AutofillDecryptActivity.kt`, `ui/autofill/AutofillFilterView.kt`, `ui/autofill/AutofillPublisherChangedActivity.kt`, `ui/autofill/AutofillSaveActivity.kt` +- Modify: `util/git/operation/{Push,Pull,Sync,Clone,Gc,ResetToRemote,BreakOutOfDetached,GitOperation}*.kt`, `util/git/sshj/SshjSessionFactory.kt` +- Modify: `Application.kt` +- Modify: `ui/compose/src/main/kotlin/app/passwordstore/ui/compose/theme/Theme.kt` +- Modify: `app/src/main/res/values/themes_material3.xml`, `app/src/main/res/values-night/themes_material3.xml` +- Test: `app/src/test/java/app/passwordstore/ui/main/LaunchActivityTest.kt` must keep passing + +- [ ] **Step 1: Activities and operations** + +```bash +grep -rl 'androidx.appcompat.app.AppCompatActivity' app/src | xargs sed -i \ + -e 's/androidx\.appcompat\.app\.AppCompatActivity/androidx.fragment.app.FragmentActivity/' \ + -e 's/\bAppCompatActivity\b/FragmentActivity/g' +sed -i '/supportActionBar?.hide()/d' \ + app/src/main/java/app/passwordstore/ui/autofill/AutofillFilterView.kt \ + app/src/main/java/app/passwordstore/ui/autofill/AutofillPublisherChangedActivity.kt +``` + +Update the `MainActivity` class comment: "Extends [BaseGitActivity] (a FragmentActivity, which BiometricPrompt needs) because the git operations require one; it hosts no fragments." + +- [ ] **Step 2: Night mode** + +`Application.kt`, replacing the `AppCompatDelegate.*` import with `android.app.UiModeManager`, and removing the `DynamicColors` import and call: + +```kotlin + private fun setNightMode() { + getSystemService(UiModeManager::class.java) + .setApplicationNightMode( + when (prefs.getString(PreferenceKeys.APP_THEME) ?: getString(R.string.app_theme_def)) { + "light" -> UiModeManager.MODE_NIGHT_NO + "dark" -> UiModeManager.MODE_NIGHT_YES + else -> UiModeManager.MODE_NIGHT_AUTO + } + ) + } +``` + +- [ ] **Step 3: Window themes** + +`values/themes_material3.xml`, whole `resources` body. Style names stay: renaming them is churn. + +```xml + <style name="AppThemeM3" parent="APSThemeM3"> + <item name="android:windowLightStatusBar">@bool/light_status_bar</item> + </style> + + <!-- Activities whose whole UI is Compose --> + <style name="NoActionBarThemeM3" parent="AppThemeM3" /> + + <style name="NoBackgroundThemeM3" parent="@style/AppThemeM3"> + <item name="android:background">@android:color/transparent</item> + <item name="android:backgroundDimEnabled">true</item> + <item name="android:navigationBarColor">@android:color/transparent</item> + <item name="android:statusBarColor">@android:color/transparent</item> + <item name="android:windowIsTranslucent">true</item> + <item name="android:windowContentOverlay">@null</item> + <item name="android:windowBackground">@android:color/transparent</item> + <item name="android:windowEnterAnimation">@android:anim/fade_in</item> + <item name="android:windowExitAnimation">@android:anim/fade_out</item> + </style> + + <style name="DialogLikeThemeM3" parent="AppThemeM3"> + <item name="android:windowIsFloating">true</item> + <item name="android:backgroundDimEnabled">true</item> + </style> + + <style name="APSThemeM3" parent="android:Theme.Material.Light.NoActionBar" /> +``` + +`values-night/themes_material3.xml`, whole `resources` body: + +```xml + <style name="APSThemeM3" parent="android:Theme.Material.NoActionBar" /> +``` + +The `android:windowLightStatusBar` item needs `@bool/light_status_bar`, which `values-night/bools.xml` already flips. + +- [ ] **Step 4: System bars** + +`Theme.kt`, the existing `SideEffect`: + +```kotlin + val view = LocalView.current + if (!view.isInEditMode) { + SideEffect { + val window = (view.context as Activity).window + val bars = WindowCompat.getInsetsController(window, view) + bars.isAppearanceLightStatusBars = !darkTheme + bars.isAppearanceLightNavigationBars = !darkTheme + paintBars(window, colorScheme.background.toArgb()) + } + } +``` + +```kotlin +/** Colors the system bars, except in windows that keep them see-through (autofill decryption). */ +@Suppress("DEPRECATION") // Deprecated with edge-to-edge, which targetSdk 34 does not force. +private fun paintBars(window: Window, color: Int) { + if (window.statusBarColor == AndroidColor.TRANSPARENT) return + window.statusBarColor = color + window.navigationBarColor = color +} +``` + +Imports: `android.graphics.Color as AndroidColor`, `android.view.Window`, `androidx.compose.ui.graphics.toArgb`. + +- [ ] **Step 5: Verify** + +Run: `grep -rn 'androidx.appcompat' app/src/main ui autofill-parser/src/main/java/com/github/androidpasswordstore/autofillparser/AutofillHelper.kt` +Expected: no output. (`FormField.kt` naming `androidx.appcompat.widget.AppCompatEditText` is a class name matched in other apps' forms and stays.) + +Run: `./gradlew spotlessApply && CI=1 ./gradlew spotlessCheck test -PslimTests :app:assembleDebug lint` +Expected: BUILD SUCCESSFUL. `metalava` is unaffected: the theme module's public API does not change. + +- [ ] **Step 6: Commit** + +```bash +git add -A +git commit -m "refactor(app): take the app's own code off AppCompat + +Activities extend FragmentActivity, window themes derive from the platform's +Material theme and night mode uses UiModeManager. APSTheme colors the system +bars, which DynamicColors did through the window theme. AppCompat stays in the +APK through zxing. + +Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>" +``` + +--- + +### Task 5: Dependencies, resources, docs + +**Files:** +- Modify: `app/build.gradle.kts:60,65,71`, `gradle/libs.versions.toml:17,30` +- Modify: `app/src/main/res/values/colors_material3.xml`, `AGENTS.md`, `TODO.md` +- Possibly modify: `app/lint-baseline.xml` + +- [ ] **Step 1: Remove the dependencies** + +From `app/build.gradle.kts` remove `implementation(libs.androidx.appcompat)` and `implementation(libs.androidx.material)`, and change the fragment comment to `// FragmentActivity, which BiometricPrompt needs.` From `gradle/libs.versions.toml` remove `androidx-appcompat` and `androidx-material`. + +- [ ] **Step 2: Remove unused colors** + +`oreo_autofill_dataset.xml` uses `@color/md_theme_light_primary`, which stays because it is a `RemoteViews` layout. Delete every other color in `colors_material3.xml`. + +- [ ] **Step 3: Confirm the graph** + +Run: `./gradlew -q :app:dependencies --configuration releaseRuntimeClasspath | grep -E 'google.android.material|appcompat:appcompat' | sort -u` +Expected: no `com.google.android.material` line; `appcompat` only below `zxing-android-embedded` and `biometric`. + +- [ ] **Step 4: Docs** + +`AGENTS.md`: +- Replace the "Material Components (Views) stays after the Compose overhaul" bullet with: "Window themes derive from the platform `android:Theme.Material.*.NoActionBar`, activities from `FragmentActivity` (`BiometricPrompt` needs it). Git operations and store actions show dialogs and snackbars through the activity-scoped `Prompts` ViewModel (`activity.prompts`), drawn by `PromptHost`, which only `MainActivity` and `AutofillSaveActivity` host. AppCompat stays in the APK through zxing (`CaptureManager`, `zxing_CaptureTheme`) and `androidx.biometric`; `oreo_autofill_dataset.xml` stays a layout: fill suggestions are `RemoteViews` drawn by the system." +- In "What this is", add: "minSdk is 31: GrapheneOS runs current Android only, and Android 12 has `UiModeManager.setApplicationNightMode`." + +`TODO.md`: replace the git dialogs item with: + +```markdown +- QR scanner: `zxing-android-embedded` is the last thing keeping AppCompat in the APK + (`androidx.biometric` references it only on the fingerprint dialog path, unused at minSdk 31). + Replacing it would let AppCompat go. +``` + +- [ ] **Step 5: Full check** + +Run: `CI=1 ./gradlew spotlessCheck test -PslimTests :app:assembleDebug :app:assembleRelease lint metalavaCheckCompatibilityRelease` +Expected: BUILD SUCCESSFUL. A lint error about a baselined jar path means the entry in `app/lint-baseline.xml` needs its path updated (see `AGENTS.md`). + +- [ ] **Step 6: Commit** + +```bash +git add -A +git commit -m "build: remove Material Components and the AppCompat dependency + +Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>" +``` + +--- + +### Task 6: Emulator run + +No code unless a check fails. Use the setup in `AGENTS.md` ("End-to-end testing on an emulator"): `scripts/e2e-env.sh up`, AVD `aps-test`, `export ANDROID_SERIAL=emulator-5554`, animations off, `settings put secure autofill_service null`. `FLAG_SECURE` windows show black in `screencap`: read them from `uiautomator dump`. + +- [ ] **Step 1: Install and clone** + +Run `./gradlew :app:installDebug`, clone from the e2e server, import the PGP key, decrypt an entry. + +- [ ] **Step 2: Check each dialog** + +Each must behave as stated: + +| Check | Expected | +|---|---| +| SSH key with passphrase, wrong passphrase | Dialog returns with the error, cleared on typing, field empty | +| Same, remember ticked, right passphrase | Next sync asks nothing | +| Same, Cancel | Operation stops, no error dialog | +| Tap outside the credential dialog | Same as Cancel | +| Missing SSH key | Three buttons; outside tap only closes; Import and Generate open setup | +| Unreachable server | Git error dialog | +| Conflict, then "abort and push" | Recovery works; notice shows on a clean store | +| Move over an existing entry | Confirm dialog, both answers | +| "Operation running" snackbar | Shows, goes away at the end; "done" replaces it | + +- [ ] **Step 3: Check themes** + +Light, dark and system default in Settings: the app switches, status and navigation bars match the screen, icons readable. With "System default", `adb shell cmd uimode night yes` follows. + +- [ ] **Step 4: Check the rest** + +- Theme change with a credential dialog open: dialog comes back, answering works. +- QR scanner opens from the editor. +- Fingerprint unlock, per `AGENTS.md`. +- Autofill windows via `am start -n` after `adb root` (picker, publisher warning, save editor): no action bar, bars look right. + +- [ ] **Step 5: Fix what failed** + +Each failure gets its own `fix(app):` commit, with the full check from Task 5 Step 5 first. + +- [ ] **Step 6: Ask the user for the device run** + +Autofill save and fill on a real device with Firefox cannot run on the emulator. The website docs live in another repository: check them for a stated minimum Android version and tell the user. Release notes for the next version must state Android 12 as the minimum. + +- [ ] **Step 7: Record the run** + +Update "Last full emulator run" in `AGENTS.md` with the date and what passed; commit as `docs: record the emulator run`. diff --git a/docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md b/docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md index dba171ac..3ccf5fb1 100644 --- a/docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md +++ b/docs/superpowers/specs/2026-11-05-git-dialogs-compose-design.md @@ -31,9 +31,9 @@ below Android 12 stay on 0.2.0; the next release notes must say so. `Prompts` is a ViewModel scoped to the activity, reached with the extension `activity.prompts` (`ViewModelProvider(activity)`), so no interface is needed. It offers: -- `suspend fun ask(title, message, confirm, dismiss = null, neutral = null): Choice`, which - suspends until a button is pressed or the dialog is dismissed. Dismissing counts as the - cancelling answer. +- `suspend fun ask(title, message, confirm, cancel = null, other = null): Choice`, which suspends + until a button is pressed or the dialog is dismissed. Dismissing answers `Choice.Cancel`, so a + tap outside the missing SSH key dialog can never mean "generate". - `askCredential(...)` for the credential dialog, delivering the entered text and the remember choice, or null on cancel. - `snackbar(message, length)`, with `length` short, long or indefinite, returning a handle to @@ -43,14 +43,18 @@ below Android 12 stay on 0.2.0; the next release notes must say so. `AutofillSaveActivity`, the only two activities that show these. It draws the current dialog and a `SnackbarHost` at the bottom of the window, above the navigation bar and keyboard. -The state lives in the ViewModel, so a theme or locale recreation redraws a pending dialog instead -of leaving the operation waiting on a dialog that no longer exists. +The state lives in the ViewModel. Git operations run in the activity's `lifecycleScope`, so a theme +or locale recreation cancels them: `ask` removes its dialog when cancelled. The credential dialog +blocks an SSH thread that cancellation cannot reach, so it stays and is redrawn by the new activity +instead of leaving that thread waiting forever. When the activity finishes for good, `onCleared` +answers every pending prompt with its cancelling answer. ### Dialogs These all move to `ask`: -- the git error dialog in `BaseGitActivity.promptOnErrorHandler`, keeping `onPromptDone` +- the git error dialog in `BaseGitActivity.promptOnErrorHandler`, whose unused `onPromptDone` + parameter goes - the missing SSH key dialog in `GitOperation` (import, generate, cancel) - `BreakOutOfDetached`'s "not needed" notice - `moveFile`'s error and `confirm` in `StoreActions` @@ -73,7 +77,9 @@ rather than queueing behind it as `SnackbarHostState` does by default. `GitComma ### minSdk `AndroidCommon.kt` sets 31. Branches that become dead are deleted, including the below-Android-11 -snackbar in `copyTextToClipboard` and its parameters. +snackbar in `copyTextToClipboard` and its parameters, and `Api26AutofillResponseBuilder`. Lint runs +with `warningsAsErrors`, so `ObsoleteSdkInt` lists whatever is missed. `StrictDomainRegexTest`'s +`@Config(sdk = [23])` goes, being below minSdk. ### AppCompat out @@ -90,10 +96,10 @@ snackbar in `copyTextToClipboard` and its parameters. `Application.setNightMode` calls `UiModeManager.setApplicationNightMode`: `light` is `MODE_NIGHT_NO`, `dark` is `MODE_NIGHT_YES`, everything else is `MODE_NIGHT_AUTO`. -"Set by Battery Saver" leaves the settings list, and `app_theme_def` becomes `follow_system`. -Android already turns dark in battery saver, so follow-system covers it. A stored `battery_saver` -value falls into the "everything else" case; no migration is needed, but the settings row must -show "System default" for it rather than nothing. +`values-v29` already selects `follow_system` and hides "Set by Battery Saver" on Android 10 and +later, so nothing changes for users: its `arrays.xml` and `prefs.xml` replace the base ones, the +folder goes, and the battery saver string leaves every locale. A stored `battery_saver` value could +only come from a device that ran the app on Android 9 or older; it still maps to `MODE_NIGHT_AUTO`. ### System bars @@ -116,7 +122,7 @@ reports as unused after this (`md_theme_*`) are deleted. :app:assembleRelease lint metalavaCheckCompatibilityRelease`. - Emulator, on the e2e store: credential dialog (wrong passphrase retry, remember, cancel), missing SSH key dialog, git error dialog, conflict recovery, move error, delete and move confirmations, - every theme setting including a stored `battery_saver`, bar colors in light and dark, QR scanner + every theme setting, bar colors in light and dark, QR scanner opens, fingerprint unlock, a theme change while a dialog is open. - Real device with Firefox: autofill save, since its window now hosts `PromptHost`, and the autofill windows' transparent bars. @@ -133,8 +139,7 @@ reports as unused after this (`md_theme_*`) are deleted. 1. minSdk 31 and dead branches. 2. `Prompts`, `PromptHost` and all call sites. -3. Material out: themes, `DynamicColors`, system bars, dependency. -4. AppCompat out: activities, night mode, settings list, dependency, docs. +3. AppCompat out: activities, themes, night mode, `DynamicColors`, system bars. +4. Dependencies and unused resources out, docs. -After step 3 the window themes must still satisfy AppCompat, so that commit moves them to -`Theme.AppCompat.DayNight.NoActionBar`, and step 4 moves them to `android:Theme.Material.*`. +AppCompat goes before the Material dependency so the window themes change only once. |