Bump version to 8.20.0

Co-authored-by: Greyson Parrelli <greyson@signal.org>

.gitattributes

@@ -1 +1,2 @@
 *.ai binary
+**/src/screenshotTest*/reference/**/*.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/android.yml

@@ -16,24 +16,25 @@ jobs:
     runs-on: ubuntu-latest-8-cores
 
     steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       # gh api repos/actions/checkout/commits/v6 --jq '.sha'
       with:
           submodules: true
+          lfs: true
 
-    - name: set up JDK 17
-      uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+    - name: set up JDK 21
+      uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
       # gh api repos/actions/setup-java/commits/v5 --jq '.sha'
       with:
         distribution: temurin
-        java-version: 17
+        java-version: 21
 
     - name: Validate Gradle Wrapper
-      uses: gradle/actions/wrapper-validation@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
 
     - name: Set up Gradle
-      uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
       with:
         # Only 8.** branch builds write to the cache; everything else (PRs, etc.) reads only.
@@ -41,15 +42,16 @@ jobs:
         # Required to persist the Gradle configuration cache across runs.
         cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-    # Pull requests run the fast custom linter (ci); pushes to main / 8.x branches run the full
-    # Android lint (qa).
+    # Pull requests run the fast custom linter (ciRemote); pushes to main / 8.x branches run the
+    # full Android lint (qaRemote). Both include screenshot validation, which is deliberately kept
+    # out of the local qa/ci tasks because screenshot rendering is host-OS dependent.
     - name: Build with Gradle
       env:
         SIGNAL_BUILD_CACHE_URL: ${{ secrets.SIGNAL_BUILD_CACHE_URL }}
         SIGNAL_BUILD_CACHE_USER: ${{ secrets.SIGNAL_BUILD_CACHE_USER }}
         SIGNAL_BUILD_CACHE_PASSWORD: ${{ secrets.SIGNAL_BUILD_CACHE_PASSWORD }}
         SIGNAL_BUILD_CACHE_PUSH: ${{ startsWith(github.ref, 'refs/heads/8.') }}
-      run: ./gradlew ${{ github.event_name == 'pull_request' && 'ci' || 'qa' }}
+      run: ./gradlew ${{ github.event_name == 'pull_request' && 'ciRemote' || 'qaRemote' }}
 
     - name: Archive reports for failed build
       if: ${{ failure() }}
@@ -57,4 +59,7 @@ jobs:
       # gh api repos/actions/upload-artifact/commits/v7 --jq '.sha'
       with:
         name: reports
-        path: '*/build/reports'
+        path: |
+          **/build/reports
+          **/build/test-results
+        if-no-files-found: ignore

.github/workflows/diffuse.yml

@@ -16,21 +16,21 @@ jobs:
     runs-on: ubuntu-latest-8-cores
 
     steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       # gh api repos/actions/checkout/commits/v6 --jq '.sha'
       with:
         submodules: true
         ref: ${{ github.event.pull_request.base.sha }}
 
-    - name: set up JDK 17
-      uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+    - name: set up JDK 21
+      uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
       # gh api repos/actions/setup-java/commits/v5 --jq '.sha'
       with:
         distribution: temurin
-        java-version: 17
+        java-version: 21
 
     - name: Set up Gradle
-      uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
       with:
         # PR-only workflow: always read from the cache, never write.
@@ -42,12 +42,12 @@ jobs:
       run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;${{ env.NDK_VERSION }}"
 
     - name: Validate Gradle Wrapper
-      uses: gradle/actions/wrapper-validation@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
 
     - name: Cache base apk
       id: cache-base
-      uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v5
       # gh api repos/actions/cache/commits/v5 --jq '.sha'
       with:
         path: diffuse-base.apk
@@ -61,7 +61,7 @@ jobs:
       if: steps.cache-base.outputs.cache-hit != 'true'
       run: mv app/build/outputs/apk/playProd/release/*arm64*.apk diffuse-base.apk
 
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       # gh api repos/actions/checkout/commits/v6 --jq '.sha'
       with:
         submodules: true

.github/workflows/docker.yml

@@ -11,11 +11,17 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         # gh api repos/actions/checkout/commits/v6 --jq '.sha'
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0
       - name: Build image
-        run: |
-          cd reproducible-builds
-          docker build -t signal-android .
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
+        with:
+          context: reproducible-builds
+          tags: signal-android
+          load: true
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
       - name: Test build
         run: docker run --memory=12g --rm -v "$(pwd)":/project -w /project signal-android ./gradlew --no-daemon --max-workers=1 -Dorg.gradle.jvmargs="-Xmx4g -XX:MaxMetaspaceSize=512m" -Dkotlin.compiler.execution.strategy=in-process bundlePlayProdRelease

.github/workflows/stale.yml

@@ -14,7 +14,7 @@ jobs:
       actions: write
 
     steps:
-      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10
+      - uses: actions/stale@1e223db275d687790206a7acac4d1a11bd6fe629 # v10
         # gh api repos/actions/stale/commits/v10 --jq '.sha'
         with:
           days-before-stale: 60

.tool-versions

@@ -1,2 +1,2 @@
-java openjdk-17.0.2
+java openjdk-21.0.2
 uv   latest

app/build.gradle.kts

@@ -2,7 +2,10 @@
 
 import com.android.build.api.artifact.ArtifactTransformationRequest
 import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.variant.HasAndroidTest
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.process.ExecOperations
+import org.gradle.work.DisableCachingByDefault
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
 import java.time.Instant
@@ -10,12 +13,14 @@ import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import java.util.Locale
 import java.util.Properties
+import javax.inject.Inject
 
 plugins {
   alias(libs.plugins.android.application)
   alias(libs.plugins.ktlint)
   alias(libs.plugins.compose.compiler)
   alias(libs.plugins.kotlinx.serialization)
+  alias(testLibs.plugins.compose.screenshot)
   alias(benchmarkLibs.plugins.baselineprofile)
   id("androidx.navigation.safeargs")
   id("kotlin-parcelize")
@@ -27,8 +32,8 @@ plugins {
 val staticIps = Properties().apply { file("static-ips.properties").reader().use { load(it) } }
 staticIps.stringPropertyNames().forEach { rootProject.extra[it] = staticIps.getProperty(it) }
 
-val canonicalVersionCode = 1705
-val canonicalVersionName = "8.15.1"
+val canonicalVersionCode = 1720
+val canonicalVersionName = "8.20.0"
 val currentHotfixVersion = 0
 val maxHotfixVersions = 100
 
@@ -127,9 +132,27 @@ ktlint {
   version.set("1.5.0")
 }
 
+// ktlint only scans convention source dirs, so the shared dirs added to the compile tasks are
+// otherwise skipped. Add them to the base test/androidTest ktlint tasks so ktlintCheck/format cover them.
+tasks.withType(org.jlleitschuh.gradle.ktlint.tasks.BaseKtLintCheckTask::class.java).configureEach {
+  if (name.endsWith("OverTestSourceSet") || name.endsWith("OverAndroidTestSourceSet")) {
+    source("$projectDir/src/testShared")
+  }
+  if (name.endsWith("OverAndroidTestSourceSet")) {
+    source("$projectDir/src/benchmarkShared/java")
+  }
+}
+
+screenshotTests {
+  // Fraction of differing pixels tolerated before a screenshot test fails (0.0001 = 0.01%).
+  imageDifferenceThreshold = 0.0001f
+}
+
 android {
   namespace = "org.thoughtcrime.securesms"
 
+  experimentalProperties["android.experimental.enableScreenshotTest"] = true
+
   buildToolsVersion = libs.versions.buildTools.get()
   compileSdkVersion(libs.versions.compileSdk.get())
   ndkVersion = libs.versions.ndk.get()
@@ -590,6 +613,43 @@ androidComponents {
     }
     variant.sources.assets?.addGeneratedSourceDirectory(taskProvider) { it.outputDir }
   }
+
+  onVariants(selector().withName("playProdDebug")) { variant ->
+    val androidTest = (variant as? HasAndroidTest)?.androidTest ?: return@onVariants
+
+    tasks.register<FirebaseTestLabTask>("firebaseTestLab") {
+      group = "Verification"
+      description = "Runs the ${variant.name} instrumentation tests on Firebase Test Lab via the gcloud CLI. Run a single class with -Pftl.class=<fqcn>[#method]; override other defaults with -Pftl.* properties."
+
+      appApkDirectory.set(variant.artifacts.get(SingleArtifact.APK))
+      testApkDirectory.set(androidTest.artifacts.get(SingleArtifact.APK))
+
+      val deviceOverride = project.providers.gradleProperty("ftl.devices").orNull
+      devices.set(
+        deviceOverride?.split(";")?.map { it.trim() }?.filter { it.isNotEmpty() }
+          ?: listOf("model=Pixel2.arm,version=31,locale=en,orientation=portrait")
+      )
+
+      useOrchestrator.set(true)
+      environmentVariables.set(mapOf("clearPackageData" to "true"))
+      testTimeout.set(project.providers.gradleProperty("ftl.timeout").getOrElse("30m"))
+      numFlakyTestAttempts.set(project.providers.gradleProperty("ftl.numFlakyTestAttempts").map { it.toInt() }.getOrElse(1))
+      gcloudProject.set(project.providers.gradleProperty("ftl.project"))
+      resultsBucket.set(project.providers.gradleProperty("ftl.resultsBucket"))
+      resultsDir.set(project.providers.gradleProperty("ftl.resultsDir"))
+
+      val testClass = project.providers.gradleProperty("ftl.class").orNull?.takeIf { it.isNotBlank() }
+      testTargets.set(
+        if (testClass != null) "class $testClass" else project.providers.gradleProperty("ftl.testTargets").orNull
+      )
+      gcloudExecutable.set(project.providers.gradleProperty("ftl.gcloud").getOrElse("gcloud"))
+      extraArgs.set(
+        project.providers.gradleProperty("ftl.extraArgs").orNull
+          ?.split(" ")?.map { it.trim() }?.filter { it.isNotEmpty() }
+          ?: emptyList()
+      )
+    }
+  }
 }
 
 baselineProfile {
@@ -662,6 +722,7 @@ dependencies {
   implementation(libs.androidx.navigation.compose)
   implementation(libs.androidx.navigation3.runtime)
   implementation(libs.androidx.navigation3.ui)
+  implementation(libs.androidx.lifecycle.viewmodel.navigation3)
   implementation(libs.androidx.lifecycle.viewmodel.ktx)
   implementation(libs.androidx.lifecycle.livedata.ktx)
   implementation(libs.androidx.lifecycle.process)
@@ -712,6 +773,11 @@ dependencies {
   }
   implementation(libs.lottie)
   implementation(libs.lottie.compose)
+
+  // Compose screenshot testing
+  screenshotTestImplementation(testLibs.compose.screenshot.validation.api)
+  screenshotTestImplementation(libs.androidx.compose.ui.tooling.core)
+  screenshotTestImplementation(libs.androidx.compose.ui.tooling.preview)
   implementation(libs.signal.android.database.sqlcipher)
   implementation(libs.androidx.sqlite)
   testImplementation(libs.androidx.sqlite.framework)
@@ -776,8 +842,18 @@ dependencies {
 
   androidTestImplementation(platform(libs.androidx.compose.bom))
   androidTestImplementation(libs.androidx.compose.ui.test.junit4)
+  androidTestImplementation(libs.androidx.compose.ui.test.manifest)
   androidTestImplementation(testLibs.androidx.test.ext.junit)
   androidTestImplementation(testLibs.espresso.core)
+  androidTestImplementation(testLibs.espresso.contrib) {
+    // espresso-contrib transitively pulls the full checkerframework jar (only its annotations are needed),
+    // whose MANIFEST.MF collides with other test dependencies during androidTest resource merging.
+    exclude(group = "org.checkerframework", module = "checker")
+    // accessibility-test-framework drags in an ancient com.google.protobuf:protobuf-lite:3.0.1 whose
+    // GeneratedMessageLite wins the merged dex and lacks registerDefaultInstance(Class, GeneratedMessageLite),
+    // crashing tests at runtime. We only use RecyclerViewActions from contrib, not the accessibility checks.
+    exclude(group = "com.google.android.apps.common.testing.accessibility.framework")
+  }
   androidTestImplementation(testLibs.androidx.test.core)
   androidTestImplementation(testLibs.androidx.test.core.ktx)
   androidTestImplementation(testLibs.androidx.test.ext.junit.ktx)
@@ -961,6 +1037,110 @@ abstract class CopyBenchmarkBackupTask : DefaultTask() {
   }
 }
 
+/**
+ * Runs an instrumentation test suite on Firebase Test Lab by shelling out to `gcloud firebase test android run`.
+ *
+ * The `gcloud` CLI must be installed and authenticated (`gcloud auth login` and a configured project, or an
+ * activated service account) before invoking this task.
+ */
+@DisableCachingByDefault(because = "Executes tests on remote devices; results must never be served from the build cache")
+abstract class FirebaseTestLabTask
+@Inject
+constructor(
+  private val execOperations: ExecOperations
+) : DefaultTask() {
+  @get:InputFiles
+  @get:PathSensitive(PathSensitivity.RELATIVE)
+  abstract val appApkDirectory: DirectoryProperty
+
+  @get:InputFiles
+  @get:PathSensitive(PathSensitivity.RELATIVE)
+  abstract val testApkDirectory: DirectoryProperty
+
+  @get:Input
+  abstract val devices: ListProperty<String>
+
+  @get:Input
+  abstract val useOrchestrator: Property<Boolean>
+
+  @get:Input
+  abstract val environmentVariables: MapProperty<String, String>
+
+  @get:Input
+  abstract val testTimeout: Property<String>
+
+  @get:Input
+  abstract val numFlakyTestAttempts: Property<Int>
+
+  @get:Input
+  @get:Optional
+  abstract val gcloudProject: Property<String>
+
+  @get:Input
+  @get:Optional
+  abstract val resultsBucket: Property<String>
+
+  @get:Input
+  @get:Optional
+  abstract val resultsDir: Property<String>
+
+  @get:Input
+  @get:Optional
+  abstract val testTargets: Property<String>
+
+  @get:Input
+  abstract val gcloudExecutable: Property<String>
+
+  @get:Input
+  abstract val extraArgs: ListProperty<String>
+
+  @TaskAction
+  fun run() {
+    val appApk = findApk(appApkDirectory.get().asFile, "app")
+    val testApk = findApk(testApkDirectory.get().asFile, "instrumentation test")
+
+    val arguments = mutableListOf(
+      gcloudExecutable.get(),
+      "firebase", "test", "android", "run",
+      "--type", "instrumentation",
+      "--app", appApk.absolutePath,
+      "--test", testApk.absolutePath,
+      "--timeout", testTimeout.get(),
+      "--num-flaky-test-attempts", numFlakyTestAttempts.get().toString()
+    )
+
+    devices.get().forEach { device ->
+      arguments += listOf("--device", device)
+    }
+
+    if (useOrchestrator.get()) {
+      arguments += "--use-orchestrator"
+    }
+
+    val environment = environmentVariables.get()
+    if (environment.isNotEmpty()) {
+      arguments += "--environment-variables"
+      arguments += environment.entries.joinToString(",") { "${it.key}=${it.value}" }
+    }
+
+    gcloudProject.orNull?.takeIf { it.isNotBlank() }?.let { arguments += listOf("--project", it) }
+    resultsBucket.orNull?.takeIf { it.isNotBlank() }?.let { arguments += listOf("--results-bucket", it) }
+    resultsDir.orNull?.takeIf { it.isNotBlank() }?.let { arguments += listOf("--results-dir", it) }
+    testTargets.orNull?.takeIf { it.isNotBlank() }?.let { arguments += listOf("--test-targets", it) }
+    arguments += extraArgs.get()
+
+    logger.lifecycle("Running Firebase Test Lab:\n  ${arguments.joinToString(" ")}")
+    execOperations.exec {
+      commandLine(arguments)
+    }
+  }
+
+  private fun findApk(directory: File, label: String): File {
+    return directory.walkTopDown().firstOrNull { it.isFile && it.extension == "apk" }
+      ?: throw GradleException("No $label APK found under ${directory.absolutePath}. Was the assemble task run?")
+  }
+}
+
 abstract class RenameApkTask : DefaultTask() {
   @get:InputFiles
   abstract val apkFolder: DirectoryProperty

app/proguard/proguard.cfg

@@ -8,6 +8,11 @@
 -keep class org.thoughtcrime.securesms.** { *; }
 -keep class org.signal.donations.json.** { *; }
 -keep class org.signal.network.** { *; }
+
+-keep class org.signal.core.util.crypto.AttachmentSecret { *; }
+-keep class org.signal.core.util.crypto.AttachmentSecret$* { *; }
+-keep class org.signal.core.util.crypto.KeyStoreHelper$SealedData { *; }
+-keep class org.signal.core.util.crypto.KeyStoreHelper$SealedData$* { *; }
 -keepclassmembers class ** {
     public void onEvent*(**);
 }

app/src/androidTest/java/org/thoughtcrime/securesms/SignalInstrumentationApplicationContext.kt

@@ -9,9 +9,11 @@ import org.thoughtcrime.securesms.database.LogDatabase
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencyProvider
 import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.logging.CustomSignalProtocolLogger
 import org.thoughtcrime.securesms.logging.PersistentLogger
 import org.thoughtcrime.securesms.testing.InMemoryLogger
+import org.thoughtcrime.securesms.testing.TestRemoteConfig
 import org.thoughtcrime.securesms.util.Environment
 
 /**
@@ -30,6 +32,13 @@ class SignalInstrumentationApplicationContext : ApplicationContext() {
     val default = ApplicationDependencyProvider(this)
     AppDependencies.init(this, InstrumentationApplicationDependencyProvider(this, default))
     AppDependencies.deadlockDetector.start()
+
+    // Stage any test-declared remote config into the store to be read in RemoteConfig.init().
+    if (TestRemoteConfig.pending.isNotEmpty()) {
+      val json = TestRemoteConfig.json
+      SignalStore.remoteConfig.currentConfig = json
+      SignalStore.remoteConfig.pendingConfig = json
+    }
   }
 
   override fun initializeLogging() {

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/BecomeASustainerUpsellTest.kt

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import androidx.navigation.fragment.NavHostFragment
+import androidx.recyclerview.widget.RecyclerView
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.action.ViewActions.scrollTo
+import androidx.test.espresso.contrib.RecyclerViewActions
+import androidx.test.espresso.matcher.ViewMatchers.hasDescendant
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.getParcelableExtraCompat
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.badges.self.none.BecomeASustainerFragment
+import org.thoughtcrime.securesms.badges.self.overview.BadgesOverviewFragment
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+import org.thoughtcrime.securesms.components.settings.app.routes.AppSettingsRoute
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.profiles.manage.EditProfileActivity
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import java.util.concurrent.TimeUnit
+
+/**
+ * Entry-path coverage for the "become a subscriber" upsell.
+ *
+ * The upsell surface is [BecomeASustainerFragment], reached from the profile screen's badges row. The
+ * handoff test asserts the sheet's button launches the recurring-donation checkout route; the gating
+ * tests assert the "user might be a sustainer" rule in [org.thoughtcrime.securesms.profiles.manage.EditProfileFragment]:
+ * a non-donor sees the upsell, an existing donor is routed to badge management instead.
+ */
+@RunWith(AndroidJUnit4::class)
+class BecomeASustainerUpsellTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  private val context: Context get() = InstrumentationRegistry.getInstrumentation().targetContext
+
+  @Before
+  fun setUp() {
+    setSelfBadges(emptyList())
+  }
+
+  @Test
+  fun nonDonor_badgeTap_showsUpsellSheet() {
+    ActivityScenario.launch(EditProfileActivity::class.java).use { scenario ->
+      onView(withId(R.id.manage_profile_badges_container)).perform(scrollTo(), click())
+
+      val sheet = awaitNavHostFragment(scenario) { it.filterIsInstance<BecomeASustainerFragment>().firstOrNull() }
+      assertThat(sheet).isNotNull()
+    }
+  }
+
+  @Test
+  fun becomeASustainer_launchesRecurringCheckoutRoute() {
+    LaunchedActivityRecorder(AppSettingsActivity::class.java).use { recorder ->
+      ActivityScenario.launch(EditProfileActivity::class.java).use { scenario ->
+        onView(withId(R.id.manage_profile_badges_container)).perform(scrollTo(), click())
+        awaitNavHostFragment(scenario) { it.filterIsInstance<BecomeASustainerFragment>().firstOrNull() }
+
+        val becomeASustainer = withText(R.string.BecomeASustainerMegaphone__become_a_sustainer)
+        onView(withId(R.id.recycler)).perform(RecyclerViewActions.scrollTo<RecyclerView.ViewHolder>(hasDescendant(becomeASustainer)))
+        onView(becomeASustainer).perform(click())
+
+        val intent = recorder.awaitLaunch()
+        val route = intent.extras!!.keySet().firstNotNullOfOrNull { intent.getParcelableExtraCompat(it, AppSettingsRoute::class.java) }
+        assertThat(route).isEqualTo(AppSettingsRoute.DonationsRoute.Donations(directToCheckoutType = InAppPaymentType.RECURRING_DONATION))
+      }
+    }
+  }
+
+  @Test
+  fun donor_badgeTap_opensBadgeManagement() {
+    setSelfBadges(listOf(donorBadge()))
+
+    ActivityScenario.launch(EditProfileActivity::class.java).use { scenario ->
+      onView(withId(R.id.manage_profile_badges_container)).perform(scrollTo(), click())
+
+      val badgeManagement = awaitNavHostFragment(scenario) { it.filterIsInstance<BadgesOverviewFragment>().firstOrNull() }
+      assertThat(badgeManagement).isNotNull()
+
+      val upsell = navHostFragments(scenario).filterIsInstance<BecomeASustainerFragment>().firstOrNull()
+      assertThat(upsell).isNull()
+    }
+  }
+
+  private fun awaitNavHostFragment(scenario: ActivityScenario<EditProfileActivity>, selector: (List<Fragment>) -> Fragment?): Fragment {
+    return await(description = "nav host fragment") { selector(navHostFragments(scenario)) }
+  }
+
+  private fun navHostFragments(scenario: ActivityScenario<EditProfileActivity>): List<Fragment> {
+    var fragments: List<Fragment> = emptyList()
+    scenario.onActivity { activity ->
+      val navHost = activity.supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as? NavHostFragment
+      fragments = navHost?.childFragmentManager?.fragments ?: emptyList()
+    }
+    return fragments
+  }
+
+  private fun setSelfBadges(badges: List<Badge>) {
+    SignalDatabase.recipients.setBadges(Recipient.self().id, badges)
+    Recipient.self().fresh()
+  }
+
+  private fun donorBadge(): Badge {
+    return Badge(
+      id = "test-donor-badge",
+      category = Badge.Category.Donor,
+      name = "Signal Sustainer",
+      description = "",
+      imageUrl = Uri.EMPTY,
+      imageDensity = "xxhdpi",
+      expirationTimestamp = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(30),
+      visible = true,
+      duration = TimeUnit.DAYS.toMillis(30)
+    )
+  }
+
+  private fun <T> await(timeoutMs: Long = 10_000, pollMs: Long = 50, description: String, supplier: () -> T?): T {
+    val deadline = System.currentTimeMillis() + timeoutMs
+    while (System.currentTimeMillis() < deadline) {
+      supplier()?.let { return it }
+      Thread.sleep(pollMs)
+    }
+    error("Timed out after ${timeoutMs}ms waiting for $description")
+  }
+
+  /**
+   * Captures the first launched activity of [activityClass] and finishes it immediately so its own
+   * downstream launches (e.g. the auto-launched checkout) don't cascade during the test.
+   */
+  private inner class LaunchedActivityRecorder(private val activityClass: Class<out Activity>) : AutoCloseable {
+    @Volatile
+    private var launched: Intent? = null
+
+    private val app = context.applicationContext as Application
+    private val callbacks = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        if (activityClass.isInstance(activity) && launched == null) {
+          launched = activity.intent
+          activity.finish()
+        }
+      }
+
+      override fun onActivityStarted(activity: Activity) = Unit
+      override fun onActivityResumed(activity: Activity) = Unit
+      override fun onActivityPaused(activity: Activity) = Unit
+      override fun onActivityStopped(activity: Activity) = Unit
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+      override fun onActivityDestroyed(activity: Activity) = Unit
+    }
+
+    init {
+      app.registerActivityLifecycleCallbacks(callbacks)
+    }
+
+    fun awaitLaunch(): Intent = await(description = "${activityClass.simpleName} launch") { launched }
+
+    override fun close() = app.unregisterActivityLifecycleCallbacks(callbacks)
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowActivityTest__OneTimeDonations.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import androidx.compose.ui.test.junit4.v2.createEmptyComposeRule
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.RootMatchers.isDialog
+import androidx.test.espresso.matcher.ViewMatchers.isClickable
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import io.mockk.unmockkObject
+import org.hamcrest.Matchers.allOf
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.deleteAll
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
+import org.thoughtcrime.securesms.database.InAppPaymentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.testing.GooglePayTestRule
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.RxTestSchedulerRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.actions.scrollToDescendant
+
+@Suppress("ClassName")
+@RunWith(AndroidJUnit4::class)
+class CheckoutFlowActivityTest__OneTimeDonations {
+  @get:Rule
+  val harness = SignalActivityRule(othersCount = 10)
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  @get:Rule
+  val rxRule = RxTestSchedulerRule()
+
+  @get:Rule
+  val googlePayRule = GooglePayTestRule()
+
+  @get:Rule
+  val composeRule = createEmptyComposeRule()
+
+  private val intent = CheckoutFlowActivity.createIntent(InstrumentationRegistry.getInstrumentation().targetContext, InAppPaymentType.ONE_TIME_DONATION)
+
+  @Before
+  fun setUp() {
+    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
+    startJobLoopForTests()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkObject(DonationPermits)
+  }
+
+  @Test
+  fun givenPermitAcquisitionFails_whenIDonateOnce_thenIExpectPaymentSetupErrorDialog() {
+    failDonationPermitAcquisition()
+
+    val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withId(R.id.boost_1), rxRule.defaultTestScheduler)
+    onView(allOf(withId(R.id.boost_1), isClickable())).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), rxRule.defaultTestScheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scenario.selectGooglePay(composeRule, rxRule.defaultTestScheduler, InAppPaymentType.ONE_TIME_DONATION)
+
+    awaitDialog(rxRule.defaultTestScheduler, R.string.DonationsErrors__error_processing_payment)
+    onView(withText(R.string.DonationsErrors__your_payment)).inRoot(isDialog()).check(matches(isDisplayed()))
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowActivityTest__RecurringDonations.kt

@@ -1,9 +1,11 @@
 package org.thoughtcrime.securesms.components.settings.app.subscription.donate
 
+import androidx.compose.ui.test.junit4.v2.createEmptyComposeRule
 import androidx.test.core.app.ActivityScenario
 import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.action.ViewActions
 import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.RootMatchers.isDialog
 import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
 import androidx.test.espresso.matcher.ViewMatchers.isNotEnabled
 import androidx.test.espresso.matcher.ViewMatchers.isSelected
@@ -11,28 +13,33 @@ import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.withText
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
-import io.mockk.every
+import io.mockk.unmockkObject
+import org.junit.After
+import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.signal.core.util.deleteAll
 import org.signal.donations.InAppPaymentType
-import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
+import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
+import org.thoughtcrime.securesms.database.InAppPaymentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
 import org.thoughtcrime.securesms.database.model.databaseprotos.InAppPaymentData
-import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.testing.GooglePayTestRule
 import org.thoughtcrime.securesms.testing.InAppPaymentsRule
 import org.thoughtcrime.securesms.testing.RxTestSchedulerRule
 import org.thoughtcrime.securesms.testing.SignalActivityRule
-import org.thoughtcrime.securesms.testing.actions.RecyclerViewScrollToBottomAction
-import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+import org.thoughtcrime.securesms.testing.actions.scrollToDescendant
+import org.thoughtcrime.securesms.testing.endpoints.DonationResponses
+import org.thoughtcrime.securesms.testing.endpoints.MockEndpoints
+import org.thoughtcrime.securesms.testing.endpoints.failure
+import org.thoughtcrime.securesms.testing.endpoints.ok
 import org.whispersystems.signalservice.api.subscriptions.SubscriberId
-import java.math.BigDecimal
 import java.util.Currency
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Duration.Companion.milliseconds
 
 @Suppress("ClassName")
 @RunWith(AndroidJUnit4::class)
@@ -46,19 +53,37 @@ class CheckoutFlowActivityTest__RecurringDonations {
   @get:Rule
   val rxRule = RxTestSchedulerRule()
 
+  @get:Rule
+  val googlePayRule = GooglePayTestRule()
+
+  @get:Rule
+  val composeRule = createEmptyComposeRule()
+
   private val intent = CheckoutFlowActivity.createIntent(InstrumentationRegistry.getInstrumentation().targetContext, InAppPaymentType.RECURRING_DONATION)
 
+  @Before
+  fun setUp() {
+    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
+    startJobLoopForTests()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkObject(DonationPermits)
+  }
+
   @Test
   fun givenRecurringDonations_whenILoadScreen_thenIExpectMonthlySelected() {
     ActivityScenario.launch<CheckoutFlowActivity>(intent)
+    scrollToDescendant(R.id.recycler, withId(R.id.monthly), rxRule.defaultTestScheduler)
     onView(withId(R.id.monthly)).check(matches(isSelected()))
   }
 
   @Test
   fun givenNoCurrentDonation_whenILoadScreen_thenIExpectContinueButton() {
     ActivityScenario.launch<CheckoutFlowActivity>(intent)
-    onView(withId(R.id.recycler)).perform(RecyclerViewScrollToBottomAction)
-    onView(withText("Continue")).check(matches(isDisplayed()))
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), rxRule.defaultTestScheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).check(matches(isDisplayed()))
   }
 
   @Test
@@ -69,8 +94,9 @@ class CheckoutFlowActivityTest__RecurringDonations {
 
     rxRule.defaultTestScheduler.triggerActions()
 
-    onView(withId(R.id.recycler)).perform(RecyclerViewScrollToBottomAction)
+    scrollToDescendant(R.id.recycler, withText(R.string.SubscribeFragment__update_subscription), rxRule.defaultTestScheduler)
     onView(withText(R.string.SubscribeFragment__update_subscription)).check(matches(isDisplayed()))
+    scrollToDescendant(R.id.recycler, withText(R.string.SubscribeFragment__cancel_subscription), rxRule.defaultTestScheduler)
     onView(withText(R.string.SubscribeFragment__cancel_subscription)).check(matches(isDisplayed()))
   }
 
@@ -82,7 +108,7 @@ class CheckoutFlowActivityTest__RecurringDonations {
 
     rxRule.defaultTestScheduler.triggerActions()
 
-    onView(withId(R.id.recycler)).perform(RecyclerViewScrollToBottomAction)
+    scrollToDescendant(R.id.recycler, withText(R.string.SubscribeFragment__cancel_subscription), rxRule.defaultTestScheduler)
     onView(withText(R.string.SubscribeFragment__cancel_subscription)).check(matches(isDisplayed()))
     onView(withText(R.string.SubscribeFragment__cancel_subscription)).perform(ViewActions.click())
     onView(withText(R.string.SubscribeFragment__confirm_cancellation)).check(matches(isDisplayed()))
@@ -97,50 +123,65 @@ class CheckoutFlowActivityTest__RecurringDonations {
 
     rxRule.defaultTestScheduler.triggerActions()
 
-    onView(withId(R.id.recycler)).perform(RecyclerViewScrollToBottomAction)
+    scrollToDescendant(R.id.recycler, withText(R.string.SubscribeFragment__update_subscription), rxRule.defaultTestScheduler)
     onView(withText(R.string.SubscribeFragment__update_subscription)).check(matches(isDisplayed()))
     onView(withText(R.string.SubscribeFragment__update_subscription)).check(matches(isNotEnabled()))
   }
 
+  @Test
+  fun givenSubscriberPermitAcquisitionFails_whenISubscribe_thenIExpectPaymentSetupErrorDialog() {
+    failDonationPermitAcquisition()
+
+    val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), rxRule.defaultTestScheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scenario.selectGooglePay(composeRule, rxRule.defaultTestScheduler, InAppPaymentType.RECURRING_DONATION)
+
+    awaitDialog(rxRule.defaultTestScheduler, R.string.DonationsErrors__error_processing_payment)
+    onView(withText(R.string.DonationsErrors__your_payment)).inRoot(isDialog()).check(matches(isDisplayed()))
+  }
+
+  @Test
+  fun givenSubscriptionPaymentMethodPermitRejected_whenISubscribe_thenIExpectPaymentSetupErrorDialog() {
+    succeedDonationPermitAcquisition()
+    MockEndpoints.responder.register({ it.method == "POST" && it.path.contains("/create_payment_method") }) {
+      failure(402)
+    }
+
+    val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), rxRule.defaultTestScheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scenario.selectGooglePay(composeRule, rxRule.defaultTestScheduler, InAppPaymentType.RECURRING_DONATION)
+
+    awaitDialog(rxRule.defaultTestScheduler, R.string.DonationsErrors__error_processing_payment)
+    onView(withText(R.string.DonationsErrors__your_payment)).inRoot(isDialog()).check(matches(isDisplayed()))
+  }
+
   private fun initialiseActiveSubscription() {
-    val currency = Currency.getInstance("USD")
-    val subscriber = InAppPaymentSubscriberRecord(
-      subscriberId = SubscriberId.generate(),
-      currency = currency,
-      type = InAppPaymentSubscriberRecord.Type.DONATION,
-      requiresCancel = false,
-      paymentMethodType = InAppPaymentData.PaymentMethodType.CARD,
-      iapSubscriptionId = null
-    )
-
-    InAppPaymentsRepository.setSubscriber(subscriber)
-    SignalStore.inAppPayments.setRecurringDonationCurrency(currency)
-
-    AppDependencies.donationsApi.apply {
-      every { getSubscription(subscriber.subscriberId) } returns NetworkResult.Success(
-        ActiveSubscription(
-          ActiveSubscription.Subscription(
-            200,
-            currency.currencyCode,
-            BigDecimal.ONE,
-            System.currentTimeMillis().milliseconds.inWholeSeconds + 30.days.inWholeSeconds,
-            true,
-            System.currentTimeMillis().milliseconds.inWholeSeconds + 30.days.inWholeSeconds,
-            false,
-            "active",
-            "STRIPE",
-            "CARD",
-            false
-          ),
-          null
-        )
-      )
-
-      every { deleteSubscription(subscriber.subscriberId) } returns NetworkResult.Success(Unit)
+    val subscriber = registerSubscriber()
+    val serialized = subscriber.subscriberId.serialize()
+    MockEndpoints.responder.register({ it.method == "GET" && it.path.contains(serialized) }) {
+      ok(DonationResponses.activeSubscription(status = "active", active = true))
     }
   }
 
   private fun initialisePendingSubscription() {
+    val subscriber = registerSubscriber()
+    val serialized = subscriber.subscriberId.serialize()
+    MockEndpoints.responder.register({ it.method == "GET" && it.path.contains(serialized) }) {
+      ok(DonationResponses.activeSubscription(status = "incomplete", active = false))
+    }
+  }
+
+  private fun registerSubscriber(): InAppPaymentSubscriberRecord {
     val currency = Currency.getInstance("USD")
     val subscriber = InAppPaymentSubscriberRecord(
       subscriberId = SubscriberId.generate(),
@@ -154,25 +195,6 @@ class CheckoutFlowActivityTest__RecurringDonations {
     InAppPaymentsRepository.setSubscriber(subscriber)
     SignalStore.inAppPayments.setRecurringDonationCurrency(currency)
 
-    AppDependencies.donationsApi.apply {
-      every { getSubscription(subscriber.subscriberId) } returns NetworkResult.Success(
-        ActiveSubscription(
-          ActiveSubscription.Subscription(
-            200,
-            currency.currencyCode,
-            BigDecimal.ONE,
-            System.currentTimeMillis().milliseconds.inWholeSeconds + 30.days.inWholeSeconds,
-            false,
-            System.currentTimeMillis().milliseconds.inWholeSeconds + 30.days.inWholeSeconds,
-            false,
-            "incomplete",
-            "STRIPE",
-            "CARD",
-            false
-          ),
-          null
-        )
-      )
-    }
+    return subscriber
   }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowActivityTest__Redemption.kt

@@ -0,0 +1,99 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import androidx.compose.ui.test.junit4.v2.createEmptyComposeRule
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.matcher.ViewMatchers.isClickable
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isNotEmpty
+import io.mockk.unmockkObject
+import org.hamcrest.Matchers.allOf
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.deleteAll
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
+import org.thoughtcrime.securesms.database.DonationReceiptTable
+import org.thoughtcrime.securesms.database.InAppPaymentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.InAppPaymentReceiptRecord
+import org.thoughtcrime.securesms.testing.GooglePayTestRule
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.RxTestSchedulerRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.actions.scrollToDescendant
+import org.thoughtcrime.securesms.testing.endpoints.MockEndpoints
+import org.thoughtcrime.securesms.testing.endpoints.registerStripeHappyPath
+import org.thoughtcrime.securesms.testing.flushUntil
+
+/**
+ * Milestone integration test: drives a Google Pay one-time donation through the entire lifecycle to
+ * receipt redemption, exercising all three outer boundaries at once — the Signal-service websocket
+ * responder (boost intent + receipt credential + redeem), the Stripe HTTP interceptor (payment
+ * method + confirm + intent status), and the test zk server (real client-side credential validation).
+ */
+@Suppress("ClassName")
+@RunWith(AndroidJUnit4::class)
+class CheckoutFlowActivityTest__Redemption {
+  @get:Rule
+  val harness = SignalActivityRule(othersCount = 10)
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  @get:Rule
+  val rxRule = RxTestSchedulerRule()
+
+  @get:Rule
+  val googlePayRule = GooglePayTestRule()
+
+  @get:Rule
+  val composeRule = createEmptyComposeRule()
+
+  private val intent = CheckoutFlowActivity.createIntent(InstrumentationRegistry.getInstrumentation().targetContext, InAppPaymentType.ONE_TIME_DONATION)
+
+  @Before
+  fun setUp() {
+    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
+    SignalDatabase.donationReceipts.writableDatabase.deleteAll(DonationReceiptTable.TABLE_NAME)
+    startJobLoopForTests()
+    succeedDonationPermitAcquisition()
+    MockEndpoints.responder.registerStripeHappyPath()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkObject(DonationPermits)
+  }
+
+  @Test
+  fun givenAllEndpointsSucceed_whenIDonateOnceWithGooglePay_thenIExpectAReceipt() {
+    val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withId(R.id.boost_1), rxRule.defaultTestScheduler)
+    onView(allOf(withId(R.id.boost_1), isClickable())).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), rxRule.defaultTestScheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).perform(ViewActions.click())
+    rxRule.defaultTestScheduler.triggerActions()
+
+    scenario.selectGooglePay(composeRule, rxRule.defaultTestScheduler, InAppPaymentType.ONE_TIME_DONATION)
+
+    rxRule.defaultTestScheduler.flushUntil {
+      SignalDatabase.donationReceipts.getReceipts(InAppPaymentReceiptRecord.Type.ONE_TIME_DONATION).isNotEmpty()
+    }
+
+    assertThat(SignalDatabase.donationReceipts.getReceipts(InAppPaymentReceiptRecord.Type.ONE_TIME_DONATION)).isNotEmpty()
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowDriver.kt

@@ -0,0 +1,280 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import android.os.Bundle
+import androidx.compose.ui.test.hasTestTag
+import androidx.compose.ui.test.junit4.ComposeTestRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollToNode
+import androidx.compose.ui.test.performTextInput
+import androidx.core.os.bundleOf
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.navigation.fragment.NavHostFragment
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.ViewMatchers.isClickable
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.isEnabled
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import io.reactivex.rxjava3.schedulers.TestScheduler
+import org.hamcrest.Matchers.allOf
+import org.signal.donations.InAppPaymentType
+import org.signal.donations.StripeIntentAccessor
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.gateway.GatewaySelectorTestTags
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.paypal.PayPalConfirmationDialogFragment
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.paypal.PayPalConfirmationResult
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.stripe.Stripe3DSDialogFragment
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.DonationTransferTestTags
+import org.thoughtcrime.securesms.testing.actions.scrollToDescendant
+import org.thoughtcrime.securesms.testing.endpoints.StripeResponses
+import org.thoughtcrime.securesms.testing.flushUntil
+
+/**
+ * Drives [CheckoutFlowActivity] through the UI "as a user" for a [DonationsCheckoutTestSpec]: selects
+ * an amount/tier, continues to the gateway selector, and completes the chosen payment method. Each
+ * payment method is a strategy dispatched on [DonationsCheckoutTestSpec.paymentMethod].
+ *
+ * Webview approval steps (PayPal, Stripe 3DS) can't complete against a mocked network, so instead of
+ * loading the approval URL we inject the fragment result the webview would have posted — the same
+ * mechanism the production dialog uses on return.
+ */
+class CheckoutFlowDriver(
+  private val composeRule: ComposeTestRule,
+  private val scheduler: TestScheduler
+) {
+
+  companion object {
+    private const val TEST_NAME = "Test McTesterson"
+    private const val TEST_EMAIL = "test@signal.org"
+
+    /** A structurally valid German IBAN (passes mod-97), for the SEPA form. */
+    private const val TEST_IBAN = "DE89370400440532013000"
+  }
+
+  fun drive(scenario: ActivityScenario<CheckoutFlowActivity>, spec: DonationsCheckoutTestSpec) {
+    scheduler.triggerActions()
+
+    selectAmountOrTier(spec.inAppPaymentType)
+    proceedToGateway()
+
+    when (spec.paymentMethod) {
+      TestPaymentMethod.GOOGLE_PAY -> scenario.selectGooglePay(composeRule, scheduler, spec.inAppPaymentType)
+      TestPaymentMethod.CREDIT_CARD -> completeCreditCard()
+      TestPaymentMethod.PAYPAL -> completePayPal(scenario, spec.inAppPaymentType)
+      TestPaymentMethod.SEPA_DEBIT -> completeSepa()
+      TestPaymentMethod.IDEAL -> completeIdeal(spec.inAppPaymentType)
+    }
+
+    if (spec.world.stripe == StripeOutcome.REQUIRES_3DS && spec.paymentMethod.usesStripe()) {
+      complete3ds(scenario, spec.inAppPaymentType)
+    }
+  }
+
+  private fun selectAmountOrTier(type: InAppPaymentType) {
+    if (type == InAppPaymentType.ONE_TIME_DONATION) {
+      scrollToDescendant(R.id.recycler, withId(R.id.boost_1), scheduler)
+      onView(allOf(withId(R.id.boost_1), isClickable())).perform(ViewActions.click())
+      scheduler.triggerActions()
+    }
+    // Recurring: the monthly tier is selected by default, so nothing to pick here.
+  }
+
+  private fun proceedToGateway() {
+    scrollToDescendant(R.id.recycler, withText(R.string.DonateToSignalFragment__continue), scheduler)
+    onView(withText(R.string.DonateToSignalFragment__continue)).perform(ViewActions.click())
+    scheduler.triggerActions()
+  }
+
+  /**
+   * Fills the [org.thoughtcrime.securesms.components.settings.app.subscription.donate.card.CreditCardFragment]
+   * with a valid test card and continues, driving the flow into the Stripe payment pipeline.
+   */
+  private fun completeCreditCard() {
+    clickGatewayButton(GatewaySelectorTestTags.CREDIT_CARD_BUTTON)
+
+    scheduler.flushUntil {
+      onView(withId(R.id.card_number)).check(matches(isDisplayed()))
+      true
+    }
+
+    onView(withId(R.id.card_number)).perform(ViewActions.typeText("4242424242424242"), ViewActions.closeSoftKeyboard())
+    onView(withId(R.id.card_expiry)).perform(ViewActions.typeText("1228"), ViewActions.closeSoftKeyboard())
+    onView(withId(R.id.card_cvv)).perform(ViewActions.typeText("123"), ViewActions.closeSoftKeyboard())
+
+    scheduler.flushUntil {
+      onView(withId(R.id.continue_button)).check(matches(isEnabled()))
+      true
+    }
+    onView(withId(R.id.continue_button)).perform(ViewActions.click())
+    scheduler.triggerActions()
+  }
+
+  /**
+   * Selects PayPal, then injects the approval result the webview would have returned. One-time uses a
+   * [PayPalConfirmationResult]; recurring posts `true`.
+   */
+  private fun completePayPal(scenario: ActivityScenario<CheckoutFlowActivity>, type: InAppPaymentType) {
+    clickGatewayButton(GatewaySelectorTestTags.PAYPAL_BUTTON)
+
+    val result: Any = if (type == InAppPaymentType.ONE_TIME_DONATION) {
+      PayPalConfirmationResult(payerId = "test-payer", paymentId = null, paymentToken = "test-token")
+    } else {
+      true
+    }
+
+    awaitDialogAndSetResult(
+      scenario = scenario,
+      dialogClass = PayPalConfirmationDialogFragment::class.java,
+      resultKey = PayPalConfirmationDialogFragment.REQUEST_KEY,
+      bundle = bundleOf(PayPalConfirmationDialogFragment.REQUEST_KEY to result)
+    )
+  }
+
+  /** Injects the 3DS return the Stripe webview would have posted, resuming the Stripe pipeline. */
+  private fun complete3ds(scenario: ActivityScenario<CheckoutFlowActivity>, type: InAppPaymentType) {
+    val accessor = if (type == InAppPaymentType.ONE_TIME_DONATION) {
+      StripeIntentAccessor(StripeIntentAccessor.ObjectType.PAYMENT_INTENT, StripeResponses.DEFAULT_PAYMENT_INTENT_ID, "${StripeResponses.DEFAULT_PAYMENT_INTENT_ID}_secret_test")
+    } else {
+      StripeIntentAccessor(StripeIntentAccessor.ObjectType.SETUP_INTENT, StripeResponses.DEFAULT_SETUP_INTENT_ID, "${StripeResponses.DEFAULT_SETUP_INTENT_ID}_secret_test")
+    }
+
+    awaitDialogAndSetResult(
+      scenario = scenario,
+      dialogClass = Stripe3DSDialogFragment::class.java,
+      resultKey = Stripe3DSDialogFragment.REQUEST_KEY,
+      bundle = bundleOf(Stripe3DSDialogFragment.REQUEST_KEY to accessor)
+    )
+  }
+
+  /**
+   * Selects SEPA, accepts the mandate (its button scrolls the text to the bottom before it agrees, so
+   * it is clicked until the details form appears), fills the bank details, and donates. SEPA requires
+   * a EUR donation currency (see [WorldState.currencyCode]).
+   */
+  private fun completeSepa() {
+    clickGatewayButton(GatewaySelectorTestTags.SEPA_BUTTON)
+
+    scheduler.flushUntil {
+      val ibanPresent = runCatching {
+        composeRule.onAllNodesWithTag(DonationTransferTestTags.SEPA_IBAN_FIELD).fetchSemanticsNodes().isNotEmpty()
+      }.getOrDefault(false)
+      if (!ibanPresent) {
+        runCatching { composeRule.onNodeWithTag(DonationTransferTestTags.SEPA_MANDATE_CONTINUE_BUTTON).performClick() }
+      }
+      ibanPresent
+    }
+
+    typeIntoField(DonationTransferTestTags.SEPA_DETAILS_LIST, DonationTransferTestTags.SEPA_IBAN_FIELD, TEST_IBAN)
+    typeIntoField(DonationTransferTestTags.SEPA_DETAILS_LIST, DonationTransferTestTags.SEPA_NAME_FIELD, TEST_NAME)
+    typeIntoField(DonationTransferTestTags.SEPA_DETAILS_LIST, DonationTransferTestTags.SEPA_EMAIL_FIELD, TEST_EMAIL)
+
+    clickWhenReady(DonationTransferTestTags.SEPA_DONATE_BUTTON)
+  }
+
+  /**
+   * Selects iDEAL, fills the bank details (email is recurring-only), and donates. iDEAL requires a EUR
+   * donation currency and, on success, lands in an awaiting-authorization state.
+   */
+  private fun completeIdeal(type: InAppPaymentType) {
+    clickGatewayButton(GatewaySelectorTestTags.IDEAL_BUTTON)
+
+    scheduler.flushUntil {
+      runCatching {
+        composeRule.onAllNodesWithTag(DonationTransferTestTags.IDEAL_NAME_FIELD).fetchSemanticsNodes().isNotEmpty()
+      }.getOrDefault(false)
+    }
+
+    typeIntoField(DonationTransferTestTags.IDEAL_DETAILS_LIST, DonationTransferTestTags.IDEAL_NAME_FIELD, TEST_NAME)
+    if (type.recurring) {
+      typeIntoField(DonationTransferTestTags.IDEAL_DETAILS_LIST, DonationTransferTestTags.IDEAL_EMAIL_FIELD, TEST_EMAIL)
+    }
+
+    clickWhenReady(DonationTransferTestTags.IDEAL_DONATE_BUTTON)
+  }
+
+  /**
+   * Scrolls the [listTag] lazy list until the field tagged [fieldTag] is composed and on-screen, then types
+   * [text] into it. The transfer forms lay their fields out in a [androidx.compose.foundation.lazy.LazyColumn],
+   * so a lower field is not composed on a short screen until scrolled to — without this, the input silently
+   * matches nothing on Firebase's smaller devices.
+   */
+  private fun typeIntoField(listTag: String, fieldTag: String, text: String) {
+    composeRule.onNodeWithTag(listTag).performScrollToNode(hasTestTag(fieldTag))
+    composeRule.onNodeWithTag(fieldTag).performTextInput(text)
+  }
+
+  /** Retries clicking a Compose node until the click lands (e.g. once a submit button becomes enabled). */
+  private fun clickWhenReady(tag: String) {
+    scheduler.flushUntil {
+      runCatching {
+        composeRule.onNodeWithTag(tag).performClick()
+        true
+      }.getOrDefault(false)
+    }
+    scheduler.triggerActions()
+  }
+
+  /**
+   * Clicks a Compose gateway-selector button and waits for the bottom sheet to dismiss. For methods
+   * other than Google Pay the checkout then navigates to the method's fragment; Google Pay instead
+   * requires a result injection (see `selectGooglePay`).
+   */
+  private fun clickGatewayButton(tag: String) {
+    scheduler.flushUntil {
+      composeRule.onAllNodesWithTag(tag).fetchSemanticsNodes().isNotEmpty()
+    }
+
+    // The selector is a vertically scrolling bottom sheet; on a short screen the lower gateway buttons are
+    // off-screen, so bring the target on-screen before clicking (mirrors GatewaySelectorBottomSheetContentTest).
+    composeRule.onNodeWithTag(GatewaySelectorTestTags.CONTAINER).performScrollToNode(hasTestTag(tag))
+    composeRule.onNodeWithTag(tag).performClick()
+
+    scheduler.flushUntil {
+      runCatching {
+        composeRule.onAllNodesWithTag(tag).fetchSemanticsNodes().isEmpty()
+      }.getOrDefault(true)
+    }
+  }
+
+  /**
+   * Waits for a navigated dialog of [dialogClass] to be present, then posts [bundle] as its fragment
+   * result on the nav host's fragment manager (where the in-progress fragment registered its listener).
+   */
+  private fun <T : Fragment> awaitDialogAndSetResult(
+    scenario: ActivityScenario<CheckoutFlowActivity>,
+    dialogClass: Class<T>,
+    resultKey: String,
+    bundle: Bundle
+  ) {
+    scheduler.flushUntil {
+      var delivered = false
+      scenario.onActivity { activity ->
+        val fragmentManager = navHostChildFragmentManager(activity)
+        if (fragmentManager != null && fragmentManager.fragments.any { dialogClass.isInstance(it) }) {
+          fragmentManager.setFragmentResult(resultKey, bundle)
+          delivered = true
+        }
+      }
+      delivered
+    }
+    scheduler.triggerActions()
+  }
+
+  private fun navHostChildFragmentManager(activity: FragmentActivity): FragmentManager? {
+    return activity.supportFragmentManager.fragments
+      .filterIsInstance<NavHostFragment>()
+      .firstOrNull()
+      ?.childFragmentManager
+  }
+
+  private fun TestPaymentMethod.usesStripe(): Boolean {
+    return this != TestPaymentMethod.PAYPAL
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowPermitTestSupport.kt

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import android.app.Activity
+import android.content.Intent
+import androidx.compose.ui.test.hasTestTag
+import androidx.compose.ui.test.junit4.ComposeTestRule
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollToNode
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.RootMatchers.isDialog
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import io.mockk.every
+import io.mockk.mockkObject
+import io.reactivex.rxjava3.schedulers.TestScheduler
+import org.signal.donations.InAppPaymentType
+import org.signal.libsignal.net.RequestResult
+import org.signal.network.rest.RestStatusCodeError
+import org.thoughtcrime.securesms.SignalInstrumentationApplicationContext
+import org.thoughtcrime.securesms.components.settings.app.subscription.GooglePayComponent
+import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.gateway.GatewaySelectorTestTags
+import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.testing.flushUntil
+
+/**
+ * Forces donation-permit acquisition to fail, so the checkout surfaces a payment-setup error before
+ * reaching the payment method. Stubs the [DonationPermits] object directly (the underlying
+ * `createDonationPermits` call rides the websocket, which the responder does not mint valid permits
+ * for). Call `unmockkObject(DonationPermits)` in teardown.
+ */
+fun failDonationPermitAcquisition(statusCode: Int = 500) {
+  AppDependencies.donationPermitsRepository.clearPermits()
+  mockkObject(DonationPermits)
+  every { DonationPermits.getDonationPermit() } returns RequestResult.NonSuccess(RestStatusCodeError(statusCode, emptyMap(), null))
+}
+
+/**
+ * Makes donation-permit acquisition succeed with a placeholder permit, letting the checkout proceed
+ * past the permit gate to the payment method. Call `unmockkObject(DonationPermits)` in teardown.
+ */
+fun succeedDonationPermitAcquisition() {
+  AppDependencies.donationPermitsRepository.clearPermits()
+  mockkObject(DonationPermits)
+  every { DonationPermits.getDonationPermit() } returns RequestResult.Success("permit")
+}
+
+/**
+ * The instrumentation app stubs [org.thoughtcrime.securesms.ApplicationContext.beginJobLoop] to a no-op, so enqueued
+ * jobs never run. The checkout pipeline drives a real setup job through the JobManager, so the loop must be started.
+ *
+ * Before starting it, cancel any leftover in-app-payment jobs. A recurring setup job retries indefinitely over a
+ * one-day lifespan, so a spec that fails setup leaves one persisted in the JobManager. On Firebase Test Lab the
+ * orchestrator's `clearPackageData` does not reliably wipe the JobManager between parameterized specs (it does on a
+ * local emulator, which is why this only surfaces on-device), so that job survives into the next spec and runs after
+ * its InAppPayment row was deleted in setup — `InAppPaymentsRepository.resolveLock` then throws "Not found" from the
+ * job thread and crashes the whole app. Clearing the queues here makes each test start from a clean job state.
+ */
+fun startJobLoopForTests() {
+  AppDependencies.jobManager.cancelAllInQueues(
+    setOf(
+      InAppPaymentsRepository.getRecurringJobQueueKey(InAppPaymentType.RECURRING_DONATION),
+      InAppPaymentsRepository.getRecurringJobQueueKey(InAppPaymentType.RECURRING_BACKUP)
+    )
+  )
+  AppDependencies.jobManager.flush()
+
+  (AppDependencies.application as SignalInstrumentationApplicationContext).beginJobLoopForTests()
+}
+
+/**
+ * Selects Google Pay in the Compose gateway selector and feeds the stubbed Google Pay result back into the
+ * checkout, navigating to the payment-in-progress screen where the pipeline runs.
+ *
+ * The gateway selector is populated by Rx work on [scheduler], so we [flushUntil] the button is present
+ * rather than sleeping. Selecting Google Pay dismisses the gateway sheet and hands a fragment result back to
+ * the checkout, which runs `launchGooglePay` -> `provideGatewayRequestForGooglePay` on [scheduler]; only then
+ * does the checkout's subscriber consume a [GooglePayComponent.googlePayResultPublisher] emission
+ * (`consumeGatewayRequestForGooglePay` returns null until then, and the publisher is a hot PublishSubject that
+ * drops earlier emissions). So we [flushUntil] the sheet has dismissed — a real signal that the click was
+ * fully processed — before dispatching the result, rather than pumping a fixed number of times and racing.
+ */
+fun ActivityScenario<CheckoutFlowActivity>.selectGooglePay(
+  composeRule: ComposeTestRule,
+  scheduler: TestScheduler,
+  inAppPaymentType: InAppPaymentType
+) {
+  scheduler.flushUntil {
+    composeRule.onAllNodesWithTag(GatewaySelectorTestTags.GOOGLE_PAY_BUTTON).fetchSemanticsNodes().isNotEmpty()
+  }
+
+  composeRule.onNodeWithTag(GatewaySelectorTestTags.CONTAINER).performScrollToNode(hasTestTag(GatewaySelectorTestTags.GOOGLE_PAY_BUTTON))
+  composeRule.onNodeWithTag(GatewaySelectorTestTags.GOOGLE_PAY_BUTTON).performClick()
+
+  scheduler.flushUntil {
+    // Once the gateway sheet dismisses there is no Compose hierarchy left, so fetchSemanticsNodes throws
+    // rather than returning empty; treat both the empty list and the missing hierarchy as "sheet gone".
+    runCatching {
+      composeRule.onAllNodesWithTag(GatewaySelectorTestTags.GOOGLE_PAY_BUTTON).fetchSemanticsNodes().isEmpty()
+    }.getOrDefault(true)
+  }
+
+  onActivity { activity ->
+    (activity as GooglePayComponent).googlePayResultPublisher.onNext(
+      GooglePayComponent.GooglePayResult(
+        requestCode = InAppPaymentsRepository.getGooglePayRequestCode(inAppPaymentType),
+        resultCode = Activity.RESULT_OK,
+        data = Intent()
+      )
+    )
+  }
+}
+
+/**
+ * Waits for a dialog whose title is [titleResId] to be displayed. Matches any dialog by title (error,
+ * confirmation, thanks, etc.) — it is not specific to error dialogs.
+ *
+ * [flushUntil] advances the Rx pipeline (which may create the payment, enqueue the real setup job, and react
+ * to its committed state) while yielding real time for any job to run, until the dialog renders. A single
+ * condition-driven pump rather than a fixed-duration wall-clock poll. Letting the Espresso check throw (rather
+ * than collapsing it to a boolean) lets [flushUntil] chain the last matcher failure as the timeout cause.
+ */
+fun awaitDialog(
+  scheduler: TestScheduler,
+  titleResId: Int,
+  timeoutMillis: Long = 15_000
+) {
+  scheduler.flushUntil(timeoutMillis) {
+    onView(withText(titleResId)).inRoot(isDialog()).check(matches(isDisplayed()))
+    true
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/DonationsCheckoutSpecTest.kt

@@ -0,0 +1,282 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import androidx.compose.ui.test.junit4.v2.createEmptyComposeRule
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.RootMatchers.isDialog
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isNotEmpty
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import io.mockk.unmockkObject
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import org.signal.core.util.deleteAll
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
+import org.thoughtcrime.securesms.database.DonationReceiptTable
+import org.thoughtcrime.securesms.database.InAppPaymentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.InAppPaymentReceiptRecord
+import org.thoughtcrime.securesms.testing.GooglePayTestRule
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.RawFlag
+import org.thoughtcrime.securesms.testing.RemoteConfigForTest
+import org.thoughtcrime.securesms.testing.RxTestSchedulerRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.flushUntil
+
+/**
+ * Spec-driven integration test for donation checkout. Each [DonationsCheckoutTestSpec] declares a
+ * "world" (what each endpoint returns) and an expected outcome; this runner applies the world, drives
+ * [CheckoutFlowActivity] through the real UI via [CheckoutFlowDriver], and asserts the outcome.
+ *
+ * Adding coverage is data: append a spec to [DonationsCheckoutSpecs.ALL].
+ */
+@RunWith(Parameterized::class)
+@RemoteConfigForTest(
+  rawFlags = [
+    RawFlag("android.sepa.debit.donations.5", "true"),
+    RawFlag("android.ideal.donations.5", "true"),
+    // Region codes are matched against the digit-only self E164 ("15555550101"), so no leading "+".
+    RawFlag("global.donations.sepaEnabledRegions", "1"),
+    RawFlag("global.donations.idealEnabledRegions", "1")
+  ]
+)
+class DonationsCheckoutSpecTest(private val spec: DonationsCheckoutTestSpec) {
+
+  @get:Rule
+  val harness = SignalActivityRule(othersCount = 10)
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  @get:Rule
+  val rxRule = RxTestSchedulerRule()
+
+  @get:Rule
+  val googlePayRule = GooglePayTestRule()
+
+  @get:Rule
+  val composeRule = createEmptyComposeRule()
+
+  @Before
+  fun setUp() {
+    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
+    SignalDatabase.donationReceipts.writableDatabase.deleteAll(DonationReceiptTable.TABLE_NAME)
+    startJobLoopForTests()
+    spec.world.apply()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkObject(DonationPermits)
+  }
+
+  @Test
+  fun runSpec() {
+    val intent = CheckoutFlowActivity.createIntent(InstrumentationRegistry.getInstrumentation().targetContext, spec.inAppPaymentType)
+    val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
+
+    CheckoutFlowDriver(composeRule, rxRule.defaultTestScheduler).drive(scenario, spec)
+
+    when (val expected = spec.expected) {
+      is ExpectedOutcome.Redeemed -> {
+        rxRule.defaultTestScheduler.flushUntil { receipts().isNotEmpty() }
+        assertThat(receipts()).isNotEmpty()
+      }
+
+      is ExpectedOutcome.ErrorDialog -> {
+        awaitDialog(rxRule.defaultTestScheduler, expected.titleRes)
+        if (expected.messageRes != null) {
+          onView(withText(expected.messageRes)).inRoot(isDialog()).check(matches(isDisplayed()))
+        }
+      }
+
+      is ExpectedOutcome.PaymentSubmitted -> {
+        rxRule.defaultTestScheduler.flushUntil { submittedPayment() != null }
+        val payment = submittedPayment()
+        assertThat(payment).isNotNull()
+        assertThat(payment!!.data.error).isNull()
+      }
+    }
+  }
+
+  /** The latest payment once it has moved past CREATED with no error, or null if not yet there. */
+  private fun submittedPayment(): InAppPaymentTable.InAppPayment? {
+    return SignalDatabase.inAppPayments.getLatestInAppPaymentByType(spec.inAppPaymentType)
+      ?.takeIf { it.state != InAppPaymentTable.State.CREATED && it.data.error == null }
+  }
+
+  private fun receipts(): List<InAppPaymentReceiptRecord> {
+    val type = if (spec.inAppPaymentType == InAppPaymentType.ONE_TIME_DONATION) {
+      InAppPaymentReceiptRecord.Type.ONE_TIME_DONATION
+    } else {
+      InAppPaymentReceiptRecord.Type.RECURRING_DONATION
+    }
+    return SignalDatabase.donationReceipts.getReceipts(type)
+  }
+
+  companion object {
+    @JvmStatic
+    @Parameterized.Parameters(name = "{0}")
+    fun specs(): Collection<DonationsCheckoutTestSpec> = DonationsCheckoutSpecs.ALL
+  }
+}
+
+/**
+ * The enumerated donation checkout scenarios. Currently seeded with Google Pay coverage; the other
+ * payment-method drivers (card, SEPA, iDEAL, PayPal) and their scenarios are added alongside their
+ * [CheckoutFlowDriver] strategies.
+ */
+object DonationsCheckoutSpecs {
+
+  private val paymentErrorDialog = ExpectedOutcome.ErrorDialog(
+    titleRes = R.string.DonationsErrors__error_processing_payment,
+    messageRes = R.string.DonationsErrors__your_payment
+  )
+
+  val ALL: List<DonationsCheckoutTestSpec> = listOf(
+    DonationsCheckoutTestSpec(
+      name = "googlePay_oneTime_happyPath_isRedeemed",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(),
+      expected = ExpectedOutcome.Redeemed
+    ),
+    DonationsCheckoutTestSpec(
+      name = "googlePay_oneTime_permitFailure_showsError",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(permit = PermitOutcome.FAILURE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "googlePay_oneTime_stripeDecline_showsError",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(stripe = StripeOutcome.DECLINE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "googlePay_oneTime_signalCreateIntent402_showsError",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(signalCreatePaymentStatus = 402),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "googlePay_recurring_permitFailure_showsError",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(permit = PermitOutcome.FAILURE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "creditCard_oneTime_happyPath_isRedeemed",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(),
+      expected = ExpectedOutcome.Redeemed
+    ),
+    DonationsCheckoutTestSpec(
+      name = "creditCard_oneTime_stripeDecline_showsError",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(stripe = StripeOutcome.DECLINE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "creditCard_oneTime_3dsApproved_isRedeemed",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(stripe = StripeOutcome.REQUIRES_3DS),
+      expected = ExpectedOutcome.Redeemed
+    ),
+    DonationsCheckoutTestSpec(
+      name = "payPal_oneTime_happyPath_isRedeemed",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.PAYPAL,
+      world = WorldState(),
+      expected = ExpectedOutcome.Redeemed
+    ),
+    DonationsCheckoutTestSpec(
+      name = "sepa_oneTime_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.SEPA_DEBIT,
+      world = WorldState(currencyCode = "EUR"),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+    DonationsCheckoutTestSpec(
+      name = "ideal_oneTime_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.IDEAL,
+      world = WorldState(currencyCode = "EUR"),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+
+    // Recurring happy paths. Asserted as "submitted": the recurring-specific work is the setup
+    // pipeline (create subscriber, setup intent, set default, set level); receipt redemption is
+    // shared with the one-time path already covered above.
+    DonationsCheckoutTestSpec(
+      name = "googlePay_recurring_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(recurringActivatesAfterSetup = true),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+    DonationsCheckoutTestSpec(
+      name = "creditCard_recurring_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(recurringActivatesAfterSetup = true),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+    DonationsCheckoutTestSpec(
+      name = "payPal_recurring_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.PAYPAL,
+      world = WorldState(recurringActivatesAfterSetup = true),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+    DonationsCheckoutTestSpec(
+      name = "sepa_recurring_happyPath_isSubmitted",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.SEPA_DEBIT,
+      world = WorldState(currencyCode = "EUR"),
+      expected = ExpectedOutcome.PaymentSubmitted
+    ),
+
+    // Additional error cases.
+    DonationsCheckoutTestSpec(
+      name = "creditCard_oneTime_permitFailure_showsError",
+      inAppPaymentType = InAppPaymentType.ONE_TIME_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(permit = PermitOutcome.FAILURE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "creditCard_recurring_stripeDecline_showsError",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.CREDIT_CARD,
+      world = WorldState(stripe = StripeOutcome.DECLINE),
+      expected = paymentErrorDialog
+    ),
+    DonationsCheckoutTestSpec(
+      name = "googlePay_recurring_signalCreatePaymentMethod402_showsError",
+      inAppPaymentType = InAppPaymentType.RECURRING_DONATION,
+      paymentMethod = TestPaymentMethod.GOOGLE_PAY,
+      world = WorldState(signalCreatePaymentStatus = 402),
+      expected = paymentErrorDialog
+    )
+  )
+}

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/DonationsCheckoutTestSpec.kt

@@ -0,0 +1,159 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate
+
+import androidx.annotation.StringRes
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.testing.endpoints.DonationResponses
+import org.thoughtcrime.securesms.testing.endpoints.EndpointResponse
+import org.thoughtcrime.securesms.testing.endpoints.MockEndpoints
+import org.thoughtcrime.securesms.testing.endpoints.StripeResponses
+import org.thoughtcrime.securesms.testing.endpoints.failure
+import org.thoughtcrime.securesms.testing.endpoints.ok
+import org.thoughtcrime.securesms.testing.endpoints.registerPayPalHappyPath
+import org.thoughtcrime.securesms.testing.endpoints.registerStripeHappyPath
+import java.util.Currency
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * A declarative "state of the world" + expected outcome for one donation checkout scenario. Specs
+ * are enumerated by [DonationsCheckoutSpecTest] and each one drives [CheckoutFlowActivity] end to end
+ * for its [paymentMethod].
+ */
+data class DonationsCheckoutTestSpec(
+  val name: String,
+  val inAppPaymentType: InAppPaymentType,
+  val paymentMethod: TestPaymentMethod,
+  val world: WorldState = WorldState(),
+  val expected: ExpectedOutcome
+) {
+  /** Used as the parameterized test label. */
+  override fun toString(): String = name
+}
+
+enum class TestPaymentMethod {
+  GOOGLE_PAY,
+  CREDIT_CARD,
+  SEPA_DEBIT,
+  IDEAL,
+  PAYPAL
+}
+
+/** Whether donation-permit acquisition succeeds or fails. */
+enum class PermitOutcome { SUCCESS, FAILURE }
+
+/** The Stripe HTTP edge's behavior for a scenario. */
+enum class StripeOutcome {
+  SUCCESS,
+  DECLINE,
+  FAILURE,
+  REQUIRES_3DS
+}
+
+/** Pre-existing recurring subscription state (recurring scenarios only). */
+enum class SubscriptionState { NONE, ACTIVE, PENDING }
+
+/**
+ * The knobs that define what each endpoint returns. [apply] registers the corresponding handlers on
+ * the shared responder (overriding the [org.thoughtcrime.securesms.testing.InAppPaymentsRule]
+ * defaults, since later registrations win) and sets the permit outcome.
+ */
+data class WorldState(
+  val permit: PermitOutcome = PermitOutcome.SUCCESS,
+  val stripe: StripeOutcome = StripeOutcome.SUCCESS,
+  val declineCode: String = "card_declined",
+  val signalCreatePaymentStatus: Int = 200,
+  val receiptCredentialStatus: Int = 200,
+  val redeemStatus: Int = 200,
+  val existingSubscription: SubscriptionState = SubscriptionState.NONE,
+  /** Donation currency to use. SEPA/iDEAL require EUR. */
+  val currencyCode: String = "USD",
+  /**
+   * For a new recurring donation: report no active subscription until the subscription level is set
+   * during setup, then report an active one. This lets the checkout show "Continue" (new subscriber)
+   * while still letting the recurring receipt-credential context job see an active subscription to redeem.
+   */
+  val recurringActivatesAfterSetup: Boolean = false
+) {
+  fun apply() {
+    val currency = Currency.getInstance(currencyCode)
+    SignalStore.inAppPayments.setOneTimeCurrency(currency)
+    SignalStore.inAppPayments.setRecurringDonationCurrency(currency)
+
+    when (permit) {
+      PermitOutcome.SUCCESS -> succeedDonationPermitAcquisition()
+      PermitOutcome.FAILURE -> failDonationPermitAcquisition()
+    }
+
+    val responder = MockEndpoints.responder
+
+    // Signal-service PayPal endpoints (harmless for non-PayPal specs; distinct paths).
+    responder.registerPayPalHappyPath()
+
+    // Stripe HTTP edge.
+    responder.registerStripeHappyPath()
+    when (stripe) {
+      StripeOutcome.SUCCESS -> Unit
+      StripeOutcome.DECLINE -> responder.register({ it.method == "POST" && (it.path.endsWith("/confirm") || it.path.contains("/payment_methods")) }) {
+        failure(402, StripeResponses.declineError(declineCode))
+      }
+      StripeOutcome.FAILURE -> responder.register({ it.method == "POST" && it.path.endsWith("/confirm") }) {
+        failure(402, StripeResponses.failureError("card_not_supported"))
+      }
+      StripeOutcome.REQUIRES_3DS -> responder.register({ it.method == "POST" && it.path.endsWith("/confirm") }) {
+        ok(StripeResponses.confirm3dsRequired())
+      }
+    }
+
+    // Signal-service edge overrides.
+    if (signalCreatePaymentStatus != 200) {
+      responder.register({ it.method == "POST" && (it.path.contains("/create_payment_method") || it.path.endsWith("/boost/create")) }) {
+        failure(signalCreatePaymentStatus)
+      }
+    }
+    if (receiptCredentialStatus != 200) {
+      responder.register({ it.method == "POST" && it.path.contains("/receipt_credentials") }) { failure(receiptCredentialStatus) }
+    }
+    if (redeemStatus != 200) {
+      responder.register({ it.method == "POST" && it.path.contains("/redeem-receipt") }) { failure(redeemStatus) }
+    }
+
+    when (existingSubscription) {
+      SubscriptionState.NONE -> Unit
+      SubscriptionState.ACTIVE -> registerSubscription(status = "active", active = true)
+      SubscriptionState.PENDING -> registerSubscription(status = "incomplete", active = false)
+    }
+
+    if (recurringActivatesAfterSetup) {
+      val activated = AtomicBoolean(false)
+      responder.register({ it.method == "PUT" && it.path.contains("/level/") }) {
+        activated.set(true)
+        ok()
+      }
+      responder.register({ it.method == "GET" && it.path.contains("/v1/subscription/") && !it.path.contains("configuration") && !it.path.contains("bank_mandate") }) {
+        if (activated.get()) ok(DonationResponses.activeSubscription()) else ok(DonationResponses.emptySubscription())
+      }
+    }
+  }
+
+  private fun registerSubscription(status: String, active: Boolean) {
+    MockEndpoints.responder.register({ it.method == "GET" && it.path.contains("/v1/subscription/") && !it.path.contains("configuration") }) {
+      EndpointResponse(status = 200, body = DonationResponses.activeSubscription(status = status, active = active))
+    }
+  }
+}
+
+/** The expected terminal result of driving a spec. */
+sealed interface ExpectedOutcome {
+  /** An error dialog with [titleRes] (and optionally [messageRes]) is shown. */
+  data class ErrorDialog(@StringRes val titleRes: Int, @StringRes val messageRes: Int? = null) : ExpectedOutcome
+
+  /** The full lifecycle completes and a donation receipt is recorded. */
+  data object Redeemed : ExpectedOutcome
+
+  /**
+   * Payment setup succeeded and the payment moved past [org.thoughtcrime.securesms.database.InAppPaymentTable.State.CREATED]
+   * with no error. Used for bank-transfer methods (SEPA/iDEAL), which don't redeem immediately —
+   * they land in a pending / awaiting-authorization state.
+   */
+  data object PaymentSubmitted : ExpectedOutcome
+}

app/src/androidTest/java/org/thoughtcrime/securesms/conversation/v2/InlineDonationPromptTest.kt

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.conversation.v2
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.view.View
+import androidx.fragment.app.FragmentActivity
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.getSerializableCompat
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.MainActivity
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.DonateToSignalFragment
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * Entry-path coverage for the inline chat donation prompt: the Release-Channel "donation request"
+ * conversation item that renders a "Donate" action button and opens the one-time checkout.
+ *
+ * The conversation is hosted by [MainActivity], so this drives it the same way
+ * [org.thoughtcrime.securesms.main.MainNavigationLaunchTest] does — a manual lifecycle-callback launch
+ * plus direct view interaction, since ActivityScenario/Espresso misbehave for the conversation
+ * custom-action intent.
+ *
+ * Unlike the megaphone and subscriber-upsell paths, this prompt is intentionally NOT gated by sustainer
+ * status; [sustainer_donatePromptStillShown] documents that.
+ */
+@RunWith(AndroidJUnit4::class)
+class InlineDonationPromptTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  private val context: Context get() = InstrumentationRegistry.getInstrumentation().targetContext
+
+  @Before
+  fun setUp() {
+    SignalStore.inAppPayments.setLastEndOfPeriod(0L)
+    SignalDatabase.recipients.setBadges(Recipient.self().id, emptyList())
+    Recipient.self().fresh()
+  }
+
+  @Test
+  fun nonSustainer_donatePromptOpensOneTimeCheckout() {
+    seedDonationRequest()
+
+    assertDonatePromptOpensCheckout()
+  }
+
+  @Test
+  fun sustainer_donatePromptStillShown() {
+    SignalStore.inAppPayments.setLastEndOfPeriod(TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) + TimeUnit.DAYS.toSeconds(30))
+    SignalDatabase.recipients.setBadges(Recipient.self().id, listOf(donorBadge()))
+    Recipient.self().fresh()
+
+    seedDonationRequest()
+
+    assertDonatePromptOpensCheckout()
+  }
+
+  private fun assertDonatePromptOpensCheckout() {
+    val activity = launchConversation()
+
+    val donateButton = awaitView(activity, R.id.conversation_update_action)
+    runOnMainSync { donateButton.performClick() }
+
+    val dialog = await(description = "one-time checkout dialog") {
+      activity.supportFragmentManager.findFragmentByTag(ONE_TIME_NAV_TAG)
+    }
+
+    assertThat(dialog).isInstanceOf(DonateToSignalFragment.Dialog::class)
+    val type = dialog.requireArguments().getSerializableCompat(DonateToSignalFragment.Dialog.ARG, InAppPaymentType::class.java)
+    assertThat(type).isEqualTo(InAppPaymentType.ONE_TIME_DONATION)
+  }
+
+  private fun seedDonationRequest() {
+    val recipientId: RecipientId = SignalDatabase.recipients.insertReleaseChannelRecipient()
+    SignalStore.releaseChannel.setReleaseChannelRecipientId(recipientId)
+
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+    SignalDatabase.messages.insertBoostRequestMessage(recipientId, threadId)
+  }
+
+  private fun launchConversation(): MainActivity {
+    val recipientId = SignalStore.releaseChannel.releaseChannelRecipientId!!
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    val conversationIntent = ConversationIntents.createBuilder(context, recipientId, threadId).blockingGet().build()
+    val launchIntent = Intent(context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    val app = context.applicationContext as Application
+    val resumed = CountDownLatch(1)
+    val holder = arrayOfNulls<MainActivity>(1)
+    val callbacks = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+      // Capture on resume rather than create: a CLEAR_TOP|SINGLE_TOP conversation intent may be
+      // delivered to an existing MainActivity via onNewIntent, which never fires onActivityCreated.
+      override fun onActivityResumed(activity: Activity) {
+        if (activity is MainActivity) {
+          holder[0] = activity
+          resumed.countDown()
+        }
+      }
+
+      override fun onActivityStarted(activity: Activity) = Unit
+      override fun onActivityPaused(activity: Activity) = Unit
+      override fun onActivityStopped(activity: Activity) = Unit
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+      override fun onActivityDestroyed(activity: Activity) = Unit
+    }
+    app.registerActivityLifecycleCallbacks(callbacks)
+
+    app.startActivity(launchIntent)
+    if (!resumed.await(15, TimeUnit.SECONDS)) {
+      app.unregisterActivityLifecycleCallbacks(callbacks)
+      error("MainActivity did not reach RESUMED within 15s")
+    }
+    app.unregisterActivityLifecycleCallbacks(callbacks)
+
+    return holder[0] ?: error("MainActivity was not captured")
+  }
+
+  private fun awaitView(activity: FragmentActivity, viewId: Int): View {
+    return await(description = "view $viewId") {
+      activity.findViewById<View>(viewId)?.takeIf { it.isShown }
+    }
+  }
+
+  private fun <T> await(
+    timeoutMs: Long = 15_000,
+    pollMs: Long = 50,
+    description: String,
+    supplier: () -> T?
+  ): T {
+    val deadline = System.currentTimeMillis() + timeoutMs
+    while (System.currentTimeMillis() < deadline) {
+      val result = runOnMainSync(supplier)
+      if (result != null) return result
+      Thread.sleep(pollMs)
+    }
+    error("Timed out after ${timeoutMs}ms waiting for $description")
+  }
+
+  private fun <T> runOnMainSync(block: () -> T): T {
+    var result: Result<T> = Result.failure(IllegalStateException("runOnMainSync produced no result"))
+    InstrumentationRegistry.getInstrumentation().runOnMainSync { result = runCatching(block) }
+    return result.getOrThrow()
+  }
+
+  private fun donorBadge(): Badge {
+    return Badge(
+      id = "test-donor-badge",
+      category = Badge.Category.Donor,
+      name = "Signal Sustainer",
+      description = "",
+      imageUrl = Uri.EMPTY,
+      imageDensity = "xxhdpi",
+      expirationTimestamp = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(30),
+      visible = true,
+      duration = TimeUnit.DAYS.toMillis(30)
+    )
+  }
+
+  companion object {
+    private const val ONE_TIME_NAV_TAG = "one_time_nav"
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/database/AttachmentTableTest.kt

@@ -11,6 +11,7 @@ import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNotEmpty
 import assertk.assertions.isNotEqualTo
+import assertk.assertions.isNull
 import assertk.assertions.isTrue
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotEquals
@@ -20,22 +21,22 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.core.models.backup.MediaName
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.models.media.TransformProperties
 import org.signal.core.util.Base64
 import org.signal.core.util.Base64.decodeBase64OrThrow
 import org.signal.core.util.copyTo
 import org.signal.core.util.stream.NullOutputStream
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.attachments.ArchivedAttachment
 import org.thoughtcrime.securesms.attachments.Attachment
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.PointerAttachment
 import org.thoughtcrime.securesms.attachments.UriAttachment
 import org.thoughtcrime.securesms.backup.v2.ArchivedMediaObject
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.mms.IncomingMessage
 import org.thoughtcrime.securesms.mms.MediaStream
-import org.thoughtcrime.securesms.mms.SentMediaQuality
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.MediaUtil
 import org.whispersystems.signalservice.api.crypto.AttachmentCipherOutputStream
@@ -67,7 +68,7 @@ class AttachmentTableTest {
 
   @Test
   fun givenABlob_whenIInsert2AttachmentsForPreUpload_thenIExpectDistinctIdsButSameFileName() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val attachment = SignalDatabase.attachments.insertAttachmentForPreUpload(highQualityImage)
@@ -80,7 +81,7 @@ class AttachmentTableTest {
   @FlakyTest
   @Test
   fun givenABlobAndDifferentTransformQuality_whenIInsert2AttachmentsForPreUpload_thenIExpectDifferentFileInfos() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val lowQualityImage = createAttachment(1, blob, TransformProperties.empty())
@@ -107,7 +108,7 @@ class AttachmentTableTest {
   @Ignore("test is flaky")
   @Test
   fun givenIdenticalAttachmentsInsertedForPreUpload_whenIUpdateAttachmentDataAndSpecifyOnlyModifyThisAttachment_thenIExpectDifferentFileInfos() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val attachment = SignalDatabase.attachments.insertAttachmentForPreUpload(highQualityImage)
@@ -143,9 +144,9 @@ class AttachmentTableTest {
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
     val compressedData = byteArrayOf(1, 2, 3)
 
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
 
-    val previousAttachment = createAttachment(1, BlobProvider.getInstance().forData(compressedData).createForSingleSessionInMemory(), TransformProperties.empty())
+    val previousAttachment = createAttachment(1, AppDependencies.blobs.forData(compressedData).createForSingleSessionInMemory(), TransformProperties.empty())
     val previousDatabaseAttachmentId: AttachmentId = SignalDatabase.attachments.insertAttachmentsForMessage(1, listOf(previousAttachment), emptyList()).values.first()
 
     val standardQualityPreUpload = createAttachment(1, blobUncompressed, TransformProperties.empty())
@@ -178,7 +179,7 @@ class AttachmentTableTest {
   fun doNotDedupedFileIfUsedByAnotherAttachmentWithADifferentTransformProperties() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
 
     val standardQualityPreUpload = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val standardDatabaseAttachment = SignalDatabase.attachments.insertAttachmentForPreUpload(standardQualityPreUpload)
@@ -204,7 +205,7 @@ class AttachmentTableTest {
   @Test
   fun resetArchiveTransferStateByPlaintextHashAndRemoteKey_singleMatch() {
     // Given an attachment with some plaintextHash+remoteKey
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blob, TransformProperties.empty())
     val attachmentId = SignalDatabase.attachments.insertAttachmentsForMessage(-1L, listOf(attachment), emptyList()).values.first()
     SignalDatabase.attachments.finalizeAttachmentAfterUpload(attachmentId, AttachmentTableTestUtil.createUploadResult(attachmentId))
@@ -219,6 +220,26 @@ class AttachmentTableTest {
     assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
   }
 
+  @Test
+  fun resetArchiveTransferStateForLocalBackupMedia_onlyResetsLocalBackupMedia() {
+    // Given one archive-finished attachment restored from a local backup, and one that wasn't
+    val localBackupMessageId = SignalDatabase.messages.insertMessageInbox(createIncomingMessage(serverTime = 0.days, attachment = createArchivedAttachment(localBackupKey = Random.nextBytes(32)))).map { it.messageId }.get()
+    val localBackupAttachmentId = SignalDatabase.attachments.getAttachmentsForMessage(localBackupMessageId).first().attachmentId
+
+    val nonLocalBackupMessageId = SignalDatabase.messages.insertMessageInbox(createIncomingMessage(serverTime = 1.days, attachment = createArchivedAttachment())).map { it.messageId }.get()
+    val nonLocalBackupAttachmentId = SignalDatabase.attachments.getAttachmentsForMessage(nonLocalBackupMessageId).first().attachmentId
+
+    SignalDatabase.attachments.setArchiveTransferState(localBackupAttachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+    SignalDatabase.attachments.setArchiveTransferState(nonLocalBackupAttachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+
+    val resetCount = SignalDatabase.attachments.resetArchiveTransferStateForLocalBackupMedia()
+
+    // Only the local-backup attachment is reset
+    assertThat(resetCount).isEqualTo(1)
+    assertThat(SignalDatabase.attachments.getAttachment(localBackupAttachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+    assertThat(SignalDatabase.attachments.getAttachment(nonLocalBackupAttachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
+  }
+
   @Test
   fun given10NewerAnd10OlderAttachments_whenIGetEachBatch_thenIExpectProperBucketing() {
     val now = System.currentTimeMillis().milliseconds
@@ -259,7 +280,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageThatExpiresIn5Minutes_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoNotExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.minutes)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -278,7 +299,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageThatExpiresIn5Days_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.days)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -297,7 +318,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageWithExpirationStartedThatExpiresIn5Days_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.days)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -317,7 +338,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithALongTextAttachment_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoNotExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty(), contentType = MediaUtil.LONG_TEXT)
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -418,6 +439,39 @@ class AttachmentTableTest {
     assertThat(dbAttachment2.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
   }
 
+  @Test
+  fun givenLocalBackupRestore_whenIFinalizeAttachment_thenIExpectArchiveStateNoneSoItGetsUploaded() {
+    val data = byteArrayOf(1, 2, 3, 4, 5)
+    val attachment = createAttachmentPointer("remote-key-1".toByteArray(), data.size)
+
+    val messageResult = SignalDatabase.messages.insertMessageInbox(createIncomingMessage(serverTime = 0.days, attachment = attachment)).get()
+    val attachmentId = messageResult.insertedAttachments!![attachment]!!
+    SignalDatabase.attachments.setTransferState(messageResult.messageId, attachmentId, AttachmentTable.TRANSFER_PROGRESS_STARTED)
+
+    // Data is restored from a local backup file, not the archive CDN
+    SignalDatabase.attachments.finalizeAttachmentAfterDownload(messageResult.messageId, attachmentId, ByteArrayInputStream(data), archiveRestore = true, restoredFromArchiveCdn = false)
+
+    val result = SignalDatabase.attachments.getAttachment(attachmentId)!!
+    assertThat(result.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+    assertThat(result.archiveCdn).isNull()
+  }
+
+  @Test
+  fun givenArchiveCdnRestore_whenIFinalizeAttachment_thenIExpectArchiveStateFinished() {
+    val data = byteArrayOf(1, 2, 3, 4, 5)
+    val attachment = createAttachmentPointer("remote-key-1".toByteArray(), data.size)
+
+    val messageResult = SignalDatabase.messages.insertMessageInbox(createIncomingMessage(serverTime = 0.days, attachment = attachment)).get()
+    val attachmentId = messageResult.insertedAttachments!![attachment]!!
+    SignalDatabase.attachments.setTransferState(messageResult.messageId, attachmentId, AttachmentTable.TRANSFER_PROGRESS_STARTED)
+
+    // Data is restored directly from the archive CDN
+    SignalDatabase.attachments.finalizeAttachmentAfterDownload(messageResult.messageId, attachmentId, ByteArrayInputStream(data), archiveRestore = true, restoredFromArchiveCdn = true)
+
+    val result = SignalDatabase.attachments.getAttachment(attachmentId)!!
+    assertThat(result.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
+  }
+
   @Test
   fun givenAttachmentsWithMatchingMediaId_whenISetArchiveFinishedForMatchingMediaObjects_thenIExpectThoseAttachmentsToBeMarkedFinished() {
     // GIVEN
@@ -585,7 +639,7 @@ class AttachmentTableTest {
     ).get()
   }
 
-  private fun createArchivedAttachment(): Attachment {
+  private fun createArchivedAttachment(localBackupKey: ByteArray? = null): Attachment {
     return ArchivedAttachment(
       contentType = "image/jpeg",
       size = 1024,
@@ -609,7 +663,7 @@ class AttachmentTableTest {
       quoteTargetContentType = null,
       uuid = UUID.randomUUID(),
       fileName = null,
-      localBackupKey = null
+      localBackupKey = localBackupKey
     )
   }
 

app/src/androidTest/java/org/thoughtcrime/securesms/database/AttachmentTableTestUtil.kt

@@ -5,10 +5,10 @@
 
 package org.thoughtcrime.securesms.database
 
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Base64
 import org.signal.core.util.Util
 import org.signal.network.api.AttachmentUploadResult
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.Cdn
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId
 import kotlin.random.Random

app/src/androidTest/java/org/thoughtcrime/securesms/database/AttachmentTableTest_deduping.kt

@@ -12,21 +12,21 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.core.models.ServiceId
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.models.media.TransformProperties
 import org.signal.core.util.Base64
 import org.signal.core.util.Util
 import org.signal.core.util.readFully
 import org.signal.core.util.stream.LimitedInputStream
 import org.signal.core.util.update
-import org.thoughtcrime.securesms.attachments.AttachmentId
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.attachments.Cdn
 import org.thoughtcrime.securesms.attachments.PointerAttachment
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.mms.MediaStream
 import org.thoughtcrime.securesms.mms.OutgoingMessage
 import org.thoughtcrime.securesms.mms.QuoteModel
-import org.thoughtcrime.securesms.mms.SentMediaQuality
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.MediaUtil
 import org.whispersystems.signalservice.internal.crypto.PaddingInputStream
@@ -671,7 +671,7 @@ class AttachmentTableTest_deduping {
     }
 
     fun insertWithData(data: ByteArray, transformProperties: TransformProperties = TransformProperties.empty()): AttachmentId {
-      val uri = BlobProvider.getInstance().forData(data).createForSingleSessionInMemory()
+      val uri = AppDependencies.blobs.forData(data).createForSingleSessionInMemory()
 
       val attachment = UriAttachmentBuilder.build(
         id = Random.nextLong(),

app/src/androidTest/java/org/thoughtcrime/securesms/database/CallTableTest.kt

@@ -10,9 +10,14 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.ringrtc.CallId
 import org.signal.ringrtc.CallManager
+import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.testing.Flag
+import org.thoughtcrime.securesms.testing.RemoteConfigForTest
 import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.TestRemoteConfigFlag
 
+@RemoteConfigForTest(flags = [Flag(TestRemoteConfigFlag.DISAPPEAR_MORE, "true")])
 @RunWith(AndroidJUnit4::class)
 class CallTableTest {
 
@@ -977,6 +982,80 @@ class CallTableTest {
 //    assertEquals(0, allCallEvents.size)
   }
 
+  @Test
+  fun givenAMissedOneToOneCall_whenIMarkAllCallEventsRead_thenTimerShouldStart() {
+    val callId = 1L
+    val peer = harness.others[0]
+    insertExpiringThread(peer)
+
+    SignalDatabase.calls.insertOneToOneCall(callId, System.currentTimeMillis(), peer, CallTable.Type.AUDIO_CALL, CallTable.Direction.INCOMING, CallTable.Event.MISSED)
+
+    val readAt = System.currentTimeMillis()
+    SignalDatabase.calls.markAllCallEventsRead(readAt = readAt)
+
+    val call = SignalDatabase.calls.getCallById(callId, peer)
+    assertEquals(readAt, SignalDatabase.messages.getMessageRecord(call!!.messageId!!).expireStarted)
+  }
+
+  @Test
+  fun givenAMissedNotificationProfileOneToOneCall_whenIMarkAllCallEventsRead_thenTimerShouldStart() {
+    val callId = 1L
+    val peer = harness.others[0]
+    insertExpiringThread(peer)
+
+    SignalDatabase.calls.insertOneToOneCall(callId, System.currentTimeMillis(), peer, CallTable.Type.AUDIO_CALL, CallTable.Direction.INCOMING, CallTable.Event.MISSED_NOTIFICATION_PROFILE)
+
+    val readAt = System.currentTimeMillis()
+    SignalDatabase.calls.markAllCallEventsRead(readAt = readAt)
+
+    val call = SignalDatabase.calls.getCallById(callId, peer)
+    assertEquals(readAt, SignalDatabase.messages.getMessageRecord(call!!.messageId!!).expireStarted)
+  }
+
+  @Test
+  fun givenAMissedGroupCall_whenIMarkAllCallEventsRead_thenTimerShouldStart() {
+    val callId = 1L
+    SignalDatabase.recipients.setExpireMessagesForGroup(groupRecipientId, 60)
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(callId, groupRecipientId, harness.others[1], System.currentTimeMillis(), CallManager.RingUpdate.EXPIRED_REQUEST)
+
+    val readAt = System.currentTimeMillis()
+    SignalDatabase.calls.markAllCallEventsRead(readAt = readAt)
+
+    val call = SignalDatabase.calls.getCallById(callId, groupRecipientId)
+    assertEquals(readAt, SignalDatabase.messages.getMessageRecord(call!!.messageId!!).expireStarted)
+  }
+
+  @Test
+  fun givenAMissedNotificationProfileGroupCall_whenIMarkAllCallEventsRead_thenTimerShouldStart() {
+    val callId = 1L
+    val ringerAci = Recipient.resolved(harness.others[1]).requireAci()
+
+    SignalDatabase.recipients.setExpireMessagesForGroup(groupRecipientId, 60)
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(callId, groupRecipientId, ringerAci, System.currentTimeMillis(), CallManager.RingUpdate.EXPIRED_REQUEST, true)
+
+    val readAt = System.currentTimeMillis()
+    SignalDatabase.calls.markAllCallEventsRead(readAt = readAt)
+
+    val call = SignalDatabase.calls.getCallById(callId, groupRecipientId)
+    assertEquals(readAt, SignalDatabase.messages.getMessageRecord(call!!.messageId!!).expireStarted)
+  }
+
+  @Test
+  fun givenAnOutgoingOneToOneCallFromSync_whenInserted_thenTimerIsStarted() {
+    val callId = 1L
+    val peer = harness.others[0]
+    val timestamp = System.currentTimeMillis()
+
+    insertExpiringThread(peer)
+    SignalDatabase.calls.insertOneToOneCall(callId, timestamp, peer, CallTable.Type.AUDIO_CALL, CallTable.Direction.OUTGOING, CallTable.Event.OUTGOING_RING, true)
+
+    val call = SignalDatabase.calls.getCallById(callId, peer)
+    val message = SignalDatabase.messages.getMessageRecord(call!!.messageId!!)
+    assertNotEquals(0L, message.expireStarted)
+  }
+
   private fun insertTwoCallEvents() {
     SignalDatabase.calls.insertAcceptedGroupCall(
       1,
@@ -992,4 +1071,10 @@ class CallTableTest {
       2000
     )
   }
+
+  private fun insertExpiringThread(recipientId: RecipientId) {
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+    MmsHelper.insert(recipient = Recipient.resolved(recipientId), expiresIn = 30_000L, threadId = threadId)
+    SignalDatabase.threads.update(threadId, false)
+  }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/dependencies/InstrumentationApplicationDependencyProvider.kt

@@ -3,19 +3,28 @@ package org.thoughtcrime.securesms.dependencies
 import android.app.Application
 import io.mockk.mockk
 import io.mockk.spyk
+import okhttp3.OkHttpClient
+import org.signal.core.util.UptimeSleepTimer
 import org.signal.core.util.billing.BillingApi
+import org.signal.libsignal.net.Network
+import org.signal.libsignal.zkgroup.receipts.ClientZkReceiptOperations
 import org.signal.network.api.ArchiveApi
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess
 import org.thoughtcrime.securesms.recipients.LiveRecipientCache
+import org.thoughtcrime.securesms.testing.endpoints.DonationTestServer
+import org.thoughtcrime.securesms.testing.endpoints.MockEndpoints
+import org.thoughtcrime.securesms.testing.endpoints.ResponderInterceptor
+import org.thoughtcrime.securesms.testing.endpoints.ResponderWebSocketConnection
 import org.whispersystems.signalservice.api.SignalServiceDataStore
 import org.whispersystems.signalservice.api.SignalServiceMessageSender
 import org.whispersystems.signalservice.api.account.AccountApi
-import org.whispersystems.signalservice.api.donations.DonationsApi
 import org.whispersystems.signalservice.api.keys.KeysApi
 import org.whispersystems.signalservice.api.message.MessageApi
 import org.whispersystems.signalservice.api.websocket.SignalWebSocket
 import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration
 import org.whispersystems.signalservice.internal.push.PushServiceSocket
+import java.util.function.Supplier
+import kotlin.time.Duration.Companion.seconds
 
 /**
  * Dependency provider used for instrumentation tests (aka androidTests).
@@ -45,8 +54,54 @@ class InstrumentationApplicationDependencyProvider(val application: Application,
     return mockk()
   }
 
-  override fun provideDonationsApi(authWebSocket: SignalWebSocket.AuthenticatedWebSocket, unauthWebSocket: SignalWebSocket.UnauthenticatedWebSocket): DonationsApi {
-    return mockk()
+  /**
+   * Adds the Stripe-matching [ResponderInterceptor] on top of the default client (which supplies the
+   * user agent + DNS), so `api.stripe.com` requests made by [org.signal.donations.StripeApi] are
+   * answered from the shared [MockEndpoints.responder] and never hit the real network.
+   */
+  override fun provideOkHttpClient(): OkHttpClient {
+    return default.provideOkHttpClient()
+      .newBuilder()
+      .addInterceptor(ResponderInterceptor(MockEndpoints.responder))
+      .build()
+  }
+
+  /**
+   * Backs the real [org.whispersystems.signalservice.api.donations.DonationsApi] (and any other
+   * websocket API) with a [ResponderWebSocketConnection] driven by the shared [MockEndpoints.responder],
+   * so Signal-service requests are answered from the scenario's "world" and never hit the network.
+   */
+  override fun provideAuthWebSocket(
+    signalServiceConfigurationSupplier: Supplier<SignalServiceConfiguration>,
+    libSignalNetworkSupplier: Supplier<Network>
+  ): SignalWebSocket.AuthenticatedWebSocket {
+    return SignalWebSocket.AuthenticatedWebSocket(
+      connectionFactory = { ResponderWebSocketConnection(MockEndpoints.responder) },
+      canConnect = { true },
+      sleepTimer = UptimeSleepTimer(),
+      disconnectTimeoutMs = 15.seconds.inWholeMilliseconds
+    )
+  }
+
+  override fun provideUnauthWebSocket(
+    signalServiceConfigurationSupplier: Supplier<SignalServiceConfiguration>,
+    libSignalNetworkSupplier: Supplier<Network>
+  ): SignalWebSocket.UnauthenticatedWebSocket {
+    return SignalWebSocket.UnauthenticatedWebSocket(
+      connectionFactory = { ResponderWebSocketConnection(MockEndpoints.responder) },
+      canConnect = { true },
+      sleepTimer = UptimeSleepTimer(),
+      disconnectTimeoutMs = 15.seconds.inWholeMilliseconds
+    )
+  }
+
+  /**
+   * Uses the test zk server's public params so credentials minted by [MockEndpoints] validate here.
+   * The real [ClientZkReceiptOperations.receiveReceiptCredential] validation still runs in the
+   * receipt-credential context job — only the params are swapped for test ones.
+   */
+  override fun provideClientZkReceiptOperations(signalServiceConfiguration: SignalServiceConfiguration): ClientZkReceiptOperations {
+    return DonationTestServer.clientReceiptOperations
   }
 
   override fun provideSignalServiceMessageSender(

app/src/androidTest/java/org/thoughtcrime/securesms/jobs/ArchiveAttachmentReconciliationJobTest.kt

@@ -0,0 +1,279 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.jobs
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockkObject
+import io.mockk.unmockkAll
+import io.mockk.verify
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.models.backup.MediaName
+import org.signal.core.models.database.AttachmentId
+import org.signal.core.util.Base64.decodeBase64OrThrow
+import org.signal.network.NetworkResult
+import org.thoughtcrime.securesms.attachments.Attachment
+import org.thoughtcrime.securesms.attachments.PointerAttachment
+import org.thoughtcrime.securesms.backup.v2.BackupRepository
+import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
+import org.thoughtcrime.securesms.database.AttachmentTable
+import org.thoughtcrime.securesms.database.BackupMediaSnapshotTable.MediaEntry
+import org.thoughtcrime.securesms.database.MessageType
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.mms.IncomingMessage
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.util.MediaUtil
+import org.whispersystems.signalservice.api.archive.ArchiveGetMediaItemsResponse
+import org.whispersystems.signalservice.api.archive.ArchiveGetMediaItemsResponse.StoredMediaObject
+import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer
+import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId
+import java.io.ByteArrayInputStream
+import java.util.Optional
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+
+@RunWith(AndroidJUnit4::class)
+class ArchiveAttachmentReconciliationJobTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @Before
+  fun setUp() {
+    SignalStore.backup.backupTier = MessageBackupTier.PAID
+    SignalStore.backup.hasBackupBeenUploaded = true
+    SignalStore.backup.lastAttachmentReconciliationTime = System.currentTimeMillis()
+    SignalStore.backup.localRestoreReconcilePending = false
+
+    mockkObject(BackupRepository)
+    mockkObject(ArchiveCommitAttachmentDeletesJob)
+    every { ArchiveCommitAttachmentDeletesJob.deleteMediaObjectsFromCdn(any(), any(), any(), any()) } returns null
+  }
+
+  @After
+  fun tearDown() {
+    unmockkAll()
+  }
+
+  /**
+   * The core of the reconcile-first restore flow: a local restore resets everything to [AttachmentTable.ArchiveTransferState.NONE], so media that genuinely is
+   * on the CDN must be promoted back to FINISHED during reconciliation -- otherwise the backfill would needlessly re-upload it. This only happens while
+   * [localRestoreReconcilePending] is set, so it never runs in the common periodic reconciliation.
+   */
+  @Test
+  fun givenLocalRestorePendingAndAttachmentOnCdn_whenIReconcile_thenIExpectItMarkedFinished() {
+    SignalStore.backup.localRestoreReconcilePending = true
+
+    val attachmentId = seedFinalizedAttachment("remote-key-1".toByteArray(), byteArrayOf(1, 2, 3, 4, 5))
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnContains(attachmentId, cdn = 3)
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
+  }
+
+  /**
+   * Guards the reconcile-first promotion above: outside the local-restore flow (the common periodic reconciliation), NONE media that happens to be on the CDN is
+   * left alone, so we don't do the expensive mark-finished scan in the common case.
+   */
+  @Test
+  fun givenNoLocalRestorePendingAndNoneAttachmentOnCdn_whenIReconcile_thenItStaysNone() {
+    val attachmentId = seedFinalizedAttachment("remote-key-common".toByteArray(), byteArrayOf(2, 3, 4, 5, 6))
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnContains(attachmentId, cdn = 3)
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+  }
+
+  @Test
+  fun givenFinishedAttachmentMissingFromCdn_whenIReconcile_thenIExpectItResetToNone() {
+    val attachmentId = seedFinalizedAttachment("remote-key-2".toByteArray(), byteArrayOf(6, 7, 8, 9, 10))
+    SignalDatabase.attachments.setArchiveTransferState(attachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnEmpty()
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+  }
+
+  /**
+   * The eventual safety net: an ordinary (non-forced) periodic reconciliation, run after the sync interval has elapsed, heals the bad state on its own -- media
+   * in the snapshot but missing from the CDN is reset to [AttachmentTable.ArchiveTransferState.NONE] and a re-upload is enqueued -- with no help from the
+   * migration or the reconcile-first flow.
+   */
+  @Test
+  fun givenFinishedMediaMissingFromCdn_whenAnOrdinaryPeriodicReconciliationRuns_thenItHealsToNoneAndReUploads() {
+    SignalStore.backup.lastAttachmentReconciliationTime = System.currentTimeMillis() - 60.days.inWholeMilliseconds
+    mockkObject(BackupMessagesJob)
+    every { BackupMessagesJob.enqueue() } just Runs
+
+    val attachmentId = seedFinalizedAttachment("remote-key-periodic".toByteArray(), byteArrayOf(1, 2, 3, 4, 5))
+    SignalDatabase.attachments.setArchiveTransferState(attachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnEmpty()
+
+    ArchiveAttachmentReconciliationJob(forced = false).run()
+
+    val healed = SignalDatabase.attachments.getAttachment(attachmentId)!!
+    assertThat(healed.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+    assertThat(healed.archiveCdn).isNull()
+    verify(exactly = 1) { BackupMessagesJob.enqueue() }
+  }
+
+  /**
+   * Reconciliation must only repair genuinely-broken state. Media that is actually present on the CDN stays [AttachmentTable.ArchiveTransferState.FINISHED], so
+   * we never needlessly reset (and therefore re-upload) media that was correctly archived.
+   */
+  @Test
+  fun givenFinishedMediaStillOnCdn_whenIReconcile_thenItStaysFinished() {
+    val attachmentId = seedFinalizedAttachment("remote-key-on-cdn".toByteArray(), byteArrayOf(6, 7, 8, 9, 10))
+    SignalDatabase.attachments.setArchiveTransferState(attachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnContains(attachmentId, cdn = 3)
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
+  }
+
+  /**
+   * The other healing direction: media that is on the CDN but locally marked [AttachmentTable.ArchiveTransferState.NONE] and absent from the current snapshot is
+   * treated as a delete-candidate. Before deleting, reconciliation confirms it's still referenced locally and recovers it to
+   * [AttachmentTable.ArchiveTransferState.FINISHED] rather than deleting it from the CDN.
+   */
+  @Test
+  fun givenNoneMediaOnCdnButNotInSnapshot_whenIReconcile_thenItIsRecoveredToFinished() {
+    val attachmentId = seedFinalizedAttachment("remote-key-flow2".toByteArray(), byteArrayOf(11, 12, 13, 14, 15))
+    SignalDatabase.attachments.setArchiveTransferState(attachmentId, AttachmentTable.ArchiveTransferState.NONE)
+    fakeCdnContains(attachmentId, cdn = 3)
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.FINISHED)
+  }
+
+  @Test
+  fun givenFirstEverReconciliation_whenIForceIt_thenItStillRunsAndRepairs() {
+    SignalStore.backup.lastAttachmentReconciliationTime = -1
+
+    val attachmentId = seedFinalizedAttachment("remote-key-3".toByteArray(), byteArrayOf(11, 12, 13, 14, 15))
+    SignalDatabase.attachments.setArchiveTransferState(attachmentId, AttachmentTable.ArchiveTransferState.FINISHED)
+    commitSnapshotFor(attachmentId, cdn = 3)
+    fakeCdnEmpty()
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalDatabase.attachments.getAttachment(attachmentId)!!.archiveTransferState).isEqualTo(AttachmentTable.ArchiveTransferState.NONE)
+  }
+
+  @Test
+  fun givenLocalRestoreReconcilePending_whenReconcileCompletes_thenIExpectFlagCleared() {
+    SignalStore.backup.localRestoreReconcilePending = true
+    fakeCdnEmpty()
+
+    ArchiveAttachmentReconciliationJob(forced = true).run()
+
+    assertThat(SignalStore.backup.localRestoreReconcilePending).isFalse()
+  }
+
+  private fun seedFinalizedAttachment(remoteKey: ByteArray, data: ByteArray): AttachmentId {
+    val attachment = createAttachmentPointer(remoteKey, data.size)
+    val messageResult = SignalDatabase.messages.insertMessageInbox(createIncomingMessage(serverTime = 0.days, attachment = attachment)).get()
+    val attachmentId = messageResult.insertedAttachments!![attachment]!!
+    SignalDatabase.attachments.setTransferState(messageResult.messageId, attachmentId, AttachmentTable.TRANSFER_PROGRESS_STARTED)
+    SignalDatabase.attachments.finalizeAttachmentAfterDownload(messageResult.messageId, attachmentId, ByteArrayInputStream(data))
+    return attachmentId
+  }
+
+  private fun commitSnapshotFor(attachmentId: AttachmentId, cdn: Int) {
+    val attachment = SignalDatabase.attachments.getAttachment(attachmentId)!!
+    val plaintextHash = attachment.dataHash!!.decodeBase64OrThrow()
+    val remoteKey = attachment.remoteKey!!.decodeBase64OrThrow()
+    val mediaId = MediaName.fromPlaintextHashAndRemoteKey(plaintextHash, remoteKey).toMediaId(SignalStore.backup.mediaRootBackupKey).encode()
+
+    SignalDatabase.backupMediaSnapshots.writePendingMediaEntries(
+      listOf(MediaEntry(mediaId = mediaId, cdn = cdn, plaintextHash = plaintextHash, remoteKey = remoteKey, isThumbnail = false))
+    )
+    SignalDatabase.backupMediaSnapshots.commitPendingRows()
+  }
+
+  private fun fakeCdnContains(attachmentId: AttachmentId, cdn: Int) {
+    val attachment = SignalDatabase.attachments.getAttachment(attachmentId)!!
+    val plaintextHash = attachment.dataHash!!.decodeBase64OrThrow()
+    val remoteKey = attachment.remoteKey!!.decodeBase64OrThrow()
+    val mediaId = MediaName.fromPlaintextHashAndRemoteKey(plaintextHash, remoteKey).toMediaId(SignalStore.backup.mediaRootBackupKey).encode()
+
+    every { BackupRepository.listRemoteMediaObjects(any(), any()) } returns NetworkResult.Success(
+      ArchiveGetMediaItemsResponse(
+        storedMediaObjects = listOf(StoredMediaObject(cdn = cdn, mediaId = mediaId, objectLength = attachment.size)),
+        backupDir = null,
+        mediaDir = null,
+        cursor = null
+      )
+    )
+  }
+
+  private fun fakeCdnEmpty() {
+    every { BackupRepository.listRemoteMediaObjects(any(), any()) } returns NetworkResult.Success(
+      ArchiveGetMediaItemsResponse(storedMediaObjects = emptyList(), backupDir = null, mediaDir = null, cursor = null)
+    )
+  }
+
+  private fun createIncomingMessage(serverTime: Duration, attachment: Attachment): IncomingMessage {
+    return IncomingMessage(
+      type = MessageType.NORMAL,
+      from = harness.others[0],
+      body = null,
+      sentTimeMillis = serverTime.inWholeMilliseconds,
+      serverTimeMillis = serverTime.inWholeMilliseconds,
+      receivedTimeMillis = serverTime.inWholeMilliseconds,
+      attachments = listOf(attachment)
+    )
+  }
+
+  private fun createAttachmentPointer(key: ByteArray, size: Int): Attachment {
+    return PointerAttachment.forPointer(
+      pointer = Optional.of(
+        SignalServiceAttachmentPointer(
+          cdnNumber = 3,
+          remoteId = SignalServiceAttachmentRemoteId.V4("asdf"),
+          contentType = MediaUtil.IMAGE_JPEG,
+          key = key,
+          size = Optional.of(size),
+          preview = Optional.empty(),
+          width = 2,
+          height = 2,
+          digest = Optional.of(byteArrayOf()),
+          incrementalDigest = Optional.empty(),
+          incrementalMacChunkSize = 0,
+          fileName = Optional.of("file.jpg"),
+          voiceNote = false,
+          isBorderless = false,
+          isGif = false,
+          caption = Optional.empty(),
+          blurHash = Optional.empty(),
+          uploadTimestamp = 0,
+          uuid = null
+        )
+      )
+    ).get()
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/jobs/AttachmentCompressionJobTest.kt

@@ -15,14 +15,13 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.core.models.media.TransformProperties
 import org.signal.core.util.StreamUtil
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.attachments.UriAttachment
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.UriAttachmentBuilder
 import org.thoughtcrime.securesms.database.transformPropertiesForSentMediaQuality
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobmanager.Job
-import org.thoughtcrime.securesms.mms.SentMediaQuality
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.MediaUtil
 import java.util.Optional
@@ -40,7 +39,7 @@ class AttachmentCompressionJobTest {
       StreamUtil.readFully(it)
     }
 
-    val blob = BlobProvider.getInstance().forData(imageBytes).createForSingleSessionOnDisk(AppDependencies.application)
+    val blob = AppDependencies.blobs.forData(imageBytes).createForSingleSessionOnDisk(AppDependencies.application)
 
     val firstPreUpload = createAttachment(1, blob, TransformProperties.empty())
     val firstDatabaseAttachment = SignalDatabase.attachments.insertAttachmentForPreUpload(firstPreUpload)

app/src/androidTest/java/org/thoughtcrime/securesms/jobs/BackupDeleteJobTest.kt

@@ -19,17 +19,31 @@ import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
+import org.signal.core.util.Base64
+import org.signal.core.util.Util
 import org.signal.network.NetworkResult
 import org.signal.network.exceptions.NonSuccessfulResponseCodeException
+import org.thoughtcrime.securesms.attachments.Cdn
+import org.thoughtcrime.securesms.attachments.PointerAttachment
 import org.thoughtcrime.securesms.backup.DeletionState
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
+import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.jobs.protos.BackupDeleteJobData
 import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.testing.Flag
+import org.thoughtcrime.securesms.testing.RemoteConfigForTest
 import org.thoughtcrime.securesms.testing.SignalActivityRule
-import org.thoughtcrime.securesms.util.RemoteConfig
+import org.thoughtcrime.securesms.testing.TestRemoteConfigFlag
+import java.util.UUID
 
+@RemoteConfigForTest(
+  flags = [
+    Flag(TestRemoteConfigFlag.INTERNAL_USER, "true"),
+    Flag(TestRemoteConfigFlag.DEFAULT_MAX_BACKOFF, "1")
+  ]
+)
 class BackupDeleteJobTest {
 
   @get:Rule
@@ -37,10 +51,6 @@ class BackupDeleteJobTest {
 
   @Before
   fun setUp() {
-    mockkObject(RemoteConfig)
-    every { RemoteConfig.internalUser } returns true
-    every { RemoteConfig.defaultMaxBackoff } returns 1000L
-
     mockkObject(BackupRepository)
     every { BackupRepository.getBackupTier() } returns NetworkResult.Success(MessageBackupTier.PAID)
     every { BackupRepository.deleteBackup() } returns NetworkResult.Success(Unit)
@@ -54,29 +64,24 @@ class BackupDeleteJobTest {
 
   @Test
   fun givenUserNotRegistered_whenIRun_thenIExpectFailure() {
-    mockkObject(SignalStore) {
-      every { SignalStore.account.isRegistered } returns false
+    SignalStore.account.setRegistered(false)
 
-      val job = BackupDeleteJob()
+    val job = BackupDeleteJob()
 
-      val result = job.run()
+    val result = job.run()
 
-      assertThat(result.isFailure).isTrue()
-    }
+    assertThat(result.isFailure).isTrue()
   }
 
   @Test
   fun givenLinkedDevice_whenIRun_thenIExpectFailure() {
-    mockkObject(SignalStore) {
-      every { SignalStore.account.isRegistered } returns true
-      every { SignalStore.account.isLinkedDevice } returns true
+    SignalStore.account.deviceId = 2
 
-      val job = BackupDeleteJob()
+    val job = BackupDeleteJob()
 
-      val result = job.run()
+    val result = job.run()
 
-      assertThat(result.isFailure).isTrue()
-    }
+    assertThat(result.isFailure).isTrue()
   }
 
   @Test
@@ -155,10 +160,7 @@ class BackupDeleteJobTest {
 
   @Test
   fun givenMediaOffloaded_whenIRun_thenIExpectAwaitingMediaDownload() {
-    mockkObject(SignalDatabase)
-    every { SignalDatabase.attachments.getRemainingRestorableAttachmentSize() } returns 1
-    every { SignalDatabase.attachments.getOptimizedMediaAttachmentSize() } returns 1
-    every { SignalDatabase.attachments.clearAllArchiveData() } returns Unit
+    insertOffloadedAttachment()
 
     SignalStore.backup.deletionState = DeletionState.CLEAR_LOCAL_STATE
 
@@ -252,4 +254,39 @@ class BackupDeleteJobTest {
 
     assertThat(result.isRetry).isTrue()
   }
+
+  private fun insertOffloadedAttachment(size: Long = 100) {
+    SignalDatabase.attachments.insertAttachmentsForMessage(
+      mmsId = 1,
+      attachments = listOf(
+        PointerAttachment(
+          contentType = "image/jpeg",
+          transferState = AttachmentTable.TRANSFER_RESTORE_OFFLOADED,
+          size = size,
+          fileName = null,
+          cdn = Cdn.CDN_3,
+          location = "somelocation",
+          key = Base64.encodeWithPadding(Util.getSecretBytes(64)),
+          iv = null,
+          digest = Util.getSecretBytes(64),
+          incrementalDigest = null,
+          incrementalMacChunkSize = 0,
+          fastPreflightId = null,
+          voiceNote = false,
+          borderless = false,
+          videoGif = false,
+          width = 100,
+          height = 100,
+          uploadTimestamp = System.currentTimeMillis(),
+          caption = null,
+          stickerLocator = null,
+          blurHash = null,
+          uuid = UUID.randomUUID(),
+          quote = false,
+          quoteTargetContentType = null
+        )
+      ),
+      quoteAttachment = emptyList()
+    )
+  }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/jobs/BackupSubscriptionCheckJobTest.kt

@@ -42,8 +42,10 @@ import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobmanager.Job
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.net.SignalNetwork
+import org.thoughtcrime.securesms.testing.Flag
+import org.thoughtcrime.securesms.testing.RemoteConfigForTest
 import org.thoughtcrime.securesms.testing.SignalActivityRule
-import org.thoughtcrime.securesms.util.RemoteConfig
+import org.thoughtcrime.securesms.testing.TestRemoteConfigFlag
 import org.whispersystems.signalservice.api.storage.IAPSubscriptionId
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription.ChargeFailure
@@ -55,6 +57,7 @@ import java.util.Currency
 import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.milliseconds
 
+@RemoteConfigForTest(flags = [Flag(TestRemoteConfigFlag.INTERNAL_USER, "true") ])
 @RunWith(AndroidJUnit4::class)
 class BackupSubscriptionCheckJobTest {
 
@@ -67,9 +70,6 @@ class BackupSubscriptionCheckJobTest {
 
   @Before
   fun setUp() {
-    mockkObject(RemoteConfig)
-    every { RemoteConfig.internalUser } returns true
-
     coEvery { AppDependencies.billingApi.getApiAvailability() } returns BillingResponseCode.OK
 
     coEvery { AppDependencies.billingApi.queryPurchases() } returns BillingPurchaseResult.Success(
@@ -88,6 +88,7 @@ class BackupSubscriptionCheckJobTest {
     every { RecurringInAppPaymentRepository.getActiveSubscriptionSync(InAppPaymentSubscriberRecord.Type.BACKUP) } returns NetworkResult.Success(
       createActiveSubscription()
     )
+    every { RecurringInAppPaymentRepository.ensureSubscriberIdSync(any(), any(), any()) } returns Unit
 
     mockkObject(BackupRepository)
     every { BackupRepository.getBackupTier() } answers {
@@ -120,8 +121,6 @@ class BackupSubscriptionCheckJobTest {
       )
     )
 
-    every { AppDependencies.donationsApi.putSubscription(any()) } returns NetworkResult.Success(Unit)
-
     insertSubscriber()
   }
 
@@ -142,26 +141,22 @@ class BackupSubscriptionCheckJobTest {
 
   @Test
   fun givenUserIsNotRegistered_whenIRun_thenIExpectSuccessAndEarlyExit() {
-    mockkObject(SignalStore.account) {
-      every { SignalStore.account.isRegistered } returns false
+    SignalStore.account.setRegistered(false)
 
-      val job = BackupSubscriptionCheckJob.create()
-      val result = job.run()
+    val job = BackupSubscriptionCheckJob.create()
+    val result = job.run()
 
-      assertEarlyExit(result)
-    }
+    assertEarlyExit(result)
   }
 
   @Test
   fun givenIsLinkedDevice_whenIRun_thenIExpectSuccessAndEarlyExit() {
-    mockkObject(SignalStore.account) {
-      every { SignalStore.account.isLinkedDevice } returns true
+    SignalStore.account.deviceId = 2
 
-      val job = BackupSubscriptionCheckJob.create()
-      val result = job.run()
+    val job = BackupSubscriptionCheckJob.create()
+    val result = job.run()
 
-      assertEarlyExit(result)
-    }
+    assertEarlyExit(result)
   }
 
   @Test

app/src/androidTest/java/org/thoughtcrime/securesms/main/MainNavigationLaunchTest.kt

@@ -32,8 +32,8 @@ import org.thoughtcrime.securesms.conversation.ConversationIntents
 import org.thoughtcrime.securesms.conversation.v2.ConversationFragment
 import org.thoughtcrime.securesms.conversationlist.ConversationListArchiveFragment
 import org.thoughtcrime.securesms.conversationlist.ConversationListFragment
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.mediasend.v2.MediaSelectionActivity
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.stories.landing.StoriesLandingFragment
@@ -49,7 +49,6 @@ import java.util.concurrent.TimeUnit
  */
 @RunWith(AndroidJUnit4::class)
 class MainNavigationLaunchTest {
-
   @get:Rule
   val harness = SignalActivityRule(othersCount = 2)
 
@@ -89,7 +88,8 @@ class MainNavigationLaunchTest {
             appendLine("fragments observed: ${recorder.allCreated}")
             appendLine("activity fragments: ${launched.activity.supportFragmentManager.fragments.map { it::class.simpleName }}")
             appendLine("vm.currentListLocation: ${vm.mainNavigationState.value.currentListLocation}")
-            appendLine("vm.earlyNavigationDetailLocationRequested: ${vm.earlyNavigationDetailLocationRequested}")
+            appendLine("vm.detailLocation: ${vm.detailLocation.value}")
+            appendLine("vm.chatsBackStackEntries: ${vm.chatsBackStackEntries.toList()}")
           }
         }
         throw IllegalStateException("${e.message}\n$state", e)
@@ -254,8 +254,9 @@ class MainNavigationLaunchTest {
           "starts handling it on cold launch, update or delete this test. Got: ${recorder.allCreated}"
       }
       val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
-      check(vm.earlyNavigationDetailLocationRequested == null) {
-        "Expected no early detail to be staged, got ${vm.earlyNavigationDetailLocationRequested}"
+      val staged = runOnMainSync { vm.chatsBackStackEntries.filterNot { it is MainNavigationDetailLocation.Empty } }
+      check(staged.isEmpty()) {
+        "Expected no detail to be staged on the chats back stack, got $staged"
       }
     }
   }
@@ -289,8 +290,9 @@ class MainNavigationLaunchTest {
         "Expected default CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
       }
       Thread.sleep(750)
-      check(vm.earlyNavigationDetailLocationRequested == null) {
-        "Expected no early detail, got ${vm.earlyNavigationDetailLocationRequested}"
+      val detailLocation = runOnMainSync { vm.detailLocation.value }
+      check(detailLocation == MainNavigationDetailLocation.Empty) {
+        "Expected Empty detail location, got $detailLocation"
       }
       check(recorder.createdArgs.isEmpty()) {
         "Expected no ConversationFragment for bare launch, got ${recorder.createdArgs.size}"
@@ -348,11 +350,13 @@ class MainNavigationLaunchTest {
       await(description = "no new ConversationFragment after Empty detail intent") {
         recorder.createdArgs.size == baseline
       }
-      // The user-visible signal that we're "back on the list" is the chat list fragment
-      // being attached, not just the VM saying CHATS.
-      awaitListFragment(launched, MainNavigationListLocation.CHATS)
 
       val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+
+      await(description = "conversation cleared from chats back stack after Empty detail intent") {
+        vm.chatsBackStackEntries.none { it is MainNavigationDetailLocation.Conversation }
+      }
+
       check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
         "Expected CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
       }
@@ -569,7 +573,7 @@ class MainNavigationLaunchTest {
   }
 
   private fun realBlob(bytes: ByteArray, mimeType: String): Uri {
-    return BlobProvider.getInstance()
+    return AppDependencies.blobs
       .forData(bytes)
       .withMimeType(mimeType)
       .createForSingleSessionInMemory()

app/src/androidTest/java/org/thoughtcrime/securesms/megaphone/DonationMegaphoneGatingTest.kt

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.megaphone
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import io.mockk.every
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.unmockkObject
+import io.mockk.unmockkStatic
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.deleteAll
+import org.thoughtcrime.securesms.components.settings.app.subscription.InAppDonations
+import org.thoughtcrime.securesms.database.InAppPaymentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.util.VersionTracker
+
+/**
+ * The "user might be a sustainer" rule for the donations remote megaphone: the `standard_donate`
+ * conditional (via [RemoteMegaphoneRepository.getRemoteMegaphoneToShow]) suppresses the megaphone for
+ * existing donors and shows it otherwise.
+ */
+@RunWith(AndroidJUnit4::class)
+class DonationMegaphoneGatingTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  @Before
+  fun setUp() {
+    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
+    SignalDatabase.remoteMegaphones.debugRemoveAll()
+    setSelfBadges(emptyList())
+
+    // Freshly-installed test APKs report 0 days installed and no configured payment methods, both of
+    // which independently fail shouldShowDonateMegaphone. Fix them so the donor badge is the only
+    // variable across the gating tests.
+    mockkStatic(VersionTracker::class)
+    mockkObject(InAppDonations)
+    every { VersionTracker.getDaysSinceFirstInstalled(any()) } returns 30L
+    every { InAppDonations.hasAtLeastOnePaymentMethodAvailable() } returns true
+  }
+
+  @After
+  fun tearDown() {
+    unmockkStatic(VersionTracker::class)
+    unmockkObject(InAppDonations)
+  }
+
+  @Test
+  fun nonDonor_showsStandardDonateMegaphone() {
+    val record = donateMegaphoneRecord(conditionalId = "standard_donate")
+    SignalDatabase.remoteMegaphones.insert(record)
+
+    assertThat(RemoteMegaphoneRepository.getRemoteMegaphoneToShow()?.uuid).isEqualTo(record.uuid)
+    assertThat(RemoteMegaphoneRepository.hasRemoteMegaphoneToShow(canShowLocalDonate = true)).isTrue()
+  }
+
+  @Test
+  fun sustainer_donorBadge_suppressesStandardDonateMegaphone() {
+    SignalDatabase.remoteMegaphones.insert(donateMegaphoneRecord(conditionalId = "standard_donate"))
+    setSelfBadges(listOf(donorBadge()))
+
+    assertThat(RemoteMegaphoneRepository.getRemoteMegaphoneToShow()).isNull()
+    assertThat(RemoteMegaphoneRepository.hasRemoteMegaphoneToShow(canShowLocalDonate = true)).isFalse()
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/megaphone/DonationMegaphoneTest.kt

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.megaphone
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import androidx.compose.ui.test.junit4.v2.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.fragment.app.DialogFragment
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.ui.compose.theme.SignalTheme
+import org.signal.core.util.getSerializableCompat
+import org.signal.donations.InAppPaymentType
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.CheckoutFlowActivity
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.RemoteMegaphoneRecord
+import org.thoughtcrime.securesms.testing.InAppPaymentsRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+
+/**
+ * Entry-path coverage for the donations remote megaphone: the megaphone shown on the conversation list
+ * that carries a "Donate" action into the one-time checkout flow.
+ *
+ * The megaphone renders through [MegaphoneComponent], so this renders that composable directly (rather
+ * than launching the full [org.thoughtcrime.securesms.MainActivity]) and asserts that tapping Donate
+ * runs the production [RemoteMegaphoneRepository] action, which navigates to [CheckoutFlowActivity]
+ * with [InAppPaymentType.ONE_TIME_DONATION]. The sustainer gating is covered by [DonationMegaphoneGatingTest].
+ */
+@RunWith(AndroidJUnit4::class)
+class DonationMegaphoneTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @get:Rule
+  val iapRule = InAppPaymentsRule()
+
+  @get:Rule
+  val composeRule = createComposeRule()
+
+  private val context: Context get() = InstrumentationRegistry.getInstrumentation().targetContext
+
+  @Before
+  fun setUp() {
+    SignalDatabase.remoteMegaphones.debugRemoveAll()
+  }
+
+  @Test
+  fun donateMegaphone_donateClick_opensOneTimeCheckout() {
+    val record = donateMegaphoneRecord(conditionalId = null)
+    SignalDatabase.remoteMegaphones.insert(record)
+
+    val controller = RecordingMegaphoneActionController()
+
+    composeRule.setContent {
+      SignalTheme {
+        MegaphoneComponent(buildDonateMegaphone(record), controller)
+      }
+    }
+
+    composeRule.onNodeWithText(record.primaryActionText!!).performClick()
+
+    val intent = controller.navigationIntent
+    assertThat(intent).isNotNull()
+    assertThat(intent!!.component?.className).isEqualTo(CheckoutFlowActivity::class.java.name)
+
+    val type = intent.extras!!.getSerializableCompat(CheckoutFlowActivity.ARG_IN_APP_PAYMENT_TYPE, InAppPaymentType::class.java)
+    assertThat(type).isEqualTo(InAppPaymentType.ONE_TIME_DONATION)
+  }
+
+  /** Mirrors [Megaphones.buildRemoteMegaphone]: wires the primary button to the real repository action. */
+  private fun buildDonateMegaphone(record: RemoteMegaphoneRecord): Megaphone {
+    return Megaphone.Builder(Megaphones.Event.REMOTE_MEGAPHONE, Megaphone.Style.BASIC)
+      .setTitle(record.title)
+      .setBody(record.body)
+      .setActionButton(record.primaryActionText!!) { _, controller ->
+        RemoteMegaphoneRepository.getAction(record.primaryActionId!!).run(context, controller, record)
+      }
+      .build()
+  }
+
+  private class RecordingMegaphoneActionController : MegaphoneActionController {
+    var navigationIntent: Intent? = null
+      private set
+
+    override fun onMegaphoneNavigationRequested(intent: Intent) {
+      navigationIntent = intent
+    }
+
+    override fun onMegaphoneNavigationRequested(intent: Intent, requestCode: Int) {
+      navigationIntent = intent
+    }
+
+    override fun onMegaphoneToastRequested(string: String) = Unit
+    override fun getMegaphoneActivity(): Activity = throw UnsupportedOperationException("not used")
+    override fun onMegaphoneSnooze(event: Megaphones.Event) = Unit
+    override fun onMegaphoneCompleted(event: Megaphones.Event) = Unit
+    override fun onMegaphoneDialogFragmentRequested(dialogFragment: DialogFragment) = Unit
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/megaphone/DonationMegaphoneTestSupport.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.megaphone
+
+import android.net.Uri
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.RemoteMegaphoneRecord
+import org.thoughtcrime.securesms.recipients.Recipient
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+fun donateMegaphoneRecord(conditionalId: String?): RemoteMegaphoneRecord {
+  val now = System.currentTimeMillis()
+  return RemoteMegaphoneRecord(
+    priority = 100,
+    uuid = UUID.randomUUID().toString(),
+    countries = null,
+    minimumVersion = 1,
+    doNotShowBefore = now - TimeUnit.DAYS.toMillis(2),
+    doNotShowAfter = now + TimeUnit.DAYS.toMillis(28),
+    showForNumberOfDays = 30,
+    conditionalId = conditionalId,
+    primaryActionId = RemoteMegaphoneRecord.ActionId.DONATE,
+    secondaryActionId = RemoteMegaphoneRecord.ActionId.SNOOZE,
+    imageUrl = null,
+    title = "Donate Test",
+    body = "Donate body test.",
+    primaryActionText = "Donate",
+    secondaryActionText = "Snooze"
+  )
+}
+
+fun donorBadge(): Badge {
+  return Badge(
+    id = "test-donor-badge",
+    category = Badge.Category.Donor,
+    name = "Signal Sustainer",
+    description = "",
+    imageUrl = Uri.EMPTY,
+    imageDensity = "xxhdpi",
+    expirationTimestamp = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(30),
+    visible = true,
+    duration = TimeUnit.DAYS.toMillis(30)
+  )
+}
+
+fun setSelfBadges(badges: List<Badge>) {
+  SignalDatabase.recipients.setBadges(Recipient.self().id, badges)
+  Recipient.self().fresh()
+}

app/src/androidTest/java/org/thoughtcrime/securesms/messages/MessageHelper.kt

@@ -18,10 +18,10 @@ import org.thoughtcrime.securesms.database.UriAttachmentBuilder
 import org.thoughtcrime.securesms.database.model.GroupsV2UpdateMessageConverter
 import org.thoughtcrime.securesms.database.model.databaseprotos.DecryptedGroupV2Context
 import org.thoughtcrime.securesms.database.model.databaseprotos.GV2UpdateDescription
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobs.ThreadUpdateJob
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.mms.OutgoingMessage
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.testing.GroupTestingUtils
@@ -120,7 +120,7 @@ class MessageHelper(private val harness: SignalActivityRule, var startTime: Long
   }
 
   fun outgoingAttachment(data: ByteArray, uuid: UUID? = UUID.randomUUID()): Attachment {
-    val uri: Uri = BlobProvider.getInstance().forData(data).createForSingleSessionInMemory()
+    val uri: Uri = AppDependencies.blobs.forData(data).createForSingleSessionInMemory()
 
     val attachment: UriAttachment = UriAttachmentBuilder.build(
       id = Random.nextLong(),

app/src/androidTest/java/org/thoughtcrime/securesms/messages/SyncMessageProcessorTest_attachmentBackfill.kt

@@ -0,0 +1,347 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.messages
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import okio.ByteString.Companion.toByteString
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.models.database.AttachmentId
+import org.signal.core.util.Base64
+import org.thoughtcrime.securesms.database.AttachmentTable
+import org.thoughtcrime.securesms.database.MessageTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.testing.MessageContentFuzzer
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.util.MediaUtil
+import org.thoughtcrime.securesms.util.TextSecurePreferences
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.AddressableMessage
+import org.whispersystems.signalservice.internal.push.AttachmentPointer
+import org.whispersystems.signalservice.internal.push.Content
+import org.whispersystems.signalservice.internal.push.ConversationIdentifier
+import org.whispersystems.signalservice.internal.push.DataMessage
+import org.whispersystems.signalservice.internal.push.SyncMessage
+import java.util.UUID
+
+@Suppress("ClassName")
+@RunWith(AndroidJUnit4::class)
+class SyncMessageProcessorTest_attachmentBackfill {
+
+  @get:Rule
+  val harness = SignalActivityRule(createGroup = true)
+
+  private lateinit var messageHelper: MessageHelper
+  private var originalDeviceId: Int = SignalServiceAddress.DEFAULT_DEVICE_ID
+
+  @Before
+  fun setUp() {
+    messageHelper = MessageHelper(harness)
+    originalDeviceId = SignalStore.account.deviceId
+    // Make this device a linked device so backfill response handling activates.
+    SignalStore.account.deviceId = 2
+
+    // Prevent AttachmentDownloadJob onAdded from async changing the attachment state.
+    TextSecurePreferences.getSharedPreferences(harness.application)
+      .edit()
+      .putStringSet(TextSecurePreferences.MEDIA_DOWNLOAD_WIFI_PREF, emptySet())
+      .putStringSet(TextSecurePreferences.MEDIA_DOWNLOAD_MOBILE_PREF, emptySet())
+      .putStringSet(TextSecurePreferences.MEDIA_DOWNLOAD_ROAMING_PREF, emptySet())
+      .commit()
+  }
+
+  @After
+  fun tearDown() {
+    SignalStore.account.deviceId = originalDeviceId
+    messageHelper.tearDown()
+  }
+
+  @Test
+  fun fresh_pointer_updates_row_and_resets_transfer_state() {
+    val (messageId, attachmentId) = insertIncomingMediaMessage(messageHelper.alice)
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    val pointer = freshPointer(cdnNumber = 3, cdnKey = "fresh-key", size = 1234, uploadTimestamp = 9_999_000L)
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = pointer))
+    )
+
+    // transferState is not asserted: the forced download job's onAdded() races it PENDING -> STARTED. The pointer fields
+    // are written synchronously and are stable.
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.remoteLocation).isEqualTo("fresh-key")
+    assertThat(refreshed.cdn.cdnNumber).isEqualTo(3)
+    assertThat(refreshed.size).isEqualTo(1234L)
+    assertThat(refreshed.uploadTimestamp).isEqualTo(9_999_000L)
+  }
+
+  @Test
+  fun terminal_error_marks_permanent_failure() {
+    val (messageId, attachmentId) = insertIncomingMediaMessage(messageHelper.alice)
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(
+          status = SyncMessage.AttachmentBackfillResponse.AttachmentData.Status.TERMINAL_ERROR
+        )
+      )
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.transferState).isEqualTo(AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE)
+  }
+
+  @Test
+  fun pending_status_leaves_row_unchanged() {
+    val (messageId, attachmentId) = insertIncomingMediaMessage(messageHelper.alice)
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(
+          status = SyncMessage.AttachmentBackfillResponse.AttachmentData.Status.PENDING
+        )
+      )
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.transferState).isEqualTo(AttachmentTable.TRANSFER_PROGRESS_FAILED)
+  }
+
+  @Test
+  fun message_not_found_error_marks_attachments_retryable_failed() {
+    val (messageId, attachmentId) = insertIncomingMediaMessage(messageHelper.alice)
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      error = SyncMessage.AttachmentBackfillResponse.Error.MESSAGE_NOT_FOUND
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.transferState).isEqualTo(AttachmentTable.TRANSFER_PROGRESS_FAILED)
+  }
+
+  @Test
+  fun primary_device_ignores_backfill_response() {
+    SignalStore.account.deviceId = SignalServiceAddress.DEFAULT_DEVICE_ID
+
+    val (messageId, attachmentId) = insertIncomingMediaMessage(messageHelper.alice)
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(
+          status = SyncMessage.AttachmentBackfillResponse.AttachmentData.Status.TERMINAL_ERROR
+        )
+      )
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.transferState).isEqualTo(AttachmentTable.TRANSFER_PROGRESS_FAILED)
+  }
+
+  @Test
+  fun multi_attachment_response_matches_positionally_with_mixed_status() {
+    val messageId = insertIncomingMessageWith(messageHelper.alice, listOf(incomingImagePointer(), incomingImagePointer()))
+    val body = SignalDatabase.attachments.getAttachmentsForMessage(messageId).sortedBy { it.displayOrder }
+    assertThat(body.size).isEqualTo(2)
+    body.forEach { SignalDatabase.attachments.setTransferProgressFailed(it.attachmentId, messageId) }
+
+    // Response is a positional array: index 0 -> body[0] (fresh pointer), index 1 -> body[1] (terminal).
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = freshPointer(cdnNumber = 3, cdnKey = "first-key", size = 11, uploadTimestamp = 111L)),
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(status = SyncMessage.AttachmentBackfillResponse.AttachmentData.Status.TERMINAL_ERROR)
+      )
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).sortedBy { it.displayOrder }
+    // remoteLocation proves index 0 routed to body[0]. transferState is not asserted: it races the download job's onAdded().
+    assertThat(refreshed[0].remoteLocation).isEqualTo("first-key")
+    assertThat(refreshed[0].cdn.cdnNumber).isEqualTo(3)
+    assertThat(refreshed[1].transferState).isEqualTo(AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE)
+  }
+
+  @Test
+  fun long_text_slot_is_applied_independently_of_the_body() {
+    val messageId = insertIncomingMessageWith(messageHelper.alice, listOf(incomingImagePointer(), incomingLongTextPointer()))
+    val all = SignalDatabase.attachments.getAttachmentsForMessage(messageId)
+    all.forEach { SignalDatabase.attachments.setTransferProgressFailed(it.attachmentId, messageId) }
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = freshPointer(cdnNumber = 3, cdnKey = "body-key", size = 22, uploadTimestamp = 222L))),
+      longText = SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = freshPointer(cdnNumber = 3, cdnKey = "long-text-key", size = 33, uploadTimestamp = 333L))
+    )
+
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId)
+    val bodyRow = refreshed.single { it.contentType != MediaUtil.LONG_TEXT }
+    val longTextRow = refreshed.single { it.contentType == MediaUtil.LONG_TEXT }
+    // The positional `attachments` array fills the body row and the separate `longText` slot fills the long-text row,
+    // with no cross-contamination. transferState is not asserted: it races the download job's onAdded().
+    assertThat(bodyRow.remoteLocation).isEqualTo("body-key")
+    assertThat(longTextRow.remoteLocation).isEqualTo("long-text-key")
+  }
+
+  @Test
+  fun remote_attachment_list_longer_than_local_skips_extras() {
+    val messageId = insertIncomingMessageWith(messageHelper.alice, listOf(incomingImagePointer()))
+    val attachmentId = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single().attachmentId
+    SignalDatabase.attachments.setTransferProgressFailed(attachmentId, messageId)
+
+    deliverBackfillResponse(
+      sender = messageHelper.alice,
+      sentTimestamp = sentTimestampFor(messageId),
+      conversationId = messageHelper.alice,
+      attachmentData = listOf(
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = freshPointer(cdnNumber = 3, cdnKey = "only-key", size = 44, uploadTimestamp = 444L)),
+        SyncMessage.AttachmentBackfillResponse.AttachmentData(attachment = freshPointer(cdnNumber = 3, cdnKey = "extra-key", size = 55, uploadTimestamp = 555L))
+      )
+    )
+
+    // The single local row is routed from index 0; the extra index-1 entry has no body[1] and must be skipped, not throw.
+    val refreshed = SignalDatabase.attachments.getAttachmentsForMessage(messageId).single()
+    assertThat(refreshed.remoteLocation).isEqualTo("only-key")
+  }
+
+  private fun insertIncomingMediaMessage(sender: RecipientId): Pair<Long, AttachmentId> {
+    messageHelper.startTime = messageHelper.nextStartTime()
+    val sentTimestamp = messageHelper.startTime
+
+    val content = Content.Builder()
+      .dataMessage(
+        DataMessage.Builder()
+          .timestamp(sentTimestamp)
+          .attachments(listOf(MessageContentFuzzer.attachmentPointer()))
+          .build()
+      )
+      .build()
+
+    messageHelper.processor.process(
+      envelope = MessageContentFuzzer.envelope(sentTimestamp),
+      content = content,
+      metadata = MessageContentFuzzer.envelopeMetadata(source = sender, destination = harness.self.id),
+      serverDeliveredTimestamp = sentTimestamp + 10
+    )
+
+    val syncMessageId = MessageTable.SyncMessageId(sender, sentTimestamp)
+    val messageId = SignalDatabase.messages.getMessageIdOrNull(syncMessageId)
+    assertThat(messageId, name = "messageId").isNotNull()
+
+    val attachment = SignalDatabase.attachments.getAttachmentsForMessage(messageId!!).single()
+    return messageId to attachment.attachmentId
+  }
+
+  private fun insertIncomingMessageWith(sender: RecipientId, pointers: List<AttachmentPointer>): Long {
+    messageHelper.startTime = messageHelper.nextStartTime()
+    val sentTimestamp = messageHelper.startTime
+
+    val content = Content.Builder()
+      .dataMessage(
+        DataMessage.Builder()
+          .timestamp(sentTimestamp)
+          .attachments(pointers)
+          .build()
+      )
+      .build()
+
+    messageHelper.processor.process(
+      envelope = MessageContentFuzzer.envelope(sentTimestamp),
+      content = content,
+      metadata = MessageContentFuzzer.envelopeMetadata(source = sender, destination = harness.self.id),
+      serverDeliveredTimestamp = sentTimestamp + 10
+    )
+
+    val messageId = SignalDatabase.messages.getMessageIdOrNull(MessageTable.SyncMessageId(sender, sentTimestamp))
+    assertThat(messageId, name = "messageId").isNotNull()
+    return messageId!!
+  }
+
+  private fun incomingImagePointer(): AttachmentPointer = MessageContentFuzzer.attachmentPointer().newBuilder().contentType("image/jpeg").build()
+
+  private fun incomingLongTextPointer(): AttachmentPointer = MessageContentFuzzer.attachmentPointer().newBuilder().contentType(MediaUtil.LONG_TEXT).build()
+
+  private fun sentTimestampFor(messageId: Long): Long {
+    return SignalDatabase.messages.getMessageRecord(messageId).dateSent
+  }
+
+  private fun deliverBackfillResponse(
+    sender: RecipientId,
+    sentTimestamp: Long,
+    conversationId: RecipientId,
+    attachmentData: List<SyncMessage.AttachmentBackfillResponse.AttachmentData> = emptyList(),
+    longText: SyncMessage.AttachmentBackfillResponse.AttachmentData? = null,
+    error: SyncMessage.AttachmentBackfillResponse.Error? = null
+  ) {
+    messageHelper.startTime = messageHelper.nextStartTime()
+    val envelopeTimestamp = messageHelper.startTime
+
+    val response = SyncMessage.AttachmentBackfillResponse(
+      targetMessage = AddressableMessage(
+        authorServiceIdBinary = Recipient.resolved(sender).requireAci().toByteString(),
+        sentTimestamp = sentTimestamp
+      ),
+      targetConversation = ConversationIdentifier(
+        threadServiceIdBinary = Recipient.resolved(conversationId).requireAci().toByteString()
+      ),
+      attachments = if (error == null) SyncMessage.AttachmentBackfillResponse.AttachmentDataList(attachments = attachmentData, longText = longText) else null,
+      error = error
+    )
+
+    val content = Content.Builder()
+      .syncMessage(SyncMessage.Builder().attachmentBackfillResponse(response).build())
+      .build()
+
+    messageHelper.processor.process(
+      envelope = MessageContentFuzzer.envelope(envelopeTimestamp, serverGuid = UUID.randomUUID()),
+      content = content,
+      metadata = MessageContentFuzzer.envelopeMetadata(source = harness.self.id, destination = harness.self.id, sourceDeviceId = 1),
+      serverDeliveredTimestamp = envelopeTimestamp + 10
+    )
+  }
+
+  private fun freshPointer(cdnNumber: Int, cdnKey: String, size: Int, uploadTimestamp: Long): AttachmentPointer {
+    return AttachmentPointer.Builder()
+      .cdnKey(cdnKey)
+      .cdnNumber(cdnNumber)
+      .key(Base64.decode("AAAAAAAA").toByteString())
+      .digest(ByteArray(32) { it.toByte() }.toByteString())
+      .size(size)
+      .uploadTimestamp(uploadTimestamp)
+      .contentType("image/jpeg")
+      .build()
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/messages/SyncMessageProcessorTest_synchronizePniChangeNumber.kt

@@ -236,8 +236,9 @@ class SyncMessageProcessorTest_synchronizePniChangeNumber {
   }
 
   @Test
-  fun skipsRedeliveryWhenPniAlreadyMatches() {
-    sendPniChangeNumber()
+  fun skipsRedeliveryWithSameServerTimestamp() {
+    val timestamp = messageHelper.nextStartTime()
+    sendPniChangeNumber(timestamp = timestamp)
     val afterFirstApply = captureOriginalState()
 
     val otherIdentity = IdentityKeyPair.generate()
@@ -247,12 +248,41 @@ class SyncMessageProcessorTest_synchronizePniChangeNumber {
       identityKeyPair = otherIdentity.serialize().toByteString(),
       signedPreKey = otherSignedPreKey.serialize().toByteString(),
       e164 = "+15555550100",
-      timestamp = messageHelper.nextStartTime() + 1000
+      timestamp = timestamp
     )
 
     assertOriginalStatePreserved(afterFirstApply)
   }
 
+  @Test
+  fun reappliesWhenServerTimestampIsNewer() {
+    sendPniChangeNumber()
+
+    val secondPniUuid = UUID.randomUUID()
+    val secondPni = ServiceId.PNI.from(secondPniUuid)
+    val secondPniBytes = UuidUtil.toByteArray(secondPniUuid).toByteString()
+    val secondIdentity = IdentityKeyPair.generate()
+    val secondSignedPreKey = PreKeyUtil.generateSignedPreKey(9999, secondIdentity.privateKey)
+    val secondE164 = "+15555550100"
+    val secondRegistrationId = 7777
+
+    sendPniChangeNumber(
+      identityKeyPair = secondIdentity.serialize().toByteString(),
+      signedPreKey = secondSignedPreKey.serialize().toByteString(),
+      lastResortKyberPreKey = null,
+      registrationId = secondRegistrationId,
+      e164 = secondE164,
+      envelopePniBinary = secondPniBytes,
+      timestamp = messageHelper.nextStartTime() + 1000
+    )
+
+    assertThat(SignalStore.account.e164).isEqualTo(secondE164)
+    assertThat(SignalStore.account.pni).isEqualTo(secondPni)
+    assertThat(SignalStore.account.pniRegistrationId).isEqualTo(secondRegistrationId)
+    assertThat(SignalStore.account.pniIdentityKey.publicKey.serialize().toByteString())
+      .isEqualTo(secondIdentity.publicKey.serialize().toByteString())
+  }
+
   @Test
   fun bailsWhenServerTimestampStale() {
     sendPniChangeNumber()

app/src/androidTest/java/org/thoughtcrime/securesms/testing/GooglePayTestRule.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.testing
+
+import com.google.android.gms.wallet.PaymentData
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkConstructor
+import io.mockk.unmockkConstructor
+import io.reactivex.rxjava3.core.Completable
+import org.junit.rules.ExternalResource
+import org.signal.donations.GooglePayApi
+
+/**
+ * Makes Google Pay appear available and return a fake [com.google.android.gms.wallet.PaymentData] without
+ * launching the real Google Pay sheet, allowing checkout to be driven to the payment pipeline in instrumentation.
+ */
+class GooglePayTestRule : ExternalResource() {
+  override fun before() {
+    val paymentData = mockk<PaymentData> {
+      every { toJson() } returns GOOGLE_PAY_PAYMENT_DATA_JSON
+    }
+
+    mockkConstructor(GooglePayApi::class)
+    every { anyConstructed<GooglePayApi>().queryIsReadyToPay() } returns Completable.complete()
+    every { anyConstructed<GooglePayApi>().requestPayment(any(), any(), any()) } just Runs
+    every { anyConstructed<GooglePayApi>().onActivityResult(any(), any(), any(), any(), any()) } answers {
+      arg<GooglePayApi.PaymentRequestCallback>(4).onSuccess(paymentData)
+    }
+  }
+
+  override fun after() {
+    unmockkConstructor(GooglePayApi::class)
+  }
+
+  companion object {
+    /**
+     * Minimal but well-formed Google Pay payload. [org.signal.donations.GooglePayPaymentSource] parses
+     * `paymentMethodData.tokenizationData.token` (itself a JSON object with an `id`) when the source is
+     * serialized into the setup job, so a relaxed mock that returns an empty body fails before the job runs.
+     */
+    const val GOOGLE_PAY_PAYMENT_DATA_JSON = """{"paymentMethodData":{"tokenizationData":{"token":"{\"id\":\"tok_test\"}"}},"email":"test@signal.org"}"""
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/InAppPaymentTestWaiters.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.testing
+
+import android.os.SystemClock
+import androidx.test.platform.app.InstrumentationRegistry
+import io.reactivex.rxjava3.schedulers.TestScheduler
+
+/**
+ * Timing primitives for in-app-payment instrumentation tests.
+ *
+ * The checkout flow runs against two clocks: the Rx pipeline that drives the UI (creating the payment,
+ * enqueuing the setup job, reacting to state changes, rendering dialogs) runs on the test's [TestScheduler]
+ * (virtual time), while the setup job itself executes on a live JobManager worker thread (real time). Neither
+ * clock can be waited on alone — the scheduler must be advanced for the pipeline to make progress, and the
+ * test must yield real time for the job to run and commit its result. [flushUntil] does both.
+ */
+
+/**
+ * Advances virtual Rx time on this [TestScheduler], drains the main looper, and yields briefly for real
+ * JobManager work, repeating until [condition] holds or [timeoutMs] elapses.
+ *
+ * [TestScheduler.triggerActions] runs the pipeline's scheduled work (which may enqueue a job or process a
+ * database update), `waitForIdleSync` renders whatever that produced, and the short sleep lets the real setup
+ * job run on its worker thread and commit the next state before the loop advances the scheduler again to pick
+ * it up. Throws once [timeoutMs] is exceeded, which means the expected UI state never materialised.
+ *
+ * [condition] may either return `false` or throw (e.g. an Espresso `check` that has not yet matched) to signal
+ * "not satisfied"; a thrown failure is retained and chained as the cause of the timeout [AssertionError] so a
+ * flake surfaces the underlying Espresso error rather than an opaque "condition not satisfied".
+ */
+fun TestScheduler.flushUntil(timeoutMs: Long = 15_000, condition: () -> Boolean) {
+  val deadline = SystemClock.uptimeMillis() + timeoutMs
+  var lastFailure: Throwable? = null
+
+  while (true) {
+    triggerActions()
+    InstrumentationRegistry.getInstrumentation().waitForIdleSync()
+
+    try {
+      if (condition()) {
+        return
+      }
+    } catch (t: Throwable) {
+      lastFailure = t
+    }
+
+    if (SystemClock.uptimeMillis() >= deadline) {
+      throw AssertionError("Condition was not satisfied within ${timeoutMs}ms of flushing the checkout pipeline.", lastFailure)
+    }
+
+    Thread.sleep(50)
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/InAppPaymentsRule.kt

@@ -7,37 +7,90 @@ package org.thoughtcrime.securesms.testing
 
 import androidx.test.platform.app.InstrumentationRegistry
 import io.mockk.every
+import org.json.JSONObject
 import org.junit.rules.ExternalResource
-import org.signal.core.util.JsonUtils
 import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.dependencies.AppDependencies
-import org.whispersystems.signalservice.internal.push.SubscriptionsConfiguration
+import org.thoughtcrime.securesms.testing.endpoints.DonationResponses
+import org.thoughtcrime.securesms.testing.endpoints.DonationTestServer
+import org.thoughtcrime.securesms.testing.endpoints.EndpointResponse
+import org.thoughtcrime.securesms.testing.endpoints.MockEndpoints
+import org.thoughtcrime.securesms.testing.endpoints.delete
+import org.thoughtcrime.securesms.testing.endpoints.get
+import org.thoughtcrime.securesms.testing.endpoints.ok
+import org.thoughtcrime.securesms.testing.endpoints.post
+import org.thoughtcrime.securesms.testing.endpoints.put
+import org.whispersystems.signalservice.internal.push.WhoAmIResponse
 
 /**
- * Sets up some common infrastructure for on-device InAppPayment testing
+ * Sets up common infrastructure for on-device InAppPayment testing.
+ *
+ * The Signal-service edge is driven through the shared [MockEndpoints.responder] (the real
+ * [org.whispersystems.signalservice.api.donations.DonationsApi] runs against these handlers), while
+ * account/archive lookups that are not websocket-backed here stay mocked via mockk. A scenario can
+ * override any default by registering a more specific handler after this rule runs (last-registered
+ * wins).
  */
 class InAppPaymentsRule : ExternalResource() {
+
   override fun before() {
-    initialiseConfigurationResponse()
-    initialisePutSubscription()
+    MockEndpoints.responder.clear()
+    registerDonationServiceDefaults()
     initialiseSetArchiveBackupId()
+    initialiseSetAccountAttributes()
+    initialiseAccountLookups()
   }
 
-  private fun initialiseConfigurationResponse() {
-    val assets = InstrumentationRegistry.getInstrumentation().context.resources.assets
-    val response = assets.open("inAppPaymentsTests/configuration.json").use { stream ->
-      NetworkResult.Success(JsonUtils.fromJson(stream, SubscriptionsConfiguration::class.java))
-    }
-
-    AppDependencies.donationsApi.apply {
-      every { getDonationsConfiguration(any()) } returns response
-    }
+  override fun after() {
+    MockEndpoints.responder.clear()
   }
 
-  private fun initialisePutSubscription() {
-    AppDependencies.donationsApi.apply {
-      every { putSubscription(any()) } returns NetworkResult.Success(Unit)
+  /**
+   * Default happy-path responses for the Signal donations endpoints. Registered generic-to-specific
+   * so more specific paths registered later win.
+   */
+  private fun registerDonationServiceDefaults() {
+    val responder = MockEndpoints.responder
+
+    // Subscriber lifecycle: create/put/update-level (PUT), cancel (DELETE) all succeed by default.
+    responder.put("/v1/subscription/") { ok() }
+    responder.delete("/v1/subscription/") { ok() }
+
+    // getSubscription defaults to "no active subscription".
+    responder.get("/v1/subscription/") { ok(DonationResponses.emptySubscription()) }
+
+    // Donations configuration (registered after the generic GET so it wins for its path).
+    val configuration = InstrumentationRegistry.getInstrumentation().context.resources.assets
+      .open("inAppPaymentsTests/configuration.json")
+      .use { it.readBytes().decodeToString() }
+    responder.get("/v1/subscription/configuration") { ok(configuration) }
+
+    // SEPA bank-transfer mandate text (registered after the generic GET so it wins for its path).
+    responder.get("/v1/subscription/bank_mandate/") { ok(DonationResponses.bankMandate()) }
+
+    // One-time (boost) payment intent.
+    responder.post("/v1/subscription/boost/create") { ok(DonationResponses.stripeClientSecret()) }
+
+    // Recurring payment method setup + default payment method + level are keyed by subscriber id in
+    // the middle of the path, so match on a distinctive suffix.
+    responder.register({ it.method == "POST" && it.path.contains("/create_payment_method") && !it.path.contains("paypal") }) {
+      ok(DonationResponses.setupIntentClientSecret())
     }
+    responder.register({ it.method == "POST" && it.path.contains("/default_payment_method") }) { ok() }
+
+    // Receipt credential submission (boost + recurring) — mint a valid credential from the client's request.
+    responder.register({ it.method == "POST" && it.path.contains("/receipt_credentials") }) { request ->
+      mintReceiptCredential(request.bodyString)
+    }
+
+    // Redemption.
+    responder.post("/v1/donation/redeem-receipt") { ok() }
+  }
+
+  private fun mintReceiptCredential(requestBody: String): EndpointResponse {
+    val requestBase64 = JSONObject(requestBody).getString("receiptCredentialRequest")
+    val minted = DonationTestServer.issueReceiptCredential(requestBase64)
+    return ok(DonationResponses.receiptCredential(minted))
   }
 
   private fun initialiseSetArchiveBackupId() {
@@ -45,4 +98,20 @@ class InAppPaymentsRule : ExternalResource() {
       every { triggerBackupIdReservation(any(), any(), any()) } returns NetworkResult.Success(Unit)
     }
   }
+
+  private fun initialiseSetAccountAttributes() {
+    AppDependencies.accountApi.apply {
+      every { setAccountAttributes(any()) } returns NetworkResult.Success(Unit)
+    }
+  }
+
+  /**
+   * whoAmI is served by the (still mocked) account API rather than the websocket responder, so
+   * background jobs that resolve the account during a test hit a handled path instead of throwing.
+   */
+  private fun initialiseAccountLookups() {
+    AppDependencies.accountApi.apply {
+      every { whoAmI() } returns NetworkResult.Success(WhoAmIResponse(number = "+15555550123"))
+    }
+  }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/testing/RemoteConfigForTest.kt

@@ -0,0 +1,82 @@
+package org.thoughtcrime.securesms.testing
+
+import org.json.JSONObject
+import org.thoughtcrime.securesms.util.RemoteConfig
+import kotlin.reflect.KProperty0
+import kotlin.reflect.jvm.isAccessible
+
+/**
+ * Declares remote config values a test needs. The [SignalTestRunner] reads this off the
+ * about-to-run test (class and/or method) and stages the values into [TestRemoteConfig], which
+ * [org.thoughtcrime.securesms.SignalInstrumentationApplicationContext] seeds into the real
+ * [RemoteConfig] before the startup `init()` runs.
+ *
+ * Method-level annotations override class-level ones for the same key. Values are strings, matching
+ * how the service delivers config; `"true"`/`"false"` are decoded into real booleans on the way into
+ * the store (same as [org.signal.network.api.RemoteConfigApi]), other values stay strings.
+ *
+ * Prefer the typed [Flag] (which resolves its key from the actual [RemoteConfig] property); use
+ * [RawFlag] for keys that don't have a [TestRemoteConfigFlag] entry.
+ *
+ * ```
+ * @RemoteConfigForTest(
+ *   flags = [Flag(TestRemoteConfigFlag.INTERNAL_USER, "true")],
+ *   rawFlags = [RawFlag("android.someOtherKey", "1")]
+ * )
+ * class MyTest { ... }
+ * ```
+ */
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+annotation class RemoteConfigForTest(
+  val flags: Array<Flag> = [],
+  val rawFlags: Array<RawFlag> = []
+)
+
+/** A flag whose key is resolved from the referenced [RemoteConfig] property at runtime. */
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Flag(val flag: TestRemoteConfigFlag, val value: String)
+
+/** A flag identified by its raw remote config key, for keys without a [TestRemoteConfigFlag] entry. */
+@Retention(AnnotationRetention.RUNTIME)
+annotation class RawFlag(val key: String, val value: String)
+
+/**
+ * Typed handles for remote config flags referenced by tests.
+ */
+enum class TestRemoteConfigFlag(private val property: KProperty0<*>) {
+  INTERNAL_USER(RemoteConfig::internalUser),
+  DEFAULT_MAX_BACKOFF(RemoteConfig::defaultMaxBackoff),
+  DISAPPEAR_MORE(RemoteConfig::disappearMore);
+
+  val key: String
+    get() {
+      property.isAccessible = true
+      val delegate = property.getDelegate() ?: error("RemoteConfig.${property.name} has no delegate; only `by remoteX(...)` configs can be referenced by ${TestRemoteConfigFlag::class.simpleName}.")
+      check(delegate is RemoteConfig.Config<*>) {
+        "RemoteConfig.${property.name} delegate is ${delegate::class.simpleName}, not RemoteConfig.Config; cannot resolve its remote config key."
+      }
+      return delegate.key
+    }
+}
+
+/**
+ * Process-static bridge between [SignalTestRunner] (which knows the running test) and
+ * [org.thoughtcrime.securesms.SignalInstrumentationApplicationContext] (which seeds the config).
+ * Safe because Orchestrator runs each test in a fresh process.
+ */
+object TestRemoteConfig {
+  @Volatile
+  var pending: Map<String, Any> = emptyMap()
+
+  /**
+   * The staged config as a JSON string ready to write into `SignalStore.remoteConfig`. Mirrors
+   * [org.signal.network.api.RemoteConfigApi]'s decode so `"true"`/`"false"` land as real booleans
+   * (like the server path) while other values stay strings.
+   */
+  val json: String
+    get() {
+      val decoded = pending.mapValues { (_, value) -> (value as? String)?.lowercase()?.toBooleanStrictOrNull() ?: value }
+      return JSONObject(decoded).toString()
+    }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/SignalTestRunner.kt

@@ -2,15 +2,62 @@ package org.thoughtcrime.securesms.testing
 
 import android.app.Application
 import android.content.Context
+import android.os.Bundle
 import androidx.test.runner.AndroidJUnitRunner
 import org.thoughtcrime.securesms.SignalInstrumentationApplicationContext
 
 /**
  * Custom runner that replaces application with [SignalInstrumentationApplicationContext].
+ *
+ * Before the application is created, it reads any [RemoteConfigForTest] declared on the
+ * about-to-run test (passed by the Orchestrator as the `class` argument, `pkg.Class#method`) and
+ * stages the values in [TestRemoteConfig] so the app can seed them into `RemoteConfig` at startup.
  */
 @Suppress("unused")
 class SignalTestRunner : AndroidJUnitRunner() {
+  override fun onCreate(arguments: Bundle?) {
+    TestRemoteConfig.pending = parseRemoteConfig(arguments?.getString("class"))
+    super.onCreate(arguments)
+  }
+
   override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application {
     return super.newApplication(cl, SignalInstrumentationApplicationContext::class.java.name, context)
   }
+
+  /**
+   * Resolves [RemoteConfigForTest] annotations from the targeted test(s). [classArg] is the
+   * instrumentation `class` argument: a comma-separated list of `pkg.Class` or `pkg.Class#method`.
+   * Method-level flags override class-level flags for the same key. Reflection failures (e.g. a
+   * whole-suite run with no `class` arg) fall back to no overrides.
+   */
+  private fun parseRemoteConfig(classArg: String?): Map<String, Any> {
+    if (classArg.isNullOrBlank()) {
+      return emptyMap()
+    }
+
+    val flags = mutableMapOf<String, Any>()
+
+    for (entry in classArg.split(",")) {
+      val (className, methodName) = entry.trim().split("#", limit = 2).let { it[0] to it.getOrNull(1) }
+
+      try {
+        // initialize = false: only read annotations, don't run the test class's static init this early.
+        val testClass = Class.forName(className, false, javaClass.classLoader)
+        val method = methodName?.let { name -> testClass.declaredMethods.firstOrNull { it.name == name } }
+
+        // Class annotation first, then method annotation so method-level flags override class-level ones.
+        listOfNotNull(
+          testClass.getAnnotation(RemoteConfigForTest::class.java),
+          method?.getAnnotation(RemoteConfigForTest::class.java)
+        ).forEach { annotation ->
+          annotation.flags.forEach { flags[it.flag.key] = it.value }
+          annotation.rawFlags.forEach { flags[it.key] = it.value }
+        }
+      } catch (_: ReflectiveOperationException) {
+        // Class/method not resolvable in this run; leave overrides as-is.
+      }
+    }
+
+    return flags
+  }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/testing/actions/RecyclerViewInteractions.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.testing.actions
+
+import android.os.SystemClock
+import android.view.View
+import androidx.annotation.IdRes
+import androidx.recyclerview.widget.RecyclerView
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.PerformException
+import androidx.test.espresso.contrib.RecyclerViewActions
+import androidx.test.espresso.matcher.ViewMatchers.hasDescendant
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.platform.app.InstrumentationRegistry
+import io.reactivex.rxjava3.schedulers.TestScheduler
+import org.hamcrest.Matcher
+
+/**
+ * Scrolls the [RecyclerView] with id [recyclerViewId] to the view holder whose item view matches [target], or
+ * whose item view contains a descendant matching [target] (e.g. a preset button inside a container row),
+ * binding it if necessary, then returns. Off-screen presets/buttons are brought on-screen before a click or
+ * assertion regardless of device size — important for Firebase Test Lab's varied screens.
+ *
+ * The DSL screens use [androidx.recyclerview.widget.ListAdapter], which diffs `submitList` on a background
+ * thread and posts the result to the main thread. espresso-contrib's [RecyclerViewActions.scrollTo] scans the
+ * adapter once and fails fast if that diff has not yet committed, so we retry within [timeoutMs], pumping the
+ * main looper (and, if supplied, advancing [scheduler] to run the Rx work that produces the list) between
+ * attempts. This is the async-diff analogue of the codebase's existing poll-until-ready test idiom; Android
+ * exposes no deterministic completion hook for the differ.
+ */
+fun scrollToDescendant(
+  @IdRes recyclerViewId: Int,
+  target: Matcher<View>,
+  scheduler: TestScheduler? = null,
+  timeoutMs: Long = 5_000
+) {
+  val deadline = SystemClock.uptimeMillis() + timeoutMs
+
+  while (true) {
+    // A holder's item view may itself be the target (a bare button row) or contain it as a descendant
+    // (a preset within a container), so try both rather than assume one shape.
+    if (tryScrollTo(recyclerViewId, target) || tryScrollTo(recyclerViewId, hasDescendant(target))) {
+      return
+    }
+
+    if (SystemClock.uptimeMillis() >= deadline) {
+      throw AssertionError("RecyclerView (id=$recyclerViewId) never bound a holder matching $target within ${timeoutMs}ms.")
+    }
+
+    scheduler?.triggerActions()
+    InstrumentationRegistry.getInstrumentation().waitForIdleSync()
+    Thread.sleep(50)
+  }
+}
+
+private fun tryScrollTo(@IdRes recyclerViewId: Int, holderMatcher: Matcher<View>): Boolean {
+  return try {
+    onView(withId(recyclerViewId)).perform(RecyclerViewActions.scrollTo<RecyclerView.ViewHolder>(holderMatcher))
+    true
+  } catch (e: PerformException) {
+    false
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/actions/RecyclerViewScrollToBottomAction.kt

@@ -1,34 +0,0 @@
-/*
- * Copyright 2025 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.testing.actions
-
-import android.view.View
-import androidx.recyclerview.widget.RecyclerView
-import androidx.test.espresso.UiController
-import androidx.test.espresso.ViewAction
-import androidx.test.espresso.matcher.ViewMatchers.isAssignableFrom
-import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
-import org.hamcrest.CoreMatchers.allOf
-import org.hamcrest.Matcher
-
-/**
- * Scrolls the RecyclerView to the bottom position.
- *
- * Borrowed from [https://stackoverflow.com/a/55990445](https://stackoverflow.com/a/55990445)
- */
-object RecyclerViewScrollToBottomAction : ViewAction {
-  override fun getDescription(): String = "scroll RecyclerView to bottom"
-
-  override fun getConstraints(): Matcher<View> = allOf(isAssignableFrom(RecyclerView::class.java), isDisplayed())
-
-  override fun perform(uiController: UiController?, view: View?) {
-    val recyclerView = view as RecyclerView
-    val itemCount = recyclerView.adapter?.itemCount
-    val position = itemCount?.minus(1) ?: 0
-    recyclerView.scrollToPosition(position)
-    uiController?.loopMainThreadUntilIdle()
-  }
-}

app/src/benchmarkShared/java/org/signal/benchmark/BenchmarkCommandReceiver.kt

@@ -16,6 +16,7 @@ import org.signal.benchmark.setup.Harness
 import org.signal.benchmark.setup.OtherClient
 import org.signal.core.util.ThreadUtil
 import org.signal.core.util.logging.Log
+import org.signal.network.websocket.WebSocketRequestMessage
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.TestDbUtils
 import org.thoughtcrime.securesms.dependencies.AppDependencies
@@ -23,7 +24,6 @@ import org.thoughtcrime.securesms.groups.GroupId
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.whispersystems.signalservice.internal.push.Envelope
 import org.whispersystems.signalservice.internal.websocket.BenchmarkWebSocketConnection
-import org.signal.network.websocket.WebSocketRequestMessage
 import kotlin.random.Random
 
 /**

app/src/benchmarkShared/java/org/signal/benchmark/BenchmarkSetupActivity.kt

@@ -32,6 +32,14 @@ class BenchmarkSetupActivity : BaseActivity() {
 
   companion object {
     private val TAG = Log.tag(BenchmarkSetupActivity::class)
+
+    const val SEARCH_KEYWORD = "lighthouse"
+
+    private val SEARCH_VOCABULARY = listOf(
+      "hello", "world", "signal", "android", "kotlin", "database", "benchmark", "conversation",
+      "morning", "evening", "weekend", "project", "meeting", "dinner", "coffee", "garden",
+      "mountain", "river", "forest", "harbor", "market", "library", "concert", "holiday"
+    )
   }
 
   override fun onCreate(savedInstanceState: Bundle?) {
@@ -51,6 +59,7 @@ class BenchmarkSetupActivity : BaseActivity() {
       when (intent.extras!!.getString("setup-type")) {
         "cold-start" -> setupColdStart()
         "conversation-open" -> setupConversationOpen()
+        "conversation-list-search" -> setupConversationListSearch()
         "message-send" -> setupMessageSend()
         "group-message-send" -> setupGroupMessageSend()
         "group-delivery-receipt" -> setupGroupReceipt(includeMsl = true)
@@ -97,6 +106,39 @@ class BenchmarkSetupActivity : BaseActivity() {
     }
   }
 
+  private fun setupConversationListSearch() {
+    TestUsers.setupSelf()
+
+    val recipientCount = 50
+    val messagesPerRecipient = 2000
+    val totalMessages = recipientCount * messagesPerRecipient
+    val generator = TestMessages.TimestampGenerator(System.currentTimeMillis() - (totalMessages * 2000L) - 60_000L)
+
+    TestUsers.setupTestRecipients(recipientCount).forEachIndexed { recipientIndex, recipientId ->
+      val recipient: Recipient = Recipient.resolved(recipientId)
+
+      for (i in 0 until messagesPerRecipient) {
+        val body = searchableMessageBody(recipientIndex, i)
+        if (i % 2 == 0) {
+          TestMessages.insertIncomingTextMessage(other = recipient, body = body, timestamp = generator.nextTimestamp())
+        } else {
+          TestMessages.insertOutgoingTextMessage(other = recipient, body = body, timestamp = generator.nextTimestamp())
+        }
+      }
+
+      SignalDatabase.messages.setAllMessagesRead()
+      SignalDatabase.threads.update(SignalDatabase.threads.getOrCreateThreadIdFor(recipient = recipient), true)
+    }
+  }
+
+  private fun searchableMessageBody(recipientIndex: Int, messageIndex: Int): String {
+    val words = SEARCH_VOCABULARY
+    val w1 = words[(recipientIndex + messageIndex) % words.size]
+    val w2 = words[(recipientIndex * 7 + messageIndex * 3) % words.size]
+    val w3 = words[(recipientIndex * 13 + messageIndex * 5) % words.size]
+    return "$w1 $w2 $SEARCH_KEYWORD $w3 message $messageIndex"
+  }
+
   private fun setupMessageSend() {
     TestUsers.setupSelf()
     TestUsers.setupTestClients(1)

app/src/benchmarkShared/java/org/signal/benchmark/setup/NoOpJob.kt

@@ -78,7 +78,6 @@ class NoOpJob(parameters: Parameters) : Job(parameters) {
       StoryOnboardingDownloadJob.KEY
     )
 
-    fun replaceFactories(factories: Map<String, Job.Factory<*>>): Map<String, Job.Factory<*>> =
-      factories.mapValues { if (it.key in STARTUP_NETWORK_JOB_KEYS) Factory() else it.value }
+    fun replaceFactories(factories: Map<String, Job.Factory<*>>): Map<String, Job.Factory<*>> = factories.mapValues { if (it.key in STARTUP_NETWORK_JOB_KEYS) Factory() else it.value }
   }
 }

app/src/benchmarkShared/java/org/signal/benchmark/setup/OtherClient.kt

@@ -241,5 +241,6 @@ class OtherClient(val serviceId: ServiceId, val e164: String, val identityKeyPai
     override fun deleteAllStaleOneTimeKyberPreKeys(threshold: Long, minCount: Int) = throw UnsupportedOperationException()
     override fun loadLastResortKyberPreKeys(): List<KyberPreKeyRecord> = throw UnsupportedOperationException()
     override fun isMultiDevice(): Boolean = throw UnsupportedOperationException()
+    override fun setMultiDevice(isMultiDevice: Boolean) = throw UnsupportedOperationException()
   }
 }

app/src/benchmarkShared/java/org/whispersystems/signalservice/internal/websocket/BenchmarkWebSocketConnection.kt

@@ -8,10 +8,10 @@ package org.whispersystems.signalservice.internal.websocket
 import io.reactivex.rxjava3.core.Observable
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.subjects.BehaviorSubject
+import org.signal.core.util.JsonUtils
 import org.signal.network.websocket.WebSocketRequestMessage
 import org.signal.network.websocket.WebSocketResponseMessage
 import org.signal.network.websocket.WebsocketResponse
-import org.signal.core.util.JsonUtils
 import org.thoughtcrime.securesms.util.SignalTrace
 import org.whispersystems.signalservice.api.websocket.WebSocketConnectionState
 import org.whispersystems.signalservice.internal.push.SendMessageResponse

app/src/main/AndroidManifest.xml

@@ -438,12 +438,7 @@
             android:theme="@style/Theme.Signal.DayNight.NoActionBar"
             android:windowSoftInputMode="adjustResize" />
 
-        <activity
-            android:name=".calls.links.details.CallLinkDetailsActivity"
-            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"
-            android:exported="false"
-            android:theme="@style/Theme.Signal.DayNight.NoActionBar"
-            android:windowSoftInputMode="stateAlwaysHidden" />
+
 
         <activity
             android:name=".calls.new.NewCallActivity"
@@ -527,6 +522,13 @@
             </intent-filter>
         </activity>
 
+        <activity
+            android:name=".preferences.EditProxyActivity"
+            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"
+            android:exported="false"
+            android:theme="@style/Signal.DayNight.NoActionBar"
+            android:windowSoftInputMode="adjustResize" />
+
         <activity
             android:name=".stories.my.MyStoriesActivity"
             android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"

app/src/main/java/org/thoughtcrime/securesms/AppCapabilities.kt

@@ -14,7 +14,7 @@ object AppCapabilities {
       versionedExpirationTimer = true,
       attachmentBackfill = true,
       spqr = true,
-      usernameChangeSyncMessage = false // TODO(michelle): Turn on once all clients support it and add a migration
+      usernameChangeSyncMessage = true
     )
   }
 }

app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java

@@ -39,6 +39,7 @@ import org.signal.core.util.MemoryTracker;
 import org.signal.core.util.Util;
 import org.signal.core.util.concurrent.AnrDetector;
 import org.signal.core.util.concurrent.SignalExecutors;
+import org.signal.core.util.crypto.AttachmentSecretProvider;
 import org.signal.core.util.logging.AndroidLogger;
 import org.signal.core.util.logging.Log;
 import org.signal.core.util.logging.Scrubber;
@@ -46,14 +47,16 @@ import org.signal.core.util.tracing.Tracer;
 import org.signal.glide.SignalGlideCodecs;
 import org.signal.libsignal.net.ChatServiceException;
 import org.signal.libsignal.protocol.logging.SignalProtocolLoggerProvider;
+import org.signal.registration.RegistrationDependencies;
 import org.signal.ringrtc.CallManager;
 import org.thoughtcrime.securesms.apkupdate.ApkUpdateRefreshListener;
 import org.thoughtcrime.securesms.avatar.AvatarPickerStorage;
 import org.thoughtcrime.securesms.backup.v2.BackupRepository;
-import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider;
+import org.thoughtcrime.securesms.preferences.EditProxyActivity;
+import org.thoughtcrime.securesms.conversation.drafts.DraftBlobs;
+import org.thoughtcrime.securesms.crypto.AppAttachmentSecretStore;
 import org.thoughtcrime.securesms.crypto.DatabaseSecretProvider;
 import org.thoughtcrime.securesms.database.LogDatabase;
-import org.thoughtcrime.securesms.database.SQLiteDatabase;
 import org.thoughtcrime.securesms.database.SignalDatabase;
 import org.thoughtcrime.securesms.database.SqlCipherLibraryLoader;
 import org.thoughtcrime.securesms.dependencies.AppDependencies;
@@ -98,10 +101,11 @@ import org.thoughtcrime.securesms.messageprocessingalarm.RoutineMessageFetchRece
 import org.thoughtcrime.securesms.messages.IncomingMessageObserver;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrations;
 import org.thoughtcrime.securesms.mms.SignalGlideModule;
-import org.thoughtcrime.securesms.providers.BlobProvider;
 import org.thoughtcrime.securesms.ratelimit.RateLimitUtil;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.registration.util.RegistrationUtil;
+import org.thoughtcrime.securesms.registration.v2.AppRegistrationNetworkController;
+import org.thoughtcrime.securesms.registration.v2.AppRegistrationStorageController;
 import org.thoughtcrime.securesms.ringrtc.RingRtcLogger;
 import org.thoughtcrime.securesms.service.AnalyzeDatabaseAlarmListener;
 import org.thoughtcrime.securesms.service.DirectoryRefreshListener;
@@ -114,14 +118,17 @@ import org.thoughtcrime.securesms.service.webrtc.ActiveCallManager;
 import org.thoughtcrime.securesms.service.webrtc.AndroidTelecomUtil;
 import org.thoughtcrime.securesms.storage.StorageSyncHelper;
 import org.thoughtcrime.securesms.util.AppStartup;
+import org.thoughtcrime.securesms.util.BatterySnapshotTracker;
+import org.thoughtcrime.securesms.util.CommunicationActions;
 import org.thoughtcrime.securesms.util.DeviceProperties;
 import org.thoughtcrime.securesms.util.DynamicTheme;
 import org.thoughtcrime.securesms.util.Environment;
-import org.thoughtcrime.securesms.util.PlayServicesUtil;
+import org.signal.core.util.PlayServicesUtil;
 import org.thoughtcrime.securesms.util.RemoteConfig;
 import org.thoughtcrime.securesms.util.SignalLocalMetrics;
 import org.thoughtcrime.securesms.util.SignalUncaughtExceptionHandler;
 import org.thoughtcrime.securesms.util.SqlCipherLogTarget;
+import org.thoughtcrime.securesms.util.SupportEmailUtil;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.thoughtcrime.securesms.util.VersionTracker;
 import org.thoughtcrime.securesms.util.dynamiclanguage.DynamicLanguageContextWrapper;
@@ -171,7 +178,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
                 SqlCipherLibraryLoader.load();
                 SignalDatabase.init(this,
                                     DatabaseSecretProvider.getOrCreateDatabaseSecret(this),
-                                    AttachmentSecretProvider.getInstance(this).getOrCreateAttachmentSecret());
+                                    AttachmentSecretProvider.getInstance(this, AppAttachmentSecretStore.INSTANCE).getOrCreateAttachmentSecret());
                 Logger.setTarget(SqlCipherLogTarget.INSTANCE);
               })
               .addBlocking("signal-store", () -> SignalStore.init(this))
@@ -179,9 +186,9 @@ public class ApplicationContext extends Application implements AppForegroundObse
                 initializeLogging();
                 Log.i(TAG, "onCreate()");
               })
+              .addBlocking("security-provider", this::initializeSecurityProvider)
               .addBlocking("app-dependencies", this::initializeAppDependencies)
               .addBlocking("anr-detector", this::startAnrDetector)
-              .addBlocking("security-provider", this::initializeSecurityProvider)
               .addBlocking("crash-handling", this::initializeCrashHandling)
               .addBlocking("rx-init", this::initializeRx)
               .addBlocking("event-bus", () -> EventBus.builder().logNoSubscriberMessages(false).installDefaultEventBus())
@@ -259,6 +266,8 @@ public class ApplicationContext extends Application implements AppForegroundObse
     long startTime = System.currentTimeMillis();
     Log.i(TAG, "App is now visible. Battery: " + DeviceProperties.getBatteryLevel(this) + "% (charging: " + DeviceProperties.isCharging(this) + ")");
 
+    BatterySnapshotTracker.emit(this, "foreground");
+
     AppDependencies.getFrameRateTracker().start();
     AppDependencies.getMegaphoneRepository().onAppForegrounded();
     AppDependencies.getDeadlockDetector().start();
@@ -299,6 +308,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
   @Override
   public void onBackground() {
     Log.i(TAG, "App is no longer visible.");
+    BatterySnapshotTracker.emit(this, "background");
     KeyCachingService.onAppBackgrounded(this);
     AppDependencies.getMessageNotifier().clearVisibleThread();
     AppDependencies.getFrameRateTracker().stop();
@@ -417,15 +427,24 @@ public class ApplicationContext extends Application implements AppForegroundObse
   }
 
   private void initializeRegistrationDependencies() {
-    org.signal.registration.RegistrationDependencies.Companion.provide(
-      new org.signal.registration.RegistrationDependencies(
-        new org.thoughtcrime.securesms.registration.v2.AppRegistrationNetworkController(this, AppDependencies.getPushServiceSocket()),
-        new org.thoughtcrime.securesms.registration.v2.AppRegistrationStorageController(this),
+    RegistrationDependencies.provide(
+      new RegistrationDependencies(
+        new AppRegistrationNetworkController(this, AppDependencies.getPushServiceSocket()),
+        new AppRegistrationStorageController(this),
         Environment.IS_LINK_AND_SYNC_AVAILABLE,
         null,
         context -> {
           context.startActivity(new Intent(context, SubmitDebugLogActivity.class));
           return Unit.INSTANCE;
+        },
+        context -> {
+          context.startActivity(EditProxyActivity.intent(context));
+          return Unit.INSTANCE;
+        },
+        (context, subject) -> {
+          String body = SupportEmailUtil.generateSupportEmailBody(context, subject, null, null);
+          CommunicationActions.openEmail(context, SupportEmailUtil.getSupportEmailAddress(context), subject, body);
+          return Unit.INSTANCE;
         }
       )
     );
@@ -571,7 +590,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
 
   @WorkerThread
   private void initializeBlobProvider() {
-    BlobProvider.getInstance().initialize(this);
+    AppDependencies.getBlobs().initialize(this, DraftBlobs.INSTANCE::deleteOrphanedDraftFiles);
   }
 
   @WorkerThread

app/src/main/java/org/thoughtcrime/securesms/BindableConversationListItem.java

@@ -1,12 +1,14 @@
 package org.thoughtcrime.securesms;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.lifecycle.LifecycleOwner;
 
 import com.bumptech.glide.RequestManager;
 
 import org.thoughtcrime.securesms.conversationlist.model.ConversationSet;
 import org.thoughtcrime.securesms.database.model.ThreadWithRecipient;
+import org.thoughtcrime.securesms.recipients.RecipientId;
 
 import java.util.Locale;
 import java.util.Set;
@@ -18,10 +20,10 @@ public interface BindableConversationListItem extends Unbindable {
             @NonNull RequestManager requestManager, @NonNull Locale locale,
             @NonNull Set<Long> typingThreads,
             @NonNull ConversationSet selectedConversations,
-            long activeThreadId);
+            @Nullable RecipientId activeRecipientId);
 
   void setSelectedConversations(@NonNull ConversationSet conversations);
-  void setActiveThreadId(long activeThreadId);
+  void setActiveRecipientId(@Nullable RecipientId activeRecipientId);
   void updateTypingIndicator(@NonNull Set<Long> typingThreads);
   void updateTimestamp();
 }

app/src/main/java/org/thoughtcrime/securesms/ContactSelectionListFragment.java

@@ -280,7 +280,7 @@ public final class ContactSelectionListFragment extends LoggingFragment {
             false,
             new ContactSelectionListAdapter.ArbitraryRepository(),
             new SearchRepository(requireContext().getString(R.string.note_to_self)),
-            new ContactSearchPagedDataSourceRepository(requireContext()),
+            new ContactSearchPagedDataSourceRepository(requireContext(), requireContext().getString(R.string.note_to_self)),
             fixedContacts,
             false
         )
@@ -600,7 +600,18 @@ public final class ContactSelectionListFragment extends LoggingFragment {
       boolean         isUnknown       = contact instanceof ContactSearchKey.UnknownRecipientKey;
       SelectedContact selectedContact = contact.requireSelectedContact();
 
-      if (!canSelectSelf && !selectedContact.hasUsername() && Recipient.self().getId().equals(selectedContact.getOrCreateRecipientId())) {
+      boolean needsSelfCheck = !canSelectSelf && !selectedContact.hasUsername();
+
+      if (needsSelfCheck) {
+        lifecycleDisposable.add(contactChipViewModel.isSelf(selectedContact)
+                                                    .subscribe(isSelf -> onItemClickResolved(contact, selectedContact, isUnknown, isSelf)));
+      } else {
+        onItemClickResolved(contact, selectedContact, isUnknown, false);
+      }
+    }
+
+    private void onItemClickResolved(ContactSearchKey contact, SelectedContact selectedContact, boolean isUnknown, boolean isSelf) {
+      if (isSelf) {
         Toast.makeText(requireContext(), R.string.ContactSelectionListFragment_you_do_not_need_to_add_yourself_to_the_group, Toast.LENGTH_SHORT).show();
         return;
       }

app/src/main/java/org/thoughtcrime/securesms/MainActivity.kt

@@ -5,17 +5,16 @@
 
 package org.thoughtcrime.securesms
 
-import android.Manifest
 import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
+import android.os.Build
 import android.os.Bundle
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
-import android.widget.Toast
 import androidx.activity.SystemBarStyle
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.setContent
@@ -25,6 +24,7 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.compose.foundation.background
 import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.BoxWithConstraintsScope
@@ -59,10 +59,13 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalResources
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
 import androidx.fragment.app.DialogFragment
 import androidx.fragment.compose.AndroidFragment
 import androidx.fragment.compose.rememberFragmentState
@@ -72,6 +75,11 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.createSavedStateHandle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
+import androidx.navigation3.runtime.NavKey
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
 import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import io.reactivex.rxjava3.subjects.PublishSubject
@@ -85,6 +93,7 @@ import kotlinx.coroutines.withContext
 import org.signal.core.ui.BottomSheetUtil
 import org.signal.core.ui.compose.Snackbars
 import org.signal.core.ui.compose.theme.SignalTheme
+import org.signal.core.ui.navigation.TransitionSpecs
 import org.signal.core.ui.permissions.Permissions
 import org.signal.core.ui.rememberIsSplitPane
 import org.signal.core.util.AppForegroundObserver
@@ -100,11 +109,14 @@ import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgressState
 import org.thoughtcrime.securesms.backup.v2.ui.CouldNotCompleteBackupRestoreSheet
 import org.thoughtcrime.securesms.backup.v2.ui.verify.VerifyBackupKeyActivity
 import org.thoughtcrime.securesms.calls.YouAreAlreadyInACallSnackbar.show
+import org.thoughtcrime.securesms.calls.callsNavEntries
 import org.thoughtcrime.securesms.calls.log.CallLogFilter
 import org.thoughtcrime.securesms.calls.log.CallLogFragment
 import org.thoughtcrime.securesms.calls.new.NewCallActivity
 import org.thoughtcrime.securesms.calls.quality.CallQuality
 import org.thoughtcrime.securesms.calls.quality.CallQualityBottomSheetFragment
+import org.thoughtcrime.securesms.chats.ConversationTransitionState
+import org.thoughtcrime.securesms.chats.chatsNavEntries
 import org.thoughtcrime.securesms.components.DebugLogsPromptDialogFragment
 import org.thoughtcrime.securesms.components.PromptBatterySaverDialogFragment
 import org.thoughtcrime.securesms.components.compose.ConnectivityWarningBottomSheet
@@ -134,8 +146,6 @@ import org.thoughtcrime.securesms.devicetransfer.olddevice.OldDeviceExitActivity
 import org.thoughtcrime.securesms.groups.ui.creategroup.CreateGroupActivity
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.lock.v2.CreateSvrPinActivity
-import org.thoughtcrime.securesms.main.ChatNavGraphState
-import org.thoughtcrime.securesms.main.DetailsScreenNavHost
 import org.thoughtcrime.securesms.main.MainBottomChrome
 import org.thoughtcrime.securesms.main.MainBottomChromeCallback
 import org.thoughtcrime.securesms.main.MainBottomChromeState
@@ -143,7 +153,6 @@ import org.thoughtcrime.securesms.main.MainContentLayoutData
 import org.thoughtcrime.securesms.main.MainMegaphoneState
 import org.thoughtcrime.securesms.main.MainNavigationBar
 import org.thoughtcrime.securesms.main.MainNavigationDetailLocation
-import org.thoughtcrime.securesms.main.MainNavigationDetailLocationEffect
 import org.thoughtcrime.securesms.main.MainNavigationListLocation
 import org.thoughtcrime.securesms.main.MainNavigationRail
 import org.thoughtcrime.securesms.main.MainNavigationRouter
@@ -156,13 +165,6 @@ import org.thoughtcrime.securesms.main.MainToolbarMode
 import org.thoughtcrime.securesms.main.MainToolbarState
 import org.thoughtcrime.securesms.main.MainToolbarViewModel
 import org.thoughtcrime.securesms.main.Material3OnScrollHelperBinder
-import org.thoughtcrime.securesms.main.callNavGraphBuilder
-import org.thoughtcrime.securesms.main.chatNavGraphBuilder
-import org.thoughtcrime.securesms.main.navigateToDetailLocation
-import org.thoughtcrime.securesms.main.rememberDetailNavHostController
-import org.thoughtcrime.securesms.main.rememberFocusRequester
-import org.thoughtcrime.securesms.main.storiesNavGraphBuilder
-import org.thoughtcrime.securesms.mediasend.camerax.CameraXRemoteConfig
 import org.thoughtcrime.securesms.mediasend.v2.MediaSelectionActivity
 import org.thoughtcrime.securesms.mediasend.v3.mediaSendLauncher
 import org.thoughtcrime.securesms.megaphone.Megaphone
@@ -177,14 +179,12 @@ import org.thoughtcrime.securesms.service.BackupMediaRestoreService
 import org.thoughtcrime.securesms.service.KeyCachingService
 import org.thoughtcrime.securesms.starred.StarredMessagesActivity
 import org.thoughtcrime.securesms.stories.Stories
-import org.thoughtcrime.securesms.stories.archive.StoryArchiveActivity
 import org.thoughtcrime.securesms.stories.landing.StoriesLandingFragment
-import org.thoughtcrime.securesms.stories.settings.StorySettingsActivity
+import org.thoughtcrime.securesms.stories.storiesNavEntries
 import org.thoughtcrime.securesms.util.AppStartup
 import org.thoughtcrime.securesms.util.CachedInflater
 import org.thoughtcrime.securesms.util.CommunicationActions
 import org.thoughtcrime.securesms.util.DynamicNoActionBarTheme
-import org.thoughtcrime.securesms.util.DynamicTheme
 import org.thoughtcrime.securesms.util.Material3OnScrollHelper
 import org.thoughtcrime.securesms.util.SplashScreenUtil
 import org.thoughtcrime.securesms.util.TopToastPopup
@@ -289,14 +289,6 @@ class MainActivity :
 
     AppStartup.getInstance().onCriticalRenderEventStart()
 
-    enableEdgeToEdge(
-      navigationBarStyle = if (DynamicTheme.isDarkTheme(this)) {
-        SystemBarStyle.dark(0)
-      } else {
-        SystemBarStyle.light(0, 0)
-      }
-    )
-
     super.onCreate(savedInstanceState, ready)
     navigator = MainNavigator(this, mainNavigationViewModel)
 
@@ -498,69 +490,21 @@ class MainActivity :
           }
         }
 
-        val chatNavGraphState = ChatNavGraphState.remember(isSplitPane)
+        val convoTransitionState = ConversationTransitionState.remember(isSplitPane)
         val mutableInteractionSource = remember { MutableInteractionSource() }
-        MainNavigationDetailLocationEffect(mainNavigationViewModel, chatNavGraphState::writeGraphicsLayerToBitmap)
 
-        val chatsNavHostController = rememberDetailNavHostController(
-          onRequestFocus = rememberFocusRequester(
-            mainNavigationViewModel = mainNavigationViewModel,
-            currentListLocation = mainNavigationState.currentListLocation,
-            isTargetListLocation = { it in listOf(MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE) }
-          )
-        ) {
-          chatNavGraphBuilder(chatNavGraphState)
+        LaunchedEffect(convoTransitionState) {
+          mainNavigationViewModel.setChatListSnapshotCaptureProvider { convoTransitionState.writeGraphicsLayerToBitmap() }
         }
 
-        val callsNavHostController = rememberDetailNavHostController(
-          onRequestFocus = rememberFocusRequester(
-            mainNavigationViewModel = mainNavigationViewModel,
-            currentListLocation = mainNavigationState.currentListLocation
-          ) { it == MainNavigationListLocation.CALLS }
-        ) {
-          callNavGraphBuilder(it)
-        }
-
-        val storiesNavHostController = rememberDetailNavHostController(
-          onRequestFocus = rememberFocusRequester(
-            mainNavigationViewModel = mainNavigationViewModel,
-            currentListLocation = mainNavigationState.currentListLocation
-          ) { it == MainNavigationListLocation.STORIES }
-        ) {
-          storiesNavGraphBuilder()
-        }
-
-        LaunchedEffect(Unit) {
-          suspend fun navigateToLocation(location: MainNavigationDetailLocation) {
-            when (location) {
-              is MainNavigationDetailLocation.Empty -> {
-                when (mainNavigationState.currentListLocation) {
-                  MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> chatsNavHostController
-                  MainNavigationListLocation.CALLS -> callsNavHostController
-                  MainNavigationListLocation.STORIES -> storiesNavHostController
-                }.navigateToDetailLocation(location)
-              }
-
-              is MainNavigationDetailLocation.Conversation -> {
-                chatNavGraphState.writeGraphicsLayerToBitmap()
-                chatsNavHostController.navigateToDetailLocation(location)
-              }
-
-              is MainNavigationDetailLocation.Chats -> chatsNavHostController.navigateToDetailLocation(location)
-              is MainNavigationDetailLocation.CallLinkDetails -> callsNavHostController.navigateToDetailLocation(location)
-              is MainNavigationDetailLocation.Calls -> callsNavHostController.navigateToDetailLocation(location)
-              is MainNavigationDetailLocation.Stories -> storiesNavHostController.navigateToDetailLocation(location)
-            }
-          }
-
-          mainNavigationViewModel.earlyNavigationDetailLocationRequested?.let { navigateToLocation(it) }
-          mainNavigationViewModel.clearEarlyDetailLocation()
-
-          mainNavigationViewModel.detailLocation.collect { navigateToLocation(it) }
+        LaunchedEffect(isSplitPane) {
+          mainNavigationViewModel.onSplitPaneChanged(isSplitPane)
         }
 
         val scope = rememberCoroutineScope()
+
         BackHandler(paneExpansionState.currentAnchor == detailOnlyAnchor) {
+          mainNavigationViewModel.goTo(MainNavigationDetailLocation.Empty)
           scope.launch {
             paneExpansionState.animateTo(listOnlyAnchor)
           }
@@ -619,7 +563,7 @@ class MainActivity :
 
         AppScaffold(
           navigator = wrappedNavigator,
-          modifier = chatNavGraphState.writeContentToGraphicsLayer(),
+          modifier = convoTransitionState.writeContentToGraphicsLayer(),
           paneExpansionState = paneExpansionState,
           contentWindowInsets = WindowInsets(),
           snackbarHost = {
@@ -730,23 +674,43 @@ class MainActivity :
           primaryContent = {
             when (mainNavigationState.currentListLocation) {
               MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> {
-                DetailsScreenNavHost(
-                  navHostController = chatsNavHostController,
-                  contentLayoutData = contentLayoutData
+                NavDisplay<NavKey>(
+                  backStack = mainNavigationViewModel.chatsBackStackEntries,
+                  onBack = { mainNavigationViewModel.popChatsDetailLocation() },
+                  transitionSpec = { TransitionSpecs.HorizontalSlide.transitionSpec },
+                  popTransitionSpec = { TransitionSpecs.HorizontalSlide.popTransitionSpec },
+                  predictivePopTransitionSpec = { TransitionSpecs.HorizontalSlide.predictivePopTransitionSpec },
+                  entryProvider = entryProvider { chatsNavEntries(convoTransitionState) }
                 )
               }
 
               MainNavigationListLocation.CALLS -> {
-                DetailsScreenNavHost(
-                  navHostController = callsNavHostController,
-                  contentLayoutData = contentLayoutData
+                NavDisplay<NavKey>(
+                  backStack = mainNavigationViewModel.callsBackStackEntries,
+                  onBack = { mainNavigationViewModel.popCallsDetailLocation() },
+                  transitionSpec = { TransitionSpecs.HorizontalSlide.transitionSpec },
+                  popTransitionSpec = { TransitionSpecs.HorizontalSlide.popTransitionSpec },
+                  predictivePopTransitionSpec = { TransitionSpecs.HorizontalSlide.predictivePopTransitionSpec },
+                  entryDecorators = listOf(
+                    rememberSaveableStateHolderNavEntryDecorator(),
+                    rememberViewModelStoreNavEntryDecorator()
+                  ),
+                  entryProvider = entryProvider { callsNavEntries(isSplitPane) }
                 )
               }
 
               MainNavigationListLocation.STORIES -> {
-                DetailsScreenNavHost(
-                  navHostController = storiesNavHostController,
-                  contentLayoutData = contentLayoutData
+                NavDisplay<NavKey>(
+                  backStack = mainNavigationViewModel.storiesBackStackEntries,
+                  onBack = { mainNavigationViewModel.popStoriesDetailLocation() },
+                  transitionSpec = { TransitionSpecs.HorizontalSlide.transitionSpec },
+                  popTransitionSpec = { TransitionSpecs.HorizontalSlide.popTransitionSpec },
+                  predictivePopTransitionSpec = { TransitionSpecs.HorizontalSlide.predictivePopTransitionSpec },
+                  entryDecorators = listOf(
+                    rememberSaveableStateHolderNavEntryDecorator(),
+                    rememberViewModelStoreNavEntryDecorator()
+                  ),
+                  entryProvider = entryProvider { storiesNavEntries() }
                 )
               }
             }
@@ -761,7 +725,7 @@ class MainActivity :
           } else {
             null
           },
-          animatorFactory = if (mainNavigationState.currentListLocation == MainNavigationListLocation.CHATS || mainNavigationState.currentListLocation == MainNavigationListLocation.ARCHIVE) {
+          animatorFactory = if (mainNavigationState.currentListLocation.isChatsTab) {
             noEnterTransitionFactory
           } else {
             AppScaffoldAnimationStateFactory.Default
@@ -829,6 +793,23 @@ class MainActivity :
           SignalTheme.colors.colorSurface1
         }
 
+        val context = LocalContext.current
+        val isDarkTheme = isSystemInDarkTheme()
+        val navBarColor = if (isSplitPane) backgroundColor.toArgb() else ContextCompat.getColor(context, CoreUiR.color.signal_colorSurface2)
+        LaunchedEffect(isDarkTheme, navBarColor) {
+          if (Build.VERSION.SDK_INT >= 26) {
+            enableEdgeToEdge(
+              navigationBarStyle = if (isDarkTheme) {
+                SystemBarStyle.dark(navBarColor)
+              } else {
+                SystemBarStyle.light(navBarColor, navBarColor)
+              }
+            )
+          } else {
+            enableEdgeToEdge()
+          }
+        }
+
         val modifier = when {
           isSplitPane -> {
             Modifier
@@ -1059,8 +1040,16 @@ class MainActivity :
         return
       }
 
+      val extras = intent.extras
+      if (extras == null) {
+        Log.w(TAG, "Received a conversation intent with no extras. Ignoring it.")
+        intent.action = null
+        setIntent(intent)
+        return
+      }
+
       mainNavigationViewModel.goTo(MainNavigationListLocation.CHATS)
-      mainNavigationViewModel.goTo(MainNavigationDetailLocation.Conversation(ConversationIntents.readArgsFromBundle(intent.extras!!)))
+      mainNavigationViewModel.goTo(MainNavigationDetailLocation.Conversation(ConversationIntents.readArgsFromBundle(extras)))
       intent.action = null
       setIntent(intent)
     }
@@ -1161,7 +1150,7 @@ class MainActivity :
       } else if (SignalStore.internal.useNewMediaActivity) {
         mediaSendLauncher.launch(
           MediaSendActivityContract.Args(
-            isCameraFirst = false,
+            isCameraFirst = true,
             isStory = destination == MainNavigationListLocation.STORIES
           )
         )
@@ -1175,24 +1164,7 @@ class MainActivity :
       }
     }
 
-    if (CameraXRemoteConfig.isSupported()) {
-      onGranted()
-    } else {
-      Permissions.with(this@MainActivity)
-        .request(Manifest.permission.CAMERA)
-        .ifNecessary()
-        .withRationaleDialog(getString(R.string.CameraXFragment_allow_access_camera), getString(R.string.CameraXFragment_to_capture_photos_and_video_allow_camera), CoreUiR.drawable.symbol_camera_24)
-        .withPermanentDenialDialog(
-          getString(R.string.CameraXFragment_signal_needs_camera_access_capture_photos),
-          null,
-          R.string.CameraXFragment_allow_access_camera,
-          R.string.CameraXFragment_to_capture_photos_videos,
-          supportFragmentManager
-        )
-        .onAllGranted(onGranted)
-        .onAnyDenied { Toast.makeText(this@MainActivity, R.string.CameraXFragment_signal_needs_camera_access_capture_photos, Toast.LENGTH_LONG).show() }
-        .execute()
-    }
+    onGranted()
   }
 
   inner class ToolbarCallback : MainToolbarCallback {
@@ -1256,11 +1228,11 @@ class MainActivity :
     }
 
     override fun onStoryPrivacyClick() {
-      startActivity(StorySettingsActivity.getIntent(this@MainActivity))
+      mainNavigationViewModel.goTo(MainNavigationDetailLocation.Stories.PrivacySettings)
     }
 
     override fun onStoryArchiveClick() {
-      startActivity(StoryArchiveActivity.createIntent(this@MainActivity))
+      mainNavigationViewModel.goTo(MainNavigationDetailLocation.Stories.Archive)
     }
 
     override fun onCloseSearchClick() {

app/src/main/java/org/thoughtcrime/securesms/PassphraseRequiredActivity.java

@@ -13,9 +13,11 @@ import androidx.core.content.ContextCompat;
 import androidx.fragment.app.Fragment;
 
 import org.greenrobot.eventbus.EventBus;
+import org.signal.core.util.AppForegroundObserver;
 import org.signal.core.util.logging.Log;
 import org.signal.core.util.tracing.Tracer;
 import org.signal.devicetransfer.TransferStatus;
+import org.signal.registration.RegistrationRoute;
 import org.thoughtcrime.securesms.components.settings.app.changenumber.ChangeNumberLockActivity;
 import org.thoughtcrime.securesms.crypto.MasterSecretUtil;
 import org.thoughtcrime.securesms.dependencies.AppDependencies;
@@ -30,11 +32,10 @@ import org.thoughtcrime.securesms.profiles.edit.CreateProfileActivity;
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.registration.ui.RegistrationActivity;
-import org.thoughtcrime.securesms.util.Environment;
 import org.thoughtcrime.securesms.restore.RestoreActivity;
 import org.thoughtcrime.securesms.service.KeyCachingService;
-import org.signal.core.util.AppForegroundObserver;
 import org.thoughtcrime.securesms.util.AppStartup;
+import org.thoughtcrime.securesms.util.Environment;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 
 import java.util.Locale;
@@ -57,6 +58,7 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
   private static final int STATE_TRANSFER_LOCKED     = 9;
   private static final int STATE_CHANGE_NUMBER_LOCK  = 10;
   private static final int STATE_TRANSFER_OR_RESTORE = 11;
+  private static final int STATE_RESUME_LINKING_REG  = 12;
 
   private SignalServiceNetworkAccess networkAccess;
   private BroadcastReceiver          clearKeyReceiver;
@@ -135,12 +137,8 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
     Intent    intent           = getIntentForState(applicationState);
     if (intent != null) {
       Log.d(TAG, "routeApplicationState(), intent: " + intent.getComponent());
-      if (applicationState == STATE_WELCOME_PUSH_SCREEN && Environment.USE_NEW_REGISTRATION) {
-        startActivity(intent);
-      } else {
         startActivity(intent);
         finish();
-      }
     }
   }
 
@@ -159,6 +157,7 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
       case STATE_TRANSFER_LOCKED:     return getOldDeviceTransferLockedIntent();
       case STATE_CHANGE_NUMBER_LOCK:  return getChangeNumberLockIntent();
       case STATE_TRANSFER_OR_RESTORE: return getTransferOrRestoreIntent();
+      case STATE_RESUME_LINKING_REG:  return getResumeLinkedRegistrationIntent();
       default:                        return null;
     }
   }
@@ -172,6 +171,8 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
       return STATE_UI_BLOCKING_UPGRADE;
     } else if (!TextSecurePreferences.hasPromptedPushRegistration(this)) {
       return STATE_WELCOME_PUSH_SCREEN;
+    } else if (shouldResumeLinkingRegistration()) {
+      return STATE_RESUME_LINKING_REG;
     } else if (userCanTransferOrRestore()) {
       return STATE_TRANSFER_OR_RESTORE;
     } else if (SignalStore.storageService().getNeedsAccountRestore()) {
@@ -196,6 +197,14 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
            RestoreDecisionStateUtil.isDecisionPending(SignalStore.registration().getRestoreDecisionState());
   }
 
+  private boolean shouldResumeLinkingRegistration() {
+    return Environment.USE_NEW_REGISTRATION &&
+           SignalStore.account().isRegistered() &&
+           !SignalStore.account().isPrimaryDevice() &&
+           !SignalStore.registration().isRegistrationComplete() &&
+           RestoreDecisionStateUtil.isDecisionPending(SignalStore.registration().getRestoreDecisionState());
+  }
+
   private boolean userMustCreateSignalPin() {
     return !SignalStore.registration().isRegistrationComplete() &&
            !SignalStore.svr().hasPin() &&
@@ -226,11 +235,7 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
   }
 
   private Intent getPushRegistrationIntent() {
-    if (Environment.USE_NEW_REGISTRATION) {
-      return org.signal.registration.RegistrationActivity.createIntent(this);
-    } else {
-      return RegistrationActivity.newIntentForNewRegistration(this, getIntent());
-    }
+    return RegistrationActivity.newIntentForNewRegistration(this, getIntent());
   }
 
   private Intent getEnterSignalPinIntent() {
@@ -250,10 +255,17 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
   }
 
   private Intent getTransferOrRestoreIntent() {
+    if (Environment.USE_NEW_REGISTRATION) {
+      return org.signal.registration.RegistrationActivity.createIntent(this, MainActivity.clearTop(this));
+    }
     Intent intent = RestoreActivity.getRestoreIntent(this);
     return getRoutedIntent(intent, MainActivity.clearTop(this));
   }
 
+  private Intent getResumeLinkedRegistrationIntent() {
+    return org.signal.registration.RegistrationActivity.createIntent(this, MainActivity.clearTop(this), RegistrationRoute.MessageSync.INSTANCE);
+  }
+
   private Intent getCreateProfileNameIntent() {
     Intent intent = CreateProfileActivity.getIntentForUserProfile(this);
     return getRoutedIntent(intent, getIntent());

app/src/main/java/org/thoughtcrime/securesms/SystemContactsEntrypointActivity.java

@@ -1,107 +1,27 @@
 package org.thoughtcrime.securesms;
 
-import android.app.Activity;
-import android.content.Intent;
-import android.database.Cursor;
 import android.os.Bundle;
-import android.provider.ContactsContract;
-import android.text.TextUtils;
 import android.widget.Toast;
 
-import androidx.annotation.NonNull;
+import androidx.activity.ComponentActivity;
+import androidx.lifecycle.ViewModelProvider;
 
-import org.signal.core.util.logging.Log;
-import org.thoughtcrime.securesms.conversation.ConversationIntents;
-import org.thoughtcrime.securesms.conversation.NewConversationActivity;
-import org.thoughtcrime.securesms.database.SignalDatabase;
-import org.thoughtcrime.securesms.recipients.Recipient;
-import org.thoughtcrime.securesms.util.Rfc5724Uri;
-
-import java.net.URISyntaxException;
-
-public class SystemContactsEntrypointActivity extends Activity {
-
-  private static final String TAG = Log.tag(SystemContactsEntrypointActivity.class);
+public class SystemContactsEntrypointActivity extends ComponentActivity {
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
-    startActivity(getNextIntent(getIntent()));
-    finish();
     super.onCreate(savedInstanceState);
-  }
 
-  private Intent getNextIntent(Intent original) {
-    DestinationAndBody destination;
+    SystemContactsEntrypointViewModel viewModel = new ViewModelProvider(this).get(SystemContactsEntrypointViewModel.class);
 
-    if (original.getData() != null && "content".equals(original.getData().getScheme())) {
-      destination = getDestinationForSyncAdapter(original);
-    } else {
-      destination = getDestinationForView(original);
-    }
-
-    final Intent nextIntent;
-
-    if (TextUtils.isEmpty(destination.destination)) {
-      nextIntent = NewConversationActivity.createIntent(this, destination.getBody());
-      Toast.makeText(this, R.string.ConversationActivity_specify_recipient, Toast.LENGTH_LONG).show();
-    } else {
-      Recipient recipient = Recipient.external(destination.getDestination());
-
-      if (recipient != null) {
-        long threadId = SignalDatabase.threads().getOrCreateThreadIdFor(recipient);
-
-        nextIntent = ConversationIntents.createBuilderSync(this, recipient.getId(), threadId)
-                                        .withDraftText(destination.getBody())
-                                        .build();
-      } else {
-        nextIntent = NewConversationActivity.createIntent(this, destination.getBody());
+    viewModel.getContactAction().observe(this, nextStep -> {
+      if (nextStep.getShowSpecifyRecipientToast()) {
         Toast.makeText(this, R.string.ConversationActivity_specify_recipient, Toast.LENGTH_LONG).show();
       }
-    }
-    return nextIntent;
-  }
+      startActivity(nextStep.getIntent());
+      finish();
+    });
 
-  private @NonNull DestinationAndBody getDestinationForView(Intent intent) {
-    try {
-      Rfc5724Uri smsUri = new Rfc5724Uri(intent.getData().toString());
-      return new DestinationAndBody(smsUri.getPath(), smsUri.getQueryParams().get("body"));
-    } catch (URISyntaxException e) {
-      Log.w(TAG, "unable to parse RFC5724 URI from intent", e);
-      return new DestinationAndBody("", "");
-    }
-  }
-
-  private @NonNull DestinationAndBody getDestinationForSyncAdapter(Intent intent) {
-    Cursor cursor = null;
-
-    try {
-      cursor = getContentResolver().query(intent.getData(), null, null, null, null);
-
-      if (cursor != null && cursor.moveToNext()) {
-        return new DestinationAndBody(cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.RawContacts.Data.DATA1)), "");
-      }
-
-      return new DestinationAndBody("", "");
-    } finally {
-      if (cursor != null) cursor.close();
-    }
-  }
-
-  private static class DestinationAndBody {
-    private final String destination;
-    private final String body;
-
-    private DestinationAndBody(String destination, String body) {
-      this.destination = destination;
-      this.body = body;
-    }
-
-    public String getDestination() {
-      return destination;
-    }
-
-    public String getBody() {
-      return body;
-    }
+    viewModel.resolveNextStep(getIntent());
   }
 }

app/src/main/java/org/thoughtcrime/securesms/SystemContactsEntrypointViewModel.kt

@@ -0,0 +1,106 @@
+package org.thoughtcrime.securesms
+
+import android.content.Context
+import android.content.Intent
+import android.provider.ContactsContract
+import android.text.TextUtils
+import androidx.annotation.WorkerThread
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.conversation.NewConversationActivity
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.util.Rfc5724Uri
+import java.net.URISyntaxException
+
+class SystemContactsEntrypointViewModel : ViewModel() {
+
+  companion object {
+    private val TAG = Log.tag(SystemContactsEntrypointViewModel::class.java)
+  }
+
+  private val internalContactAction = MutableLiveData<ContactAction>()
+  val contactAction: LiveData<ContactAction> = internalContactAction
+
+  fun resolveNextStep(original: Intent) {
+    viewModelScope.launch {
+      val result = withContext(Dispatchers.IO) {
+        getContactAction(AppDependencies.application, original)
+      }
+
+      internalContactAction.value = result
+    }
+  }
+
+  @WorkerThread
+  private fun getContactAction(context: Context, original: Intent): ContactAction {
+    val destination = if (original.data != null && "content" == original.data?.scheme) {
+      getDestinationForSyncAdapter(context, original)
+    } else {
+      getDestinationForView(original)
+    }
+
+    val destinationAddress = destination.destination
+    if (TextUtils.isEmpty(destinationAddress)) {
+      return ContactAction(NewConversationActivity.createIntent(context, destination.body), true)
+    }
+
+    val recipient = Recipient.external(destinationAddress!!)
+
+    if (recipient != null) {
+      val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(recipient)
+
+      val nextIntent = ConversationIntents.createBuilderSync(context, recipient.id, threadId)
+        .withDraftText(destination.body)
+        .build()
+
+      return ContactAction(nextIntent, false)
+    }
+
+    return ContactAction(NewConversationActivity.createIntent(context, destination.body), true)
+  }
+
+  private fun getDestinationForView(intent: Intent): DestinationAndBody {
+    return try {
+      val smsUri = Rfc5724Uri(intent.data.toString())
+      DestinationAndBody(smsUri.path, smsUri.queryParams["body"])
+    } catch (e: URISyntaxException) {
+      Log.w(TAG, "unable to parse RFC5724 URI from intent", e)
+      DestinationAndBody("", "")
+    }
+  }
+
+  private fun getDestinationForSyncAdapter(context: Context, intent: Intent): DestinationAndBody {
+    val uri = intent.data
+    if (uri == null || uri.authority != ContactsContract.AUTHORITY) {
+      Log.w(TAG, "Ignoring content URI with an unexpected authority.")
+      return DestinationAndBody("", "")
+    }
+
+    context.contentResolver.query(uri, null, null, null, null).use { cursor ->
+      if (cursor != null && cursor.moveToNext()) {
+        return DestinationAndBody(cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.RawContacts.Data.DATA1)), "")
+      }
+
+      return DestinationAndBody("", "")
+    }
+  }
+
+  data class ContactAction(
+    val intent: Intent,
+    val showSpecifyRecipientToast: Boolean
+  )
+
+  private data class DestinationAndBody(
+    val destination: String?,
+    val body: String?
+  )
+}

app/src/main/java/org/thoughtcrime/securesms/attachments/DatabaseAttachment.kt

@@ -4,6 +4,7 @@ import android.net.Uri
 import android.os.Parcel
 import androidx.core.os.ParcelCompat
 import org.signal.blurhash.BlurHash
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.models.media.TransformProperties
 import org.signal.core.util.ParcelUtil
 import org.thoughtcrime.securesms.audio.AudioHash

app/src/main/java/org/thoughtcrime/securesms/audio/AudioRecorder.java

@@ -11,10 +11,11 @@ import androidx.annotation.Nullable;
 
 import org.signal.core.util.ThreadUtil;
 import org.signal.core.util.concurrent.SignalExecutors;
+import org.signal.core.util.contentproviders.BlobProvider;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.components.voice.VoiceNoteDraft;
+import org.thoughtcrime.securesms.dependencies.AppDependencies;
 import org.thoughtcrime.securesms.notifications.v2.InChatNotificationSoundSuppressor;
-import org.thoughtcrime.securesms.providers.BlobProvider;
 import org.thoughtcrime.securesms.util.MediaUtil;
 
 import java.io.IOException;
@@ -88,9 +89,9 @@ public class AudioRecorder {
 
         ParcelFileDescriptor fds[] = ParcelFileDescriptor.createPipe();
 
-        BlobProvider.BlobBuilder blobBuilder = BlobProvider.getInstance()
-                                                           .forData(new ParcelFileDescriptor.AutoCloseInputStream(fds[0]), 0)
-                                                           .withMimeType(MediaUtil.AUDIO_AAC);
+        BlobProvider.BlobBuilder blobBuilder = AppDependencies.getBlobs()
+                                                              .forData(new ParcelFileDescriptor.AutoCloseInputStream(fds[0]), 0)
+                                                              .withMimeType(MediaUtil.AUDIO_AAC);
 
         recordingUri       = blobBuilder.buildUriForDraftAttachment();
         recordingUriFuture = blobBuilder.createForDraftAttachmentAsync(context);

app/src/main/java/org/thoughtcrime/securesms/audio/AudioWaveFormGenerator.java

@@ -33,7 +33,7 @@ public final class AudioWaveFormGenerator {
    */
   @WorkerThread
   public static @NonNull AudioFileInfo generateWaveForm(@NonNull Context context, @NonNull Uri uri) throws IOException {
-    try (MediaInput dataSource = DecryptableUriMediaInput.createForUri(context, uri)) {
+    try (MediaInput dataSource = DecryptableUriMediaInput.INSTANCE.createForUri(context, uri)) {
       long[] wave        = new long[BAR_COUNT];
       int[]  waveSamples = new int[BAR_COUNT];
 

app/src/main/java/org/thoughtcrime/securesms/audio/AudioWaveForms.kt

@@ -7,9 +7,9 @@ import androidx.annotation.AnyThread
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
 import io.reactivex.rxjava3.subjects.SingleSubject
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.attachments.Attachment
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.model.databaseprotos.AudioWaveFormData

app/src/main/java/org/thoughtcrime/securesms/avatar/AvatarRenderer.kt

@@ -11,9 +11,9 @@ import androidx.appcompat.content.res.AppCompatResources
 import com.airbnb.lottie.SimpleColorFilter
 import org.signal.core.models.media.Media
 import org.signal.core.util.concurrent.SignalExecutors
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.mms.PartAuthority
 import org.thoughtcrime.securesms.profiles.AvatarHelper
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.util.MediaUtil
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
@@ -80,7 +80,7 @@ object AvatarRenderer {
 
   private fun renderPhoto(context: Context, avatar: Avatar.Photo, onAvatarRendered: (Media) -> Unit) {
     SignalExecutors.BOUNDED.execute {
-      val blob = BlobProvider.getInstance()
+      val blob = AppDependencies.blobs
         .forData(AvatarPickerStorage.read(context, PartAuthority.getAvatarPickerFilename(avatar.uri)), avatar.size)
         .createForSingleSessionOnDisk(context)
 
@@ -124,7 +124,7 @@ object AvatarRenderer {
 
       val bytes = outStream.toByteArray()
       val inStream = ByteArrayInputStream(bytes)
-      val uri = BlobProvider.getInstance().forData(inStream, bytes.size.toLong()).createForSingleSessionOnDisk(context)
+      val uri = AppDependencies.blobs.forData(inStream, bytes.size.toLong()).createForSingleSessionOnDisk(context)
 
       onAvatarRendered(createMedia(uri, bytes.size.toLong()))
     }

app/src/main/java/org/thoughtcrime/securesms/avatar/photo/PhotoEditorFragment.kt

@@ -11,7 +11,7 @@ import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.avatar.AvatarBundler
 import org.thoughtcrime.securesms.avatar.AvatarPickerStorage
 import org.thoughtcrime.securesms.database.SignalDatabase
-import org.thoughtcrime.securesms.providers.BlobProvider
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.scribbles.ImageEditorFragment
 
 class PhotoEditorFragment : Fragment(R.layout.avatar_photo_editor_fragment), ImageEditorFragment.Controller {
@@ -39,15 +39,15 @@ class PhotoEditorFragment : Fragment(R.layout.avatar_photo_editor_fragment), Ima
 
     SignalExecutors.BOUNDED.execute {
       val editedImageUri = imageEditorFragment.renderToSingleUseBlob()
-      val size = BlobProvider.getFileSize(editedImageUri) ?: 0
-      val inputStream = BlobProvider.getInstance().getStream(applicationContext, editedImageUri)
+      val size = AppDependencies.blobs.getFileSize(editedImageUri) ?: 0
+      val inputStream = AppDependencies.blobs.getStream(applicationContext, editedImageUri)
       val onDiskUri = AvatarPickerStorage.save(applicationContext, inputStream)
       val photo = AvatarBundler.extractPhoto(args.photoAvatar)
       val database = SignalDatabase.avatarPicker
       val newPhoto = photo.copy(uri = onDiskUri, size = size)
 
       database.update(newPhoto)
-      BlobProvider.getInstance().delete(requireContext(), photo.uri)
+      AppDependencies.blobs.delete(requireContext(), photo.uri)
 
       ThreadUtil.runOnMain {
         setFragmentResult(REQUEST_KEY_EDIT, AvatarBundler.bundlePhoto(newPhoto))

app/src/main/java/org/thoughtcrime/securesms/avatar/picker/AvatarPickerFragment.kt

@@ -1,13 +1,11 @@
 package org.thoughtcrime.securesms.avatar.picker
 
-import android.Manifest
 import android.app.Activity
 import android.content.Intent
 import android.os.Bundle
 import android.view.Gravity
 import android.view.View
 import android.widget.PopupMenu
-import android.widget.Toast
 import androidx.activity.result.ActivityResultLauncher
 import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.Fragment
@@ -30,12 +28,10 @@ import org.thoughtcrime.securesms.avatar.vector.VectorAvatarCreationFragment
 import org.thoughtcrime.securesms.components.ButtonStripItemView
 import org.thoughtcrime.securesms.components.recyclerview.GridDividerDecoration
 import org.thoughtcrime.securesms.mediasend.AvatarSelectionActivity
-import org.thoughtcrime.securesms.mediasend.camerax.CameraXRemoteConfig
 import org.thoughtcrime.securesms.util.ViewUtil
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
 import org.thoughtcrime.securesms.util.visible
-import org.signal.core.ui.R as CoreUiR
 
 /**
  * Primary Avatar picker fragment, displays current user avatar and a list of recently used avatars and defaults.
@@ -223,22 +219,8 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
 
   @Suppress("DEPRECATION")
   private fun openCameraCapture() {
-    if (CameraXRemoteConfig.isSupported()) {
-      val intent = AvatarSelectionActivity.getIntentForCameraCapture(requireContext())
-      startActivityForResult(intent, REQUEST_CODE_SELECT_IMAGE)
-    } else {
-      Permissions.with(this)
-        .request(Manifest.permission.CAMERA)
-        .ifNecessary()
-        .onAllGranted {
-          val intent = AvatarSelectionActivity.getIntentForCameraCapture(requireContext())
-          startActivityForResult(intent, REQUEST_CODE_SELECT_IMAGE)
-        }
-        .withRationaleDialog(getString(R.string.CameraXFragment_allow_access_camera), getString(R.string.CameraXFragment_to_capture_photos_allow_camera), CoreUiR.drawable.symbol_camera_24)
-        .withPermanentDenialDialog(getString(R.string.AvatarSelectionBottomSheetDialogFragment__taking_a_photo_requires_the_camera_permission), null, R.string.CameraXFragment_allow_access_camera, R.string.CameraXFragment_to_capture_photos, getParentFragmentManager())
-        .onAnyDenied { Toast.makeText(requireContext(), R.string.AvatarSelectionBottomSheetDialogFragment__taking_a_photo_requires_the_camera_permission, Toast.LENGTH_SHORT).show() }
-        .execute()
-    }
+    val intent = AvatarSelectionActivity.getIntentForCameraCapture(requireContext())
+    startActivityForResult(intent, REQUEST_CODE_SELECT_IMAGE)
   }
 
   @Suppress("DEPRECATION")

app/src/main/java/org/thoughtcrime/securesms/avatar/picker/AvatarPickerRepository.kt

@@ -16,9 +16,9 @@ import org.thoughtcrime.securesms.avatar.AvatarRenderer
 import org.thoughtcrime.securesms.avatar.Avatars
 import org.thoughtcrime.securesms.conversation.colors.AvatarColor
 import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.groups.GroupId
 import org.thoughtcrime.securesms.profiles.AvatarHelper
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.NameUtil
 import org.whispersystems.signalservice.api.util.StreamDetails
@@ -36,7 +36,7 @@ class AvatarPickerRepository(context: Context) {
       try {
         val bytes = StreamUtil.readFully(details.stream)
         Avatar.Photo(
-          BlobProvider.getInstance().forData(bytes).createForSingleSessionInMemory(),
+          AppDependencies.blobs.forData(bytes).createForSingleSessionInMemory(),
           details.length,
           Avatar.DatabaseId.DoNotPersist
         )
@@ -56,7 +56,7 @@ class AvatarPickerRepository(context: Context) {
       try {
         val bytes = AvatarHelper.getAvatarBytes(applicationContext, recipient.id)
         Avatar.Photo(
-          BlobProvider.getInstance().forData(bytes).createForSingleSessionInMemory(),
+          AppDependencies.blobs.forData(bytes).createForSingleSessionInMemory(),
           AvatarHelper.getAvatarLength(applicationContext, recipient.id),
           Avatar.DatabaseId.DoNotPersist
         )

app/src/main/java/org/thoughtcrime/securesms/backup/ArchiveUploadProgress.kt

@@ -19,11 +19,11 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.withContext
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.bytes
 import org.signal.core.util.logging.Log
 import org.signal.core.util.throttleLatest
 import org.thoughtcrime.securesms.BuildConfig
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.dependencies.AppDependencies
@@ -50,7 +50,7 @@ object ArchiveUploadProgress {
 
   private val TAG = Log.tag(ArchiveUploadProgress::class)
 
-  private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+  private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
 
   private val _progress: MutableSharedFlow<Unit> = MutableSharedFlow(replay = 1)
 
@@ -119,7 +119,7 @@ object ArchiveUploadProgress {
       updateState(notify = false) { updated }
     }
     .onStart { emit(uploadProgress) }
-    .flowOn(Dispatchers.IO)
+    .flowOn(Dispatchers.Default)
     .shareIn(scope, SharingStarted.Eagerly, replay = 1)
 
   init {

app/src/main/java/org/thoughtcrime/securesms/backup/BackupFrameOutputStream.java

@@ -11,7 +11,7 @@ import org.signal.core.util.Conversions;
 import org.signal.core.util.logging.Log;
 import org.signal.libsignal.protocol.kdf.HKDF;
 import org.signal.libsignal.protocol.util.ByteUtil;
-import org.thoughtcrime.securesms.attachments.AttachmentId;
+import org.signal.core.models.database.AttachmentId;
 import org.thoughtcrime.securesms.backup.proto.Attachment;
 import org.thoughtcrime.securesms.backup.proto.Avatar;
 import org.thoughtcrime.securesms.backup.proto.BackupFrame;

app/src/main/java/org/thoughtcrime/securesms/backup/BackupPassphrase.java

@@ -6,7 +6,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import org.signal.core.util.logging.Log;
-import org.thoughtcrime.securesms.crypto.KeyStoreHelper;
+import org.signal.core.util.crypto.KeyStoreHelper;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 
 /**

app/src/main/java/org/thoughtcrime/securesms/backup/FullBackupExporter.java

@@ -19,13 +19,13 @@ import org.signal.core.util.SetUtil;
 import org.signal.core.util.SqlUtil;
 import org.signal.core.util.Stopwatch;
 import org.signal.core.util.logging.Log;
-import org.thoughtcrime.securesms.attachments.AttachmentId;
+import org.signal.core.models.database.AttachmentId;
 import org.thoughtcrime.securesms.backup.proto.KeyValue;
 import org.thoughtcrime.securesms.backup.proto.SharedPreference;
 import org.thoughtcrime.securesms.backup.proto.SqlStatement;
-import org.thoughtcrime.securesms.crypto.AttachmentSecret;
-import org.thoughtcrime.securesms.crypto.ClassicDecryptingPartInputStream;
-import org.thoughtcrime.securesms.crypto.ModernDecryptingPartInputStream;
+import org.signal.core.util.crypto.AttachmentSecret;
+import org.signal.core.util.crypto.ClassicDecryptingPartInputStream;
+import org.signal.core.util.crypto.ModernDecryptingPartInputStream;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.database.BackupMediaSnapshotTable;
 import org.thoughtcrime.securesms.database.EmojiSearchTable;

app/src/main/java/org/thoughtcrime/securesms/backup/FullBackupImporter.java

@@ -24,8 +24,8 @@ import org.thoughtcrime.securesms.backup.proto.KeyValue;
 import org.thoughtcrime.securesms.backup.proto.SharedPreference;
 import org.thoughtcrime.securesms.backup.proto.SqlStatement;
 import org.thoughtcrime.securesms.backup.proto.Sticker;
-import org.thoughtcrime.securesms.crypto.AttachmentSecret;
-import org.thoughtcrime.securesms.crypto.ModernEncryptingPartOutputStream;
+import org.signal.core.util.crypto.AttachmentSecret;
+import org.signal.core.util.crypto.ModernEncryptingPartOutputStream;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.database.EmojiSearchTable;
 import org.thoughtcrime.securesms.database.KeyValueDatabase;

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ArchiveRestoreProgress.kt

@@ -16,13 +16,13 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.update
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.bytes
 import org.signal.core.util.concurrent.SignalExecutors
 import org.signal.core.util.logging.Log
 import org.signal.core.util.safeUnregisterReceiver
 import org.signal.core.util.throttleLatest
 import org.thoughtcrime.securesms.BuildConfig
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.RestoreState
 import org.thoughtcrime.securesms.database.DatabaseObserver
 import org.thoughtcrime.securesms.database.SignalDatabase
@@ -82,7 +82,7 @@ object ArchiveRestoreProgress {
   val stateFlow: Flow<ArchiveRestoreProgressState> = store
     .throttleLatest(1.seconds)
     .distinctUntilChanged()
-    .flowOn(Dispatchers.IO)
+    .flowOn(Dispatchers.Default)
 
   init {
     SignalExecutors.BOUNDED.execute { update() }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/BackupRepository.kt

@@ -34,6 +34,7 @@ import org.signal.core.models.backup.BackupId
 import org.signal.core.models.backup.MediaName
 import org.signal.core.models.backup.MediaRootBackupKey
 import org.signal.core.models.backup.MessageBackupKey
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Base64
 import org.signal.core.util.Base64.decodeBase64OrThrow
 import org.signal.core.util.CursorUtil
@@ -46,6 +47,7 @@ import org.signal.core.util.bytes
 import org.signal.core.util.concurrent.LimitedWorker
 import org.signal.core.util.concurrent.SignalDispatchers
 import org.signal.core.util.concurrent.SignalExecutors
+import org.signal.core.util.crypto.AttachmentSecretProvider
 import org.signal.core.util.decodeOrNull
 import org.signal.core.util.forceForeignKeyConstraintsEnabled
 import org.signal.core.util.fullWalCheckpoint
@@ -72,9 +74,7 @@ import org.signal.network.NetworkResult
 import org.signal.network.StatusCodeErrorAction
 import org.signal.network.api.SvrBApi
 import org.signal.network.exceptions.NonSuccessfulResponseCodeException
-import org.signal.network.rest.toNetworkResult
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.Cdn
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.backup.ArchiveUploadProgress
@@ -94,7 +94,7 @@ import org.thoughtcrime.securesms.backup.v2.ui.BackupAlert
 import org.thoughtcrime.securesms.backup.v2.ui.subscription.MessageBackupsType
 import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
 import org.thoughtcrime.securesms.components.settings.app.subscription.RecurringInAppPaymentRepository
-import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider
+import org.thoughtcrime.securesms.crypto.AppAttachmentSecretStore
 import org.thoughtcrime.securesms.crypto.DatabaseSecretProvider
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.BackupMediaSnapshotTable.ArchiveMediaItem
@@ -102,6 +102,7 @@ import org.thoughtcrime.securesms.database.KeyValueDatabase
 import org.thoughtcrime.securesms.database.KyberPreKeyTable
 import org.thoughtcrime.securesms.database.OneTimePreKeyTable
 import org.thoughtcrime.securesms.database.SearchTable
+import org.thoughtcrime.securesms.database.SessionTable
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.SignedPreKeyTable
 import org.thoughtcrime.securesms.database.StickerTable
@@ -141,7 +142,6 @@ import org.thoughtcrime.securesms.logsubmit.SubmitDebugLogRepository
 import org.thoughtcrime.securesms.net.SignalNetwork
 import org.thoughtcrime.securesms.notifications.NotificationChannels
 import org.thoughtcrime.securesms.notifications.NotificationIds
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.service.BackupMediaRestoreService
@@ -647,7 +647,7 @@ object BackupRepository {
     val state = SignalStore.backup.backupDownloadNotifierState ?: return null
     val nextSheetDisplayTime = state.lastSheetDisplaySeconds.seconds + state.intervalSeconds.seconds
 
-    val remainingAttachmentSize = withContext(SignalDispatchers.IO) {
+    val remainingAttachmentSize = withContext(SignalDispatchers.Default) {
       SignalDatabase.attachments.getRemainingRestorableAttachmentSize()
     }
 
@@ -718,7 +718,7 @@ object BackupRepository {
       SignalDatabase(
         context = context,
         databaseSecret = DatabaseSecretProvider.getOrCreateDatabaseSecret(context),
-        attachmentSecret = AttachmentSecretProvider.getInstance(context).getOrCreateAttachmentSecret(),
+        attachmentSecret = AttachmentSecretProvider.getInstance(context, AppAttachmentSecretStore).getOrCreateAttachmentSecret(),
         name = "$baseName.db"
       )
     }
@@ -1127,7 +1127,7 @@ object BackupRepository {
     }
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal = { false })
+      import(reader, selfData, backupMode = BackupMode.LOCAL, cancellationSignal = { false })
     }
   }
 
@@ -1158,7 +1158,7 @@ object BackupRepository {
       }
 
       return frameReader.use { reader ->
-        import(reader, selfData, cancellationSignal)
+        import(reader, selfData, backupMode = BackupMode.REMOTE, cancellationSignal = cancellationSignal)
       }
     } catch (e: IOException) {
       Log.w(TAG, "Unable to restore signal backup", e)
@@ -1186,7 +1186,7 @@ object BackupRepository {
     )
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal)
+      import(reader, selfData, backupMode = BackupMode.LINK_SYNC, cancellationSignal = cancellationSignal)
     }
   }
 
@@ -1212,7 +1212,7 @@ object BackupRepository {
     }
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal)
+      import(reader, selfData, backupMode = BackupMode.REMOTE, cancellationSignal = cancellationSignal)
     }
   }
 
@@ -1228,13 +1228,14 @@ object BackupRepository {
     val frameReader = PlainTextBackupReader(inputStreamFactory(), length)
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal)
+      import(reader, selfData, backupMode = BackupMode.PLAINTEXT_EXPORT, cancellationSignal = cancellationSignal)
     }
   }
 
   private fun import(
     frameReader: BackupImportReader,
     selfData: SelfData,
+    backupMode: BackupMode,
     cancellationSignal: () -> Boolean
   ): ImportResult {
     val stopwatch = Stopwatch("import")
@@ -1251,6 +1252,7 @@ object BackupRepository {
       return ImportResult.Failure
     }
     SignalStore.backup.hasInvalidBackupVersion = false
+    val selfId: RecipientId
 
     var transactionSuccessful = false
     try {
@@ -1291,7 +1293,16 @@ object BackupRepository {
       }
 
       Log.d(TAG, "[import] --- Recreating all tables ---")
-      val skipTables = setOf(KyberPreKeyTable.TABLE_NAME, OneTimePreKeyTable.TABLE_NAME, SignedPreKeyTable.TABLE_NAME)
+      val skipTables = buildSet {
+        add(KyberPreKeyTable.TABLE_NAME)
+        add(OneTimePreKeyTable.TABLE_NAME)
+        add(SignedPreKeyTable.TABLE_NAME)
+
+        // Preserve the session established with the primary during linking
+        if (backupMode.isLinkAndSync) {
+          add(SessionTable.TABLE_NAME)
+        }
+      }
       val tableMetadata = SignalDatabase.rawDatabase.getAllTableDefinitions().filter { !it.name.startsWith(SearchTable.FTS_TABLE_NAME + "_") }
       for (table in tableMetadata) {
         if (skipTables.contains(table.name)) {
@@ -1322,7 +1333,7 @@ object BackupRepository {
       SignalStore.backup.mediaRootBackupKey = mediaRootBackupKey
 
       // Add back self after clearing data
-      val selfId: RecipientId = SignalDatabase.recipients.getAndPossiblyMerge(selfData.aci, selfData.pni, selfData.e164, pniVerified = true, changeSelf = true)
+      selfId = SignalDatabase.recipients.getAndPossiblyMerge(selfData.aci, selfData.pni, selfData.e164, pniVerified = true, changeSelf = true)
       SignalDatabase.recipients.setProfileKey(selfId, selfData.profileKey)
       SignalDatabase.recipients.setProfileSharing(selfId, true)
 
@@ -1533,7 +1544,7 @@ object BackupRepository {
     Log.d(TAG, "[import] Finished! ${eventTimer.stop().summary}")
     stopwatch.stop(TAG)
 
-    return ImportResult.Success(backupTime = header.backupTimeMs)
+    return ImportResult.Success(backupTime = header.backupTimeMs, selfRecipientId = selfId)
   }
 
   fun listRemoteMediaObjects(limit: Int, cursor: String? = null): NetworkResult<ArchiveGetMediaItemsResponse> {
@@ -1664,6 +1675,19 @@ object BackupRepository {
       }
   }
 
+  /**
+   * Stores the remote backup's last-modified time in [BackupValues.lastBackupTime], (404/401 clear it to 0).
+   */
+  fun refreshBackupFileTimestamp(): NetworkResult<ZonedDateTime> {
+    return getBackupFileLastModified().also { result ->
+      when (result) {
+        is NetworkResult.Success -> SignalStore.backup.lastBackupTime = result.result.toMillis()
+        is NetworkResult.StatusCodeError if (result.code == 404 || result.code == 401) -> SignalStore.backup.lastBackupTime = 0L
+        else -> Log.w(TAG, "Failed to refresh last backup time from remote: ${result::class.simpleName}")
+      }
+    }
+  }
+
   /**
    * Returns an object with details about the remote backup state.
    */
@@ -2236,7 +2260,7 @@ object BackupRepository {
     }
 
     Log.i(TAG, "[remoteRestore] Downloading backup")
-    val tempBackupFile = BlobProvider.getInstance().forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
+    val tempBackupFile = AppDependencies.blobs.forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
     when (val result = downloadBackupFile(tempBackupFile, progressListener)) {
       is NetworkResult.Success -> Log.i(TAG, "[remoteRestore] Download successful")
       else -> {
@@ -2311,19 +2335,23 @@ object BackupRepository {
       forwardSecrecyToken = forwardSecrecyToken,
       cancellationSignal = cancellationSignal
     )
-    if (result == ImportResult.Failure) {
-      Log.w(TAG, "[remoteRestore] Failed to import backup")
-      return RemoteRestoreResult.Failure
+
+    return when (result) {
+      is ImportResult.Failure -> {
+        Log.w(TAG, "[remoteRestore] Failed to import backup")
+        RemoteRestoreResult.Failure
+      }
+
+      is ImportResult.Success -> {
+        Log.i(TAG, "[remoteRestore] Restore successful")
+        BackupMediaRestoreService.resetTimeout()
+        AppDependencies.jobManager.add(BackupRestoreMediaJob())
+        RemoteRestoreResult.Success(result.selfRecipientId)
+      }
     }
-
-    BackupMediaRestoreService.resetTimeout()
-    AppDependencies.jobManager.add(BackupRestoreMediaJob())
-
-    Log.i(TAG, "[remoteRestore] Restore successful")
-    return RemoteRestoreResult.Success
   }
 
-  suspend fun restoreLinkAndSyncBackup(response: TransferArchiveResponse, ephemeralBackupKey: MessageBackupKey) {
+  suspend fun restoreLinkAndSyncBackup(response: TransferArchiveResponse, ephemeralBackupKey: MessageBackupKey): RemoteRestoreResult {
     val context = AppDependencies.application
     ArchiveRestoreProgress.onRestorePending()
 
@@ -2355,9 +2383,16 @@ object BackupRepository {
       override fun shouldCancel() = cancellationSignal()
     }
 
+    val cdn = response.cdn
+    val key = response.key
+    if (cdn == null || key == null) {
+      Log.w(TAG, "[restoreLinkAndSyncBackup] Response has no archive location (error=${response.error}); nothing to download.")
+      return RemoteRestoreResult.Failure
+    }
+
     Log.i(TAG, "[restoreLinkAndSyncBackup] Downloading backup")
-    val tempBackupFile = BlobProvider.getInstance().forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
-    when (val result = AppDependencies.signalServiceMessageReceiver.retrieveLinkAndSyncBackup(response.cdn, response.key, tempBackupFile, progressListener)) {
+    val tempBackupFile = AppDependencies.blobs.forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
+    when (val result = AppDependencies.signalServiceMessageReceiver.retrieveLinkAndSyncBackup(cdn, key, tempBackupFile, progressListener)) {
       is NetworkResult.Success -> Log.i(TAG, "[restoreLinkAndSyncBackup] Download successful")
       else -> {
         Log.w(TAG, "[restoreLinkAndSyncBackup] Failed to download backup file", result.getCause())
@@ -2386,16 +2421,19 @@ object BackupRepository {
       cancellationSignal = cancellationSignal
     )
 
-    if (result == ImportResult.Failure) {
-      Log.w(TAG, "[restoreLinkAndSyncBackup] Failed to import backup")
-      return RemoteRestoreResult.Failure
+    return when (result) {
+      is ImportResult.Failure -> {
+        Log.w(TAG, "[restoreLinkAndSyncBackup] Failed to import backup")
+        RemoteRestoreResult.Failure
+      }
+
+      is ImportResult.Success -> {
+        Log.i(TAG, "[restoreLinkAndSyncBackup] Restore successful")
+        BackupMediaRestoreService.resetTimeout()
+        AppDependencies.jobManager.add(BackupRestoreMediaJob())
+        RemoteRestoreResult.Success(result.selfRecipientId)
+      }
     }
-
-    BackupMediaRestoreService.resetTimeout()
-    AppDependencies.jobManager.add(BackupRestoreMediaJob())
-
-    Log.i(TAG, "[restoreLinkAndSyncBackup] Restore successful")
-    return RemoteRestoreResult.Success
   }
 
   private fun buildDebugInfo(): ByteString {
@@ -2525,12 +2563,12 @@ data class StagedBackupKeyRotations(
 )
 
 sealed class ImportResult {
-  data class Success(val backupTime: Long) : ImportResult()
+  data class Success(val backupTime: Long, val selfRecipientId: RecipientId) : ImportResult()
   data object Failure : ImportResult()
 }
 
 sealed interface RemoteRestoreResult {
-  data object Success : RemoteRestoreResult
+  data class Success(val selfRecipientId: RecipientId) : RemoteRestoreResult
   data object NetworkError : RemoteRestoreResult
   data object Canceled : RemoteRestoreResult
   data object Failure : RemoteRestoreResult
@@ -2559,6 +2597,9 @@ enum class BackupMode {
 
   val isLocalBackup: Boolean
     get() = this == LOCAL
+
+  val isPlaintextExport: Boolean
+    get() = this == PLAINTEXT_EXPORT
 }
 
 /**

app/src/main/java/org/thoughtcrime/securesms/backup/v2/BackupRestoreManager.kt

@@ -5,8 +5,8 @@
 
 package org.thoughtcrime.securesms.backup.v2
 
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.concurrent.SignalExecutors
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.model.MessageRecord

app/src/main/java/org/thoughtcrime/securesms/backup/v2/BatchArchiveMediaResult.kt

@@ -5,7 +5,7 @@
 
 package org.thoughtcrime.securesms.backup.v2
 
-import org.thoughtcrime.securesms.attachments.AttachmentId
+import org.signal.core.models.database.AttachmentId
 import org.whispersystems.signalservice.api.archive.BatchArchiveMediaResponse
 
 /**

app/src/main/java/org/thoughtcrime/securesms/backup/v2/MessageBackupTier.kt

@@ -6,6 +6,7 @@
 package org.thoughtcrime.securesms.backup.v2
 
 import org.signal.core.util.LongSerializer
+import org.signal.libsignal.zkgroup.backups.BackupLevel
 
 /**
  * Serializable enum value for what we think a user's current backup tier is.
@@ -18,6 +19,13 @@ enum class MessageBackupTier(val value: Int) {
   FREE(0),
   PAID(1);
 
+  fun toBackupLevel(): Long {
+    return when (this) {
+      FREE -> BackupLevel.FREE.value.toLong()
+      PAID -> BackupLevel.PAID.value.toLong()
+    }
+  }
+
   companion object Serializer : LongSerializer<MessageBackupTier?> {
     override fun serialize(data: MessageBackupTier?): Long {
       return data?.value?.toLong() ?: -1
@@ -26,5 +34,13 @@ enum class MessageBackupTier(val value: Int) {
     override fun deserialize(data: Long): MessageBackupTier? {
       return entries.firstOrNull { it.value == data.toInt() }
     }
+
+    fun fromBackupLevel(backupLevel: Long?): MessageBackupTier? {
+      return when (backupLevel) {
+        BackupLevel.FREE.value.toLong() -> FREE
+        BackupLevel.PAID.value.toLong() -> PAID
+        else -> null
+      }
+    }
   }
 }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/database/AttachmentTableArchiveExtensions.kt

@@ -5,8 +5,8 @@
 
 package org.thoughtcrime.securesms.backup.v2.database
 
+import org.signal.core.models.database.AttachmentId
 import org.thoughtcrime.securesms.attachments.Attachment
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.database.AttachmentTable
 
 fun AttachmentTable.restoreWallpaperAttachment(attachment: Attachment): AttachmentId? {

app/src/main/java/org/thoughtcrime/securesms/backup/v2/database/MessageTableArchiveExtensions.kt

@@ -167,7 +167,11 @@ fun MessageTable.getMessagesForBackup(db: SignalDatabase, backupTime: Long, self
         .where(
           buildString {
             append("$STORY_TYPE = 0 AND $PARENT_STORY_ID <= 0 AND $SCHEDULED_DATE = -1 AND ")
-            append("($EXPIRES_IN == 0 OR $EXPIRES_IN > ${1.days.inWholeMilliseconds})")
+            if (exportState.backupMode.isPlaintextExport) {
+              append("$EXPIRES_IN == 0")
+            } else {
+              append("($EXPIRES_IN == 0 OR $EXPIRES_IN > ${1.days.inWholeMilliseconds})")
+            }
             append(" AND $DATE_RECEIVED >= $lastSeenReceivedTime $cutoffQuery")
           }
         )

app/src/main/java/org/thoughtcrime/securesms/backup/v2/exporters/ChatItemArchiveExporter.kt

@@ -42,6 +42,7 @@ import org.signal.archive.proto.Text
 import org.signal.archive.proto.ThreadMergeChatUpdate
 import org.signal.archive.proto.ViewOnceMessage
 import org.signal.core.models.ServiceId
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Base64
 import org.signal.core.util.EventTimer
 import org.signal.core.util.Hex
@@ -68,7 +69,6 @@ import org.signal.core.util.requireLong
 import org.signal.core.util.requireLongOrNull
 import org.signal.core.util.requireString
 import org.signal.core.util.toByteArray
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.backup.v2.BackupMode
 import org.thoughtcrime.securesms.backup.v2.ExportOddities
@@ -647,15 +647,22 @@ private fun BackupMessageRecord.toBasicChatItemBuilder(selfRecipientId: Recipien
     }
   }
 
-  if (!MessageTypes.isExpirationTimerUpdate(record.type) && builder.expiresInMs != null && builder.expireStartDate != null) {
-    val cutoffDuration = ChatItemArchiveExporter.EXPIRATION_CUTOFF.inWholeMilliseconds
-    val expiresAt = builder.expireStartDate!! + builder.expiresInMs!!
-    val threshold = if (exportState.backupMode.isLinkAndSync) backupStartTime else backupStartTime + cutoffDuration
-
-    if (expiresAt < threshold || (builder.expiresInMs!! <= cutoffDuration && !exportState.backupMode.isLinkAndSync)) {
+  if (!MessageTypes.isExpirationTimerUpdate(record.type) && builder.expiresInMs != null) {
+    if (exportState.backupMode.isPlaintextExport) {
       Log.w(TAG, ExportSkips.messageExpiresTooSoon(record.dateSent))
       return null
     }
+
+    if (builder.expireStartDate != null) {
+      val cutoffDuration = ChatItemArchiveExporter.EXPIRATION_CUTOFF.inWholeMilliseconds
+      val expiresAt = builder.expireStartDate!! + builder.expiresInMs!!
+      val threshold = if (exportState.backupMode.isLinkAndSync) backupStartTime else backupStartTime + cutoffDuration
+
+      if (expiresAt < threshold || (builder.expiresInMs!! <= cutoffDuration && !exportState.backupMode.isLinkAndSync)) {
+        Log.w(TAG, ExportSkips.messageExpiresTooSoon(record.dateSent))
+        return null
+      }
+    }
   }
 
   if (builder.expireStartDate != null && builder.expiresInMs == null) {

app/src/main/java/org/thoughtcrime/securesms/backup/v2/importer/ChatArchiveImporter.kt

@@ -7,10 +7,10 @@ package org.thoughtcrime.securesms.backup.v2.importer
 
 import androidx.core.content.contentValuesOf
 import org.signal.archive.proto.Chat
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.SqlUtil
 import org.signal.core.util.insertInto
 import org.signal.core.util.toInt
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.v2.ImportState
 import org.thoughtcrime.securesms.backup.v2.database.restoreWallpaperAttachment
 import org.thoughtcrime.securesms.backup.v2.util.parseChatWallpaper

app/src/main/java/org/thoughtcrime/securesms/backup/v2/local/LocalArchiver.kt

@@ -16,6 +16,7 @@ import org.signal.archive.stream.EncryptedBackupReader
 import org.signal.core.models.backup.BackupId
 import org.signal.core.models.backup.MediaName
 import org.signal.core.models.backup.MessageBackupKey
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Stopwatch
 import org.signal.core.util.StreamUtil
 import org.signal.core.util.Util
@@ -23,9 +24,9 @@ import org.signal.core.util.logging.Log
 import org.signal.core.util.readFully
 import org.signal.core.util.toJson
 import org.signal.libsignal.crypto.Aes256Ctr32
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.LocalExportProgress
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
+import org.thoughtcrime.securesms.backup.v2.ImportResult
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.keyvalue.SignalStore
@@ -269,13 +270,18 @@ object LocalArchiver {
 
       val mainStreamLength = snapshotFileSystem.mainLength() ?: return ArchiveResult.failure(RestoreFailure.MainStream)
 
-      BackupRepository.importLocal(
+      val importResult = BackupRepository.importLocal(
         mainStreamFactory = { snapshotFileSystem.mainInputStream()!! },
         mainStreamLength = mainStreamLength,
         selfData = selfData,
         backupId = backupId,
         messageBackupKey = messageBackupKey
       )
+
+      if (importResult is ImportResult.Failure) {
+        Log.w(TAG, "Local backup import failed")
+        return RestoreResult.failure(RestoreFailure.ImportFailed)
+      }
     } finally {
       metadataStream?.close()
     }
@@ -350,6 +356,7 @@ object LocalArchiver {
     data object MainStream : RestoreFailure
     data object Cancelled : RestoreFailure
     data object BackupIdMissing : RestoreFailure
+    data object ImportFailed : RestoreFailure
     data class VersionMismatch(val backupVersion: Int, val supportedVersion: Int) : RestoreFailure
   }
 

app/src/main/java/org/thoughtcrime/securesms/backup/v2/processor/AccountDataArchiveProcessor.kt

@@ -12,11 +12,11 @@ import org.signal.archive.proto.AccountData
 import org.signal.archive.proto.ChatStyle
 import org.signal.archive.proto.Frame
 import org.signal.archive.stream.BackupFrameEmitter
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.UuidUtil
 import org.signal.core.util.logging.Log
 import org.signal.core.util.toByteArray
-import org.signal.libsignal.zkgroup.backups.BackupLevel
-import org.thoughtcrime.securesms.attachments.AttachmentId
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.backup.v2.ExportState
 import org.thoughtcrime.securesms.backup.v2.ImportState
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
@@ -126,7 +126,7 @@ object AccountDataArchiveProcessor {
             hasCompletedUsernameOnboarding = signalStore.uiHintValues.hasCompletedUsernameOnboarding(),
             customChatColors = db.chatColorsTable.getSavedChatColors().toRemoteChatColors().also { colors -> exportState.customChatColorIds.addAll(colors.map { it.id }) },
             optimizeOnDeviceStorage = signalStore.backupValues.optimizeStorage && signalStore.backupValues.backupTier == MessageBackupTier.PAID,
-            backupTier = signalStore.backupValues.backupTier.toRemoteBackupTier(),
+            backupTier = signalStore.backupValues.backupTier?.toBackupLevel(),
             defaultSentMediaQuality = signalStore.settingsValues.sentMediaQuality.toRemoteSentMediaQuality(),
             autoDownloadSettings = AccountData.AutoDownloadSettings(
               images = getRemoteAutoDownloadOption("image", mobileAutoDownload, wifiAutoDownload),
@@ -276,7 +276,7 @@ object AccountDataArchiveProcessor {
     SignalStore.story.userHasSeenGroupStoryEducationSheet = settings.hasSeenGroupStoryEducationSheet
     SignalStore.story.viewedReceiptsEnabled = settings.storyViewReceiptsEnabled ?: settings.readReceipts
     SignalStore.backup.optimizeStorage = settings.optimizeOnDeviceStorage
-    SignalStore.backup.backupTier = settings.backupTier?.toLocalBackupTier()
+    SignalStore.backup.backupTier = MessageBackupTier.fromBackupLevel(settings.backupTier)
     SignalStore.settings.sentMediaQuality = settings.defaultSentMediaQuality.toLocalSentMediaQuality()
     SignalStore.settings.setTheme(settings.appTheme.toLocalTheme())
     SignalStore.settings.setCallDataMode(settings.callsUseLessDataSetting.toLocalCallDataMode())
@@ -455,35 +455,19 @@ object AccountDataArchiveProcessor {
       }
   }
 
-  private fun MessageBackupTier?.toRemoteBackupTier(): Long? {
+  private fun SentMediaQuality.toRemoteSentMediaQuality(): AccountData.SentMediaQuality {
     return when (this) {
-      MessageBackupTier.FREE -> BackupLevel.FREE.value.toLong()
-      MessageBackupTier.PAID -> BackupLevel.PAID.value.toLong()
-      null -> null
+      SentMediaQuality.STANDARD -> AccountData.SentMediaQuality.STANDARD
+      SentMediaQuality.HIGH -> AccountData.SentMediaQuality.HIGH
     }
   }
 
-  private fun Long?.toLocalBackupTier(): MessageBackupTier? {
+  private fun AccountData.SentMediaQuality?.toLocalSentMediaQuality(): SentMediaQuality {
     return when (this) {
-      BackupLevel.FREE.value.toLong() -> MessageBackupTier.FREE
-      BackupLevel.PAID.value.toLong() -> MessageBackupTier.PAID
-      else -> null
-    }
-  }
-
-  private fun org.thoughtcrime.securesms.mms.SentMediaQuality.toRemoteSentMediaQuality(): AccountData.SentMediaQuality {
-    return when (this) {
-      org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD -> AccountData.SentMediaQuality.STANDARD
-      org.thoughtcrime.securesms.mms.SentMediaQuality.HIGH -> AccountData.SentMediaQuality.HIGH
-    }
-  }
-
-  private fun AccountData.SentMediaQuality?.toLocalSentMediaQuality(): org.thoughtcrime.securesms.mms.SentMediaQuality {
-    return when (this) {
-      AccountData.SentMediaQuality.HIGH -> org.thoughtcrime.securesms.mms.SentMediaQuality.HIGH
-      AccountData.SentMediaQuality.STANDARD -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
-      AccountData.SentMediaQuality.UNKNOWN_QUALITY -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
-      null -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
+      AccountData.SentMediaQuality.HIGH -> SentMediaQuality.HIGH
+      AccountData.SentMediaQuality.STANDARD -> SentMediaQuality.STANDARD
+      AccountData.SentMediaQuality.UNKNOWN_QUALITY -> SentMediaQuality.STANDARD
+      null -> SentMediaQuality.STANDARD
     }
   }
 

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/BackupAlertDelegate.kt

@@ -49,7 +49,7 @@ object BackupAlertDelegate {
   }
 
   private suspend fun displayBackupDownloadNotifier(fragmentManager: FragmentManager) {
-    val downloadYourBackupToday = withContext(SignalDispatchers.IO) { BackupRepository.getDownloadYourBackupData() }
+    val downloadYourBackupToday = withContext(SignalDispatchers.Default) { BackupRepository.getDownloadYourBackupData() }
     when (downloadYourBackupToday?.type) {
       BackupDownloadNotifierState.Type.SHEET -> {
         Log.d(TAG, "Displaying 'Download your backup today' sheet.")

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/ConfirmRecoveryKeyBottomSheet.kt

@@ -0,0 +1,85 @@
+package org.thoughtcrime.securesms.backup.v2.ui.subscription
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.signal.core.ui.compose.horizontalGutters
+import org.thoughtcrime.securesms.R
+
+/**
+ * Bottom sheet shown when confirming your recovery key after saving to password manager
+ */
+@Composable
+fun ConfirmRecoveryKeySheet(
+  onConfirm: () -> Unit = {},
+  onSeeAgain: () -> Unit = {},
+  modifier: Modifier = Modifier
+) {
+  Column(
+    modifier = modifier.horizontalGutters(),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    Icon(
+      imageVector = ImageVector.vectorResource(R.drawable.backup_confirm_80),
+      tint = Color.Unspecified,
+      contentDescription = null,
+      modifier = Modifier.padding(top = 24.dp, bottom = 16.dp)
+    )
+
+    Text(
+      text = stringResource(R.string.MessageBackupsKeyVerifyScreen__confirm_your_backup_key),
+      style = MaterialTheme.typography.titleLarge,
+      textAlign = TextAlign.Center,
+      modifier = Modifier.padding(bottom = 12.dp)
+    )
+
+    Text(
+      text = stringResource(R.string.MessageBackupsKeyRecordScreen__confirm_that_your_recovery),
+      textAlign = TextAlign.Center,
+      color = MaterialTheme.colorScheme.onSurfaceVariant
+    )
+
+    Spacer(modifier = Modifier.size(60.dp))
+
+    Buttons.LargeTonal(onClick = onConfirm) {
+      Text(text = stringResource(R.string.MessageBackupsKeyRecordScreen__confirm_recovery))
+    }
+
+    TextButton(
+      onClick = onSeeAgain,
+      modifier = Modifier.padding(vertical = 16.dp)
+    ) {
+      Text(text = stringResource(R.string.MessageBackupsKeyRecordScreen__see_key_again))
+    }
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun ConfirmRecoveryKeyPreview() {
+  Previews.BottomSheetContentPreview {
+    ConfirmRecoveryKeySheet(
+      onConfirm = {},
+      onSeeAgain = {},
+      modifier = Modifier.fillMaxSize()
+    )
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/MessageBackupsFlowFragment.kt

@@ -68,7 +68,8 @@ class MessageBackupsFlowFragment : ComposeFragment(), InAppPaymentCheckoutDelega
   private val viewModel: MessageBackupsFlowViewModel by viewModel {
     MessageBackupsFlowViewModel(
       initialTierSelection = requireArguments().getSerializableCompat(TIER, MessageBackupTier::class.java),
-      googlePlayApiAvailability = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(requireContext())
+      googlePlayApiAvailability = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(requireContext()),
+      isCredentialManagerSupported = AndroidCredentialRepository.isCredentialManagerSupported(requireContext())
     )
   }
 
@@ -155,6 +156,32 @@ class MessageBackupsFlowFragment : ComposeFragment(), InAppPaymentCheckoutDelega
         val context = LocalContext.current
         val passwordManagerSettingsIntent = AndroidCredentialRepository.getCredentialManagerSettingsIntent(requireContext())
 
+        MessageBackupsKeyRecordScreen(
+          backupKey = state.accountEntropyPool.displayValue,
+          keySaveState = state.backupKeySaveState,
+          canOpenPasswordManagerSettings = passwordManagerSettingsIntent != null,
+          onNavigationClick = viewModel::goToPreviousStage,
+          mode = remember {
+            MessageBackupsKeyRecordMode.Passkey(
+              onSaveToPasswordManager = viewModel::onBackupKeySaveRequested,
+              onSaveManually = viewModel::goToRecordManually,
+              onSaveSuccessful = viewModel::goToNextStage
+            )
+          },
+          onCopyToClipboardClick = { Util.copyToClipboard(context, it, CLIPBOARD_TIMEOUT_SECONDS) },
+          onRequestSaveToPasswordManager = viewModel::onBackupKeySaveRequested,
+          onConfirmSaveToPasswordManager = viewModel::onBackupKeySaveConfirmed,
+          onSaveStateCleared = viewModel::onBackupKeySaveStateCleared,
+          onSaveToPasswordManagerComplete = viewModel::onBackupKeySaveCompleted,
+          onGoToPasswordManagerSettingsClick = { requireContext().startActivity(passwordManagerSettingsIntent) },
+          notifyKeyIsSameAsOnDeviceBackupKey = SignalStore.backup.newLocalBackupsEnabled
+        )
+      }
+
+      composable(route = MessageBackupsStage.Route.BACKUP_KEY_RECORD_MANUALLY.name) {
+        val context = LocalContext.current
+        val passwordManagerSettingsIntent = AndroidCredentialRepository.getCredentialManagerSettingsIntent(requireContext())
+
         MessageBackupsKeyRecordScreen(
           backupKey = state.accountEntropyPool.displayValue,
           keySaveState = state.backupKeySaveState,

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/MessageBackupsFlowViewModel.kt

@@ -53,6 +53,7 @@ import kotlin.time.Duration.Companion.seconds
 class MessageBackupsFlowViewModel(
   private val initialTierSelection: MessageBackupTier?,
   googlePlayApiAvailability: Int,
+  private val isCredentialManagerSupported: Boolean,
   startScreen: MessageBackupsStage = if (SignalStore.backup.backupTier == null) MessageBackupsStage.EDUCATION else MessageBackupsStage.TYPE_SELECTION
 ) : ViewModel(), BackupKeyCredentialManagerHandler {
 
@@ -144,7 +145,7 @@ class MessageBackupsFlowViewModel(
               }
             } catch (e: Exception) {
               Log.d(TAG, "Failed to handle purchase.", e)
-              withContext(SignalDispatchers.IO) {
+              withContext(SignalDispatchers.Default) {
                 InAppPaymentsRepository.handlePipelineError(
                   inAppPaymentId = id,
                   error = e
@@ -238,8 +239,9 @@ class MessageBackupsFlowViewModel(
       when (it.stage) {
         MessageBackupsStage.CANCEL -> error("Unsupported state transition from terminal state CANCEL")
         MessageBackupsStage.EDUCATION -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_EDUCATION)
-        MessageBackupsStage.BACKUP_KEY_EDUCATION -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_RECORD)
-        MessageBackupsStage.BACKUP_KEY_RECORD -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_VERIFY)
+        MessageBackupsStage.BACKUP_KEY_EDUCATION -> it.copy(stage = if (isCredentialManagerSupported) MessageBackupsStage.BACKUP_KEY_RECORD else MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY)
+        MessageBackupsStage.BACKUP_KEY_RECORD -> it.copy(stage = MessageBackupsStage.TYPE_SELECTION)
+        MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_VERIFY)
         MessageBackupsStage.BACKUP_KEY_VERIFY -> it.copy(stage = MessageBackupsStage.TYPE_SELECTION)
         MessageBackupsStage.TYPE_SELECTION -> validateTypeAndUpdateState(it)
         MessageBackupsStage.CHECKOUT_SHEET -> it.copy(stage = MessageBackupsStage.PROCESS_PAYMENT)
@@ -262,7 +264,8 @@ class MessageBackupsFlowViewModel(
           MessageBackupsStage.EDUCATION -> MessageBackupsStage.CANCEL
           MessageBackupsStage.BACKUP_KEY_EDUCATION -> MessageBackupsStage.EDUCATION
           MessageBackupsStage.BACKUP_KEY_RECORD -> MessageBackupsStage.BACKUP_KEY_EDUCATION
-          MessageBackupsStage.BACKUP_KEY_VERIFY -> MessageBackupsStage.BACKUP_KEY_RECORD
+          MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY -> if (isCredentialManagerSupported) MessageBackupsStage.BACKUP_KEY_RECORD else MessageBackupsStage.BACKUP_KEY_EDUCATION
+          MessageBackupsStage.BACKUP_KEY_VERIFY -> MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY
           MessageBackupsStage.TYPE_SELECTION -> MessageBackupsStage.BACKUP_KEY_RECORD
           MessageBackupsStage.CHECKOUT_SHEET -> MessageBackupsStage.TYPE_SELECTION
           MessageBackupsStage.CREATING_IN_APP_PAYMENT -> MessageBackupsStage.CREATING_IN_APP_PAYMENT
@@ -277,6 +280,12 @@ class MessageBackupsFlowViewModel(
     }
   }
 
+  fun goToRecordManually() {
+    internalStateFlow.update {
+      it.copy(stage = MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY)
+    }
+  }
+
   fun onMessageBackupTierUpdated(messageBackupTier: MessageBackupTier) {
     internalStateFlow.update {
       it.copy(
@@ -288,7 +297,7 @@ class MessageBackupsFlowViewModel(
   private fun validateTypeAndUpdateState(state: MessageBackupsFlowState): MessageBackupsFlowState {
     return when (state.selectedMessageBackupTier!!) {
       MessageBackupTier.FREE -> {
-        viewModelScope.launch(SignalDispatchers.IO) {
+        viewModelScope.launch(SignalDispatchers.Default) {
           SignalDatabase.recipients.markNeedsSync(Recipient.self().id)
           StorageSyncHelper.scheduleSyncForDataChange()
         }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/MessageBackupsKeyEducationScreen.kt

@@ -5,6 +5,7 @@
 
 package org.thoughtcrime.securesms.backup.v2.ui.subscription
 
+import android.widget.Toast
 import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import androidx.compose.foundation.Image
@@ -28,6 +29,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
@@ -46,6 +48,7 @@ import org.signal.core.ui.compose.SignalIcons
 import org.signal.core.ui.compose.horizontalGutters
 import org.signal.core.ui.compose.theme.SignalTheme
 import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.compose.rememberBiometricsAuthentication
 import org.signal.core.ui.R as CoreUiR
 
 enum class MessageBackupsKeyEducationScreenMode {
@@ -80,6 +83,14 @@ fun MessageBackupsKeyEducationScreen(
   mode: MessageBackupsKeyEducationScreenMode = MessageBackupsKeyEducationScreenMode.DEFAULT
 ) {
   val scrollState = rememberScrollState()
+  val context = LocalContext.current
+  val biometrics = rememberBiometricsAuthentication(
+    promptTitle = stringResource(R.string.RemoteBackupsSettingsFragment__unlock_to_view_backup_key),
+    educationSheetMessage = stringResource(R.string.RemoteBackupsSettingsFragment__to_view_your_key),
+    onAuthenticationFailed = {
+      Toast.makeText(context, R.string.RemoteBackupsSettingsFragment__authentication_required, Toast.LENGTH_SHORT).show()
+    }
+  )
 
   Scaffolds.Settings(
     title = "",
@@ -139,7 +150,7 @@ fun MessageBackupsKeyEducationScreen(
           .padding(top = 16.dp, bottom = 24.dp)
       ) {
         Buttons.LargeTonal(
-          onClick = onNextClick,
+          onClick = { biometrics.withBiometricsAuthentication(onNextClick) },
           modifier = Modifier.align(Alignment.Center)
         ) {
           Text(

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/MessageBackupsKeyRecordScreen.kt

@@ -6,14 +6,22 @@
 package org.thoughtcrime.securesms.backup.v2.ui.subscription
 
 import android.content.Context
+import android.widget.Toast
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.LocalOnBackPressedDispatcherOwner
 import androidx.annotation.UiContext
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
@@ -22,6 +30,7 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.SnackbarHostState
@@ -34,9 +43,16 @@ import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.CompositingStrategy
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.testTag
@@ -48,6 +64,7 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import kotlinx.coroutines.launch
 import org.signal.core.ui.compose.BottomSheets
 import org.signal.core.ui.compose.Buttons
 import org.signal.core.ui.compose.DayNightPreviews
@@ -85,6 +102,11 @@ sealed interface MessageBackupsKeyRecordMode {
     val isOptimizedStorageEnabled: Boolean,
     val canRotateKey: Boolean
   ) : MessageBackupsKeyRecordMode
+  data class Passkey(
+    val onSaveToPasswordManager: () -> Unit,
+    val onSaveManually: () -> Unit,
+    val onSaveSuccessful: () -> Unit
+  ) : MessageBackupsKeyRecordMode
 }
 
 /**
@@ -136,18 +158,24 @@ fun MessageBackupsKeyRecordScreen(
   onRequestSaveToPasswordManager: () -> Unit = {},
   onConfirmSaveToPasswordManager: () -> Unit = {},
   onSaveToPasswordManagerComplete: (CredentialManagerResult) -> Unit = {},
+  onSaveStateCleared: () -> Unit = {},
   onGoToPasswordManagerSettingsClick: () -> Unit = {},
   mode: MessageBackupsKeyRecordMode = MessageBackupsKeyRecordMode.Next(onNextClick = {}),
   notifyKeyIsSameAsOnDeviceBackupKey: Boolean = false
 ) {
   TemporaryScreenshotSecurity.bind()
 
+  val context = LocalContext.current
+  val coroutineScope = rememberCoroutineScope()
   val snackbarHostState = remember { SnackbarHostState() }
   val backupKeyString = remember(backupKey) {
     backupKey.chunked(4).joinToString("  ")
   }
 
-  if (mode is MessageBackupsKeyRecordMode.Next) {
+  val showAsPasskey = mode is MessageBackupsKeyRecordMode.Passkey
+  var showExpandedPasskey by remember { mutableStateOf(false) }
+
+  if (mode is MessageBackupsKeyRecordMode.Next || mode is MessageBackupsKeyRecordMode.Passkey) {
     RecordScreenBackHandler()
   }
 
@@ -157,7 +185,6 @@ fun MessageBackupsKeyRecordScreen(
     val url = stringResource(R.string.recovery_key_phishing_support_url)
     val events: (RecoveryKeyWarningSheetEvent) -> Unit = {
       when (it) {
-        RecoveryKeyWarningSheetEvent.DoNotShareClick -> error("Not supported")
         RecoveryKeyWarningSheetEvent.GotItClick -> {
           onCopyToClipboardClick(backupKeyString)
           displayRecoveryKeyCopyWarning = false
@@ -167,7 +194,7 @@ fun MessageBackupsKeyRecordScreen(
           displayRecoveryKeyCopyWarning = false
         }
 
-        RecoveryKeyWarningSheetEvent.PasteKeyClick -> error("Not supported")
+        RecoveryKeyWarningSheetEvent.DoNotShareClick -> error("Not supported")
         RecoveryKeyWarningSheetEvent.ShareKeyClick -> error("Not supported")
       }
     }
@@ -184,6 +211,41 @@ fun MessageBackupsKeyRecordScreen(
     }
   }
 
+  var displayKeyVerificationError by remember { mutableStateOf(false) }
+  if (displayKeyVerificationError) {
+    ConfirmationFailureDialog(mode) {
+      displayKeyVerificationError = false
+    }
+  }
+
+  var displayConfirmKey by remember { mutableStateOf(false) }
+  if (displayConfirmKey) {
+    val context = LocalContext.current
+    val credentialId = stringResource(R.string.MessageBackupsKeyRecordScreen__backup_key_password_manager_id)
+    val successMessage = stringResource(R.string.MessageBackupsKeyRecordScreen__recover_key_confirmed)
+    ModalBottomSheet(
+      sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true),
+      containerColor = SignalTheme.colors.colorSurface1,
+      onDismissRequest = { displayConfirmKey = false }
+    ) {
+      ConfirmRecoveryKeySheet(
+        onConfirm = {
+          coroutineScope.launch {
+            val retrieved = getKeyFromCredentialManager(context, credentialId)
+            if (retrieved == backupKey) {
+              Toast.makeText(context, successMessage, Toast.LENGTH_SHORT).show()
+              (mode as? MessageBackupsKeyRecordMode.Passkey)?.onSaveSuccessful()
+            } else {
+              displayKeyVerificationError = true
+            }
+          }
+          displayConfirmKey = false
+        },
+        onSeeAgain = { displayConfirmKey = false }
+      )
+    }
+  }
+
   Scaffolds.Settings(
     title = "",
     navigationIcon = SignalIcons.ArrowStart.imageVector,
@@ -217,7 +279,11 @@ fun MessageBackupsKeyRecordScreen(
 
           item {
             Text(
-              text = stringResource(R.string.MessageBackupsKeyRecordScreen__record_your_backup_key),
+              text = if (showAsPasskey) {
+                stringResource(R.string.MessageBackupsKeyRecordScreen__save_your_recovery_key)
+              } else {
+                stringResource(R.string.MessageBackupsKeyRecordScreen__record_your_backup_key)
+              },
               style = MaterialTheme.typography.headlineMedium,
               modifier = Modifier.padding(top = 16.dp)
             )
@@ -226,6 +292,8 @@ fun MessageBackupsKeyRecordScreen(
           item {
             val text = if (notifyKeyIsSameAsOnDeviceBackupKey) {
               stringResource(R.string.MessageBackupsKeyRecordScreen__this_key_is_the_same_as_your_on_device_recovery_key)
+            } else if (showAsPasskey) {
+              stringResource(R.string.MessageBackupsKeyRecordScreen__your_recovery_key)
             } else {
               stringResource(R.string.MessageBackupsKeyRecordScreen__this_key_is_required_to_recover)
             }
@@ -240,47 +308,113 @@ fun MessageBackupsKeyRecordScreen(
           }
 
           item {
-            Box(
-              modifier = Modifier
-                .padding(top = 24.dp, bottom = 16.dp)
-                .background(
-                  color = SignalTheme.colors.colorSurface1,
-                  shape = RoundedCornerShape(10.dp)
-                )
-                .padding(24.dp)
-            ) {
-              Text(
-                text = backupKeyString,
-                style = MaterialTheme.typography.bodyLarge
-                  .copy(
-                    fontSize = 18.sp,
-                    fontWeight = FontWeight(400),
-                    letterSpacing = 1.44.sp,
-                    lineHeight = 36.sp,
-                    textAlign = TextAlign.Center,
-                    fontFamily = MonoTypeface.fontFamily()
+            AnimatedContent(
+              targetState = showAsPasskey && !showExpandedPasskey,
+              transitionSpec = { fadeIn() togetherWith fadeOut() using SizeTransform(clip = false) },
+              label = "passkey",
+              modifier = Modifier.padding(top = 24.dp, bottom = 16.dp)
+            ) { isCollapsed ->
+              if (isCollapsed) {
+                Box(
+                  contentAlignment = Alignment.CenterEnd,
+                  modifier = Modifier.background(
+                    color = SignalTheme.colors.colorSurface1,
+                    shape = RoundedCornerShape(50.dp)
+                  )
+                ) {
+                  Text(
+                    text = backupKeyString,
+                    maxLines = 1,
+                    style = MaterialTheme.typography.bodyLarge
+                      .copy(
+                        fontSize = 18.sp,
+                        fontWeight = FontWeight(400),
+                        letterSpacing = 1.44.sp,
+                        lineHeight = 36.sp,
+                        textAlign = TextAlign.Center,
+                        fontFamily = MonoTypeface.fontFamily()
+                      ),
+                    modifier = Modifier
+                      .padding(10.dp)
+                      .graphicsLayer { compositingStrategy = CompositingStrategy.Offscreen }
+                      .drawWithContent {
+                        drawContent()
+                        drawRect(
+                          brush = Brush.horizontalGradient(
+                            0f to Color.Black,
+                            0.75f to Color.Transparent
+                          ),
+                          blendMode = BlendMode.DstIn
+                        )
+                      }
                   )
-              )
-            }
-          }
 
-          item {
-            Buttons.Small(
-              onClick = {
-                if (mode is MessageBackupsKeyRecordMode.CreateNewKey) {
-                  displayRecoveryKeyCopyWarning = true
-                } else {
-                  onCopyToClipboardClick(backupKeyString)
+                  Row(
+                    modifier = Modifier
+                      .background(
+                        color = SignalTheme.colors.colorSurface1,
+                        shape = RoundedCornerShape(50.dp)
+                      )
+                      .padding(horizontal = 12.dp)
+                      .clickable(onClick = { showExpandedPasskey = true }),
+                    verticalAlignment = Alignment.CenterVertically
+                  ) {
+                    Icon(
+                      imageVector = ImageVector.vectorResource(R.drawable.symbol_tap_20),
+                      contentDescription = stringResource(R.string.MessageBackupsKeyRecordScreen__see_full_key)
+                    )
+                    Text(
+                      text = stringResource(R.string.MessageBackupsKeyRecordScreen__see_full_key),
+                      style = MaterialTheme.typography.labelMedium,
+                      modifier = Modifier.padding(start = 4.dp, end = 12.dp)
+                    )
+                  }
+                }
+              } else {
+                Box(
+                  modifier = Modifier
+                    .background(
+                      color = SignalTheme.colors.colorSurface1,
+                      shape = RoundedCornerShape(10.dp)
+                    )
+                    .padding(24.dp)
+                ) {
+                  Text(
+                    text = backupKeyString,
+                    style = MaterialTheme.typography.bodyLarge
+                      .copy(
+                        fontSize = 18.sp,
+                        fontWeight = FontWeight(400),
+                        letterSpacing = 1.44.sp,
+                        lineHeight = 36.sp,
+                        textAlign = TextAlign.Center,
+                        fontFamily = MonoTypeface.fontFamily()
+                      )
+                  )
                 }
               }
-            ) {
-              Text(
-                text = stringResource(R.string.MessageBackupsKeyRecordScreen__copy_to_clipboard)
-              )
             }
           }
 
-          if (AndroidCredentialRepository.isCredentialManagerSupported) {
+          if (!showAsPasskey || showExpandedPasskey) {
+            item {
+              Buttons.Small(
+                onClick = {
+                  if (mode is MessageBackupsKeyRecordMode.CreateNewKey) {
+                    displayRecoveryKeyCopyWarning = true
+                  } else {
+                    onCopyToClipboardClick(backupKeyString)
+                  }
+                }
+              ) {
+                Text(
+                  text = stringResource(R.string.MessageBackupsKeyRecordScreen__copy_to_clipboard)
+                )
+              }
+            }
+          }
+
+          if (!showAsPasskey && AndroidCredentialRepository.isCredentialManagerSupported(context)) {
             item {
               Buttons.Small(
                 onClick = { onRequestSaveToPasswordManager() }
@@ -301,6 +435,10 @@ fun MessageBackupsKeyRecordScreen(
           is MessageBackupsKeyRecordMode.CreateNewKey -> {
             CreateNewKeyButton(mode)
           }
+
+          is MessageBackupsKeyRecordMode.Passkey -> {
+            SaveButtons(mode)
+          }
         }
       }
 
@@ -327,7 +465,12 @@ fun MessageBackupsKeyRecordScreen(
         is BackupKeySaveState.Success -> {
           val snackbarMessage = stringResource(R.string.MessageBackupsKeyRecordScreen__save_to_password_manager_success)
           LaunchedEffect(keySaveState) {
-            snackbarHostState.showSnackbar(snackbarMessage)
+            if (showAsPasskey) {
+              displayConfirmKey = true
+            } else {
+              snackbarHostState.showSnackbar(snackbarMessage)
+            }
+            onSaveStateCleared()
           }
         }
 
@@ -344,6 +487,24 @@ fun MessageBackupsKeyRecordScreen(
   }
 }
 
+@Composable
+private fun SaveButtons(mode: MessageBackupsKeyRecordMode.Passkey) {
+  Buttons.LargeTonal(
+    onClick = mode.onSaveToPasswordManager
+  ) {
+    Text(text = stringResource(R.string.MessageBackupsKeyRecordScreen__save_to_password_manager))
+  }
+
+  TextButton(
+    onClick = mode.onSaveManually,
+    modifier = Modifier
+      .padding(vertical = 24.dp)
+      .horizontalGutters()
+  ) {
+    Text(text = stringResource(R.string.MessageBackupsKeyRecordScreen__save_key_manually))
+  }
+}
+
 @Composable
 private fun NextButton(onNextClick: () -> Unit) {
   Box(
@@ -579,6 +740,26 @@ private fun KeyLimitExceededDialog(
   )
 }
 
+@Composable
+private fun ConfirmationFailureDialog(mode: MessageBackupsKeyRecordMode, onDismiss: () -> Unit) {
+  Dialogs.AdvancedAlertDialog(
+    title = stringResource(R.string.MessageBackupsKeyRecordScreen__recover_key_error),
+    body = stringResource(R.string.MessageBackupsKeyRecordScreen__recover_key_error_body),
+    positive = stringResource(R.string.MessageBackupsKeyRecordScreen__save_to_password_manager),
+    onPositive = {
+      (mode as? MessageBackupsKeyRecordMode.Passkey)?.onSaveToPasswordManager()
+      onDismiss()
+    },
+    neutral = stringResource(R.string.MessageBackupsKeyRecordScreen__save_key_manually),
+    onNeutral = {
+      (mode as? MessageBackupsKeyRecordMode.Passkey)?.onSaveManually()
+      onDismiss()
+    },
+    negative = stringResource(android.R.string.cancel),
+    onNegative = onDismiss
+  )
+}
+
 private suspend fun saveKeyToCredentialManager(
   @UiContext activityContext: Context,
   backupKey: String
@@ -590,6 +771,13 @@ private suspend fun saveKeyToCredentialManager(
   )
 }
 
+private suspend fun getKeyFromCredentialManager(
+  @UiContext activityContext: Context,
+  id: String
+): String? {
+  return AndroidCredentialRepository.getCredential(activityContext, id)
+}
+
 @DayNightPreviews
 @Composable
 private fun MessageBackupsKeyRecordScreenPreview() {
@@ -622,6 +810,23 @@ private fun MessageBackupsKeyRecordScreenSameAsOnDeviceKeyPreview() {
   }
 }
 
+@DayNightPreviews
+@Composable
+private fun MessageBackupsKeySaveScreenPreview() {
+  Previews.Preview {
+    MessageBackupsKeyRecordScreen(
+      backupKey = (0 until 63).map { (('A'..'Z') + ('0'..'9')).random() }.joinToString("") + "0",
+      keySaveState = null,
+      canOpenPasswordManagerSettings = true,
+      mode = MessageBackupsKeyRecordMode.Passkey(
+        onSaveToPasswordManager = {},
+        onSaveManually = {},
+        onSaveSuccessful = {}
+      )
+    )
+  }
+}
+
 @DayNightPreviews
 @Composable
 private fun SaveKeyConfirmationDialogPreview() {

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/subscription/MessageBackupsStage.kt

@@ -15,6 +15,7 @@ enum class MessageBackupsStage(
   EDUCATION(route = Route.EDUCATION),
   BACKUP_KEY_EDUCATION(route = Route.BACKUP_KEY_EDUCATION),
   BACKUP_KEY_RECORD(route = Route.BACKUP_KEY_RECORD),
+  BACKUP_KEY_RECORD_MANUALLY(route = Route.BACKUP_KEY_RECORD_MANUALLY),
   BACKUP_KEY_VERIFY(route = Route.BACKUP_KEY_VERIFY),
   TYPE_SELECTION(route = Route.TYPE_SELECTION),
   CREATING_IN_APP_PAYMENT(route = Route.TYPE_SELECTION),
@@ -32,6 +33,7 @@ enum class MessageBackupsStage(
     EDUCATION,
     BACKUP_KEY_EDUCATION,
     BACKUP_KEY_RECORD,
+    BACKUP_KEY_RECORD_MANUALLY,
     BACKUP_KEY_VERIFY,
     TYPE_SELECTION;
 

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/verify/VerifyBackupKeyActivity.kt

@@ -61,7 +61,7 @@ class VerifyBackupKeyActivity : PassphraseRequiredActivity() {
             // Matches existing behavior: show a generic "authentication required" toast.
             Toast.makeText(
               context,
-              R.string.RemoteBackupsSettingsFragment__authenticatino_required,
+              R.string.RemoteBackupsSettingsFragment__authentication_required,
               Toast.LENGTH_SHORT
             ).show()
           }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/warning/RecoveryKeyPasteWarningFragment.kt

@@ -5,22 +5,16 @@
 
 package org.thoughtcrime.securesms.backup.v2.ui.warning
 
-import android.app.Dialog
 import android.content.DialogInterface
-import android.graphics.Color
-import android.graphics.drawable.ColorDrawable
 import android.os.Bundle
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ModalBottomSheet
-import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.fragment.app.setFragmentResult
-import org.signal.core.ui.compose.BottomSheets
-import org.signal.core.ui.compose.ComposeFullScreenDialogFragment
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.backup.v2.ui.warning.RecoveryKeyPasteWarningFragment.Companion.REQUEST_KEY
+import org.thoughtcrime.securesms.util.CommunicationActions
 
 /**
  * Displayed via the [org.thoughtcrime.securesms.components.settings.conversation.ConversationSettingsFragment] whenever the user
@@ -30,7 +24,7 @@ import org.signal.core.ui.compose.ComposeFullScreenDialogFragment
  * indicating whether the user chose to proceed with the paste. The host can rely on this firing for
  * every dismissal path (paste, decline, or cancel) to restore its own state.
  */
-class RecoveryKeyPasteWarningFragment : ComposeFullScreenDialogFragment() {
+class RecoveryKeyPasteWarningFragment : ComposeBottomSheetDialogFragment() {
 
   companion object {
     const val REQUEST_KEY = "recovery_key_request"
@@ -38,13 +32,6 @@ class RecoveryKeyPasteWarningFragment : ComposeFullScreenDialogFragment() {
 
   private var shouldPaste = false
 
-  override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
-    return super.onCreateDialog(savedInstanceState).apply {
-      window?.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
-      window?.setWindowAnimations(0)
-    }
-  }
-
   override fun onDismiss(dialog: DialogInterface) {
     setFragmentResult(
       REQUEST_KEY,
@@ -56,10 +43,10 @@ class RecoveryKeyPasteWarningFragment : ComposeFullScreenDialogFragment() {
     super.onDismiss(dialog)
   }
 
-  @OptIn(ExperimentalMaterial3Api::class)
   @Composable
-  override fun DialogContent() {
-    var isDisplayingFinalWarningDialog by remember { mutableStateOf(false) }
+  override fun SheetContent() {
+    val context = LocalContext.current
+    val url = stringResource(R.string.recovery_key_phishing_support_url)
 
     val eventHandler: (RecoveryKeyWarningSheetEvent) -> Unit = {
       when (it) {
@@ -67,34 +54,25 @@ class RecoveryKeyPasteWarningFragment : ComposeFullScreenDialogFragment() {
           dismissAllowingStateLoss()
         }
 
-        RecoveryKeyWarningSheetEvent.GotItClick -> error("Not supported for paste")
-        RecoveryKeyWarningSheetEvent.LearnMoreClick -> error("Not supported for paste")
-        RecoveryKeyWarningSheetEvent.PasteKeyClick -> {
-          shouldPaste = true
+        RecoveryKeyWarningSheetEvent.GotItClick -> {
+          error("Not supported for paste")
+        }
+
+        RecoveryKeyWarningSheetEvent.LearnMoreClick -> {
+          CommunicationActions.openBrowserLink(context, url)
           dismissAllowingStateLoss()
         }
 
         RecoveryKeyWarningSheetEvent.ShareKeyClick -> {
-          isDisplayingFinalWarningDialog = true
+          shouldPaste = true
+          dismissAllowingStateLoss()
         }
       }
     }
 
-    if (isDisplayingFinalWarningDialog) {
-      RecoveryKeyWarningDialog(
-        events = eventHandler
-      )
-    } else {
-      ModalBottomSheet(
-        onDismissRequest = { dismissAllowingStateLoss() },
-        dragHandle = { BottomSheets.Handle() },
-        sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
-      ) {
-        RecoveryKeyWarningSheetContent(
-          clipStage = ClipStage.PASTE,
-          events = eventHandler
-        )
-      }
-    }
+    RecoveryKeyWarningSheetContent(
+      clipStage = ClipStage.PASTE,
+      events = eventHandler
+    )
   }
 }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/warning/RecoveryKeyWarningSheetContent.kt

@@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -22,16 +23,17 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.LinkAnnotation
 import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.TextLinkStyles
 import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withLink
 import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
 import org.signal.core.ui.compose.Buttons
 import org.signal.core.ui.compose.DayNightPreviews
-import org.signal.core.ui.compose.Dialogs
 import org.signal.core.ui.compose.Previews
 import org.signal.core.ui.compose.horizontalGutters
 import org.thoughtcrime.securesms.R
@@ -64,17 +66,32 @@ fun RecoveryKeyWarningSheetContent(
       modifier = Modifier.padding(bottom = 12.dp)
     )
 
-    val signalWillNeverMessageYou = stringResource(R.string.RecoveryKeyWarningSheetContent__signal_will_never_message_you)
-    val recoveryKeyWarningBody = stringResource(R.string.RecoveryKeyWarningSheetContent__for_your_recovery_key_never_respond)
-
     Text(
       text = buildAnnotatedString {
         withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
-          append(signalWillNeverMessageYou)
+          append(stringResource(R.string.RecoveryKeyWarningSheetContent__signal_will_never_message_you))
         }
 
         append(" ")
-        append(recoveryKeyWarningBody)
+        append(stringResource(R.string.RecoveryKeyWarningSheetContent__for_your_recovery_key_never_respond))
+
+        if (clipStage == ClipStage.PASTE) {
+          append(" ")
+          withLink(
+            link = LinkAnnotation.Clickable(
+              tag = "learn-more",
+              styles = TextLinkStyles(
+                style = SpanStyle(
+                  color = MaterialTheme.colorScheme.primary
+                )
+              )
+            ) {
+              events(RecoveryKeyWarningSheetEvent.LearnMoreClick)
+            }
+          ) {
+            append(stringResource(R.string.RecoveryKeyWarningSheetContent__learn_more_period))
+          }
+        }
       },
       textAlign = TextAlign.Center,
       color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -113,40 +130,18 @@ fun PasteActionButtons(events: (RecoveryKeyWarningSheetEvent) -> Unit) {
     Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__do_not_share_key))
   }
 
-  TextButton(onClick = {
-    events(RecoveryKeyWarningSheetEvent.ShareKeyClick)
-  }) {
+  TextButton(
+    colors = ButtonDefaults.textButtonColors(
+      contentColor = MaterialTheme.colorScheme.error
+    ),
+    onClick = {
+      events(RecoveryKeyWarningSheetEvent.ShareKeyClick)
+    }
+  ) {
     Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__share_key))
   }
 }
 
-@Composable
-fun RecoveryKeyWarningDialog(events: (RecoveryKeyWarningSheetEvent) -> Unit) {
-  val bodyIntro = stringResource(R.string.RecoveryKeyWarningDialog__do_not_share_your_recovery_key_with_anyone)
-  val bodyEmphasis = stringResource(R.string.RecoveryKeyWarningDialog__signal_will_never_message_you_for_your_recovery_key)
-  val bodyOutro = stringResource(R.string.RecoveryKeyWarningDialog__never_respond_to_a_chat)
-
-  Dialogs.SimpleAlertDialog(
-    title = AnnotatedString(stringResource(R.string.RecoveryKeyWarningDialog__do_not_share_recovery_key)),
-    body = buildAnnotatedString {
-      append(bodyIntro)
-      append(" ")
-
-      withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
-        append(bodyEmphasis)
-      }
-
-      append(" ")
-      append(bodyOutro)
-    },
-    confirm = AnnotatedString(stringResource(R.string.RecoveryKeyWarningDialog__paste_key)),
-    confirmColor = MaterialTheme.colorScheme.error,
-    dismiss = AnnotatedString(stringResource(R.string.RecoveryKeyWarningDialog__dont_share)),
-    onConfirm = { events(RecoveryKeyWarningSheetEvent.PasteKeyClick) },
-    onDeny = { events(RecoveryKeyWarningSheetEvent.DoNotShareClick) }
-  )
-}
-
 enum class ClipStage {
   COPY,
   PASTE
@@ -175,11 +170,3 @@ private fun RecoveryKeyWarningSheetContentPastePreview() {
     )
   }
 }
-
-@DayNightPreviews
-@Composable
-private fun RecoveryKeyWarningDialogPreview() {
-  Previews.Preview {
-    RecoveryKeyWarningDialog(events = {})
-  }
-}

app/src/main/java/org/thoughtcrime/securesms/backup/v2/ui/warning/RecoveryKeyWarningSheetEvent.kt

@@ -8,7 +8,6 @@ package org.thoughtcrime.securesms.backup.v2.ui.warning
 sealed interface RecoveryKeyWarningSheetEvent {
   data object DoNotShareClick : RecoveryKeyWarningSheetEvent
   data object ShareKeyClick : RecoveryKeyWarningSheetEvent
-  data object PasteKeyClick : RecoveryKeyWarningSheetEvent
   data object GotItClick : RecoveryKeyWarningSheetEvent
   data object LearnMoreClick : RecoveryKeyWarningSheetEvent
 }

app/src/main/java/org/thoughtcrime/securesms/backup/v2/util/ChatStyleConverter.kt

@@ -7,8 +7,8 @@ package org.thoughtcrime.securesms.backup.v2.util
 
 import org.signal.archive.proto.ChatStyle
 import org.signal.archive.proto.FilePointer
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.logging.Log
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.v2.BackupMode
 import org.thoughtcrime.securesms.backup.v2.ImportState
 import org.thoughtcrime.securesms.conversation.colors.ChatColors

app/src/main/java/org/thoughtcrime/securesms/badges/self/expired/MonthlyDonationCanceledViewModel.kt

@@ -40,7 +40,7 @@ class MonthlyDonationCanceledViewModel(
 
   private fun initializeFromInAppPaymentId(inAppPaymentId: InAppPaymentTable.InAppPaymentId) {
     viewModelScope.launch {
-      val inAppPayment = withContext(Dispatchers.IO) {
+      val inAppPayment = withContext(Dispatchers.Default) {
         SignalDatabase.inAppPayments.getById(inAppPaymentId)
       }
 

app/src/main/java/org/thoughtcrime/securesms/banner/Banner.kt

@@ -8,6 +8,7 @@ package org.thoughtcrime.securesms.banner
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.runtime.Composable
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
 
 /**
  * This class represents a banner across the top of the screen.
@@ -28,6 +29,12 @@ abstract class Banner<Model> {
    */
   abstract val dataFlow: Flow<Model>
 
+  /**
+   * Emits whenever this banner's [enabled] state may have changed.
+   */
+  open val stateUpdates: Flow<Unit>
+    get() = emptyFlow()
+
   /**
    * Composable function to display the content emitted from [dataFlow].
    * You likely want to use [org.thoughtcrime.securesms.banner.ui.compose.DefaultBanner].

app/src/main/java/org/thoughtcrime/securesms/banner/BannerManager.kt

@@ -15,6 +15,11 @@ import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.onStart
 import org.signal.core.ui.compose.theme.SignalTheme
 import org.signal.core.util.logging.Log
 
@@ -32,6 +37,22 @@ class BannerManager @JvmOverloads constructor(
     val TAG = Log.tag(BannerManager::class)
   }
 
+  private fun selectEnabledBanner(): Banner<Any>? = banners.firstOrNull { it.enabled } as Banner<Any>?
+
+  /**
+   * Reactively selects which [Banner] should be shown. Re-evaluates whenever any banner signals via
+   * [Banner.stateUpdates] that its eligibility may have changed.
+   */
+  private val selectedBanner: Flow<Banner<Any>?> =
+    if (banners.isEmpty()) {
+      flowOf(null)
+    } else {
+      merge(*banners.map { it.stateUpdates }.toTypedArray())
+        .onStart { emit(Unit) }
+        .map { selectEnabledBanner() }
+        .distinctUntilChanged()
+    }
+
   /**
    * Re-evaluates the [Banner]s, choosing one to render (if any) and updating the view.
    */
@@ -39,19 +60,20 @@ class BannerManager @JvmOverloads constructor(
     composeView.apply {
       setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
       setContent {
-        val banner: Banner<Any>? = banners.firstOrNull { it.enabled } as Banner<Any>?
-        if (banner == null) {
+        val banner: Banner<Any>? by selectedBanner.collectAsStateWithLifecycle(initialValue = selectEnabledBanner())
+        val selected = banner
+        if (selected == null) {
           onNoBannerShownListener()
           return@setContent
         }
 
-        key(banner) {
-          val bannerState by banner.dataFlow.collectAsStateWithLifecycle(initialValue = null)
+        key(selected) {
+          val bannerState by selected.dataFlow.collectAsStateWithLifecycle(initialValue = null)
 
           bannerState?.let { model ->
             SignalTheme {
               Box {
-                banner.DisplayBanner(model, PaddingValues(horizontal = 12.dp, vertical = 8.dp))
+                selected.DisplayBanner(model, PaddingValues(horizontal = 12.dp, vertical = 8.dp))
               }
             }
             onNewBannerShownListener()
@@ -66,16 +88,14 @@ class BannerManager @JvmOverloads constructor(
    */
   @Composable
   fun Banner() {
-    val banner: Banner<Any>? = banners.firstOrNull { it.enabled } as Banner<Any>?
-    if (banner == null) {
-      return
-    }
+    val banner: Banner<Any>? by selectedBanner.collectAsStateWithLifecycle(initialValue = selectEnabledBanner())
+    val selected = banner ?: return
 
-    key(banner) {
-      val bannerState by banner.dataFlow.collectAsStateWithLifecycle(initialValue = null)
+    key(selected) {
+      val bannerState by selected.dataFlow.collectAsStateWithLifecycle(initialValue = null)
 
       bannerState?.let { model ->
-        banner.DisplayBanner(model, PaddingValues(horizontal = 12.dp, vertical = 8.dp))
+        selected.DisplayBanner(model, PaddingValues(horizontal = 12.dp, vertical = 8.dp))
       }
     }
   }

app/src/main/java/org/thoughtcrime/securesms/banner/banners/ArchiveRestoreStatusBanner.kt

@@ -9,7 +9,9 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.runtime.Composable
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onStart
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgress
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgressState
@@ -32,6 +34,12 @@ class ArchiveRestoreStatusBanner(private val listener: RestoreProgressBannerList
       }
   }
 
+  override val stateUpdates: Flow<Unit>
+    get() = ArchiveRestoreProgress.stateFlow
+      .map { enabled }
+      .distinctUntilChanged()
+      .map { }
+
   @Composable
   override fun DisplayBanner(model: ArchiveRestoreProgressState, contentPadding: PaddingValues) {
     ArchiveRestoreStatusBanner(
@@ -40,7 +48,6 @@ class ArchiveRestoreStatusBanner(private val listener: RestoreProgressBannerList
       onActionClick = listener::onActionClick,
       onDismissClick = {
         ArchiveRestoreProgress.clearFinishedStatus()
-        listener.onDismissComplete()
       }
     )
   }
@@ -48,6 +55,5 @@ class ArchiveRestoreStatusBanner(private val listener: RestoreProgressBannerList
   interface RestoreProgressBannerListener {
     fun onBannerClick()
     fun onActionClick(data: ArchiveRestoreProgressState)
-    fun onDismissComplete()
   }
 }

app/src/main/java/org/thoughtcrime/securesms/banner/banners/ArchiveUploadStatusBanner.kt

@@ -9,6 +9,7 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.runtime.Composable
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import org.signal.core.util.bytes
 import org.thoughtcrime.securesms.backup.ArchiveUploadProgress
@@ -78,6 +79,12 @@ class ArchiveUploadStatusBanner(private val listener: UploadProgressBannerListen
       }
   }
 
+  override val stateUpdates: Flow<Unit>
+    get() = ArchiveUploadProgress.progress
+      .map { enabled }
+      .distinctUntilChanged()
+      .map { }
+
   @Composable
   override fun DisplayBanner(model: ArchiveUploadStatusBannerViewState, contentPadding: PaddingValues) {
     ArchiveUploadStatusBannerView(
@@ -92,7 +99,7 @@ class ArchiveUploadStatusBanner(private val listener: UploadProgressBannerListen
           }
           ArchiveUploadStatusBannerViewEvents.HideClicked -> {
             SignalStore.backup.uploadBannerVisible = false
-            listener.onHidden()
+            ArchiveUploadProgress.triggerUpdate()
           }
         }
       }
@@ -105,6 +112,5 @@ class ArchiveUploadStatusBanner(private val listener: UploadProgressBannerListen
   interface UploadProgressBannerListener {
     fun onBannerClick()
     fun onCancelClicked()
-    fun onHidden()
   }
 }

app/src/main/java/org/thoughtcrime/securesms/banner/banners/UnauthorizedBanner.kt

@@ -12,7 +12,10 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.rx3.asFlow
 import org.signal.core.ui.compose.DayNightPreviews
 import org.signal.core.ui.compose.Previews
 import org.thoughtcrime.securesms.R
@@ -21,6 +24,8 @@ import org.thoughtcrime.securesms.banner.ui.compose.Action
 import org.thoughtcrime.securesms.banner.ui.compose.DefaultBanner
 import org.thoughtcrime.securesms.banner.ui.compose.Importance
 import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor
+import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.registration.ui.RegistrationActivity
 import org.thoughtcrime.securesms.util.TextSecurePreferences
 
@@ -35,23 +40,47 @@ class UnauthorizedBanner(val context: Context) : Banner<Unit>() {
   override val dataFlow: Flow<Unit>
     get() = flowOf(Unit)
 
+  override val stateUpdates: Flow<Unit>
+    get() = Recipient.self()
+      .live()
+      .observable()
+      .asFlow()
+      .map { enabled }
+      .distinctUntilChanged()
+      .map { }
+
   @Composable
   override fun DisplayBanner(model: Unit, contentPadding: PaddingValues) {
-    Banner(contentPadding)
+    Banner(contentPadding, SignalStore.account.isLinkedDevice)
   }
 }
 
 @Composable
-private fun Banner(contentPadding: PaddingValues) {
+private fun Banner(contentPadding: PaddingValues, isLinkedDevice: Boolean) {
   val context = LocalContext.current
 
   DefaultBanner(
     title = null,
-    body = stringResource(id = R.string.UnauthorizedReminder_this_is_likely_because_you_registered_your_phone_number_with_Signal_on_a_different_device),
+    body = stringResource(
+      id = if (isLinkedDevice) {
+        R.string.UnauthorizedReminder_this_device_is_no_longer_linked_relink_to_continue_messaging
+      } else {
+        R.string.UnauthorizedReminder_this_is_likely_because_you_registered_your_phone_number_with_Signal_on_a_different_device
+      }
+    ),
     importance = Importance.ERROR,
     actions = listOf(
-      Action(R.string.UnauthorizedReminder_reregister_action) {
-        val registrationIntent = RegistrationActivity.newIntentForReRegistration(context)
+      Action(if (isLinkedDevice) R.string.UnauthorizedReminder_relink_action else R.string.UnauthorizedReminder_reregister_action) {
+        if (SignalStore.misc.isOldDeviceTransferLocked) {
+          SignalStore.misc.isOldDeviceTransferLocked = false
+          DeviceTransferBlockingInterceptor.getInstance().unblockNetwork()
+        }
+
+        val registrationIntent = if (isLinkedDevice) {
+          RegistrationActivity.newIntentForReLinkDevice(context)
+        } else {
+          RegistrationActivity.newIntentForReRegistration(context)
+        }
         context.startActivity(registrationIntent)
       }
     ),
@@ -63,6 +92,6 @@ private fun Banner(contentPadding: PaddingValues) {
 @Composable
 private fun BannerPreview() {
   Previews.Preview {
-    Banner(PaddingValues(0.dp))
+    Banner(PaddingValues(0.dp), isLinkedDevice = false)
   }
 }