Bump version to 8.20.3

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

.github/workflows/android.yml

@@ -23,7 +23,7 @@ jobs:
           lfs: true
 
     - name: set up JDK 21
-      uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+      uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
       # gh api repos/actions/setup-java/commits/v5 --jq '.sha'
       with:
         distribution: temurin
@@ -42,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() }}

.github/workflows/diffuse.yml

@@ -23,7 +23,7 @@ jobs:
         ref: ${{ github.event.pull_request.base.sha }}
 
     - name: set up JDK 21
-      uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+      uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
       # gh api repos/actions/setup-java/commits/v5 --jq '.sha'
       with:
         distribution: temurin

.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

app/build.gradle.kts

@@ -32,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 = 1717
-val canonicalVersionName = "8.19.0"
+val canonicalVersionCode = 1723
+val canonicalVersionName = "8.20.3"
 val currentHotfixVersion = 0
 val maxHotfixVersions = 100
 
@@ -132,6 +132,17 @@ 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
@@ -831,6 +842,7 @@ 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) {

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

@@ -17,7 +17,9 @@ 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
@@ -25,6 +27,7 @@ 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
@@ -59,6 +62,11 @@ class CheckoutFlowActivityTest__OneTimeDonations {
     startJobLoopForTests()
   }
 
+  @After
+  fun tearDown() {
+    unmockkObject(DonationPermits)
+  }
+
   @Test
   fun givenPermitAcquisitionFails_whenIDonateOnce_thenIExpectPaymentSetupErrorDialog() {
     failDonationPermitAcquisition()

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

@@ -13,8 +13,6 @@ 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.mockkObject
 import io.mockk.unmockkObject
 import org.junit.After
 import org.junit.Before
@@ -23,9 +21,6 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.core.util.deleteAll
 import org.signal.donations.InAppPaymentType
-import org.signal.libsignal.net.RequestResult
-import org.signal.network.NetworkResult
-import org.signal.network.exceptions.NonSuccessfulResponseCodeException
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits
@@ -33,19 +28,18 @@ 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.scrollToDescendant
-import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+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)
@@ -153,10 +147,10 @@ class CheckoutFlowActivityTest__RecurringDonations {
 
   @Test
   fun givenSubscriptionPaymentMethodPermitRejected_whenISubscribe_thenIExpectPaymentSetupErrorDialog() {
-    AppDependencies.donationPermitsRepository.clearPermits()
-    mockkObject(DonationPermits)
-    every { DonationPermits.getDonationPermit() } returns RequestResult.Success("permit")
-    every { AppDependencies.donationsApi.createStripeSubscriptionPaymentMethod(any(), any(), any()) } returns NetworkResult.StatusCodeError(NonSuccessfulResponseCodeException(402))
+    succeedDonationPermitAcquisition()
+    MockEndpoints.responder.register({ it.method == "POST" && it.path.contains("/create_payment_method") }) {
+      failure(402)
+    }
 
     val scenario = ActivityScenario.launch<CheckoutFlowActivity>(intent)
     rxRule.defaultTestScheduler.triggerActions()
@@ -172,44 +166,22 @@ class CheckoutFlowActivityTest__RecurringDonations {
   }
 
   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(),
@@ -223,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

@@ -7,10 +7,12 @@ 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
@@ -18,6 +20,7 @@ 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
@@ -26,23 +29,52 @@ 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 real donation-permit acquisition to fail at the issuer, exercising the permit code path through
- * [org.thoughtcrime.securesms.components.settings.app.subscription.permits.DonationPermits].
+ * 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()
-  every { AppDependencies.donationsApi.createDonationPermits(any()) } returns RequestResult.NonSuccess(RestStatusCodeError(statusCode, emptyMap(), null))
+  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()
 }
 
@@ -67,6 +99,7 @@ fun ActivityScenario<CheckoutFlowActivity>.selectGooglePay(
     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 {

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/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/BackupSubscriptionCheckJobTest.kt

@@ -121,8 +121,6 @@ class BackupSubscriptionCheckJobTest {
       )
     )
 
-    every { AppDependencies.donationsApi.putSubscription(any()) } returns NetworkResult.Success(Unit)
-
     insertSubscriber()
   }
 

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/SyncMessageProcessorTest_attachmentBackfill.kt

@@ -26,6 +26,7 @@ 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
@@ -51,6 +52,14 @@ class SyncMessageProcessorTest_attachmentBackfill {
     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

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

@@ -7,43 +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.signal.network.exceptions.NonSuccessfulResponseCodeException
 import org.thoughtcrime.securesms.dependencies.AppDependencies
-import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
-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()
-    initialiseAccountAndSubscriptionLookups()
+    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)
-      every { createSubscriber(any(), 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() {
@@ -59,23 +106,12 @@ class InAppPaymentsRule : ExternalResource() {
   }
 
   /**
-   * Starting the real job loop lets background jobs unrelated to the assertion under test run against the strict
-   * API mocks (e.g. [org.thoughtcrime.securesms.jobs.InAppPaymentRecurringContextJob] querying whoAmI, the
-   * active subscription, and then submitting receipt credentials). Stub these calls so those jobs hit a handled
-   * path and terminate quietly instead of throwing [io.mockk.MockKException] on a job thread, which crashes the
-   * whole app process (the test asserts nothing, so it surfaces as "Application crashed" with no failed test).
-   * Tests that supply an active subscription push the job past the [getSubscription] guard to
-   * [submitReceiptCredentials], so that must be stubbed too. End-to-end coverage of that pipeline is tracked
-   * separately; here we only keep the process alive and the logs clean.
+   * 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 initialiseAccountAndSubscriptionLookups() {
+  private fun initialiseAccountLookups() {
     AppDependencies.accountApi.apply {
       every { whoAmI() } returns NetworkResult.Success(WhoAmIResponse(number = "+15555550123"))
     }
-
-    AppDependencies.donationsApi.apply {
-      every { getSubscription(any()) } returns NetworkResult.Success(ActiveSubscription.EMPTY)
-      every { submitReceiptCredentials(any(), any()) } returns NetworkResult.StatusCodeError(NonSuccessfulResponseCodeException(402))
-    }
   }
 }

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/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/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

@@ -1536,7 +1536,7 @@
         </receiver>
 
         <receiver
-            android:name="org.thoughtcrime.securesms.jobs.ForegroundServiceUtil$Receiver"
+            android:name="org.signal.core.util.ForegroundServiceUtil$Receiver"
             android:exported="false" />
 
         <receiver

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

@@ -9,10 +9,10 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity;
+import org.thoughtcrime.securesms.keyvalue.SignalStore;
 
 public class DeviceProvisioningActivity extends PassphraseRequiredActivity {
 
-  @SuppressWarnings("unused")
   private static final String TAG = Log.tag(DeviceProvisioningActivity.class);
 
   @Override
@@ -22,6 +22,13 @@ public class DeviceProvisioningActivity extends PassphraseRequiredActivity {
 
   @Override
   protected void onCreate(Bundle bundle, boolean ready) {
+    if (SignalStore.account().isLinkedDevice()) {
+      Log.i(TAG, "Cannot link a device from a linked device. Ignoring provisioning intent.");
+      startActivity(MainActivity.clearTop(this));
+      finish();
+      return;
+    }
+
     AlertDialog dialog = new MaterialAlertDialogBuilder(this)
         .setTitle(getString(R.string.DeviceProvisioningActivity_link_a_signal_device))
         .setMessage(getString(R.string.DeviceProvisioningActivity_to_link_a_desktop_or_ipad_to_this_signal_account))

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

@@ -76,6 +76,7 @@ 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
@@ -671,46 +672,54 @@ class MainActivity :
             }
           },
           primaryContent = {
-            when (mainNavigationState.currentListLocation) {
-              MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> {
-                NavDisplay(
-                  backStack = mainNavigationViewModel.chatsBackStackEntries,
-                  onBack = { mainNavigationViewModel.popChatsDetailLocation() },
-                  transitionSpec = TransitionSpecs.HorizontalSlide.transitionSpec,
-                  popTransitionSpec = TransitionSpecs.HorizontalSlide.popTransitionSpec,
-                  predictivePopTransitionSpec = TransitionSpecs.HorizontalSlide.predictivePopTransitionSpec,
-                  entryProvider = entryProvider { chatsNavEntries(convoTransitionState) }
-                )
-              }
+            Box(
+              modifier = Modifier
+                .padding(end = contentLayoutData.detailPaddingEnd)
+                .clip(contentLayoutData.shape)
+                .background(color = MaterialTheme.colorScheme.surface)
+                .fillMaxSize()
+            ) {
+              when (mainNavigationState.currentListLocation) {
+                MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> {
+                  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 -> {
-                NavDisplay(
-                  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.CALLS -> {
+                  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 -> {
-                NavDisplay(
-                  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() }
-                )
+                MainNavigationListLocation.STORIES -> {
+                  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() }
+                  )
+                }
               }
             }
           },

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

@@ -255,6 +255,9 @@ 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));
   }

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

@@ -79,7 +79,13 @@ class SystemContactsEntrypointViewModel : ViewModel() {
   }
 
   private fun getDestinationForSyncAdapter(context: Context, intent: Intent): DestinationAndBody {
-    context.contentResolver.query(intent.data!!, null, null, null, null).use { cursor ->
+    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)), "")
       }

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

@@ -13,10 +13,14 @@ import androidx.fragment.app.setFragmentResult
 import androidx.fragment.app.setFragmentResultListener
 import androidx.fragment.app.viewModels
 import androidx.navigation.Navigation
+import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import org.signal.core.models.media.Media
+import org.signal.core.ui.WindowBreakpoint
+import org.signal.core.ui.getWindowBreakpoint
 import org.signal.core.ui.permissions.Permissions
 import org.signal.core.util.ThreadUtil
+import org.signal.core.util.dp
 import org.signal.core.util.getParcelableExtraCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.avatar.Avatar
@@ -31,6 +35,7 @@ import org.thoughtcrime.securesms.mediasend.AvatarSelectionActivity
 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.padding
 import org.thoughtcrime.securesms.util.visible
 
 /**
@@ -65,8 +70,25 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
     val saveButton: View = view.findViewById(R.id.avatar_picker_save)
     val clearButton: View = view.findViewById(R.id.avatar_picker_clear)
 
+    val spanCount = when (resources.getWindowBreakpoint()) {
+      is WindowBreakpoint.Small -> 4
+      else -> 6
+    }
+
+    val recyclerPadding = when (resources.getWindowBreakpoint()) {
+      is WindowBreakpoint.Small -> 0
+      else -> 112.dp
+    }
+
     recycler = view.findViewById(R.id.avatar_picker_recycler)
-    recycler.addItemDecoration(GridDividerDecoration(4, ViewUtil.dpToPx(16)))
+    recycler.addItemDecoration(GridDividerDecoration(spanCount, ViewUtil.dpToPx(16)))
+    recycler.padding(
+      left = recyclerPadding,
+      right = recyclerPadding
+    )
+
+    val gridLayoutManager: GridLayoutManager = recycler.layoutManager as GridLayoutManager
+    gridLayoutManager.spanCount = spanCount
 
     val adapter = MappingAdapter()
     AvatarPickerItem.register(adapter, this::onAvatarClick, this::onAvatarLongClick)

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

@@ -53,7 +53,7 @@ public enum BackupFileIOError {
 
     PendingIntent pendingIntent           = PendingIntent.getActivity(context, -1, AppSettingsActivity.backups(context), PendingIntentFlags.mutable());
     Notification backupFailedNotification = new NotificationCompat.Builder(context, NotificationChannels.getInstance().FAILURES)
-                                                                  .setSmallIcon(R.drawable.ic_signal_backup)
+                                                                  .setSmallIcon(org.signal.core.ui.R.drawable.ic_signal_backup)
                                                                   .setContentTitle(context.getString(titleId))
                                                                   .setContentText(context.getString(messageId))
                                                                   .setStyle(new NotificationCompat.BigTextStyle().bigText(context.getString(messageId)))

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

@@ -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
@@ -184,6 +185,7 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
+import org.signal.registration.R as RegistrationR
 
 object BackupRepository {
 
@@ -1126,7 +1128,7 @@ object BackupRepository {
     }
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal = { false })
+      import(reader, selfData, backupMode = BackupMode.LOCAL, cancellationSignal = { false })
     }
   }
 
@@ -1157,7 +1159,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)
@@ -1185,7 +1187,7 @@ object BackupRepository {
     )
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal)
+      import(reader, selfData, backupMode = BackupMode.LINK_SYNC, cancellationSignal = cancellationSignal)
     }
   }
 
@@ -1211,7 +1213,7 @@ object BackupRepository {
     }
 
     return frameReader.use { reader ->
-      import(reader, selfData, cancellationSignal)
+      import(reader, selfData, backupMode = BackupMode.REMOTE, cancellationSignal = cancellationSignal)
     }
   }
 
@@ -1227,13 +1229,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")
@@ -1291,7 +1294,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)) {
@@ -1664,6 +1676,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.
    */
@@ -2334,7 +2359,7 @@ object BackupRepository {
     try {
       DataRestoreConstraint.isRestoringData = true
       return withContext(Dispatchers.IO) {
-        return@withContext BackupProgressService.start(context, context.getString(R.string.BackupProgressService_title)).use {
+        return@withContext BackupProgressService.start(context, context.getString(RegistrationR.string.MessageSyncScreen__syncing_messages)).use {
           restoreLinkAndSyncBackup(response, ephemeralBackupKey, controller = it, cancellationSignal = { !isActive })
         }
       }
@@ -2349,7 +2374,7 @@ object BackupRepository {
     val progressListener = object : ProgressListener {
       override fun onAttachmentProgress(progress: AttachmentTransferProgress) {
         controller.update(
-          title = AppDependencies.application.getString(R.string.BackupProgressService_title_downloading),
+          title = AppDependencies.application.getString(RegistrationR.string.MessageSyncScreen__syncing_messages),
           progress = progress.value,
           indeterminate = false
         )
@@ -2381,7 +2406,7 @@ object BackupRepository {
     }
 
     controller.update(
-      title = AppDependencies.application.getString(R.string.BackupProgressService_title),
+      title = AppDependencies.application.getString(RegistrationR.string.MessageSyncScreen__syncing_messages),
       progress = 0f,
       indeterminate = true
     )

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/local/LocalArchiver.kt

@@ -26,6 +26,7 @@ import org.signal.core.util.toJson
 import org.signal.libsignal.crypto.Aes256Ctr32
 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

@@ -16,7 +16,6 @@ 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.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.backup.v2.ExportState
 import org.thoughtcrime.securesms.backup.v2.ImportState
@@ -127,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),
@@ -277,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())
@@ -456,22 +455,6 @@ object AccountDataArchiveProcessor {
       }
   }
 
-  private fun MessageBackupTier?.toRemoteBackupTier(): Long? {
-    return when (this) {
-      MessageBackupTier.FREE -> BackupLevel.FREE.value.toLong()
-      MessageBackupTier.PAID -> BackupLevel.PAID.value.toLong()
-      null -> null
-    }
-  }
-
-  private fun Long?.toLocalBackupTier(): MessageBackupTier? {
-    return when (this) {
-      BackupLevel.FREE.value.toLong() -> MessageBackupTier.FREE
-      BackupLevel.PAID.value.toLong() -> MessageBackupTier.PAID
-      else -> null
-    }
-  }
-
   private fun SentMediaQuality.toRemoteSentMediaQuality(): AccountData.SentMediaQuality {
     return when (this) {
       SentMediaQuality.STANDARD -> AccountData.SentMediaQuality.STANDARD

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

@@ -26,6 +26,10 @@ class UsernameOutOfSyncBanner(private val onActionClick: (UsernameSyncState) ->
 
   override val enabled: Boolean
     get() {
+      if (SignalStore.account.isLinkedDevice) {
+        return false
+      }
+
       return when (SignalStore.account.usernameSyncState) {
         AccountValues.UsernameSyncState.USERNAME_AND_LINK_CORRUPTED -> true
         AccountValues.UsernameSyncState.LINK_CORRUPTED -> true

app/src/main/java/org/thoughtcrime/securesms/calls/links/CallLinks.kt

@@ -110,6 +110,9 @@ object CallLinks {
     } catch (_: UnsupportedEncodingException) {
       Log.w(TAG, "Invalid url: $url")
       return null
+    } catch (_: IllegalArgumentException) {
+      Log.w(TAG, "Invalid url: $url")
+      return null
     }
 
     val key = fragmentQuery[ROOT_KEY]

app/src/main/java/org/thoughtcrime/securesms/components/SignalProgressDialog.kt

@@ -48,11 +48,15 @@ class SignalProgressDialog private constructor(
   }
 
   fun hide() {
-    dialog.hide()
+    if (dialog.window?.decorView?.isAttachedToWindow == true) {
+      dialog.hide()
+    }
   }
 
   fun dismiss() {
-    dialog.dismiss()
+    if (dialog.window?.decorView?.isAttachedToWindow == true) {
+      dialog.dismiss()
+    }
   }
 
   companion object {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/AppSettingsActivity.kt

@@ -90,7 +90,11 @@ class AppSettingsActivity : DSLSettingsActivity(), GooglePayComponent {
         is AppSettingsRoute.BackupsRoute.Backups -> AppSettingsFragmentDirections.actionDirectToBackupsSettingsFragment().setLaunchCheckoutFlow(appSettingsRoute.launchCheckoutFlow)
         AppSettingsRoute.Invite -> AppSettingsFragmentDirections.actionDirectToInviteFragment()
         AppSettingsRoute.DataAndStorageRoute.DataAndStorage -> AppSettingsFragmentDirections.actionDirectToStoragePreferenceFragment()
-        AppSettingsRoute.AccountRoute.Account -> AppSettingsFragmentDirections.actionDirectToAccountSettingsFragment()
+        AppSettingsRoute.AccountRoute.Account -> if (SignalStore.account.isPrimaryDevice) {
+          AppSettingsFragmentDirections.actionDirectToAccountSettingsFragment()
+        } else {
+          AppSettingsFragmentDirections.actionDirectToLinkedDeviceAccountSettingsFragment()
+        }
         else -> error("Unsupported start location: ${appSettingsRoute?.javaClass?.name}")
       }
     }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/AppSettingsFragment.kt

@@ -76,6 +76,7 @@ import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaym
 import org.thoughtcrime.securesms.components.settings.app.subscription.completed.InAppPaymentsBottomSheetDelegate
 import org.thoughtcrime.securesms.compose.rememberStatusBarColorNestedScrollModifier
 import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.profiles.ProfileName
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.CommunicationActions
@@ -96,7 +97,11 @@ class AppSettingsFragment : ComposeFragment(), Callbacks {
         appSettingsRouter.currentRoute.collect { route ->
           when (route) {
             is AppSettingsRoute.BackupsRoute.Remote -> findNavController().safeNavigate(R.id.action_appSettingsFragment_to_remoteBackupsSettingsFragment)
-            is AppSettingsRoute.AccountRoute.Account -> findNavController().safeNavigate(R.id.action_appSettingsFragment_to_accountSettingsFragment)
+            is AppSettingsRoute.AccountRoute.Account -> if (SignalStore.account.isPrimaryDevice) {
+              findNavController().safeNavigate(R.id.action_appSettingsFragment_to_accountSettingsFragment)
+            } else {
+              findNavController().safeNavigate(R.id.action_appSettingsFragment_to_linkedDeviceAccountSettingsFragment)
+            }
             is AppSettingsRoute.LinkDeviceRoute.LinkDevice -> findNavController().safeNavigate(R.id.action_appSettingsFragment_to_linkDeviceFragment)
             is AppSettingsRoute.DonationsRoute.Donations -> findNavController().safeNavigate(R.id.action_appSettingsFragment_to_manageDonationsFragment)
             is AppSettingsRoute.AppearanceRoute.Appearance -> findNavController().safeNavigate(R.id.action_appSettingsFragment_to_appearanceSettingsFragment)
@@ -292,17 +297,17 @@ private fun AppSettingsContent(
           BackupFailureState.NONE -> Unit
         }
 
-        if (state.isPrimaryDevice) {
-          item {
-            Rows.TextRow(
-              text = stringResource(R.string.AccountSettingsFragment__account),
-              icon = painterResource(CoreUiR.drawable.symbol_person_circle_24),
-              onClick = {
-                callbacks.navigate(AppSettingsRoute.AccountRoute.Account)
-              }
-            )
-          }
+        item {
+          Rows.TextRow(
+            text = stringResource(R.string.AccountSettingsFragment__account),
+            icon = painterResource(CoreUiR.drawable.symbol_person_circle_24),
+            onClick = {
+              callbacks.navigate(AppSettingsRoute.AccountRoute.Account)
+            }
+          )
+        }
 
+        if (state.isPrimaryDevice) {
           item {
             Rows.TextRow(
               text = stringResource(R.string.preferences__linked_devices),
@@ -412,20 +417,20 @@ private fun AppSettingsContent(
           )
         }
 
-        if (state.isPrimaryDevice) {
-          item {
-            Rows.TextRow(
-              icon = SignalIcons.Backup.imageVector,
-              text = stringResource(R.string.preferences_chats__backups),
-              onClick = {
-                callbacks.navigate(AppSettingsRoute.BackupsRoute.Backups())
-              },
-              onLongClick = {
-                callbacks.copyRemoteBackupsSubscriberIdToClipboard()
-              },
-              enabled = isRegisteredAndUpToDate
-            )
-          }
+        item {
+          Rows.TextRow(
+            icon = SignalIcons.Backup.imageVector,
+            text = stringResource(R.string.preferences_chats__backups),
+            onClick = {
+              callbacks.navigate(AppSettingsRoute.BackupsRoute.Backups())
+            },
+            onLongClick = if (state.isPrimaryDevice) {
+              { callbacks.copyRemoteBackupsSubscriberIdToClipboard() }
+            } else {
+              null
+            },
+            enabled = isRegisteredAndUpToDate
+          )
         }
 
         item {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/account/LinkedDeviceAccountLearnMoreBottomSheet.kt

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.account
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.FragmentManager
+import org.signal.core.ui.BottomSheetUtil
+import org.signal.core.ui.compose.BottomSheets
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.signal.core.ui.compose.SignalIcons
+import org.signal.core.ui.compose.horizontalGutters
+import org.thoughtcrime.securesms.R
+
+/**
+ * Bottom sheet shown from the linked-device Account settings screen explaining what linked devices
+ * are and that account management lives on the primary device.
+ */
+class LinkedDeviceAccountLearnMoreBottomSheet : ComposeBottomSheetDialogFragment() {
+
+  override val peekHeightPercentage: Float = 0.75f
+
+  companion object {
+    @JvmStatic
+    fun show(fragmentManager: FragmentManager) {
+      LinkedDeviceAccountLearnMoreBottomSheet()
+        .show(fragmentManager, BottomSheetUtil.STANDARD_BOTTOM_SHEET_FRAGMENT_TAG)
+    }
+  }
+
+  @Composable
+  override fun SheetContent() {
+    LinkedDeviceAccountLearnMoreSheet()
+  }
+}
+
+@Composable
+private fun LinkedDeviceAccountLearnMoreSheet() {
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally,
+    modifier = Modifier
+      .fillMaxWidth()
+      .horizontalGutters()
+      .padding(bottom = 48.dp)
+  ) {
+    BottomSheets.Handle()
+
+    Icon(
+      imageVector = SignalIcons.Devices.imageVector,
+      contentDescription = null,
+      tint = MaterialTheme.colorScheme.primary,
+      modifier = Modifier
+        .padding(top = 16.dp, bottom = 24.dp)
+        .clip(RoundedCornerShape(50))
+        .background(MaterialTheme.colorScheme.primary.copy(alpha = 0.12f))
+        .padding(horizontal = 20.dp, vertical = 6.dp)
+        .size(40.dp)
+    )
+
+    val linkedDevices = stringResource(R.string.LinkedDeviceAccountLearnMoreBottomSheet__linked_devices)
+    val text = stringResource(R.string.LinkedDeviceAccountLearnMoreBottomSheet__linked_devices_let_you_access)
+    val annotatedText = remember(text, linkedDevices) {
+      buildAnnotatedString {
+        val start = text.indexOf(linkedDevices)
+        if (start >= 0) {
+          append(text.substring(0, start))
+          withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+            append(linkedDevices)
+          }
+          append(text.substring(start + linkedDevices.length))
+        } else {
+          append(text)
+        }
+      }
+    }
+
+    Text(
+      text = annotatedText,
+      style = MaterialTheme.typography.bodyLarge,
+      modifier = Modifier
+        .fillMaxWidth()
+        .padding(bottom = 20.dp)
+    )
+
+    BulletRow(stringResource(R.string.LinkedDeviceAccountLearnMoreBottomSheet__you_can_link_a_desktop))
+    BulletRow(stringResource(R.string.LinkedDeviceAccountLearnMoreBottomSheet__your_primary_device_manages))
+    BulletRow(stringResource(R.string.LinkedDeviceAccountLearnMoreBottomSheet__some_account_settings))
+  }
+}
+
+@Composable
+private fun BulletRow(text: String) {
+  Row(
+    modifier = Modifier
+      .fillMaxWidth()
+      .padding(bottom = 12.dp),
+    verticalAlignment = Alignment.Top
+  ) {
+    Text(
+      text = "\u2022",
+      style = MaterialTheme.typography.bodyLarge,
+      modifier = Modifier.padding(end = 8.dp)
+    )
+
+    Text(
+      text = text,
+      style = MaterialTheme.typography.bodyLarge
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun LinkedDeviceAccountLearnMoreSheetPreview() {
+  Previews.BottomSheetContentPreview {
+    LinkedDeviceAccountLearnMoreSheet()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/account/LinkedDeviceAccountSettingsEvent.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.account
+
+sealed interface LinkedDeviceAccountSettingsEvent {
+  /** The user tapped "Learn more" on the linked-device callout. */
+  data object LearnMoreClicked : LinkedDeviceAccountSettingsEvent
+
+  /** The user tapped the navigation (back) icon. */
+  data object NavigateBackClicked : LinkedDeviceAccountSettingsEvent
+
+  /** The user tapped the "Delete app data" row. */
+  data object DeleteAppDataClicked : LinkedDeviceAccountSettingsEvent
+
+  /** The user confirmed the delete in the confirmation dialog. */
+  data object DeleteConfirmed : LinkedDeviceAccountSettingsEvent
+
+  /** The user dismissed the delete confirmation dialog. */
+  data object DeleteDismissed : LinkedDeviceAccountSettingsEvent
+
+  /** The fragment reported that clearing application data failed. */
+  data object DataWipeFailed : LinkedDeviceAccountSettingsEvent
+
+  /** The fragment has handled the current [LinkedDeviceAccountSettingsState.oneTimeEvent]. */
+  data object ConsumeOneTimeEvent : LinkedDeviceAccountSettingsEvent
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/account/LinkedDeviceAccountSettingsFragment.kt

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.account
+
+import android.widget.Toast
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.viewModels
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.ComposeFragment
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Dialogs
+import org.signal.core.ui.compose.Dividers
+import org.signal.core.ui.compose.Previews
+import org.signal.core.ui.compose.Rows
+import org.signal.core.ui.compose.Scaffolds
+import org.signal.core.ui.compose.SignalIcons
+import org.signal.core.ui.compose.theme.SignalTheme
+import org.signal.core.util.ServiceUtil
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.account.LinkedDeviceAccountSettingsState.OneTimeEvent
+import org.thoughtcrime.securesms.compose.rememberStatusBarColorNestedScrollModifier
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+
+/**
+ * Account settings shown when the current device is a linked (non-primary) device. Account
+ * management lives on the primary device, so this screen only surfaces an informational callout
+ * and the ability to delete the Signal data stored on this device.
+ */
+class LinkedDeviceAccountSettingsFragment : ComposeFragment() {
+
+  private val viewModel: LinkedDeviceAccountSettingsViewModel by viewModels()
+
+  @Composable
+  override fun FragmentContent() {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+
+    LaunchedEffect(state.oneTimeEvent) {
+      viewModel.onEvent(LinkedDeviceAccountSettingsEvent.ConsumeOneTimeEvent)
+      when (state.oneTimeEvent) {
+        OneTimeEvent.OpenLearnMore -> LinkedDeviceAccountLearnMoreBottomSheet.show(childFragmentManager)
+        OneTimeEvent.NavigateBack -> requireActivity().onBackPressedDispatcher.onBackPressed()
+        OneTimeEvent.WipeData -> {
+          if (!ServiceUtil.getActivityManager(AppDependencies.application).clearApplicationUserData()) {
+            viewModel.onEvent(LinkedDeviceAccountSettingsEvent.DataWipeFailed)
+          }
+        }
+        OneTimeEvent.DeleteFailed -> Toast.makeText(requireContext(), R.string.preferences_account_delete_all_data_failed, Toast.LENGTH_LONG).show()
+        null -> Unit
+      }
+    }
+
+    LinkedDeviceAccountSettingsScreen(
+      state = state,
+      onEvent = viewModel::onEvent
+    )
+  }
+}
+
+@Composable
+private fun LinkedDeviceAccountSettingsScreen(
+  state: LinkedDeviceAccountSettingsState,
+  onEvent: (LinkedDeviceAccountSettingsEvent) -> Unit
+) {
+  Scaffolds.Settings(
+    title = stringResource(R.string.AccountSettingsFragment__account),
+    onNavigationClick = { onEvent(LinkedDeviceAccountSettingsEvent.NavigateBackClicked) },
+    navigationIcon = SignalIcons.ArrowStart.imageVector
+  ) { paddingValues ->
+    LazyColumn(
+      modifier = Modifier
+        .padding(paddingValues)
+        .then(rememberStatusBarColorNestedScrollModifier())
+    ) {
+      item {
+        LinkedDeviceCallout(onLearnMoreClick = { onEvent(LinkedDeviceAccountSettingsEvent.LearnMoreClicked) })
+      }
+
+      item {
+        Dividers.Default()
+      }
+
+      item {
+        Rows.TextRow(
+          text = stringResource(R.string.LinkedDeviceAccountSettingsFragment__delete_app_data),
+          label = stringResource(R.string.LinkedDeviceAccountSettingsFragment__this_will_remove_all_data),
+          onClick = { onEvent(LinkedDeviceAccountSettingsEvent.DeleteAppDataClicked) }
+        )
+      }
+    }
+  }
+
+  if (state.showDeleteConfirmationDialog) {
+    DeleteAppDataConfirmationDialog(
+      onConfirm = { onEvent(LinkedDeviceAccountSettingsEvent.DeleteConfirmed) },
+      onDismiss = { onEvent(LinkedDeviceAccountSettingsEvent.DeleteDismissed) }
+    )
+  }
+
+  if (state.deleting) {
+    Dialogs.IndeterminateProgressDialog()
+  }
+}
+
+@Composable
+private fun LinkedDeviceCallout(
+  onLearnMoreClick: () -> Unit
+) {
+  Row(
+    modifier = Modifier
+      .padding(horizontal = 24.dp, vertical = 12.dp)
+      .fillMaxWidth()
+      .background(color = SignalTheme.colors.colorSurface2, shape = RoundedCornerShape(12.dp))
+      .padding(20.dp)
+  ) {
+    Icon(
+      imageVector = SignalIcons.Devices.imageVector,
+      contentDescription = null,
+      tint = MaterialTheme.colorScheme.onSurface
+    )
+
+    Spacer(modifier = Modifier.width(24.dp))
+
+    Column {
+      Text(
+        text = stringResource(R.string.LinkedDeviceAccountSettingsFragment__this_is_a_linked_device),
+        style = MaterialTheme.typography.bodyLarge,
+        color = MaterialTheme.colorScheme.onSurface
+      )
+
+      Spacer(modifier = Modifier.height(4.dp))
+
+      Text(
+        text = stringResource(R.string.LinkedDeviceAccountSettingsFragment__to_manage_your_account_settings),
+        style = MaterialTheme.typography.bodyMedium,
+        color = MaterialTheme.colorScheme.onSurfaceVariant
+      )
+
+      Spacer(modifier = Modifier.height(12.dp))
+
+      Buttons.Small(
+        onClick = onLearnMoreClick,
+        colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.secondaryContainer, contentColor = MaterialTheme.colorScheme.onSecondaryContainer)
+      ) {
+        Text(text = stringResource(R.string.LearnMoreTextView_learn_more))
+      }
+    }
+  }
+}
+
+@Composable
+private fun DeleteAppDataConfirmationDialog(
+  onConfirm: () -> Unit,
+  onDismiss: () -> Unit
+) {
+  Dialogs.SimpleAlertDialog(
+    title = stringResource(R.string.LinkedDeviceAccountSettingsFragment__delete_app_data_question),
+    body = stringResource(R.string.LinkedDeviceAccountSettingsFragment__this_will_delete_all_data_and_messages),
+    confirm = stringResource(R.string.delete),
+    confirmColor = MaterialTheme.colorScheme.error,
+    onConfirm = onConfirm,
+    dismiss = stringResource(android.R.string.cancel),
+    onDismiss = onDismiss
+  )
+}
+
+@DayNightPreviews
+@Composable
+private fun LinkedDeviceAccountSettingsScreenPreview() {
+  Previews.Preview {
+    LinkedDeviceAccountSettingsScreen(
+      state = LinkedDeviceAccountSettingsState(),
+      onEvent = {}
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun LinkedDeviceAccountSettingsScreenDeleteConfirmationPreview() {
+  Previews.Preview {
+    LinkedDeviceAccountSettingsScreen(
+      state = LinkedDeviceAccountSettingsState(showDeleteConfirmationDialog = true),
+      onEvent = {}
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun LinkedDeviceAccountSettingsScreenDeletingPreview() {
+  Previews.Preview {
+    LinkedDeviceAccountSettingsScreen(
+      state = LinkedDeviceAccountSettingsState(deleting = true),
+      onEvent = {}
+    )
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/account/LinkedDeviceAccountSettingsState.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.account
+
+data class LinkedDeviceAccountSettingsState(
+  val showDeleteConfirmationDialog: Boolean = false,
+  val deleting: Boolean = false,
+  val oneTimeEvent: OneTimeEvent? = null
+) {
+  /** One-time side effects the fragment must carry out (they need Android/fragment context). Consumed via [LinkedDeviceAccountSettingsEvent.ConsumeOneTimeEvent]. */
+  sealed interface OneTimeEvent {
+    data object OpenLearnMore : OneTimeEvent
+    data object NavigateBack : OneTimeEvent
+    data object WipeData : OneTimeEvent
+    data object DeleteFailed : OneTimeEvent
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/account/LinkedDeviceAccountSettingsViewModel.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.account
+
+import androidx.annotation.VisibleForTesting
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.withContext
+import org.signal.core.ui.compose.EventDrivenViewModel
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.components.settings.app.account.LinkedDeviceAccountSettingsState.OneTimeEvent
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.linkdevice.LinkDeviceRepository
+
+/**
+ * Drives the account settings screen shown on a linked (non-primary) device. Owns the screen state
+ * and, on delete, makes a best-effort attempt to unlink this device from the server before the
+ * fragment wipes local data.
+ */
+class LinkedDeviceAccountSettingsViewModel(
+  private val selfDeviceId: () -> Int = { SignalStore.account.deviceId },
+  private val removeDevice: suspend (Int) -> Boolean = LinkDeviceRepository::removeDevice
+) : EventDrivenViewModel<LinkedDeviceAccountSettingsEvent>(TAG) {
+
+  companion object {
+    private val TAG = Log.tag(LinkedDeviceAccountSettingsViewModel::class)
+  }
+
+  private val _state = MutableStateFlow(LinkedDeviceAccountSettingsState())
+  val state: StateFlow<LinkedDeviceAccountSettingsState> = _state.asStateFlow()
+
+  override suspend fun processEvent(event: LinkedDeviceAccountSettingsEvent) {
+    applyEvent(_state.value, event) { _state.value = it }
+  }
+
+  @VisibleForTesting
+  suspend fun applyEvent(state: LinkedDeviceAccountSettingsState, event: LinkedDeviceAccountSettingsEvent, stateEmitter: (LinkedDeviceAccountSettingsState) -> Unit) {
+    when (event) {
+      LinkedDeviceAccountSettingsEvent.LearnMoreClicked -> stateEmitter(state.copy(oneTimeEvent = OneTimeEvent.OpenLearnMore))
+      LinkedDeviceAccountSettingsEvent.NavigateBackClicked -> stateEmitter(state.copy(oneTimeEvent = OneTimeEvent.NavigateBack))
+      LinkedDeviceAccountSettingsEvent.DeleteAppDataClicked -> stateEmitter(state.copy(showDeleteConfirmationDialog = true))
+      LinkedDeviceAccountSettingsEvent.DeleteDismissed -> stateEmitter(state.copy(showDeleteConfirmationDialog = false))
+      LinkedDeviceAccountSettingsEvent.DeleteConfirmed -> {
+        val deletingState = state.copy(showDeleteConfirmationDialog = false, deleting = true)
+        stateEmitter(deletingState)
+        withContext(Dispatchers.IO) { removeDevice(selfDeviceId()) }
+        stateEmitter(deletingState.copy(oneTimeEvent = OneTimeEvent.WipeData))
+      }
+      LinkedDeviceAccountSettingsEvent.DataWipeFailed -> stateEmitter(state.copy(deleting = false, oneTimeEvent = OneTimeEvent.DeleteFailed))
+      LinkedDeviceAccountSettingsEvent.ConsumeOneTimeEvent -> stateEmitter(state.copy(oneTimeEvent = null))
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/BackupsSettingsFragment.kt

@@ -35,6 +35,11 @@ import androidx.compose.ui.platform.LocalLocale
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.LinkAnnotation
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.withLink
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
 import androidx.fragment.app.viewModels
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -58,6 +63,7 @@ import org.thoughtcrime.securesms.backup.v2.ui.subscription.MessageBackupsType
 import org.thoughtcrime.securesms.components.settings.app.subscription.MessageBackupsCheckoutLauncher.createBackupsCheckoutLauncher
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.payments.FiatMoneyUtil
+import org.thoughtcrime.securesms.util.CommunicationActions
 import org.thoughtcrime.securesms.util.DateUtils
 import org.thoughtcrime.securesms.util.Environment
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
@@ -86,7 +92,7 @@ class BackupsSettingsFragment : ComposeFragment() {
       findNavController().safeNavigate(R.id.action_backupsSettingsFragment_to_remoteBackupsSettingsFragment)
     }
 
-    if (savedInstanceState == null && args.launchCheckoutFlow) {
+    if (savedInstanceState == null && args.launchCheckoutFlow && SignalStore.account.isPrimaryDevice) {
       checkoutLauncher.launch(null)
     }
   }
@@ -103,7 +109,9 @@ class BackupsSettingsFragment : ComposeFragment() {
           is BackupState.Error -> Unit
 
           BackupState.None -> {
-            checkoutLauncher.launch(null)
+            if (!state.isLinkedDevice) {
+              checkoutLauncher.launch(null)
+            }
           }
 
           else -> {
@@ -112,13 +120,14 @@ class BackupsSettingsFragment : ComposeFragment() {
         }
       },
       onOnDeviceBackupsRowClick = {
-        if (SignalStore.backup.newLocalBackupsEnabled || (Environment.Backups.isNewFormatSupportedForLocalBackup() && !SignalStore.settings.isBackupEnabled)) {
+        if (state.isLinkedDevice || SignalStore.backup.newLocalBackupsEnabled || (Environment.Backups.isNewFormatSupportedForLocalBackup() && !SignalStore.settings.isBackupEnabled)) {
           findNavController().safeNavigate(R.id.action_backupsSettingsFragment_to_localBackupsFragment)
         } else {
           findNavController().safeNavigate(R.id.action_backupsSettingsFragment_to_backupsPreferenceFragment)
         }
       },
-      onBackupTierInternalOverrideChanged = { viewModel.onBackupTierInternalOverrideChanged(it) }
+      onBackupTierInternalOverrideChanged = { viewModel.onBackupTierInternalOverrideChanged(it) },
+      onLearnMoreClick = { CommunicationActions.openBrowserLink(requireContext(), "https://support.signal.org/hc/articles/360007059752") }
     )
   }
 }
@@ -129,7 +138,8 @@ private fun BackupsSettingsContent(
   onNavigationClick: () -> Unit = {},
   onBackupsRowClick: () -> Unit = {},
   onOnDeviceBackupsRowClick: () -> Unit = {},
-  onBackupTierInternalOverrideChanged: (MessageBackupTier?) -> Unit = {}
+  onBackupTierInternalOverrideChanged: (MessageBackupTier?) -> Unit = {},
+  onLearnMoreClick: () -> Unit = {}
 ) {
   Scaffolds.Settings(
     title = stringResource(R.string.preferences_chats__backups),
@@ -166,21 +176,29 @@ private fun BackupsSettingsContent(
       }
 
       item {
+        val displayActionButton = !backupsSettingsState.isLinkedDevice
+
         when (backupsSettingsState.backupState) {
           is BackupState.LocalStore -> {
             LocalStoreBackupRow(
               backupState = backupsSettingsState.backupState,
               lastBackupAt = backupsSettingsState.lastBackupAt,
-              onBackupsRowClick = onBackupsRowClick
+              onBackupsRowClick = onBackupsRowClick,
+              displayActionButton = displayActionButton
             )
 
             OtherWaysToBackUpHeading()
           }
 
           is BackupState.Inactive -> {
-            InactiveBackupsRow(
-              onBackupsRowClick = onBackupsRowClick
-            )
+            if (backupsSettingsState.isLinkedDevice) {
+              BackupsOffLinkedDeviceRow(onLearnMoreClick = onLearnMoreClick)
+            } else {
+              InactiveBackupsRow(
+                onBackupsRowClick = onBackupsRowClick,
+                displayActionButton = true
+              )
+            }
 
             OtherWaysToBackUpHeading()
           }
@@ -189,23 +207,30 @@ private fun BackupsSettingsContent(
             ActiveBackupsRow(
               backupState = backupsSettingsState.backupState,
               onBackupsRowClick = onBackupsRowClick,
-              lastBackupAt = backupsSettingsState.lastBackupAt
+              lastBackupAt = backupsSettingsState.lastBackupAt,
+              displayActionButton = true
             )
 
             OtherWaysToBackUpHeading()
           }
 
           BackupState.None -> {
-            NeverEnabledBackupsRow(
-              onBackupsRowClick = onBackupsRowClick
-            )
+            if (backupsSettingsState.isLinkedDevice) {
+              BackupsOffLinkedDeviceRow(onLearnMoreClick = onLearnMoreClick)
+            } else {
+              NeverEnabledBackupsRow(
+                onBackupsRowClick = onBackupsRowClick,
+                displayActionButton = true
+              )
+            }
 
             OtherWaysToBackUpHeading()
           }
 
           is BackupState.Error -> {
             WaitingForNetworkRow(
-              onBackupsRowClick = onBackupsRowClick
+              onBackupsRowClick = onBackupsRowClick,
+              displayActionButton = displayActionButton
             )
 
             OtherWaysToBackUpHeading()
@@ -213,7 +238,8 @@ private fun BackupsSettingsContent(
 
           BackupState.NotFound -> {
             NotFoundBackupRow(
-              onBackupsRowClick = onBackupsRowClick
+              onBackupsRowClick = onBackupsRowClick,
+              displayActionButton = displayActionButton
             )
 
             OtherWaysToBackUpHeading()
@@ -221,7 +247,8 @@ private fun BackupsSettingsContent(
 
           is BackupState.Pending -> {
             PendingBackupRow(
-              onBackupsRowClick = onBackupsRowClick
+              onBackupsRowClick = onBackupsRowClick,
+              displayActionButton = displayActionButton
             )
 
             OtherWaysToBackUpHeading()
@@ -231,7 +258,8 @@ private fun BackupsSettingsContent(
             ActiveBackupsRow(
               backupState = backupsSettingsState.backupState,
               lastBackupAt = backupsSettingsState.lastBackupAt,
-              onBackupsRowClick = onBackupsRowClick
+              onBackupsRowClick = onBackupsRowClick,
+              displayActionButton = displayActionButton
             )
 
             OtherWaysToBackUpHeading()
@@ -262,7 +290,8 @@ private fun OtherWaysToBackUpHeading() {
 
 @Composable
 private fun NeverEnabledBackupsRow(
-  onBackupsRowClick: () -> Unit = {}
+  onBackupsRowClick: () -> Unit = {},
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     modifier = Modifier.wrapContentHeight(),
@@ -291,13 +320,15 @@ private fun NeverEnabledBackupsRow(
           style = MaterialTheme.typography.bodyMedium
         )
 
-        Buttons.MediumTonal(
-          onClick = onBackupsRowClick,
-          modifier = Modifier.padding(top = 12.dp)
-        ) {
-          Text(
-            text = stringResource(R.string.BackupsSettingsFragment_set_up)
-          )
+        if (displayActionButton) {
+          Buttons.MediumTonal(
+            onClick = onBackupsRowClick,
+            modifier = Modifier.padding(top = 12.dp)
+          ) {
+            Text(
+              text = stringResource(R.string.BackupsSettingsFragment_set_up)
+            )
+          }
         }
       }
     }
@@ -305,12 +336,57 @@ private fun NeverEnabledBackupsRow(
 }
 
 @Composable
-private fun WaitingForNetworkRow(onBackupsRowClick: () -> Unit = {}) {
+private fun BackupsOffLinkedDeviceRow(
+  onLearnMoreClick: () -> Unit = {}
+) {
+  val description = buildAnnotatedString {
+    append(stringResource(R.string.BackupsSettingsFragment__automatic_backups_get_started_on_your_phone))
+    append(" ")
+    withLink(LinkAnnotation.Clickable(tag = "learn-more") { onLearnMoreClick() }) {
+      withStyle(SpanStyle(color = MaterialTheme.colorScheme.primary)) {
+        append(stringResource(R.string.RemoteBackupsSettingsFragment__learn_more))
+      }
+    }
+  }
+
+  Rows.TextRow(
+    modifier = Modifier.wrapContentHeight(),
+    icon = {
+      Box(
+        modifier = Modifier
+          .padding(top = 12.dp)
+          .align(Alignment.Top)
+      ) {
+        Icon(
+          painter = SignalIcons.Backup.painter,
+          contentDescription = null
+        )
+      }
+    },
+    text = {
+      Column {
+        Text(
+          text = stringResource(R.string.RemoteBackupsSettingsFragment__signal_backups),
+          style = MaterialTheme.typography.bodyLarge
+        )
+
+        Text(
+          text = description,
+          color = MaterialTheme.colorScheme.onSurfaceVariant,
+          style = MaterialTheme.typography.bodyMedium
+        )
+      }
+    }
+  )
+}
+
+@Composable
+private fun WaitingForNetworkRow(onBackupsRowClick: () -> Unit = {}, displayActionButton: Boolean = true) {
   Rows.TextRow(
     text = {
       Column {
         Text(text = stringResource(R.string.RemoteBackupsSettingsFragment__waiting_for_network))
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     },
     icon = {
@@ -321,7 +397,8 @@ private fun WaitingForNetworkRow(onBackupsRowClick: () -> Unit = {}) {
 
 @Composable
 private fun InactiveBackupsRow(
-  onBackupsRowClick: () -> Unit = {}
+  onBackupsRowClick: () -> Unit = {},
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     text = {
@@ -336,7 +413,7 @@ private fun InactiveBackupsRow(
           style = MaterialTheme.typography.bodyMedium,
           color = MaterialTheme.colorScheme.onSurfaceVariant
         )
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     },
     icon = {
@@ -354,7 +431,8 @@ private fun InactiveBackupsRow(
 
 @Composable
 private fun NotFoundBackupRow(
-  onBackupsRowClick: () -> Unit = {}
+  onBackupsRowClick: () -> Unit = {},
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     modifier = Modifier.wrapContentHeight(),
@@ -382,7 +460,7 @@ private fun NotFoundBackupRow(
           style = MaterialTheme.typography.bodyMedium,
           color = MaterialTheme.colorScheme.onSurfaceVariant
         )
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     }
   )
@@ -390,7 +468,8 @@ private fun NotFoundBackupRow(
 
 @Composable
 private fun PendingBackupRow(
-  onBackupsRowClick: () -> Unit = {}
+  onBackupsRowClick: () -> Unit = {},
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     modifier = Modifier.wrapContentHeight(),
@@ -418,14 +497,18 @@ private fun PendingBackupRow(
           style = MaterialTheme.typography.bodyMedium
         )
 
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     }
   )
 }
 
 @Composable
-private fun ViewSettingsButton(onClick: () -> Unit) {
+private fun ViewSettingsButton(onClick: () -> Unit, visible: Boolean = true) {
+  if (!visible) {
+    return
+  }
+
   Buttons.MediumTonal(
     onClick = onClick,
     modifier = Modifier.padding(top = 12.dp)
@@ -440,7 +523,8 @@ private fun ViewSettingsButton(onClick: () -> Unit) {
 private fun LocalStoreBackupRow(
   backupState: BackupState.LocalStore,
   lastBackupAt: Duration,
-  onBackupsRowClick: () -> Unit
+  onBackupsRowClick: () -> Unit,
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     modifier = Modifier.wrapContentHeight(),
@@ -475,7 +559,7 @@ private fun LocalStoreBackupRow(
         )
 
         LastBackedUpText(lastBackupAt)
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     }
   )
@@ -485,7 +569,8 @@ private fun LocalStoreBackupRow(
 private fun ActiveBackupsRow(
   backupState: BackupState.WithTypeAndRenewalTime,
   lastBackupAt: Duration,
-  onBackupsRowClick: () -> Unit = {}
+  onBackupsRowClick: () -> Unit = {},
+  displayActionButton: Boolean = true
 ) {
   Rows.TextRow(
     modifier = Modifier.wrapContentHeight(),
@@ -552,7 +637,7 @@ private fun ActiveBackupsRow(
 
         LastBackedUpText(lastBackupAt)
 
-        ViewSettingsButton(onBackupsRowClick)
+        ViewSettingsButton(onBackupsRowClick, displayActionButton)
       }
     }
   )
@@ -644,7 +729,8 @@ private fun BackupsSettingsContentPreview() {
           renewalTime = 0.seconds,
           price = FiatMoney(BigDecimal.valueOf(4), Currency.getInstance("CAD"))
         ),
-        lastBackupAt = 0.seconds
+        lastBackupAt = 0.seconds,
+        isLinkedDevice = false
       )
     )
   }
@@ -652,14 +738,21 @@ private fun BackupsSettingsContentPreview() {
 
 @DayNightPreviews
 @Composable
-private fun BackupsSettingsContentBackupTierInternalOverridePreview() {
+private fun BackupsSettingsContentLinkedDevicePreview() {
   Previews.Preview {
     BackupsSettingsContent(
       backupsSettingsState = BackupsSettingsState(
-        backupState = BackupState.None,
-        showBackupTierInternalOverride = true,
-        backupTierInternalOverride = null,
-        lastBackupAt = 0.seconds
+        backupState = BackupState.ActivePaid(
+          messageBackupsType = MessageBackupsType.Paid(
+            pricePerMonth = FiatMoney(BigDecimal.valueOf(2.99), Currency.getInstance("USD")),
+            storageAllowanceBytes = 1_000_000,
+            mediaTtl = 30.days
+          ),
+          renewalTime = 0.seconds,
+          price = FiatMoney(BigDecimal.valueOf(2.99), Currency.getInstance("USD"))
+        ),
+        lastBackupAt = 0.seconds,
+        isLinkedDevice = true
       )
     )
   }
@@ -758,3 +851,11 @@ private fun NeverEnabledBackupsRowPreview() {
     NeverEnabledBackupsRow()
   }
 }
+
+@DayNightPreviews
+@Composable
+private fun BackupsOffLinkedDeviceRowPreview() {
+  Previews.Preview {
+    BackupsOffLinkedDeviceRow()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/BackupsSettingsState.kt

@@ -17,5 +17,6 @@ data class BackupsSettingsState(
   val backupState: BackupState,
   val lastBackupAt: Duration = SignalStore.backup.lastBackupTime.milliseconds,
   val showBackupTierInternalOverride: Boolean = false,
-  val backupTierInternalOverride: MessageBackupTier? = null
+  val backupTierInternalOverride: MessageBackupTier? = null,
+  val isLinkedDevice: Boolean = SignalStore.account.isLinkedDevice
 )

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/BackupsSettingsViewModel.kt

@@ -15,6 +15,7 @@ import kotlinx.coroutines.launch
 import org.signal.core.util.concurrent.SignalDispatchers
 import org.signal.core.util.logging.Log
 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.SignalDatabase
 import org.thoughtcrime.securesms.keyvalue.SignalStore
@@ -44,7 +45,7 @@ class BackupsSettingsViewModel : ViewModel() {
           it.copy(
             backupState = enabledState,
             lastBackupAt = SignalStore.backup.lastBackupTime.milliseconds,
-            showBackupTierInternalOverride = Environment.IS_STAGING,
+            showBackupTierInternalOverride = Environment.IS_STAGING && SignalStore.account.isPrimaryDevice,
             backupTierInternalOverride = SignalStore.backup.backupTierInternalOverride
           )
         }
@@ -59,6 +60,12 @@ class BackupsSettingsViewModel : ViewModel() {
           }
         }
     }
+
+    if (SignalStore.account.isLinkedDevice) {
+      viewModelScope.launch(Dispatchers.IO) {
+        BackupRepository.refreshBackupFileTimestamp()
+      }
+    }
   }
 
   fun onBackupTierInternalOverrideChanged(tier: MessageBackupTier?) {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/remote/RemoteBackupsSettingsFragment.kt

@@ -452,7 +452,8 @@ private fun RemoteBackupsSettingsContent(
               state = state.backupState,
               onLearnMoreClick = contentCallbacks::onLearnMoreAboutLostSubscription,
               onRenewClick = contentCallbacks::onRenewLostSubscription,
-              isRenewEnabled = backupDeleteState.isIdle()
+              isRenewEnabled = backupDeleteState.isIdle(),
+              isLinkedDevice = state.isLinkedDevice
             )
           }
 
@@ -464,7 +465,8 @@ private fun RemoteBackupsSettingsContent(
               onBackupTypeActionButtonClicked = contentCallbacks::onBackupTypeActionClick,
               isPaidTierPricingAvailable = state.isPaidTierPricingAvailable,
               isGooglePlayServicesAvailable = state.isGooglePlayServicesAvailable,
-              buttonsEnabled = backupDeleteState.isIdle()
+              buttonsEnabled = backupDeleteState.isIdle(),
+              isLinkedDevice = state.isLinkedDevice
             )
           }
 
@@ -473,13 +475,16 @@ private fun RemoteBackupsSettingsContent(
               title = stringResource(R.string.RemoteBackupsSettingsFragment__your_subscription_was_not_found),
               onRenewClick = contentCallbacks::onRenewLostSubscription,
               onLearnMoreClick = contentCallbacks::onLearnMoreAboutLostSubscription,
-              isRenewEnabled = backupDeleteState.isIdle()
+              isRenewEnabled = backupDeleteState.isIdle(),
+              isLinkedDevice = state.isLinkedDevice
             )
           }
         }
       }
 
-      if (backupDeleteState != DeletionState.NONE && backupDeleteState != DeletionState.CLEAR_LOCAL_STATE) {
+      if (state.isLinkedDevice) {
+        appendReducedBackupDetailsItems(state)
+      } else if (backupDeleteState != DeletionState.NONE && backupDeleteState != DeletionState.CLEAR_LOCAL_STATE) {
         appendBackupDeletionItems(
           backupDeleteState = backupDeleteState,
           backupRestoreState = backupRestoreState,
@@ -973,12 +978,58 @@ private fun LazyListScope.appendBackupDetailsItems(
   }
 }
 
+private fun LazyListScope.appendReducedBackupDetailsItems(
+  state: RemoteBackupsSettingsState
+) {
+  item {
+    Dividers.Default()
+  }
+
+  item {
+    Texts.SectionHeader(text = stringResource(id = R.string.RemoteBackupsSettingsFragment__backup_details))
+  }
+
+  item {
+    ReadOnlyLastBackupRow(lastBackupTimestamp = state.lastBackupTimestamp)
+  }
+}
+
+@Composable
+private fun ReadOnlyLastBackupRow(
+  lastBackupTimestamp: Long
+) {
+  val label = if (lastBackupTimestamp > 0) {
+    val context = LocalContext.current
+
+    val day = remember(lastBackupTimestamp) {
+      DateUtils.getDayPrecisionTimeString(context, Locale.getDefault(), lastBackupTimestamp)
+    }
+
+    val time = remember(lastBackupTimestamp) {
+      DateUtils.getOnlyTimeString(context, lastBackupTimestamp)
+    }
+
+    stringResource(
+      id = R.string.RemoteBackupsSettingsFragment__your_phone_s,
+      stringResource(id = R.string.RemoteBackupsSettingsFragment__s_at_s, day, time)
+    )
+  } else {
+    stringResource(id = R.string.RemoteBackupsSettingsFragment__never)
+  }
+
+  Rows.TextRow(
+    text = stringResource(id = R.string.RemoteBackupsSettingsFragment__last_backup),
+    label = label
+  )
+}
+
 @Composable
 private fun BackupCard(
   backupState: BackupState.WithTypeAndRenewalTime,
   isPaidTierPricingAvailable: Boolean,
   isGooglePlayServicesAvailable: Boolean,
   buttonsEnabled: Boolean,
+  isLinkedDevice: Boolean = false,
   onBackupTypeActionButtonClicked: (MessageBackupTier) -> Unit = {}
 ) {
   val messageBackupsType = backupState.messageBackupsType
@@ -1070,7 +1121,21 @@ private fun BackupCard(
       )
     }
 
-    if (backupState.isActive() && isPaidTierPricingAvailable && isGooglePlayServicesAvailable) {
+    if (isLinkedDevice) {
+      val primaryDeviceText = when (backupState) {
+        is BackupState.ActivePaid -> stringResource(R.string.RemoteBackupsSettingsFragment__you_can_manage_or_cancel_your_subscription_on_your_primary_device)
+        is BackupState.Canceled -> stringResource(R.string.RemoteBackupsSettingsFragment__you_can_manage_or_renew_your_subscription_on_your_primary_device)
+        is BackupState.ActiveFree -> stringResource(R.string.RemoteBackupsSettingsFragment__you_can_manage_or_upgrade_your_subscription_on_your_primary_device)
+        else -> stringResource(R.string.RemoteBackupsSettingsFragment__you_can_manage_or_upgrade_backups_on_your_primary_device)
+      }
+
+      Text(
+        text = primaryDeviceText,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        style = MaterialTheme.typography.bodyMedium,
+        modifier = Modifier.padding(top = 12.dp)
+      )
+    } else if (backupState.isActive() && isPaidTierPricingAvailable && isGooglePlayServicesAvailable) {
       val buttonText = when (messageBackupsType) {
         is MessageBackupsType.Paid -> stringResource(R.string.RemoteBackupsSettingsFragment__manage_or_cancel)
         is MessageBackupsType.Free -> stringResource(R.string.RemoteBackupsSettingsFragment__upgrade)
@@ -1270,6 +1335,7 @@ private fun PendingCard(
 private fun SubscriptionNotFoundCard(
   title: String,
   isRenewEnabled: Boolean,
+  isLinkedDevice: Boolean = false,
   onRenewClick: () -> Unit = {},
   onLearnMoreClick: () -> Unit = {}
 ) {
@@ -1308,38 +1374,47 @@ private fun SubscriptionNotFoundCard(
       }
     }
 
-    Row(
-      horizontalArrangement = spacedBy(16.dp)
-    ) {
-      Buttons.MediumTonal(
-        onClick = onRenewClick,
-        colors = ButtonDefaults.filledTonalButtonColors().copy(
-          containerColor = SignalTheme.colors.colorTransparent5,
-          contentColor = colorResource(CoreUiR.color.signal_light_colorOnSurface)
-        ),
-        modifier = Modifier
-          .padding(top = 24.dp)
-          .weight(1f)
+    if (isLinkedDevice) {
+      Text(
+        text = stringResource(R.string.RemoteBackupsSettingsFragment__you_can_manage_or_upgrade_backups_on_your_primary_device),
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        style = MaterialTheme.typography.bodyMedium,
+        modifier = Modifier.padding(top = 12.dp)
+      )
+    } else {
+      Row(
+        horizontalArrangement = spacedBy(16.dp)
       ) {
-        Text(
-          text = stringResource(R.string.RemoteBackupsSettingsFragment__renew)
-        )
-      }
+        Buttons.MediumTonal(
+          onClick = onRenewClick,
+          colors = ButtonDefaults.filledTonalButtonColors().copy(
+            containerColor = SignalTheme.colors.colorTransparent5,
+            contentColor = colorResource(CoreUiR.color.signal_light_colorOnSurface)
+          ),
+          modifier = Modifier
+            .padding(top = 24.dp)
+            .weight(1f)
+        ) {
+          Text(
+            text = stringResource(R.string.RemoteBackupsSettingsFragment__renew)
+          )
+        }
 
-      Buttons.MediumTonal(
-        onClick = onLearnMoreClick,
-        enabled = isRenewEnabled,
-        colors = ButtonDefaults.filledTonalButtonColors().copy(
-          containerColor = SignalTheme.colors.colorTransparent5,
-          contentColor = colorResource(CoreUiR.color.signal_light_colorOnSurface)
-        ),
-        modifier = Modifier
-          .padding(top = 24.dp)
-          .weight(1f)
-      ) {
-        Text(
-          text = stringResource(R.string.RemoteBackupsSettingsFragment__learn_more)
-        )
+        Buttons.MediumTonal(
+          onClick = onLearnMoreClick,
+          enabled = isRenewEnabled,
+          colors = ButtonDefaults.filledTonalButtonColors().copy(
+            containerColor = SignalTheme.colors.colorTransparent5,
+            contentColor = colorResource(CoreUiR.color.signal_light_colorOnSurface)
+          ),
+          modifier = Modifier
+            .padding(top = 24.dp)
+            .weight(1f)
+        ) {
+          Text(
+            text = stringResource(R.string.RemoteBackupsSettingsFragment__learn_more)
+          )
+        }
       }
     }
   }
@@ -1349,6 +1424,7 @@ private fun SubscriptionNotFoundCard(
 private fun SubscriptionMismatchMissingGooglePlayCard(
   state: BackupState.SubscriptionMismatchMissingGooglePlay,
   isRenewEnabled: Boolean,
+  isLinkedDevice: Boolean = false,
   onRenewClick: () -> Unit = {},
   onLearnMoreClick: () -> Unit = {}
 ) {
@@ -1357,6 +1433,7 @@ private fun SubscriptionMismatchMissingGooglePlayCard(
   SubscriptionNotFoundCard(
     title = pluralStringResource(R.plurals.RemoteBackupsSettingsFragment__your_subscription_on_this_device_is_valid, days.toInt(), days),
     isRenewEnabled = isRenewEnabled,
+    isLinkedDevice = isLinkedDevice,
     onRenewClick = onRenewClick,
     onLearnMoreClick = onLearnMoreClick
   )
@@ -1847,6 +1924,64 @@ private fun RemoteBackupsSettingsInternalUserContentPreview() {
   }
 }
 
+@DayNightPreviews
+@Composable
+private fun RemoteBackupsSettingsLinkedDevicePaidContentPreview() {
+  Previews.Preview {
+    RemoteBackupsSettingsContent(
+      state = RemoteBackupsSettingsState(
+        backupsEnabled = true,
+        isLinkedDevice = true,
+        lastBackupTimestamp = -1,
+        canBackUpUsingCellular = false,
+        canRestoreUsingCellular = false,
+        dialog = RemoteBackupsSettingsState.Dialog.NONE,
+        snackbar = RemoteBackupsSettingsState.Snackbar.NONE,
+        backupMediaSize = 2300000,
+        backupState = BackupState.ActivePaid(
+          messageBackupsType = MessageBackupsType.Paid(
+            pricePerMonth = FiatMoney(BigDecimal.valueOf(2.99), Currency.getInstance("USD")),
+            storageAllowanceBytes = 1_000_000,
+            mediaTtl = 30.days
+          ),
+          price = FiatMoney(BigDecimal.valueOf(2.99), Currency.getInstance("USD")),
+          renewalTime = 1_752_710_400.seconds
+        )
+      ),
+      statusBarColorNestedScrollConnection = null,
+      backupDeleteState = DeletionState.NONE,
+      backupRestoreState = BackupRestoreState.None,
+      contentCallbacks = ContentCallbacks.Empty,
+      backupProgress = null
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun RemoteBackupsSettingsLinkedDeviceNotFoundContentPreview() {
+  Previews.Preview {
+    RemoteBackupsSettingsContent(
+      state = RemoteBackupsSettingsState(
+        backupsEnabled = true,
+        isLinkedDevice = true,
+        lastBackupTimestamp = -1,
+        canBackUpUsingCellular = false,
+        canRestoreUsingCellular = false,
+        dialog = RemoteBackupsSettingsState.Dialog.NONE,
+        snackbar = RemoteBackupsSettingsState.Snackbar.NONE,
+        backupMediaSize = 2300000,
+        backupState = BackupState.NotFound
+      ),
+      statusBarColorNestedScrollConnection = null,
+      backupDeleteState = DeletionState.NONE,
+      backupRestoreState = BackupRestoreState.None,
+      contentCallbacks = ContentCallbacks.Empty,
+      backupProgress = null
+    )
+  }
+}
+
 @DayNightPreviews
 @Composable
 private fun RedemptionErrorAlertPreview() {
@@ -1875,10 +2010,8 @@ private fun ErrorCardPreview() {
 @Composable
 private fun PendingCardPreview() {
   Previews.Preview {
-    val locale = LocalLocale.current.platformLocale
-
     PendingCard(
-      price = FiatMoney(BigDecimal.TEN, Currency.getInstance(locale))
+      price = FiatMoney(BigDecimal.TEN, Currency.getInstance(Locale.US))
     )
   }
 }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/remote/RemoteBackupsSettingsState.kt

@@ -35,7 +35,8 @@ data class RemoteBackupsSettingsState(
   val backupCreationError: BackupValues.BackupCreationError? = null,
   val lastMessageCutoffTime: Long = 0,
   val freeTierMediaRetentionDays: Int = -1,
-  val isGooglePlayServicesAvailable: Boolean = false
+  val isGooglePlayServicesAvailable: Boolean = false,
+  val isLinkedDevice: Boolean = false
 ) {
 
   data class BackupMediaDetails(

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/backups/remote/RemoteBackupsSettingsViewModel.kt

@@ -79,7 +79,8 @@ class RemoteBackupsSettingsViewModel : ViewModel() {
       internalUser = RemoteConfig.internalUser,
       includeDebuglog = SignalStore.internal.includeDebuglogInBackup.takeIf { RemoteConfig.internalUser },
       backupCreationError = SignalStore.backup.backupCreationError,
-      lastMessageCutoffTime = SignalStore.backup.lastUsedMessageCutoffTime
+      lastMessageCutoffTime = SignalStore.backup.lastUsedMessageCutoffTime,
+      isLinkedDevice = SignalStore.account.isLinkedDevice
     )
   )
 
@@ -92,6 +93,14 @@ class RemoteBackupsSettingsViewModel : ViewModel() {
   private var forQuickRestore = false
 
   init {
+    if (state.value.isLinkedDevice) {
+      initLinkedDevice()
+    } else {
+      initPrimaryDevice()
+    }
+  }
+
+  private fun initPrimaryDevice() {
     ArchiveUploadProgress.triggerUpdate()
 
     viewModelScope.launch(Dispatchers.IO) {
@@ -199,6 +208,29 @@ class RemoteBackupsSettingsViewModel : ViewModel() {
     }
   }
 
+  /**
+   * Render remote backups as read-only and refresh the last-backup time from the CDN.
+   */
+  private fun initLinkedDevice() {
+    viewModelScope.launch(Dispatchers.IO) {
+      BackupStateObserver(viewModelScope, useDatabaseFallbackOnNetworkError = true).backupState.collect { backupState ->
+        _state.update {
+          it.copy(backupState = backupState)
+        }
+      }
+    }
+
+    viewModelScope.launch(Dispatchers.Default) {
+      SignalStore.backup.lastBackupTimeFlow.collect { lastBackupTime ->
+        _state.update { it.copy(lastBackupTimestamp = lastBackupTime) }
+      }
+    }
+
+    viewModelScope.launch(Dispatchers.IO) {
+      BackupRepository.refreshBackupFileTimestamp()
+    }
+  }
+
   fun setCanBackUpUsingCellular(canBackUpUsingCellular: Boolean) {
     SignalStore.backup.backupWithCellular = canBackUpUsingCellular
     _state.update {
@@ -259,6 +291,10 @@ class RemoteBackupsSettingsViewModel : ViewModel() {
   }
 
   fun refresh() {
+    if (state.value.isLinkedDevice) {
+      return
+    }
+
     viewModelScope.launch(Dispatchers.IO) {
       val id = SignalDatabase.inAppPayments.getLatestInAppPaymentByType(InAppPaymentType.RECURRING_BACKUP)?.id
 

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/InternalSettingsFragment.kt

@@ -588,19 +588,6 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
 
       dividerPref()
 
-      sectionHeaderPref(DSLSettingsText.from("Media"))
-
-      switchPref(
-        title = DSLSettingsText.from("Enable HEVC Encoding for HD Videos"),
-        summary = DSLSettingsText.from("Videos sent in \"HD\" quality will be encoded in HEVC on compatible devices."),
-        isChecked = state.hevcEncoding,
-        onClick = {
-          viewModel.setHevcEncoding(!state.hevcEncoding)
-        }
-      )
-
-      dividerPref()
-
       sectionHeaderPref(DSLSettingsText.from("Conversations and Shortcuts"))
 
       clickPref(

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/InternalSettingsState.kt

@@ -28,7 +28,6 @@ data class InternalSettingsState(
   val pnpInitialized: Boolean,
   val useConversationItemV2ForMedia: Boolean,
   val hasPendingOneTimeDonation: Boolean,
-  val hevcEncoding: Boolean,
   val forceSplitPane: Boolean,
   val forceSinglePane: Boolean,
   val useNewMediaActivity: Boolean,

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/InternalSettingsViewModel.kt

@@ -152,11 +152,6 @@ class InternalSettingsViewModel(private val repository: InternalSettingsReposito
     refresh()
   }
 
-  fun setHevcEncoding(enabled: Boolean) {
-    SignalStore.internal.hevcEncoding = enabled
-    refresh()
-  }
-
   fun addSampleReleaseNote(callToAction: String = "action") {
     repository.addSampleReleaseNote(callToAction)
   }
@@ -242,7 +237,6 @@ class InternalSettingsViewModel(private val repository: InternalSettingsReposito
     pnpInitialized = SignalStore.misc.hasPniInitializedDevices,
     useConversationItemV2ForMedia = SignalStore.internal.useConversationItemV2Media,
     hasPendingOneTimeDonation = SignalStore.inAppPayments.getPendingOneTimeDonation() != null,
-    hevcEncoding = SignalStore.internal.hevcEncoding,
     forceSplitPane = SignalStore.internal.forceSplitPane,
     forceSinglePane = SignalStore.internal.forceSinglePane,
     useNewMediaActivity = SignalStore.internal.useNewMediaActivity,

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/privacy/advanced/AdvancedPrivacySettingsViewModel.kt

@@ -71,6 +71,8 @@ class AdvancedPrivacySettingsViewModel(
 
   fun setAllowAutomaticVerification(enabled: Boolean) {
     SignalStore.settings.automaticVerificationEnabled = enabled
+    SignalStore.misc.hasKeyTransparencyFailure = false
+    SignalStore.misc.hasSeenKeyTransparencyFailure = false
     refresh()
     viewModelScope.launch(SignalDispatchers.Default) {
       if (!enabled) {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/privacy/expire/ExpireTimerSettingsFragment.kt

@@ -67,7 +67,9 @@ class ExpireTimerSettingsFragment : ComposeFragment() {
           if (state.isGroupCreate) {
             requireActivity().setResult(Activity.RESULT_OK, Intent().putExtra(FOR_RESULT_VALUE, saveState.result))
           }
-          requireActivity().onNavigateUp()
+          if (!NavHostFragment.findNavController(this).popBackStack()) {
+            requireActivity().onNavigateUp()
+          }
         }
 
         is ProcessState.Failure -> {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/storage/ManageStorageSettingsViewModel.kt

@@ -133,6 +133,7 @@ class ManageStorageSettingsViewModel : ViewModel() {
 
   private suspend fun getOnDeviceStorageOptimizationState(): OnDeviceStorageOptimizationState {
     return when {
+      !SignalStore.account.isPrimaryDevice -> OnDeviceStorageOptimizationState.FEATURE_NOT_AVAILABLE
       !SignalStore.backup.areBackupsEnabled || !BackupUpgradeAvailabilityChecker.isUpgradeAvailable(AppDependencies.application) -> OnDeviceStorageOptimizationState.FEATURE_NOT_AVAILABLE
       SignalStore.backup.backupTier != MessageBackupTier.PAID -> OnDeviceStorageOptimizationState.REQUIRES_PAID_TIER
       SignalStore.backup.optimizeStorage -> OnDeviceStorageOptimizationState.ENABLED

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/CheckoutFlowActivity.kt

@@ -9,6 +9,7 @@ import android.content.Context
 import android.content.Intent
 import android.os.Parcelable
 import androidx.activity.result.contract.ActivityResultContract
+import androidx.annotation.VisibleForTesting
 import androidx.fragment.app.Fragment
 import io.reactivex.rxjava3.subjects.PublishSubject
 import io.reactivex.rxjava3.subjects.Subject
@@ -26,7 +27,8 @@ import org.thoughtcrime.securesms.components.settings.app.subscription.GooglePay
 class CheckoutFlowActivity : FragmentWrapperActivity(), GooglePayComponent {
 
   companion object {
-    private const val ARG_IN_APP_PAYMENT_TYPE = "in_app_payment_type"
+    @VisibleForTesting
+    const val ARG_IN_APP_PAYMENT_TYPE = "in_app_payment_type"
     const val RESULT_DATA = "result_data"
 
     fun createIntent(context: Context, inAppPaymentType: InAppPaymentType): Intent {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/DonateToSignalFragment.kt

@@ -3,6 +3,7 @@ package org.thoughtcrime.securesms.components.settings.app.subscription.donate
 import android.text.SpannableStringBuilder
 import android.view.View
 import android.view.ViewGroup
+import androidx.annotation.VisibleForTesting
 import androidx.appcompat.widget.Toolbar
 import androidx.core.content.ContextCompat
 import androidx.core.os.bundleOf
@@ -78,7 +79,8 @@ class DonateToSignalFragment :
 
     companion object {
 
-      private const val ARG = "in_app_payment_type"
+      @VisibleForTesting
+      const val ARG = "in_app_payment_type"
 
       @JvmStatic
       fun create(inAppPaymentType: InAppPaymentType): DialogFragment {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/gateway/GatewaySelectorBottomSheetContent.kt

@@ -93,12 +93,14 @@ private fun Loading() {
 
 @Composable
 private fun Ready(state: GatewaySelectorState.Ready, onEvent: (GatewaySelectorBottomSheetEvent) -> Unit) {
+  Spacer(modifier = Modifier.size(38.dp))
+
   BadgeImage112(
     badge = state.inAppPayment.data.badge!!.let { Badges.fromDatabaseBadge(it) },
-    modifier = Modifier.size(112.dp)
+    modifier = Modifier.size(80.dp)
   )
 
-  Spacer(modifier = Modifier.size(12.dp))
+  Spacer(modifier = Modifier.size(16.dp))
 
   TitleAndSubtitle(state.inAppPayment)
 

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/transfer/DonationTransferTestTags.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer
+
+/**
+ * Test tags for the bank-transfer (SEPA) and iDEAL Compose entry forms, so instrumentation tests can
+ * drive them reliably. Follows the central-object convention used by the registration module's
+ * `TestTags`.
+ */
+object DonationTransferTestTags {
+  // SEPA bank transfer mandate
+  const val SEPA_MANDATE_CONTINUE_BUTTON = "sepa_mandate_continue_button"
+
+  // SEPA bank transfer details
+  const val SEPA_DETAILS_LIST = "sepa_details_list"
+  const val SEPA_IBAN_FIELD = "sepa_iban_field"
+  const val SEPA_NAME_FIELD = "sepa_name_field"
+  const val SEPA_EMAIL_FIELD = "sepa_email_field"
+  const val SEPA_DONATE_BUTTON = "sepa_donate_button"
+
+  // iDEAL transfer details
+  const val IDEAL_DETAILS_LIST = "ideal_details_list"
+  const val IDEAL_NAME_FIELD = "ideal_name_field"
+  const val IDEAL_EMAIL_FIELD = "ideal_email_field"
+  const val IDEAL_DONATE_BUTTON = "ideal_donate_button"
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/transfer/details/BankTransferDetailsFragment.kt

@@ -32,6 +32,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
@@ -63,6 +64,7 @@ import org.thoughtcrime.securesms.components.settings.app.subscription.donate.In
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.stripe.StripePaymentInProgressFragment
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.stripe.StripePaymentInProgressViewModel
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.BankTransferRequestKeys
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.DonationTransferTestTags
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.details.BankTransferDetailsViewModel.Field
 import org.thoughtcrime.securesms.database.InAppPaymentTable
 import org.thoughtcrime.securesms.payments.FiatMoneyUtil
@@ -237,6 +239,7 @@ fun BankTransferDetailsContent(
         modifier = Modifier
           .weight(1f)
           .padding(horizontal = 24.dp)
+          .testTag(DonationTransferTestTags.SEPA_DETAILS_LIST)
       ) {
         item {
           val learnMore = stringResource(id = R.string.BankTransferDetailsFragment__learn_more)
@@ -292,6 +295,7 @@ fun BankTransferDetailsContent(
               .defaultMinSize(minHeight = 78.dp)
               .onFocusChanged { onFocusChanged(Field.IBAN, it.hasFocus) }
               .focusRequester(focusRequester)
+              .testTag(DonationTransferTestTags.SEPA_IBAN_FIELD)
           )
         }
 
@@ -320,6 +324,7 @@ fun BankTransferDetailsContent(
               .padding(top = 16.dp)
               .defaultMinSize(minHeight = 78.dp)
               .onFocusChanged { onFocusChanged(Field.NAME, it.hasFocus) }
+              .testTag(DonationTransferTestTags.SEPA_NAME_FIELD)
           )
         }
 
@@ -348,6 +353,7 @@ fun BankTransferDetailsContent(
               .padding(top = 16.dp)
               .defaultMinSize(minHeight = 78.dp)
               .onFocusChanged { onFocusChanged(Field.EMAIL, it.hasFocus) }
+              .testTag(DonationTransferTestTags.SEPA_EMAIL_FIELD)
           )
         }
 
@@ -373,6 +379,7 @@ fun BankTransferDetailsContent(
         modifier = Modifier
           .defaultMinSize(minWidth = 220.dp)
           .padding(vertical = 16.dp)
+          .testTag(DonationTransferTestTags.SEPA_DONATE_BUTTON)
       ) {
         Text(text = donateLabel)
       }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/transfer/ideal/IdealTransferDetailsFragment.kt

@@ -26,6 +26,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusDirection
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
@@ -60,6 +61,7 @@ import org.thoughtcrime.securesms.components.settings.app.subscription.donate.ga
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.stripe.StripePaymentInProgressFragment
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.stripe.StripePaymentInProgressViewModel
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.BankTransferRequestKeys
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.DonationTransferTestTags
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.ideal.IdealTransferDetailsViewModel.Field
 import org.thoughtcrime.securesms.database.InAppPaymentTable
 import org.thoughtcrime.securesms.payments.FiatMoneyUtil
@@ -241,6 +243,7 @@ private fun IdealTransferDetailsContent(
         modifier = Modifier
           .weight(1f)
           .padding(horizontal = 24.dp)
+          .testTag(DonationTransferTestTags.IDEAL_DETAILS_LIST)
       ) {
         item {
           val learnMore = stringResource(id = R.string.IdealTransferDetailsFragment__learn_more)
@@ -283,6 +286,7 @@ private fun IdealTransferDetailsContent(
               .padding(top = 16.dp)
               .defaultMinSize(minHeight = 78.dp)
               .onFocusChanged { onFocusChanged(Field.NAME, it.hasFocus) }
+              .testTag(DonationTransferTestTags.IDEAL_NAME_FIELD)
           )
         }
 
@@ -316,6 +320,7 @@ private fun IdealTransferDetailsContent(
                 .padding(top = 16.dp)
                 .defaultMinSize(minHeight = 78.dp)
                 .onFocusChanged { onFocusChanged(Field.EMAIL, it.hasFocus) }
+                .testTag(DonationTransferTestTags.IDEAL_EMAIL_FIELD)
             )
           }
         }
@@ -327,6 +332,7 @@ private fun IdealTransferDetailsContent(
         modifier = Modifier
           .defaultMinSize(minWidth = 220.dp)
           .padding(bottom = 16.dp)
+          .testTag(DonationTransferTestTags.IDEAL_DONATE_BUTTON)
       ) {
         Text(text = donateLabel)
       }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/transfer/mandate/BankTransferMandateFragment.kt

@@ -40,6 +40,7 @@ import androidx.compose.ui.Alignment.Companion.CenterHorizontally
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
@@ -58,6 +59,7 @@ import org.signal.core.ui.compose.SignalIcons
 import org.signal.core.ui.compose.Texts
 import org.signal.core.ui.compose.theme.SignalTheme
 import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.subscription.donate.transfer.DonationTransferTestTags
 import org.thoughtcrime.securesms.compose.StatusBarColorAnimator
 import org.thoughtcrime.securesms.database.model.databaseprotos.InAppPaymentData
 import org.thoughtcrime.securesms.util.SpanUtil
@@ -267,6 +269,7 @@ fun BankTransferScreen(
               .wrapContentWidth()
               .padding(top = 16.dp, bottom = 16.dp)
               .defaultMinSize(minWidth = 220.dp)
+              .testTag(DonationTransferTestTags.SEPA_MANDATE_CONTINUE_BUTTON)
           ) {
             Text(text = if (listState.canScrollForward) stringResource(id = R.string.BankTransferMandateFragment__read_more) else stringResource(id = R.string.BankTransferMandateFragment__agree))
           }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/thanks/ThanksForYourSupportBottomSheetDialogFragment.kt

@@ -1,6 +1,5 @@
 package org.thoughtcrime.securesms.components.settings.app.subscription.thanks
 
-import android.animation.Animator
 import android.content.DialogInterface
 import android.os.Bundle
 import android.text.SpannableStringBuilder
@@ -11,14 +10,12 @@ import android.widget.TextView
 import androidx.core.content.ContextCompat
 import androidx.core.text.method.LinkMovementMethodCompat
 import com.airbnb.lottie.LottieAnimationView
-import com.airbnb.lottie.LottieDrawable
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.materialswitch.MaterialSwitch
 import io.reactivex.rxjava3.kotlin.subscribeBy
 import org.signal.core.ui.FixedRoundedCornerBottomSheetDialogFragment
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.animation.AnimationCompleteListener
 import org.thoughtcrime.securesms.badges.BadgeImageView
 import org.thoughtcrime.securesms.badges.BadgeRepository
 import org.thoughtcrime.securesms.badges.models.Badge
@@ -122,23 +119,8 @@ class ThanksForYourSupportBottomSheetDialogFragment : FixedRoundedCornerBottomSh
       controlState = ControlState.DISPLAY
     }
 
-    if (args.badge.isBoost()) {
-      badgeView.visibility = View.INVISIBLE
-      lottie.visible = true
-      lottie.playAnimation()
-      lottie.addAnimatorListener(object : AnimationCompleteListener() {
-        override fun onAnimationEnd(animation: Animator) {
-          lottie.removeAnimatorListener(this)
-          lottie.setMinAndMaxFrame(30, 91)
-          lottie.repeatMode = LottieDrawable.RESTART
-          lottie.repeatCount = LottieDrawable.INFINITE
-          lottie.frame = 30
-          lottie.playAnimation()
-        }
-      })
-    } else {
-      lottie.visible = false
-    }
+    // New badge does not have a lottie, so we just hide it and show a static image.
+    lottie.visible = false
 
     done.setOnClickListener { dismissAllowingStateLoss() }
   }

app/src/main/java/org/thoughtcrime/securesms/contacts/paged/ContactSearchModels.kt

@@ -18,6 +18,7 @@ import androidx.appcompat.widget.AppCompatImageView
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -234,6 +235,7 @@ object ContactSearchModels {
       ) { model ->
         Text(
           text = if (model.empty.query.isNullOrEmpty()) stringResource(R.string.SearchFragment_no_results_empty) else stringResource(R.string.SearchFragment_no_results, model.empty.query),
+          color = MaterialTheme.colorScheme.onSurface,
           textAlign = TextAlign.Center,
           modifier = Modifier
             .fillMaxWidth()

app/src/main/java/org/thoughtcrime/securesms/conversation/ConversationUpdateItem.java

@@ -697,7 +697,7 @@ public final class ConversationUpdateItem extends FrameLayout
       });
 
       actionButton.setText(R.string.ConversationActivity__invite_to_signal);
-    } else if (conversationMessage.getMessageRecord().isPaymentsRequestToActivate() && !conversationMessage.getMessageRecord().isOutgoing() && !SignalStore.payments().mobileCoinPaymentsEnabled()) {
+    } else if (conversationMessage.getMessageRecord().isPaymentsRequestToActivate() && !conversationMessage.getMessageRecord().isOutgoing() && !SignalStore.payments().mobileCoinPaymentsEnabled() && SignalStore.account().isPrimaryDevice()) {
       actionButton.setText(R.string.ConversationUpdateItem_activate_payments);
       actionButton.setVisibility(VISIBLE);
       actionButton.setOnClickListener(v -> {
@@ -707,7 +707,7 @@ public final class ConversationUpdateItem extends FrameLayout
           passthroughClickListener.onClick(v);
         }
       });
-    } else if (conversationMessage.getMessageRecord().isPaymentsActivated() && !conversationMessage.getMessageRecord().isOutgoing()) {
+    } else if (conversationMessage.getMessageRecord().isPaymentsActivated() && !conversationMessage.getMessageRecord().isOutgoing() && SignalStore.account().isPrimaryDevice()) {
       actionButton.setText(R.string.ConversationUpdateItem_send_payment);
       actionButton.setVisibility(VISIBLE);
       actionButton.setOnClickListener(v -> {

app/src/main/java/org/thoughtcrime/securesms/conversation/MenuState.java

@@ -260,7 +260,7 @@ public final class MenuState {
     return builder.shouldShowCopyAction(!actionMessage && !remoteDelete && hasText && !hasGift && !hasPayment && !hasPoll)
                   .shouldShowDeleteAction(!hasInMemory && onlyContainsCompleteMessages(selectedParts))
                   .shouldShowReactions(!conversationRecipient.isReleaseNotes() && !conversationRecipient.isInactiveGroup())
-                  .shouldShowPaymentDetails(hasPayment)
+                  .shouldShowPaymentDetails(hasPayment && SignalStore.account().isPrimaryDevice())
                   .shouldShowPollTerminate(hasPollTerminate)
                   .shouldShowPinMessage(canPinMessage)
                   .shouldShowUnpinMessage(canUnpinMessage)

app/src/main/java/org/thoughtcrime/securesms/conversation/plaintext/PlaintextExportRepository.kt

@@ -44,6 +44,18 @@ object PlaintextExportRepository {
   private val TAG = Log.tag(PlaintextExportRepository::class.java)
   private const val BATCH_SIZE = 500
 
+  private val EMOJI_REGEX = Regex(
+    "[" +
+      "\\x{1F000}-\\x{1FAFF}" +
+      "\\x{2600}-\\x{27BF}" +
+      "\\x{2300}-\\x{23FF}" +
+      "\\x{2B00}-\\x{2BFF}" +
+      "\\x{FE00}-\\x{FE0F}" +
+      "\\x{200D}" +
+      "\\x{20E3}" +
+      "]"
+  )
+
   fun export(
     context: Context,
     threadId: Long,
@@ -435,7 +447,13 @@ object PlaintextExportRepository {
 
   @VisibleForTesting
   internal fun sanitizeFileName(name: String): String {
-    return name.replace(Regex("[\\\\/:*?\"<>|]"), "_").trim().take(100)
+    val sanitized = name
+      .replace(EMOJI_REGEX, "")
+      .replace(Regex("[\\\\/:*?\"<>|]"), "_")
+      .replace(Regex("\\s+"), " ")
+      .trim()
+      .take(100)
+    return if (sanitized.isEmpty() || sanitized.all { it == '.' }) "chat" else sanitized
   }
 
   private fun <T> ExecutorService.submitTyped(callable: Callable<T>): Future<T> {

app/src/main/java/org/thoughtcrime/securesms/conversation/v2/keyboard/AttachmentKeyboardFragment.kt

@@ -128,7 +128,7 @@ class AttachmentKeyboardFragment : LoggingFragment(R.layout.attachment_keyboard_
 
   private fun updateButtonsAvailable(recipient: Recipient) {
     val paymentsValues = SignalStore.payments
-    val isPaymentsAvailable = paymentsValues.paymentsAvailability.isSendAllowed && !recipient.isSelf && !recipient.isGroup && recipient.isRegistered
+    val isPaymentsAvailable = paymentsValues.paymentsAvailability.isSendAllowed && !recipient.isSelf && !recipient.isGroup && recipient.isRegistered && SignalStore.account.isPrimaryDevice
 
     if (!isPaymentsAvailable) {
       attachmentKeyboardView.filterAttachmentKeyboardButtons(removePaymentFilter)

app/src/main/java/org/thoughtcrime/securesms/conversationlist/ConversationListFragment.java

@@ -27,7 +27,6 @@ import android.graphics.Canvas;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
-import android.os.AsyncTask;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
@@ -1224,33 +1223,22 @@ public class ConversationListFragment extends MainFragment implements Conversati
       final Set<Long> selectedConversations = new HashSet<>(ids);
 
       if (!selectedConversations.isEmpty()) {
-        new AsyncTask<Void, Void, Void>() {
-          private SignalProgressDialog dialog;
+        SignalProgressDialog progressDialog = SignalProgressDialog.show(requireActivity(),
+                                                                        context.getString(R.string.ConversationListFragment_deleting),
+                                                                        context.getResources().getQuantityString(R.plurals.ConversationListFragment_deleting_selected_conversations, conversationsCount),
+                                                                        true,
+                                                                        false);
 
-          @Override
-          protected void onPreExecute() {
-            dialog = SignalProgressDialog.show(requireActivity(),
-                                               context.getString(R.string.ConversationListFragment_deleting),
-                                               context.getResources().getQuantityString(R.plurals.ConversationListFragment_deleting_selected_conversations, conversationsCount),
-                                               true,
-                                               false);
-          }
-
-          @Override
-          protected Void doInBackground(Void... params) {
-            Log.d(TAG, "[handleDelete] Deleting " + selectedConversations.size() + " chats");
-            SignalDatabase.threads().deleteConversations(selectedConversations, true);
-            AppDependencies.getMessageNotifier().updateNotification(AppDependencies.getApplication());
-            Log.d(TAG, "[handleDelete] Delete complete");
-            return null;
-          }
-
-          @Override
-          protected void onPostExecute(Void result) {
-            dialog.dismiss();
-            endActionModeIfActive();
-          }
-        }.executeOnExecutor(SignalExecutors.BOUNDED);
+        SimpleTask.run(getViewLifecycleOwner().getLifecycle(), () -> {
+          Log.d(TAG, "[handleDelete] Deleting " + selectedConversations.size() + " chats");
+          SignalDatabase.threads().deleteConversations(selectedConversations, true);
+          AppDependencies.getMessageNotifier().updateNotification(AppDependencies.getApplication());
+          Log.d(TAG, "[handleDelete] Delete complete");
+          return null;
+        }, unused -> {
+          progressDialog.dismiss();
+          endActionModeIfActive();
+        });
       }
     });
 

app/src/main/java/org/thoughtcrime/securesms/dependencies/AppDependencies.kt

@@ -498,6 +498,7 @@ object AppDependencies {
     fun provideProfileService(profileOperations: ClientZkProfileOperations, authWebSocket: SignalWebSocket.AuthenticatedWebSocket, unauthWebSocket: SignalWebSocket.UnauthenticatedWebSocket): ProfileService
     fun provideDeadlockDetector(): DeadlockDetector
     fun provideClientZkReceiptOperations(signalServiceConfiguration: SignalServiceConfiguration): ClientZkReceiptOperations
+    fun provideOkHttpClient(): OkHttpClient
     fun provideScheduledMessageManager(): ScheduledMessageManager
     fun providePinnedMessageManager(): PinnedMessageManager
     fun provideLibsignalNetwork(config: SignalServiceConfiguration): Network

app/src/main/java/org/thoughtcrime/securesms/dependencies/ApplicationDependencyProvider.java

@@ -9,6 +9,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 import androidx.media3.exoplayer.ExoPlayer;
 
+import okhttp3.OkHttpClient;
 import org.jetbrains.annotations.NotNull;
 import org.signal.billing.BillingFactory;
 import org.signal.core.models.ServiceId.ACI;
@@ -209,6 +210,7 @@ public class ApplicationDependencyProvider implements AppDependencies.Provider {
                                                 protocolStore.aci(),
                                                 new SignalProtocolAddress(pushServiceSocket.getCredentialsProvider().getAci().getLibSignalServiceId(),
                                                                           pushServiceSocket.getCredentialsProvider().getDeviceId()),
+                                                ReentrantSessionLock.INSTANCE,
                                                 PreKeyBatcher.INSTANCE
                                               )
                                             );
@@ -541,6 +543,14 @@ public class ApplicationDependencyProvider implements AppDependencies.Provider {
     return provideClientZkOperations(signalServiceConfiguration).getReceiptOperations();
   }
 
+  @Override
+  public @NonNull OkHttpClient provideOkHttpClient() {
+    return new OkHttpClient.Builder()
+        .addInterceptor(new StandardUserAgentInterceptor())
+        .dns(SignalServiceNetworkAccess.DNS)
+        .build();
+  }
+
   @Override
   public @NonNull BillingApi provideBillingApi() {
     return BillingFactory.create(GooglePlayBillingDependencies.INSTANCE, Environment.Backups.supportsGooglePlayBilling());

app/src/main/java/org/thoughtcrime/securesms/dependencies/NetworkDependenciesModule.kt

@@ -37,7 +37,6 @@ import org.thoughtcrime.securesms.groups.GroupsV2Authorization
 import org.thoughtcrime.securesms.groups.GroupsV2AuthorizationMemoryValueCache
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.messages.IncomingMessageObserver
-import org.thoughtcrime.securesms.net.StandardUserAgentInterceptor
 import org.thoughtcrime.securesms.payments.Payments
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess
 import org.thoughtcrime.securesms.push.SignalServiceTrustStore
@@ -244,10 +243,7 @@ class NetworkDependenciesModule(
   }
 
   val okHttpClient: OkHttpClient by lazy {
-    OkHttpClient.Builder()
-      .addInterceptor(StandardUserAgentInterceptor())
-      .dns(SignalServiceNetworkAccess.DNS)
-      .build()
+    provider.provideOkHttpClient()
   }
 
   val signalOkHttpClient: OkHttpClient by lazy {

app/src/main/java/org/thoughtcrime/securesms/devicetransfer/newdevice/NewDeviceTransferSetupFragment.java

@@ -85,7 +85,7 @@ public final class NewDeviceTransferSetupFragment extends DeviceTransferSetupFra
   protected void startTransfer() {
     PendingIntent pendingIntent = PendingIntent.getActivity(requireContext(), 0, MainActivity.clearTop(requireContext()), PendingIntentFlags.mutable());
 
-    TransferNotificationData notificationData = new TransferNotificationData(NotificationIds.DEVICE_TRANSFER, NotificationChannels.getInstance().BACKUPS, R.drawable.ic_signal_backup);
+    TransferNotificationData notificationData = new TransferNotificationData(NotificationIds.DEVICE_TRANSFER, NotificationChannels.getInstance().BACKUPS, org.signal.core.ui.R.drawable.ic_signal_backup);
     DeviceToDeviceTransferService.startServer(requireContext(), new NewDeviceServerTask(), notificationData, pendingIntent);
   }
 }

app/src/main/java/org/thoughtcrime/securesms/devicetransfer/olddevice/OldDeviceTransferSetupFragment.java

@@ -58,7 +58,7 @@ public final class OldDeviceTransferSetupFragment extends DeviceTransferSetupFra
     intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
     PendingIntent pendingIntent = PendingIntent.getActivity(requireContext(), 0, intent, PendingIntentFlags.mutable());
 
-    DeviceToDeviceTransferService.TransferNotificationData notificationData = new DeviceToDeviceTransferService.TransferNotificationData(NotificationIds.DEVICE_TRANSFER, NotificationChannels.getInstance().BACKUPS, R.drawable.ic_signal_backup);
+    DeviceToDeviceTransferService.TransferNotificationData notificationData = new DeviceToDeviceTransferService.TransferNotificationData(NotificationIds.DEVICE_TRANSFER, NotificationChannels.getInstance().BACKUPS, org.signal.core.ui.R.drawable.ic_signal_backup);
     DeviceToDeviceTransferService.startClient(requireContext(), new OldDeviceClientTask(), notificationData, pendingIntent);
   }
 

app/src/main/java/org/thoughtcrime/securesms/gcm/FcmFetchForegroundService.kt

@@ -7,11 +7,11 @@ import android.content.Intent
 import android.os.IBinder
 import android.os.PowerManager
 import androidx.core.app.NotificationCompat
+import org.signal.core.util.ForegroundServiceUtil
 import org.signal.core.util.PendingIntentFlags
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.MainActivity
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.jobs.ForegroundServiceUtil
 import org.thoughtcrime.securesms.notifications.NotificationChannels
 import org.thoughtcrime.securesms.notifications.NotificationIds
 import org.thoughtcrime.securesms.util.WakeLockUtil

app/src/main/java/org/thoughtcrime/securesms/glide/DecryptableStreamLocalUriFetcher.java

@@ -32,7 +32,7 @@ class DecryptableStreamLocalUriFetcher extends StreamLocalUriFetcher {
 
   private static final String TAG = Log.tag(DecryptableStreamLocalUriFetcher.class);
 
-  private static final long TOTAL_PIXEL_SIZE_LIMIT = 200_000_000L; // 200 megapixels
+  private static final long TOTAL_PIXEL_SIZE_LIMIT = 210_000_000L; // 210 megapixels
 
   private final Context context;
   private final long    thumbnailTimeUs;
@@ -89,7 +89,13 @@ class DecryptableStreamLocalUriFetcher extends StreamLocalUriFetcher {
       InputStream            stream      = PartAuthority.getAttachmentThumbnailStream(context, uri);
       Pair<Integer, Integer> dimensions  = BitmapUtil.getDimensions(stream);
       long                   totalPixels = (long) dimensions.getFirst() * dimensions.getSecond();
-      return totalPixels < TOTAL_PIXEL_SIZE_LIMIT;
+      boolean                safe        = totalPixels < TOTAL_PIXEL_SIZE_LIMIT;
+
+      if (!safe) {
+        Log.w(TAG, "Unsafe size! (" + dimensions.getFirst() + " x " + dimensions.getSecond() + ") = " + totalPixels);
+      }
+
+      return safe;
     } catch (BitmapDecodingException e) {
       Long size = PartAuthority.getAttachmentSize(context, uri);
       return size != null && size < GlideStreamConfig.getMarkReadLimitBytes();

app/src/main/java/org/thoughtcrime/securesms/jobmanager/impl/DataRestoreConstraint.kt

@@ -12,6 +12,7 @@ object DataRestoreConstraint : Constraint {
   const val KEY = "DataRestoreConstraint"
 
   @JvmStatic
+  @Volatile
   var isRestoringData: Boolean = false
     set(value) {
       field = value

app/src/main/java/org/thoughtcrime/securesms/jobs/AvatarGroupsV2DownloadJob.java

@@ -18,6 +18,7 @@ import org.thoughtcrime.securesms.dependencies.AppDependencies;
 import org.thoughtcrime.securesms.groups.GroupId;
 import org.thoughtcrime.securesms.jobmanager.JsonJobData;
 import org.thoughtcrime.securesms.jobmanager.Job;
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint;
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint;
 import org.thoughtcrime.securesms.profiles.AvatarHelper;
 import org.thoughtcrime.securesms.recipients.Recipient;
@@ -62,6 +63,7 @@ public final class AvatarGroupsV2DownloadJob extends BaseJob {
   public AvatarGroupsV2DownloadJob(@NonNull GroupId.V2 groupId, @NonNull String cdnKey, boolean force) {
     this(new Parameters.Builder()
                        .addConstraint(NetworkConstraint.KEY)
+                       .addConstraint(DataRestoreConstraint.KEY)
                        .setQueue("AvatarGroupsV2DownloadJob::" + groupId)
                        .setMaxAttempts(10)
                        .build(),

app/src/main/java/org/thoughtcrime/securesms/jobs/CheckKeyTransparencyJob.kt

@@ -135,7 +135,7 @@ class CheckKeyTransparencyJob private constructor(
       keyTransparencyStore = KeyTransparencyStore
     )
 
-    Log.i(TAG, "Key transparency complete, result: $result. Included username in check: ${Recipient.self().usernameSyncMessagesCapability.isSupported}, next check time: ${SignalStore.misc.nextKeyTransparencyTime}")
+    Log.i(TAG, "Key transparency complete, result: $result. Included username in check: ${Recipient.self().usernameSyncMessagesCapability.isSupported}, discoverability: ${SignalStore.phoneNumberPrivacy.phoneNumberDiscoverabilityMode}, next check time: ${SignalStore.misc.nextKeyTransparencyTime}")
     return when (result) {
       is RequestResult.Success -> {
         SignalStore.misc.hasKeyTransparencyFailure = false
@@ -144,9 +144,10 @@ class CheckKeyTransparencyJob private constructor(
       }
 
       is RequestResult.NonSuccess -> {
-        if (!showFailure) {
+        if (!showFailure && !SignalStore.misc.hasKeyTransparencyFailure) {
           Log.w(TAG, "Verification failure. Enqueuing this job again to run again a day.")
-          StorageSyncJob.forRemoteChange()
+          AppDependencies.jobManager.add(StorageSyncJob.forRemoteChange())
+          AppDependencies.jobManager.add(RefreshAttributesJob())
           enqueueFollowingFailure()
         } else {
           Log.w(TAG, "Second verification failure. Showing failure sheet.")

app/src/main/java/org/thoughtcrime/securesms/jobs/IndividualSendJobV2.kt

@@ -444,6 +444,7 @@ class IndividualSendJobV2 private constructor(parameters: Parameters, private va
           timestamp = timestamp,
           message = dataMessage,
           editMessage = editMessage,
+          expirationStartTimestamp = if ((dataMessage?.expireTimer ?: 0) > 0) System.currentTimeMillis() else null,
           unidentifiedStatus = listOf(
             SyncMessage.Sent.UnidentifiedDeliveryStatus(
               destinationServiceIdBinary = recipientServiceId.toByteString(),

app/src/main/java/org/thoughtcrime/securesms/jobs/LocalArchiveJob.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import org.signal.core.util.Stopwatch
+import org.signal.core.util.UnableToStartException
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.backup.BackupFileIOError
@@ -24,6 +25,7 @@ import org.thoughtcrime.securesms.notifications.NotificationChannels
 import org.thoughtcrime.securesms.service.GenericForegroundService
 import org.thoughtcrime.securesms.service.NotificationController
 import java.io.IOException
+import org.signal.core.ui.R as CoreUiR
 
 /**
  * Local backup job for installs using new backupv2 folder format.
@@ -57,7 +59,7 @@ class LocalArchiveJob internal constructor(parameters: Parameters) : Job(paramet
         context,
         context.getString(R.string.LocalBackupJob_creating_signal_backup),
         NotificationChannels.getInstance().BACKUPS,
-        R.drawable.ic_signal_backup
+        CoreUiR.drawable.ic_signal_backup
       )
     } catch (e: UnableToStartException) {
       Log.w(TAG, "Unable to start foreground backup service, continuing without service")

app/src/main/java/org/thoughtcrime/securesms/jobs/LocalBackupJob.java

@@ -13,6 +13,7 @@ import org.signal.core.ui.permissions.Permissions;
 import org.signal.core.ui.util.StorageUtil;
 import org.signal.core.util.NoExternalStorageException;
 import org.signal.core.util.Stopwatch;
+import org.signal.core.util.UnableToStartException;
 import org.signal.core.util.crypto.AttachmentSecretProvider;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.R;
@@ -117,7 +118,7 @@ public final class LocalBackupJob extends BaseJob {
     try (NotificationController notification = GenericForegroundService.startForegroundTask(context,
                                                                      context.getString(R.string.LocalBackupJob_creating_signal_backup),
                                                                      NotificationChannels.getInstance().BACKUPS,
-                                                                     R.drawable.ic_signal_backup))
+                                                                     org.signal.core.ui.R.drawable.ic_signal_backup))
     {
       updater.setNotification(notification);
       EventBus.getDefault().register(updater);

app/src/main/java/org/thoughtcrime/securesms/jobs/LocalBackupJobApi29.java

@@ -12,6 +12,7 @@ import org.greenrobot.eventbus.EventBus;
 import org.greenrobot.eventbus.Subscribe;
 import org.greenrobot.eventbus.ThreadMode;
 import org.signal.core.util.Stopwatch;
+import org.signal.core.util.UnableToStartException;
 import org.signal.core.util.androidx.DocumentFileUtil;
 import org.signal.core.util.androidx.DocumentFileUtil.OperationResult;
 import org.signal.core.util.crypto.AttachmentSecretProvider;
@@ -89,7 +90,7 @@ public final class LocalBackupJobApi29 extends BaseJob {
       notification = GenericForegroundService.startForegroundTask(context,
                                                                   context.getString(R.string.LocalBackupJob_creating_signal_backup),
                                                                   NotificationChannels.getInstance().BACKUPS,
-                                                                  R.drawable.ic_signal_backup);
+                                                                  org.signal.core.ui.R.drawable.ic_signal_backup);
     } catch (UnableToStartException e) {
       Log.w(TAG, "Unable to start foreground backup service, continuing without service");
     }

app/src/main/java/org/thoughtcrime/securesms/jobs/LocalPlaintextArchiveJob.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import org.signal.core.util.PendingIntentFlags.immutable
 import org.signal.core.util.Stopwatch
+import org.signal.core.util.UnableToStartException
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.backup.LocalExportProgress
@@ -28,6 +29,7 @@ import java.io.IOException
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
+import org.signal.core.ui.R as CoreUiR
 
 class LocalPlaintextArchiveJob internal constructor(
   private val destinationUri: String,
@@ -73,7 +75,7 @@ class LocalPlaintextArchiveJob internal constructor(
         context,
         context.getString(R.string.LocalBackupJob_creating_signal_backup),
         NotificationChannels.getInstance().BACKUPS,
-        R.drawable.ic_signal_backup,
+        CoreUiR.drawable.ic_signal_backup,
         contentIntent
       )
     } catch (e: UnableToStartException) {

app/src/main/java/org/thoughtcrime/securesms/jobs/MessageFetchJob.java

@@ -15,6 +15,7 @@ import org.thoughtcrime.securesms.messages.WebSocketDrainer;
 import org.thoughtcrime.securesms.notifications.NotificationChannels;
 import org.thoughtcrime.securesms.service.GenericForegroundService;
 import org.signal.core.util.AppForegroundObserver;
+import org.signal.core.util.UnableToStartException;
 import org.signal.network.exceptions.PushNetworkException;
 
 import java.io.IOException;

app/src/main/java/org/thoughtcrime/securesms/jobs/MessageSendLogCleanupJob.kt

@@ -8,6 +8,7 @@ package org.thoughtcrime.securesms.jobs
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobmanager.Job
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint
 import org.thoughtcrime.securesms.util.RemoteConfig
 import java.util.concurrent.TimeUnit
 
@@ -23,6 +24,7 @@ class MessageSendLogCleanupJob private constructor(parameters: Parameters) : Job
       AppDependencies.jobManager.add(
         MessageSendLogCleanupJob(
           Parameters.Builder()
+            .addConstraint(DataRestoreConstraint.KEY)
             .setInitialDelay(TimeUnit.MINUTES.toMillis(1))
             .setLifespan(TimeUnit.HOURS.toMillis(1))
             .setMaxInstancesForFactory(1)

app/src/main/java/org/thoughtcrime/securesms/jobs/RefreshAttributesJob.java

@@ -108,8 +108,10 @@ public class RefreshAttributesJob extends BaseJob {
     if (SignalStore.account().isPrimaryDevice()) {
       setPrimaryDeviceAttributes(svrValues, capabilities);
     } else {
-      Log.i(TAG, "Linked device, refreshing device capabilities only. Capabilities: " + capabilities);
+      boolean phoneNumberDiscoverable = SignalStore.phoneNumberPrivacy().getPhoneNumberDiscoverabilityMode() == PhoneNumberDiscoverabilityMode.DISCOVERABLE;
+      Log.i(TAG, "Linked device, refreshing device capabilities and phone number discoverability. Capabilities: " + capabilities + ", discoverable: " + phoneNumberDiscoverable);
       RequestResultUtil.successOrThrow(SignalNetwork.account().setCapabilities(capabilities));
+      RequestResultUtil.successOrThrow(SignalNetwork.account().setPhoneNumberDiscoverability(phoneNumberDiscoverable));
     }
 
     hasRefreshedThisAppCycle = true;

app/src/main/java/org/thoughtcrime/securesms/jobs/RequestGroupV2InfoJob.java

@@ -9,6 +9,7 @@ import org.thoughtcrime.securesms.groups.GroupId;
 import org.thoughtcrime.securesms.groups.v2.processing.GroupsV2StateProcessor;
 import org.thoughtcrime.securesms.jobmanager.JsonJobData;
 import org.thoughtcrime.securesms.jobmanager.Job;
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint;
 import org.thoughtcrime.securesms.jobmanager.impl.DecryptionsDrainedConstraint;
 
 /**
@@ -34,6 +35,7 @@ public final class RequestGroupV2InfoJob extends BaseJob {
     this(new Parameters.Builder()
                        .setQueue("RequestGroupV2InfoSyncJob")
                        .addConstraint(DecryptionsDrainedConstraint.KEY)
+                       .addConstraint(DataRestoreConstraint.KEY)
                        .setMaxAttempts(Parameters.UNLIMITED)
                        .build(),
          groupId,

app/src/main/java/org/thoughtcrime/securesms/jobs/RestoreLocalAttachmentJob.kt

@@ -186,6 +186,10 @@ class RestoreLocalAttachmentJob private constructor(
     } catch (e: IOException) {
       Log.w(TAG, "Experienced an exception while trying to read attachment.", e)
       return Result.retry(defaultBackoff())
+    } catch (e: SecurityException) {
+      Log.w(TAG, "Lost access to the backup directory. Unable to restore attachment.", e)
+      SignalStore.backup.localRestoreDirectoryError = true
+      return Result.failure()
     }
 
     return Result.success()

app/src/main/java/org/thoughtcrime/securesms/jobs/RetrieveProfileAvatarJob.java

@@ -17,6 +17,7 @@ import org.thoughtcrime.securesms.database.model.ProfileAvatarFileDetails;
 import org.thoughtcrime.securesms.dependencies.AppDependencies;
 import org.thoughtcrime.securesms.jobmanager.JsonJobData;
 import org.thoughtcrime.securesms.jobmanager.Job;
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint;
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.profiles.AvatarHelper;
@@ -77,6 +78,7 @@ public class RetrieveProfileAvatarJob extends BaseJob {
     this(new Job.Parameters.Builder().setGlobalPriority(priority)
                                      .setQueue("RetrieveProfileAvatarJob::" + recipient.getId().toQueueKey())
                                      .addConstraint(NetworkConstraint.KEY)
+                                     .addConstraint(DataRestoreConstraint.KEY)
                                      .setLifespan(TimeUnit.HOURS.toMillis(1))
                                      .build(),
          recipient,

app/src/main/java/org/thoughtcrime/securesms/jobs/RetrieveProfileJob.kt

@@ -28,6 +28,7 @@ import org.thoughtcrime.securesms.database.model.RecipientRecord
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobmanager.Job
 import org.thoughtcrime.securesms.jobmanager.JsonJobData
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.net.SignalNetwork
@@ -61,6 +62,7 @@ class RetrieveProfileJob private constructor(parameters: Parameters, private val
   private constructor(recipientIds: Set<RecipientId>, skipDebounce: Boolean) : this(
     parameters = Parameters.Builder()
       .addConstraint(NetworkConstraint.KEY)
+      .addConstraint(DataRestoreConstraint.KEY)
       .apply {
         if (recipientIds.size < 5) {
           setQueue(recipientIds.map { it.toLong() }.sorted().joinToString(separator = "_", prefix = QUEUE_PREFIX))

app/src/main/java/org/thoughtcrime/securesms/jobs/StickerDownloadJob.java

@@ -11,6 +11,7 @@ import org.thoughtcrime.securesms.database.model.StickerRecord;
 import org.thoughtcrime.securesms.dependencies.AppDependencies;
 import org.thoughtcrime.securesms.jobmanager.JsonJobData;
 import org.thoughtcrime.securesms.jobmanager.Job;
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint;
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint;
 import org.thoughtcrime.securesms.mms.PartAuthority;
 import org.signal.core.util.Hex;
@@ -44,6 +45,7 @@ public class StickerDownloadJob extends BaseJob {
   StickerDownloadJob(@NonNull IncomingSticker sticker, boolean notify) {
     this(new Job.Parameters.Builder()
                            .addConstraint(NetworkConstraint.KEY)
+                           .addConstraint(DataRestoreConstraint.KEY)
                            .setLifespan(TimeUnit.DAYS.toMillis(30))
                            .build(),
         sticker,

app/src/main/java/org/thoughtcrime/securesms/jobs/StickerPackDownloadJob.java

@@ -13,6 +13,7 @@ import org.thoughtcrime.securesms.dependencies.AppDependencies;
 import org.thoughtcrime.securesms.jobmanager.JsonJobData;
 import org.thoughtcrime.securesms.jobmanager.Job;
 import org.thoughtcrime.securesms.jobmanager.JobManager;
+import org.thoughtcrime.securesms.jobmanager.impl.DataRestoreConstraint;
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint;
 import org.thoughtcrime.securesms.stickers.BlessedPacks;
 import org.signal.core.util.Hex;
@@ -63,6 +64,7 @@ public class StickerPackDownloadJob extends BaseJob {
   {
     this(new Parameters.Builder()
                        .addConstraint(NetworkConstraint.KEY)
+                       .addConstraint(DataRestoreConstraint.KEY)
                        .setLifespan(TimeUnit.DAYS.toMillis(30))
                        .setQueue("StickerPackDownloadJob_" + packId)
                        .build(),

app/src/main/java/org/thoughtcrime/securesms/keyvalue/InternalValues.kt

@@ -30,7 +30,6 @@ class InternalValues internal constructor(store: KeyValueStore) : SignalStoreVal
     const val LAST_SCROLL_POSITION: String = "internal.last_scroll_position"
     const val CONVERSATION_ITEM_V2_MEDIA: String = "internal.conversation_item_v2_media"
     const val WEB_SOCKET_SHADOWING_STATS: String = "internal.web_socket_shadowing_stats"
-    const val ENCODE_HEVC: String = "internal.hevc_encoding"
     const val FORCE_SPLIT_PANE_ON_COMPACT_LANDSCAPE: String = "internal.force.split.pane.on.compact.landscape.ui"
     const val FORCE_SINGLE_PANE_ON_ALL_DEVICES: String = "internal.force_single_pane_on_all_devices"
     const val SHOW_ARCHIVE_STATE_HINT: String = "internal.show_archive_state_hint"
@@ -171,8 +170,6 @@ class InternalValues internal constructor(store: KeyValueStore) : SignalStoreVal
    */
   var callingUseInputVoiceComm by booleanValue(CALLING_USE_INPUT_VOICE_COMM, true).defaultForExternalUsers()
 
-  var hevcEncoding by booleanValue(ENCODE_HEVC, false).defaultForExternalUsers()
-
   var lastScrollPosition: Int by integerValue(LAST_SCROLL_POSITION, 0).defaultForExternalUsers()
 
   var useConversationItemV2Media by booleanValue(CONVERSATION_ITEM_V2_MEDIA, false).defaultForExternalUsers()

app/src/main/java/org/thoughtcrime/securesms/keyvalue/SignalStore.kt

@@ -133,6 +133,14 @@ class SignalStore(context: Application, private val store: KeyValueStore) {
       instance!!.store.resetCache()
     }
 
+    /**
+     * Swaps out the singleton for a test instance. Pass null to clear it. Should only be used for testing!
+     */
+    @VisibleForTesting
+    fun testInject(instance: SignalStore?) {
+      Companion.instance = instance
+    }
+
     /**
      * Restoring a backup changes the underlying disk values, so the cache needs to be reset.
      */

app/src/main/java/org/thoughtcrime/securesms/linkdevice/LinkDeviceRepository.kt

@@ -51,7 +51,7 @@ object LinkDeviceRepository {
   private val TAG = Log.tag(LinkDeviceRepository::class)
   private const val DECRYPTION_INFO = "deviceCreatedAt"
 
-  fun removeDevice(deviceId: Int): Boolean {
+  suspend fun removeDevice(deviceId: Int): Boolean {
     return when (val result = AppDependencies.linkDeviceApi.removeDevice(deviceId)) {
       is NetworkResult.Success -> {
         LinkedDeviceInactiveCheckJob.enqueue()

app/src/main/java/org/thoughtcrime/securesms/mediasend/v2/MediaSelectionState.kt

@@ -7,12 +7,13 @@ import org.signal.mediasend.SentMediaQuality
 import org.signal.mediasend.edit.video.VideoTrimData
 import org.thoughtcrime.securesms.conversation.MessageSendType
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.thoughtcrime.securesms.mms.PushMediaConstraints
+import org.thoughtcrime.securesms.mms.TranscodingConfigProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.stories.Stories
 import org.thoughtcrime.securesms.util.MediaUtil
 import org.thoughtcrime.securesms.util.RemoteConfig
-import org.thoughtcrime.securesms.video.TranscodingPreset
+import org.thoughtcrime.securesms.video.TranscodingConfig
+import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
 data class MediaSelectionState(
@@ -31,13 +32,12 @@ data class MediaSelectionState(
   val cameraFirstCapture: Media? = null,
   val isStory: Boolean,
   val storySendRequirements: Stories.MediaTransform.SendRequirements = Stories.MediaTransform.SendRequirements.CAN_NOT_SEND,
-  val suppressEmptyError: Boolean = true
+  val suppressEmptyError: Boolean = true,
+  val transcodingConfigs: List<TranscodingConfig.QualityTier> = TranscodingConfigProvider.getConfigsForMediaQuality(SentMediaQuality.fromCode(quality.code))
 ) {
 
   val isVideoTrimmingVisible: Boolean = focusedMedia != null && MediaUtil.isVideoType(focusedMedia.contentType) && MediaConstraints.isVideoTranscodeAvailable() && !focusedMedia.isVideoGif
 
-  val transcodingPreset: TranscodingPreset = PushMediaConstraints(SentMediaQuality.fromCode(quality.code)).videoTranscodingSettings
-
   val maxSelection = RemoteConfig.maxAttachmentCount
 
   val canSend = !isSent && selectedMedia.isNotEmpty()
@@ -46,11 +46,11 @@ data class MediaSelectionState(
     return editorStateMap[uri] as? VideoTrimData ?: VideoTrimData()
   }
 
-  fun calculateMaxVideoDurationUs(maxFileSize: Long): Long {
+  fun calculateMaxVideoDurationUs(maxFileSize: Long, videoDuration: Duration): Long {
     return if (isStory && !MediaConstraints.isVideoTranscodeAvailable()) {
       Stories.MAX_VIDEO_DURATION_MILLIS
     } else {
-      transcodingPreset.calculateMaxVideoUploadDurationInSeconds(maxFileSize).seconds.inWholeMicroseconds
+      TranscodingConfig.calculateMaxVideoUploadDurationInSeconds(transcodingConfigs, videoDuration, maxFileSize).seconds.inWholeMicroseconds
     }
   }