diff --git a/app/src/androidTest/kotlin/org/libremail/ui/onboarding/BatteryOptimizationStepTest.kt b/app/src/androidTest/kotlin/org/libremail/ui/onboarding/BatteryOptimizationStepTest.kt index a0b0852..d1cbfb2 100644 --- a/app/src/androidTest/kotlin/org/libremail/ui/onboarding/BatteryOptimizationStepTest.kt +++ b/app/src/androidTest/kotlin/org/libremail/ui/onboarding/BatteryOptimizationStepTest.kt @@ -4,6 +4,7 @@ package org.libremail.ui.onboarding import android.app.Activity import android.app.Instrumentation import android.net.Uri +import android.os.ParcelFileDescriptor import android.provider.Settings import androidx.activity.ComponentActivity import androidx.compose.material3.Text @@ -11,8 +12,10 @@ import androidx.compose.runtime.getValue import androidx.compose.ui.test.assertIsDisplayed import androidx.compose.ui.test.junit4.createAndroidComposeRule import androidx.compose.ui.test.onAllNodesWithText +import androidx.compose.ui.test.onNodeWithContentDescription import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performScrollTo import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.navigation.NavType import androidx.navigation.compose.NavHost @@ -26,6 +29,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry import kotlinx.coroutines.runBlocking import org.hamcrest.CoreMatchers.allOf +import org.junit.Before import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith @@ -62,6 +66,25 @@ class BatteryOptimizationStepTest { composeTestRule.onAllNodesWithText(text).fetchSemanticsNodes().isNotEmpty() } + /** + * Disable device animations (as CI's emulator-runner does) so [BatteryOptimizationScreen] renders + * the reduced-motion static guide illustration (#174): the looping variant's infinite transition + * would otherwise never let Compose/Espresso `waitForIdle` settle on a local emulator that boots + * with animations on. + */ + @Before + fun disableAnimations() { + val automation = InstrumentationRegistry.getInstrumentation().uiAutomation + listOf( + "settings put global animator_duration_scale 0", + "settings put global window_animation_scale 0", + "settings put global transition_animation_scale 0", + ).forEach { command -> + ParcelFileDescriptor.AutoCloseInputStream(automation.executeShellCommand(command)) + .use { it.readBytes() } + } + } + /** * Renders the "add another? → battery → inbox" tail with one account already added this session, * starting on the add-another prompt. [handled] seeds the persisted "prompt handled" flag so the @@ -132,12 +155,15 @@ class BatteryOptimizationStepTest { composeTestRule.onNodeWithText(string(R.string.onboarding_add_another_no)).performClick() - // The battery opt-in step is shown... + // The battery opt-in step is shown, with the illustrated "Battery → Unrestricted" guide... waitForText(string(R.string.onboarding_battery_title)) composeTestRule.onNodeWithText(string(R.string.onboarding_battery_title)).assertIsDisplayed() + composeTestRule + .onNodeWithContentDescription(string(R.string.onboarding_battery_animation_description)) + .assertIsDisplayed() // ...and "Not now" continues to the inbox and records the prompt as handled (so it won't nag). - composeTestRule.onNodeWithText(string(R.string.onboarding_battery_not_now)).performClick() + composeTestRule.onNodeWithText(string(R.string.onboarding_battery_not_now)).performScrollTo().performClick() waitForText(INBOX_MARKER) composeTestRule.onNodeWithText(INBOX_MARKER).assertIsDisplayed() composeTestRule.waitUntil(5_000) { runBlocking { settingsRepository.isBatteryPromptHandled() } } @@ -157,7 +183,9 @@ class BatteryOptimizationStepTest { Intents.intending(hasAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)) .respondWith(Instrumentation.ActivityResult(Activity.RESULT_OK, null)) - composeTestRule.onNodeWithText(string(R.string.onboarding_battery_take_me)).performClick() + composeTestRule.onNodeWithText(string(R.string.onboarding_battery_take_me)) + .performScrollTo() + .performClick() // Deep-links to *this app's* details screen (where Battery → Unrestricted lives). Intents.intended( diff --git a/app/src/main/kotlin/org/libremail/mail/GraphSender.kt b/app/src/main/kotlin/org/libremail/mail/GraphSender.kt index a183458..bbe3762 100644 --- a/app/src/main/kotlin/org/libremail/mail/GraphSender.kt +++ b/app/src/main/kotlin/org/libremail/mail/GraphSender.kt @@ -7,6 +7,7 @@ import kotlinx.coroutines.withContext import org.json.JSONArray import org.json.JSONObject import org.libremail.domain.model.OutgoingMessage +import org.libremail.reporting.AppLog import java.io.IOException import java.net.HttpURLConnection import java.net.URL @@ -34,6 +35,14 @@ class GraphSender @Inject constructor() { message: OutgoingMessage, attachments: List = emptyList(), ) = withContext(Dispatchers.IO) { + // Guard before any attachment is read into memory: Graph sendMail carries attachment bytes inline + // (base64) in a single ~4 MB request, so an oversized file would blow that request limit and risk + // an OOM from readBytes(). Fail with mayHaveSent=false so the outbox falls back to SMTP, which + // streams attachments and handles far larger files (#298). + attachments.firstOrNull { it.file.length() > MAX_ATTACHMENT_BYTES }?.let { + AppLog.w(TAG, "Attachment over Graph sendMail size limit; not sending via Graph") + throw GraphSendException("Attachment exceeds the Graph sendMail size limit", mayHaveSent = false) + } val payload = buildSendMailPayload(message, attachments) val connection = (URL(SEND_MAIL_URL).openConnection() as HttpURLConnection).apply { requestMethod = "POST" @@ -76,8 +85,13 @@ class GraphSender @Inject constructor() { } private companion object { + const val TAG = "GraphSender" const val SEND_MAIL_URL = "https://graph.microsoft.com/v1.0/me/sendMail" const val TIMEOUT_MS = 15_000 + + // Per-file ceiling kept below Graph sendMail's ~4 MB whole-request cap, so one attachment can never + // exceed the request limit or OOM when read into the base64 payload; larger files fall back to SMTP. + const val MAX_ATTACHMENT_BYTES = 3L * 1024 * 1024 const val HTTP_OK_MIN = 200 const val HTTP_OK_MAX = 299 const val ERROR_BODY_LIMIT = 500 diff --git a/app/src/main/kotlin/org/libremail/mail/HtmlToText.kt b/app/src/main/kotlin/org/libremail/mail/HtmlToText.kt index 495368a..0c77768 100644 --- a/app/src/main/kotlin/org/libremail/mail/HtmlToText.kt +++ b/app/src/main/kotlin/org/libremail/mail/HtmlToText.kt @@ -12,23 +12,29 @@ package org.libremail.mail */ object HtmlToText { + // Hoisted out of convert() so each pattern is compiled once, not four times per call — convert() + // runs once per fetched HTML body during sync, so this is a hot path (#298). + private val SCRIPT_STYLE = Regex("(?is)<(script|style)\\b[^>]*>.*?") + private val LIST_ITEM = Regex("(?i)]*>") private val BLOCK_BREAK = Regex( "(?i)]*>|", ) - private val LIST_ITEM = Regex("(?i)]*>") + private val TAG = Regex("<[^>]*>") + private val SPACES_AND_TABS = Regex("[ \\t]+") + private val BLANK_LINES = Regex("\n{3,}") fun convert(html: String): String { var s = html // Drop script/style contents outright so their text never leaks into the output. - s = s.replace(Regex("(?is)<(script|style)\\b[^>]*>.*?"), "") + s = SCRIPT_STYLE.replace(s, "") s = LIST_ITEM.replace(s, "\n• ") s = BLOCK_BREAK.replace(s, "\n") - s = s.replace(Regex("<[^>]*>"), "") + s = TAG.replace(s, "") s = decodeEntities(s) // Collapse runs of spaces/tabs, then trim trailing spaces and cap consecutive blank lines. - s = s.replace(Regex("[ \\t]+"), " ") + s = SPACES_AND_TABS.replace(s, " ") s = s.lineSequence().joinToString("\n") { it.trim() } - s = s.replace(Regex("\n{3,}"), "\n\n") + s = BLANK_LINES.replace(s, "\n\n") return s.trim() } diff --git a/app/src/main/kotlin/org/libremail/reporting/DiagnosticsCollector.kt b/app/src/main/kotlin/org/libremail/reporting/DiagnosticsCollector.kt index 2581525..6fdf54a 100644 --- a/app/src/main/kotlin/org/libremail/reporting/DiagnosticsCollector.kt +++ b/app/src/main/kotlin/org/libremail/reporting/DiagnosticsCollector.kt @@ -99,14 +99,24 @@ private fun providerLabel(account: Account): String = when (account.authType) { AuthType.PASSWORD_IMAP -> imapProviderLabel(account.imap.host) } +/** + * Buckets an IMAP host to a coarse provider by matching brand tokens at DNS-label boundaries rather + * than as raw substrings, so a custom domain that merely contains a brand name — e.g. + * `mail.notgmail.example` — is no longer mislabeled (here it would have read as Gmail) (#298). The + * short, common tokens (`me`/`mac`/`live`) match only as a registrable-domain suffix, never as a bare + * label, so an innocent `me.company.example` doesn't read as iCloud either. + */ private fun imapProviderLabel(host: String): String { val h = host.lowercase() + val labels = h.split('.') + fun hasLabel(vararg brands: String) = brands.any { it in labels } + fun hasDomain(vararg domains: String) = domains.any { h == it || h.endsWith(".$it") } return when { - "gmail" in h || "googlemail" in h -> "Gmail" - "yahoo" in h -> "Yahoo" - "icloud" in h || "me.com" in h || "mac.com" in h -> "iCloud" - "outlook" in h || "office365" in h || "hotmail" in h || "live.com" in h -> "Outlook" - "aol" in h -> "AOL" + hasLabel("gmail", "googlemail") -> "Gmail" + hasLabel("yahoo") -> "Yahoo" + hasLabel("icloud") || hasDomain("me.com", "mac.com") -> "iCloud" + hasLabel("outlook", "office365", "hotmail") || hasDomain("live.com") -> "Outlook" + hasLabel("aol") -> "AOL" else -> "Other" } } diff --git a/app/src/main/kotlin/org/libremail/reporting/ReportStore.kt b/app/src/main/kotlin/org/libremail/reporting/ReportStore.kt index 3fe7b67..d4cfa63 100644 --- a/app/src/main/kotlin/org/libremail/reporting/ReportStore.kt +++ b/app/src/main/kotlin/org/libremail/reporting/ReportStore.kt @@ -9,6 +9,9 @@ import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch import java.io.File +import java.nio.file.AtomicMoveNotSupportedException +import java.nio.file.Files +import java.nio.file.StandardCopyOption /** * File-backed store of pending [DebugReport]s — one JSON file per report under [directory]. @@ -52,7 +55,7 @@ class ReportStore( synchronized(lock) { val serialized = serializeForDisk(report) ?: return directory.mkdirs() - File(directory, fileName(report.id)).writeText(serialized) + writeAtomically(File(directory, fileName(report.id)), serialized) _reports.value = scan() } } @@ -69,7 +72,7 @@ class ReportStore( val report = _reports.value.firstOrNull { it.id == id } ?: return if (report.surfaced) return val serialized = serializeForDisk(report.copy(surfaced = true)) ?: return - File(directory, fileName(id)).writeText(serialized) + writeAtomically(File(directory, fileName(id)), serialized) _reports.value = scan() } } @@ -135,10 +138,38 @@ class ReportStore( return runCatching { DebugReport.fromStorageJson(json) }.getOrNull() } + /** + * Writes [content] to [target] via a temp file + atomic rename, so a process death mid-write — the + * crash path that saves a report while the app is dying — can never leave a torn `.json` that [scan] + * would fail to parse and silently drop (#298). The temp file uses a non-`.json` suffix so [scan] + * ignores it (and any orphan left by an interrupted write), and the rename replaces an existing file + * (the [markSurfaced] rewrite) atomically. Falls back to a plain replace on the rare filesystem + * without atomic rename — still safer than an in-place truncate-then-write. + */ + private fun writeAtomically(target: File, content: String) { + val tmp = File(directory, target.name + TMP_SUFFIX) + tmp.writeText(content) + try { + Files.move( + tmp.toPath(), + target.toPath(), + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.REPLACE_EXISTING, + ) + } catch (e: AtomicMoveNotSupportedException) { + AppLog.w(TAG, "Atomic report write unsupported here; falling back to a non-atomic replace", e) + Files.move(tmp.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING) + } + } + private fun fileName(id: String) = "$id$SUFFIX" private companion object { const val SUFFIX = ".json" + + // Suffix for the write-and-rename temp file. Deliberately NOT ending in [SUFFIX] so scan() never + // treats a half-written or orphaned temp as a report (#298). + const val TMP_SUFFIX = ".tmp" const val TAG = "ReportStore" /** diff --git a/app/src/main/kotlin/org/libremail/richtext/RichText.kt b/app/src/main/kotlin/org/libremail/richtext/RichText.kt index 4da265e..23029ad 100644 --- a/app/src/main/kotlin/org/libremail/richtext/RichText.kt +++ b/app/src/main/kotlin/org/libremail/richtext/RichText.kt @@ -109,11 +109,17 @@ internal fun lineMarker(line: String): String? = when { */ internal fun mergeSameValueSpans(spans: List): List { val merged = ArrayList() + // Index of the right-most merged run for each style value. Spans are processed in ascending start + // order, and runs of one value stay non-overlapping with strictly increasing ends, so only that + // value's last run can touch the next span — track it directly instead of re-scanning `merged` for + // every span (the old O(n^2) indexOfLast). The produced list is byte-for-byte identical (#298). + val lastRunByStyle = HashMap() for (span in spans.sortedWith(compareBy({ it.start }, { it.end }))) { - val i = merged.indexOfLast { it.style == span.style && span.start <= it.end } - if (i >= 0) { + val i = lastRunByStyle[span.style] + if (i != null && span.start <= merged[i].end) { merged[i] = merged[i].copy(end = maxOf(merged[i].end, span.end)) } else { + lastRunByStyle[span.style] = merged.size merged.add(span) } } diff --git a/app/src/main/kotlin/org/libremail/richtext/RichTextEditing.kt b/app/src/main/kotlin/org/libremail/richtext/RichTextEditing.kt index ed67e10..65bccf9 100644 --- a/app/src/main/kotlin/org/libremail/richtext/RichTextEditing.kt +++ b/app/src/main/kotlin/org/libremail/richtext/RichTextEditing.kt @@ -33,10 +33,15 @@ object RichTextEditing { return content.copy(spans = (otherKinds + updated).sortedBy { it.start }) } - /** Links [[start], [end]) to [url], replacing any links that overlap the range. */ + /** + * Links [[start], [end]) to [url]. A link that only partially overlaps the range keeps its + * non-overlapping remainder — the same split [toggleStyle]/[subtractRange] does for spans — instead + * of being dropped whole, so relinking part of a longer link no longer silently un-links the rest + * of it (#298). A link fully inside the range is replaced outright. + */ fun applyLink(content: RichTextContent, start: Int, end: Int, url: String): RichTextContent { if (start >= end || url.isBlank()) return content - val kept = content.links.filter { it.end <= start || it.start >= end } + val kept = subtractLinkRange(content.links, start, end) return content.copy(links = (kept + RichLink(start, end, url)).sortedBy { it.start }) } @@ -221,6 +226,17 @@ private fun subtractRange(spans: List, start: Int, end: Int): List, start: Int, end: Int): List = links.flatMap { link -> + when { + link.end <= start || link.start >= end -> listOf(link) + else -> buildList { + if (link.start < start) add(link.copy(end = start)) + if (link.end > end) add(link.copy(start = end)) + } + } +} + // --- block marker helpers --- private val ORDERED = Regex("^\\d+\\. ") diff --git a/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimation.kt b/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimation.kt new file mode 100644 index 0000000..abac1ce --- /dev/null +++ b/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimation.kt @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +package org.libremail.ui.onboarding + +import android.content.Context +import android.provider.Settings +import androidx.compose.animation.core.FastOutSlowInEasing +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight +import androidx.compose.material.icons.filled.Check +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.clearAndSetSemantics +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import org.libremail.R + +/** + * Lightweight, dependency-free "Battery → Unrestricted" walkthrough shown on + * [BatteryOptimizationScreen] before the user leaves for system settings (#174). It is the first + * animation in the app, so the approach was chosen to add **no** new dependency (no Lottie, no + * `AnimatedVectorDrawable`): a stylized Compose illustration driven by [rememberInfiniteTransition]. + * + * The visual is deliberately **generic** — a faux settings card with a "Battery" row (tap it) and an + * "Unrestricted" option (choose it), not a screen recording of any one OEM's real UI, which varies by + * manufacturer (#150) and would look wrong or go stale on most devices. A looping highlight moves from + * the Battery row to the Unrestricted option while a "tap" dot pulses, illustrating the two-step path. + * + * Accessibility (all required by #174): + * - **Reduced motion:** when the system "Remove animations" setting is on ([rememberReducedMotion]), + * the same card renders **at rest** (no infinite transition) — a static illustration of the end + * state instead of movement. + * - **TalkBack:** the whole illustration exposes a single [contentDescription] (its decorative inner + * labels are cleared), mirroring the on-screen `onboarding_battery_guidance` text so screen-reader + * users get the same steps. The animation is additive — the guidance text always stays on screen. + * + * @param reducedMotion when true, render the static (motionless) variant. Defaults to the live system + * setting; overridable so tests can drive either path deterministically. + */ +@Composable +fun BatteryGuideAnimation(modifier: Modifier = Modifier, reducedMotion: Boolean = rememberReducedMotion()) { + val description = stringResource(R.string.onboarding_battery_animation_description) + Box( + modifier = modifier + .fillMaxWidth() + .widthIn(max = 360.dp) + .clearAndSetSemantics { contentDescription = description }, + contentAlignment = Alignment.Center, + ) { + if (reducedMotion) { + // Static fallback: the end state at rest — "Battery ›" then "Unrestricted ✓", no motion. + GuideCard(focusUnrestricted = true, tapAlpha = 0f) + } else { + val transition = rememberInfiniteTransition(label = "batteryGuide") + // 0f..1f highlights the Battery row; 1f..2f highlights the Unrestricted option, then loops. + val phase by transition.animateFloat( + initialValue = 0f, + targetValue = 2f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = 3600, easing = LinearEasing), + repeatMode = RepeatMode.Restart, + ), + label = "phase", + ) + // A gentle pulse for the "tap here" dot so the guide never looks frozen. + val tapAlpha by transition.animateFloat( + initialValue = 0.25f, + targetValue = 1f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = 900, easing = FastOutSlowInEasing), + repeatMode = RepeatMode.Reverse, + ), + label = "tap", + ) + GuideCard(focusUnrestricted = phase >= 1f, tapAlpha = tapAlpha) + } + } +} + +/** + * Reads the system "animation duration scale" once and reports whether animations are effectively + * off (scale 0 — the "Remove animations" accessibility setting, or a battery-saver / test harness + * that disables them). Callers use it to skip motion in favour of a static illustration. + */ +@Composable +fun rememberReducedMotion(): Boolean { + val context = LocalContext.current + return remember(context) { isReducedMotion(context) } +} + +/** Non-composable core of [rememberReducedMotion], split out so it is unit-testable without Compose. */ +internal fun isReducedMotion(context: Context): Boolean { + val scale = Settings.Global.getFloat( + context.contentResolver, + Settings.Global.ANIMATOR_DURATION_SCALE, + ANIMATIONS_ENABLED_SCALE, + ) + return scale == NO_ANIMATION_SCALE +} + +/** + * The faux settings card: a decorative header pill above the "Battery" row and the "Unrestricted" + * option. [focusUnrestricted] moves the highlight/selection from the first row to the second (the + * choice being demonstrated); [tapAlpha] drives the pulsing "tap here" dot on the focused row. + */ +@Composable +private fun GuideCard(focusUnrestricted: Boolean, tapAlpha: Float) { + Surface( + shape = RoundedCornerShape(20.dp), + color = MaterialTheme.colorScheme.surfaceVariant, + modifier = Modifier.fillMaxWidth(), + ) { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp), + ) { + // Decorative "screen title" pill — hints "a system settings screen" without naming an OEM. + Box( + Modifier + .width(96.dp) + .height(10.dp) + .clip(CircleShape) + .background(MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.35f)), + ) + GuideRow( + label = stringResource(R.string.onboarding_battery_anim_battery), + highlighted = !focusUnrestricted, + tapAlpha = if (focusUnrestricted) 0f else tapAlpha, + ) { + Icon( + imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + GuideRow( + label = stringResource(R.string.onboarding_battery_anim_unrestricted), + highlighted = focusUnrestricted, + tapAlpha = if (focusUnrestricted) tapAlpha else 0f, + ) { + if (focusUnrestricted) { + Icon( + imageVector = Icons.Filled.Check, + contentDescription = null, + tint = MaterialTheme.colorScheme.primary, + ) + } else { + Box( + Modifier + .size(20.dp) + .border(2.dp, MaterialTheme.colorScheme.outline, CircleShape), + ) + } + } + } + } +} + +/** + * One row of the faux settings list: a generic leading glyph (a dependency-free stand-in for an OEM + * setting icon), the [label], a pulsing "tap here" dot (via [tapAlpha]) and a caller-supplied + * [trailing] affordance (a chevron for "opens a sub-screen", a check/radio for "selectable option"). + */ +@Composable +private fun GuideRow(label: String, highlighted: Boolean, tapAlpha: Float, trailing: @Composable () -> Unit) { + Row( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(12.dp)) + .background( + if (highlighted) { + MaterialTheme.colorScheme.primaryContainer + } else { + MaterialTheme.colorScheme.surface + }, + ) + .padding(horizontal = 12.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + Box( + Modifier + .size(24.dp) + .clip(RoundedCornerShape(6.dp)) + .background( + if (highlighted) { + MaterialTheme.colorScheme.primary + } else { + MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f) + }, + ), + ) + Text( + text = label, + style = MaterialTheme.typography.bodyMedium, + fontWeight = if (highlighted) FontWeight.SemiBold else FontWeight.Normal, + color = if (highlighted) { + MaterialTheme.colorScheme.onPrimaryContainer + } else { + MaterialTheme.colorScheme.onSurface + }, + modifier = Modifier.weight(1f), + ) + Box( + Modifier + .size(12.dp) + .alpha(tapAlpha) + .clip(CircleShape) + .background(MaterialTheme.colorScheme.primary.copy(alpha = 0.6f)), + ) + trailing() + } +} + +// Animation-scale sentinels for isReducedMotion (kept as named constants so detekt's MagicNumber rule +// — which is not relaxed for this non-@Composable helper — stays satisfied). +private const val ANIMATIONS_ENABLED_SCALE = 1f +private const val NO_ANIMATION_SCALE = 0f diff --git a/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreen.kt b/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreen.kt index 9ad77bc..9c4d10a 100644 --- a/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreen.kt +++ b/app/src/main/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreen.kt @@ -1,7 +1,6 @@ // SPDX-License-Identifier: GPL-3.0-or-later package org.libremail.ui.onboarding -import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize @@ -10,6 +9,8 @@ import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.CheckCircle import androidx.compose.material.icons.filled.Notifications @@ -20,6 +21,7 @@ import androidx.compose.material3.OutlinedButton import androidx.compose.material3.Scaffold import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -31,35 +33,51 @@ import androidx.lifecycle.Lifecycle import androidx.lifecycle.compose.LifecycleEventEffect import androidx.lifecycle.compose.collectAsStateWithLifecycle import org.libremail.R +import org.libremail.reporting.AppLog /** * Final onboarding step (shown only when needed, see [OnboardingViewModel.batteryPromptNeeded]): * invites the user to allow unrestricted background/battery usage so push and periodic sync aren't - * throttled by Doze. **Take me there** deep-links as directly as possible toward the per-app battery - * screen (see [org.libremail.push.BatteryOptimizationManager] for the best-effort fallback chain; no - * restricted permission is ever used); **Not now** skips. Either way [onFinish] proceeds to the inbox. - * On returning from Settings the status is re-read and, if the app is now unrestricted, the screen - * reflects that with a "done" state. + * throttled by Doze. A short, dependency-free [BatteryGuideAnimation] illustrates the "Battery → + * Unrestricted" path **before** the user leaves the app (#174), since the deep link can't guarantee + * landing on the exact per-OEM screen (#150); the guidance text stays on screen for TalkBack and + * reduced-motion users. **Take me there** deep-links as directly as possible toward the per-app + * battery screen (see [org.libremail.push.BatteryOptimizationManager] for the best-effort fallback + * chain; no restricted permission is ever used); **Not now** skips. Either way [onFinish] proceeds to + * the inbox. On returning from Settings the status is re-read and, if the app is now unrestricted, the + * screen reflects that with a "done" state. * * @param viewModel the graph-scoped onboarding view model (holds live battery status + the flag). * @param onFinish leaves onboarding for the inbox; the caller also marks the prompt handled. + * @param reducedMotion whether to render the static (motionless) guide; defaults to the live system + * "Remove animations" setting, overridable so tests drive either path deterministically. */ @Composable -fun BatteryOptimizationScreen(viewModel: OnboardingViewModel, onFinish: () -> Unit) { +fun BatteryOptimizationScreen( + viewModel: OnboardingViewModel, + onFinish: () -> Unit, + reducedMotion: Boolean = rememberReducedMotion(), +) { val unrestricted by viewModel.batteryUnrestricted.collectAsStateWithLifecycle() val context = LocalContext.current // Re-check on every resume so returning from the system settings screen reflects the new state. LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.refreshBatteryStatus() } + // One-shot breadcrumb (PII-free) so a debug report shows the step was reached, plus the two state + // booleans that steer what it renders (already-unrestricted "done" state, and static vs animated). + LaunchedEffect(Unit) { + AppLog.i(TAG, "Battery opt-in shown (unrestricted=$unrestricted, reducedMotion=$reducedMotion)") + } + Scaffold { padding -> Column( modifier = Modifier .fillMaxSize() + .verticalScroll(rememberScrollState()) .padding(padding) .padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally, - verticalArrangement = Arrangement.Center, ) { Icon( imageVector = if (unrestricted) Icons.Filled.CheckCircle else Icons.Filled.Notifications, @@ -88,12 +106,19 @@ fun BatteryOptimizationScreen(viewModel: OnboardingViewModel, onFinish: () -> Un if (unrestricted) { Button( - onClick = onFinish, + onClick = { + AppLog.i(TAG, "Battery opt-in: continue to inbox") + onFinish() + }, modifier = Modifier.fillMaxWidth().widthIn(max = 360.dp), ) { Text(stringResource(R.string.onboarding_battery_continue)) } } else { + // Illustrated "tap Battery → choose Unrestricted" guide, above the (retained) text + // guidance so the animation is additive, not a replacement for the accessible path. + BatteryGuideAnimation(reducedMotion = reducedMotion) + Spacer(Modifier.height(24.dp)) Text( text = stringResource(R.string.onboarding_battery_guidance), style = MaterialTheme.typography.bodyMedium, @@ -105,8 +130,10 @@ fun BatteryOptimizationScreen(viewModel: OnboardingViewModel, onFinish: () -> Un onClick = { // Mark handled up front: the user is leaving for Settings and might not return // to this screen. Launching app-details always resolves; guard defensively. + AppLog.i(TAG, "Battery opt-in: opening system settings") viewModel.markBatteryPromptHandled() runCatching { context.startActivity(viewModel.batterySettingsIntent()) } + .onFailure { AppLog.w(TAG, "Battery settings intent failed to launch", it) } }, modifier = Modifier.fillMaxWidth().widthIn(max = 360.dp), ) { @@ -114,7 +141,10 @@ fun BatteryOptimizationScreen(viewModel: OnboardingViewModel, onFinish: () -> Un } Spacer(Modifier.height(12.dp)) OutlinedButton( - onClick = onFinish, + onClick = { + AppLog.i(TAG, "Battery opt-in skipped") + onFinish() + }, modifier = Modifier.fillMaxWidth().widthIn(max = 360.dp), ) { Text(stringResource(R.string.onboarding_battery_not_now)) @@ -123,3 +153,5 @@ fun BatteryOptimizationScreen(viewModel: OnboardingViewModel, onFinish: () -> Un } } } + +private const val TAG = "BatteryOptIn" diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 8c6b86a..6499b27 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -189,6 +189,12 @@ You\'re all set Background usage is unrestricted — new mail will arrive instantly. Continue to inbox + + Animation showing how to enable unrestricted battery use: in your device settings, open Battery, then choose Unrestricted. + Battery + Unrestricted Suggest recipients as you type diff --git a/app/src/test/kotlin/org/libremail/mail/GraphSenderSendTest.kt b/app/src/test/kotlin/org/libremail/mail/GraphSenderSendTest.kt index dbcb6de..c4c02ea 100644 --- a/app/src/test/kotlin/org/libremail/mail/GraphSenderSendTest.kt +++ b/app/src/test/kotlin/org/libremail/mail/GraphSenderSendTest.kt @@ -1,14 +1,20 @@ // SPDX-License-Identifier: GPL-3.0-or-later package org.libremail.mail +import io.mockk.every +import io.mockk.mockkStatic +import io.mockk.unmockkAll import kotlinx.coroutines.test.runTest import org.junit.After +import org.junit.Before import org.junit.Test import org.libremail.domain.model.OutgoingMessage import java.io.ByteArrayOutputStream +import java.io.File import java.io.IOException import java.io.InputStream import java.io.OutputStream +import java.io.RandomAccessFile import java.net.HttpURLConnection import java.net.URL import java.net.URLConnection @@ -18,6 +24,7 @@ import java.util.concurrent.atomic.AtomicReference import kotlin.test.assertEquals import kotlin.test.assertFailsWith import kotlin.test.assertFalse +import kotlin.test.assertNull import kotlin.test.assertTrue /** @@ -30,8 +37,19 @@ import kotlin.test.assertTrue */ class GraphSenderSendTest { + @Before + fun setUp() { + // send() now breadcrumbs through AppLog on the oversized-attachment guard; android.util.Log is a + // no-op stub under plain JVM tests, so mock it (fully qualified, so this file never imports it). + mockkStatic(android.util.Log::class) + every { android.util.Log.w(any(), any()) } returns 0 + } + @After - fun tearDown() = armed.set(null) + fun tearDown() { + armed.set(null) + unmockkAll() + } private val message = OutgoingMessage(accountId = "outlook:me@x.com", to = "bob@example.org", subject = "Hi", body = "Body") @@ -84,6 +102,26 @@ class GraphSenderSendTest { assertFalse(ex.mayHaveSent, "the request never reached Graph, so a retry is safe") } + @Test + fun `an oversized attachment fails safe-to-fall-back before opening a connection`() = runTest { + val last = arm() // armed, but the guard must trip before any connection is opened + val big = File.createTempFile("graph-big", ".bin") + try { + // 4 MiB, over the 3 MiB per-file cap. setLength allocates the size without writing the bytes, + // so the guard (which reads file.length()) trips without the test materializing 4 MiB. + RandomAccessFile(big, "rw").use { it.setLength(4L * 1024 * 1024) } + + val ex = assertFailsWith { + GraphSender().send("token", message, listOf(SendableAttachment(big))) + } + + assertFalse(ex.mayHaveSent, "oversized never reached Graph, so SMTP fallback is safe") + assertNull(last.get(), "the guard must trip before any connection is opened") + } finally { + big.delete() + } + } + @Test fun `GraphSendException carries its message, flag and cause`() { val cause = IOException("boom") diff --git a/app/src/test/kotlin/org/libremail/reporting/DiagnosticsCollectorTest.kt b/app/src/test/kotlin/org/libremail/reporting/DiagnosticsCollectorTest.kt index 859d2fa..2f75273 100644 --- a/app/src/test/kotlin/org/libremail/reporting/DiagnosticsCollectorTest.kt +++ b/app/src/test/kotlin/org/libremail/reporting/DiagnosticsCollectorTest.kt @@ -169,6 +169,26 @@ class DiagnosticsCollectorTest { ) } + @Test + fun `provider label matches brand tokens at label boundaries, not as substrings`() = runTest { + every { settingsRepository.settings } returns flowOf(AppSettings()) + // Each custom host merely CONTAINS a brand name inside a longer DNS label; the old substring match + // mislabeled them (notgmail→Gmail, yahooligans→Yahoo, me.company→iCloud, kaolin→AOL). They must all + // bucket to "Other" now (#298). + every { accountRepository.observeAccounts() } returns flowOf( + listOf( + account("1@x", AuthType.PASSWORD_IMAP, "mail.notgmail.example"), + account("2@x", AuthType.PASSWORD_IMAP, "imap.yahooligans.example"), + account("3@x", AuthType.PASSWORD_IMAP, "me.company.example"), + account("4@x", AuthType.PASSWORD_IMAP, "kaolin.example"), + ), + ) + + val report = collector.collectManual() + + assertEquals(List(4) { "Other (PASSWORD_IMAP)" }, report.accounts) + } + private fun account(email: String, authType: AuthType, imapHost: String) = Account( id = "id:$email", email = email, diff --git a/app/src/test/kotlin/org/libremail/reporting/ReportStoreTest.kt b/app/src/test/kotlin/org/libremail/reporting/ReportStoreTest.kt index 9becacd..9f9c885 100644 --- a/app/src/test/kotlin/org/libremail/reporting/ReportStoreTest.kt +++ b/app/src/test/kotlin/org/libremail/reporting/ReportStoreTest.kt @@ -111,6 +111,29 @@ class ReportStoreTest { assertEquals(listOf("valid"), store.reports.value.map { it.id }) } + @Test + fun `save leaves no temporary file behind (atomic write renames it into place)`() { + val store = newStore() + + store.save(report("a")) + + // The write-and-rename temp must not linger: only the final ".json" remains on disk (#298). + assertEquals(listOf("a.json"), tempFolder.root.listFiles()?.map { it.name }.orEmpty()) + } + + @Test + fun `a stray temp file from an interrupted write is never scanned as a report`() { + // A process death mid-write leaves a ".json.tmp" file, never a torn ".json". scan() filters on + // ".json", so the orphan is ignored and a valid report saved alongside still lists cleanly — the + // old in-place write could instead leave a truncated ".json" that scan() silently dropped (#298). + File(tempFolder.root, "torn.json.tmp").writeText("{ half-written") + val store = newStore() + + store.save(report("valid")) + + assertEquals(listOf("valid"), store.reports.value.map { it.id }) + } + @Test fun `purgeOlderThan deletes reports strictly older than the cutoff`() { val store = newStore() diff --git a/app/src/test/kotlin/org/libremail/richtext/RichTextEditingTest.kt b/app/src/test/kotlin/org/libremail/richtext/RichTextEditingTest.kt index 52553e4..e7707e1 100644 --- a/app/src/test/kotlin/org/libremail/richtext/RichTextEditingTest.kt +++ b/app/src/test/kotlin/org/libremail/richtext/RichTextEditingTest.kt @@ -301,18 +301,53 @@ class RichTextEditingTest { } @Test - fun `applyLink keeps links wholly outside the range and replaces overlapping ones`() { + fun `applyLink keeps links outside the range and splits partial overlaps, keeping the remainder`() { val content = RichTextContent( "0123456789", links = listOf(RichLink(0, 2, "a"), RichLink(3, 6, "b"), RichLink(7, 9, "c")), ) val result = RichTextEditing.applyLink(content, 4, 7, "http://new") assertEquals( - listOf(RichLink(0, 2, "a"), RichLink(4, 7, "http://new"), RichLink(7, 9, "c")), + // "a" is wholly outside; "b" (3,6) overlaps [4,7) so only its (3,4) remainder survives (it is + // no longer dropped whole); the new link takes [4,7); "c" starts at the range end, kept whole. + listOf(RichLink(0, 2, "a"), RichLink(3, 4, "b"), RichLink(4, 7, "http://new"), RichLink(7, 9, "c")), result.links.sortedBy { it.start }, ) } + @Test + fun `applyLink over the middle of a link relinks the middle and keeps both surrounding remainders`() { + val content = RichTextContent("0123456789", links = listOf(RichLink(0, 8, "old"))) + val result = RichTextEditing.applyLink(content, 3, 5, "new") + assertEquals( + listOf(RichLink(0, 3, "old"), RichLink(3, 5, "new"), RichLink(5, 8, "old")), + result.links.sortedBy { it.start }, + ) + } + + // --- mergeSameValueSpans (shared merge used by toggleStyle and the HTML parser) --- + + @Test + fun `mergeSameValueSpans coalesces touching and overlapping runs of the same value only`() { + val merged = mergeSameValueSpans( + listOf( + RichSpan(5, 8, RichStyle.Bold), // out of order, and overlaps the (3,6) run below + RichSpan(0, 3, RichStyle.Bold), + RichSpan(3, 6, RichStyle.Bold), // touches (0,3) and overlaps (5,8) → one 0..8 run + RichSpan(0, 4, RichStyle.Italic), // a different value never folds into the Bold run + RichSpan(10, 12, RichStyle.Bold), // a gap breaks the run into a fresh one + ), + ) + assertEquals( + listOf( + RichSpan(0, 8, RichStyle.Bold), + RichSpan(0, 4, RichStyle.Italic), + RichSpan(10, 12, RichStyle.Bold), + ), + merged, + ) + } + // --- styleAt / isStyled caret edges --- @Test diff --git a/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimationJvmTest.kt b/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimationJvmTest.kt new file mode 100644 index 0000000..c15f4cf --- /dev/null +++ b/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryGuideAnimationJvmTest.kt @@ -0,0 +1,97 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +package org.libremail.ui.onboarding + +import android.content.Context +import android.provider.Settings +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.junit4.v2.createComposeRule +import androidx.compose.ui.test.onNodeWithContentDescription +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.libremail.R +import org.libremail.ui.theme.LibreMailTheme +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +/** + * Robolectric JVM Compose test (#174) for the dependency-free "Battery → Unrestricted" guide + * illustration. Covers both the looping animated variant and the reduced-motion static fallback, the + * default `reducedMotion` argument reading the system animation-scale setting, and the non-composable + * [isReducedMotion] decision. The illustration exposes a single [contentDescription] to TalkBack, so + * every render is asserted through it. + * + * The animated variant is driven with `mainClock.autoAdvance = false` and hand-advanced, so the + * infinite transition never spins the Robolectric clock into a `waitForIdle` hang. + */ +@RunWith(RobolectricTestRunner::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +@Config(sdk = [36], qualifiers = "+w411dp-h800dp") +class BatteryGuideAnimationJvmTest { + + @get:Rule + val composeTestRule = createComposeRule() + + private val context: Context get() = RuntimeEnvironment.getApplication() + + private fun description() = context.getString(R.string.onboarding_battery_animation_description) + + @Test + fun reducedMotion_rendersStaticGuideWithDescription() { + composeTestRule.setContent { + LibreMailTheme(darkTheme = false, dynamicColor = false) { + BatteryGuideAnimation(reducedMotion = true) + } + } + + composeTestRule.onNodeWithContentDescription(description()).assertIsDisplayed() + } + + @Test + fun motionOn_rendersAnimatedGuide_acrossBothSteps() { + // Hand-drive the clock so the looping guide can't hang waitForIdle. + composeTestRule.mainClock.autoAdvance = false + composeTestRule.setContent { + LibreMailTheme(darkTheme = false, dynamicColor = false) { + BatteryGuideAnimation(reducedMotion = false) + } + } + + // First frame: the "Battery" step is highlighted. + composeTestRule.onNodeWithContentDescription(description()).assertIsDisplayed() + // Advance past the halfway point so the highlight/selection moves to the "Unrestricted" step. + composeTestRule.mainClock.advanceTimeBy(2000) + composeTestRule.onNodeWithContentDescription(description()).assertIsDisplayed() + } + + @Test + fun defaultReducedMotionArg_readsSystemAnimationScale() { + Settings.Global.putFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 0f) + // Defensive: even if the setting round-trip surprised us into the animated branch, a manual + // clock keeps the test from hanging. + composeTestRule.mainClock.autoAdvance = false + composeTestRule.setContent { + LibreMailTheme(darkTheme = false, dynamicColor = false) { + BatteryGuideAnimation() + } + } + + composeTestRule.onNodeWithContentDescription(description()).assertIsDisplayed() + } + + @Test + fun isReducedMotion_trueWhenAnimationsDisabled() { + Settings.Global.putFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 0f) + assertTrue(isReducedMotion(context)) + } + + @Test + fun isReducedMotion_falseWhenAnimationsEnabled() { + Settings.Global.putFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f) + assertFalse(isReducedMotion(context)) + } +} diff --git a/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreenJvmTest.kt b/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreenJvmTest.kt index 9474018..4ae42cf 100644 --- a/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreenJvmTest.kt +++ b/app/src/test/kotlin/org/libremail/ui/onboarding/BatteryOptimizationScreenJvmTest.kt @@ -7,6 +7,7 @@ import android.provider.Settings import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.ui.test.assertIsDisplayed import androidx.compose.ui.test.junit4.v2.createComposeRule +import androidx.compose.ui.test.onNodeWithContentDescription import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.performClick import androidx.lifecycle.Lifecycle @@ -19,6 +20,7 @@ import io.mockk.verify import kotlinx.coroutines.flow.MutableStateFlow import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue +import org.junit.Before import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith @@ -54,6 +56,14 @@ class BatteryOptimizationScreenJvmTest { private fun string(resId: Int): String = context.getString(resId) + // Force the reduced-motion (static) illustration so the looping guide animation never spins the + // Robolectric clock (which would hang waitForIdle); the animated path is covered by + // BatteryGuideAnimationJvmTest. Also exercises the screen's default rememberReducedMotion argument. + @Before + fun forceReducedMotion() { + Settings.Global.putFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 0f) + } + /** RESUMED owner so `collectAsStateWithLifecycle` collects and the ON_RESUME effect fires. */ private val resumedOwner = object : LifecycleOwner { private val registry = @@ -79,9 +89,11 @@ class BatteryOptimizationScreenJvmTest { setContent(vm, onFinish = { finished = true }) composeTestRule.onNodeWithText(string(R.string.onboarding_battery_done_title)).assertIsDisplayed() - // The request/skip affordances are gone in the "done" state. + // The request/skip affordances — and the how-to guide illustration — are gone in the "done" state. composeTestRule.onNodeWithText(string(R.string.onboarding_battery_take_me)).assertDoesNotExist() composeTestRule.onNodeWithText(string(R.string.onboarding_battery_not_now)).assertDoesNotExist() + composeTestRule.onNodeWithContentDescription(string(R.string.onboarding_battery_animation_description)) + .assertDoesNotExist() composeTestRule.onNodeWithText(string(R.string.onboarding_battery_continue)).performClick() assertTrue(finished) @@ -99,6 +111,9 @@ class BatteryOptimizationScreenJvmTest { composeTestRule.onNodeWithText(string(R.string.onboarding_battery_title)).assertIsDisplayed() composeTestRule.onNodeWithText(string(R.string.onboarding_battery_guidance)).assertIsDisplayed() + // The illustrated "Battery → Unrestricted" guide is shown (as one TalkBack-friendly node). + composeTestRule.onNodeWithContentDescription(string(R.string.onboarding_battery_animation_description)) + .assertIsDisplayed() composeTestRule.onNodeWithText(string(R.string.onboarding_battery_take_me)).performClick() // Take me there marks the prompt handled up front, then launches the resolved settings intent.