Bump version to 8.17.0

Co-authored-by: Cody Henthorne <cody@signal.org>

.gitattributes

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

.github/workflows/android.yml

@@ -16,24 +16,25 @@ jobs:
     runs-on: ubuntu-latest-8-cores
 
     steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       # gh api repos/actions/checkout/commits/v6 --jq '.sha'
       with:
           submodules: true
+          lfs: true
 
     - name: set up JDK 17
-      uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+      uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
       # gh api repos/actions/setup-java/commits/v5 --jq '.sha'
       with:
         distribution: temurin
         java-version: 17
 
     - name: Validate Gradle Wrapper
-      uses: gradle/actions/wrapper-validation@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
 
     - name: Set up Gradle
-      uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
+      uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6
       # gh api repos/gradle/actions/commits/v6 --jq '.sha'
       with:
         # Only 8.** branch builds write to the cache; everything else (PRs, etc.) reads only.
@@ -41,13 +42,15 @@ 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).
     - 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 qa
+      run: ./gradlew ${{ github.event_name == 'pull_request' && 'ci' || 'qa' }}
 
     - name: Archive reports for failed build
       if: ${{ failure() }}

.github/workflows/diffuse.yml

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

.github/workflows/docker.yml

@@ -11,7 +11,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         # gh api repos/actions/checkout/commits/v6 --jq '.sha'
       - name: Build image
         run: |

app/build.gradle.kts

@@ -16,6 +16,7 @@ plugins {
   alias(libs.plugins.ktlint)
   alias(libs.plugins.compose.compiler)
   alias(libs.plugins.kotlinx.serialization)
+  alias(testLibs.plugins.compose.screenshot)
   alias(benchmarkLibs.plugins.baselineprofile)
   id("androidx.navigation.safeargs")
   id("kotlin-parcelize")
@@ -27,8 +28,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 = 1703
-val canonicalVersionName = "8.14.3"
+val canonicalVersionCode = 1710
+val canonicalVersionName = "8.17.0"
 val currentHotfixVersion = 0
 val maxHotfixVersions = 100
 
@@ -127,9 +128,16 @@ ktlint {
   version.set("1.5.0")
 }
 
+screenshotTests {
+  // Fraction of differing pixels tolerated before a screenshot test fails (0.0001 = 0.01%).
+  imageDifferenceThreshold = 0.0001f
+}
+
 android {
   namespace = "org.thoughtcrime.securesms"
 
+  experimentalProperties["android.experimental.enableScreenshotTest"] = true
+
   buildToolsVersion = libs.versions.buildTools.get()
   compileSdkVersion(libs.versions.compileSdk.get())
   ndkVersion = libs.versions.ndk.get()
@@ -712,6 +720,11 @@ dependencies {
   }
   implementation(libs.lottie)
   implementation(libs.lottie.compose)
+
+  // Compose screenshot testing
+  screenshotTestImplementation(testLibs.compose.screenshot.validation.api)
+  screenshotTestImplementation(libs.androidx.compose.ui.tooling.core)
+  screenshotTestImplementation(libs.androidx.compose.ui.tooling.preview)
   implementation(libs.signal.android.database.sqlcipher)
   implementation(libs.androidx.sqlite)
   testImplementation(libs.androidx.sqlite.framework)

app/proguard/proguard.cfg

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

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

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

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

@@ -0,0 +1,393 @@
+/*
+ * 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.Intent
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isGreaterThan
+import assertk.assertions.isGreaterThanOrEqualTo
+import assertk.assertions.isLessThan
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.thoughtcrime.securesms.MainActivity
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.database.MessageType
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.mms.IncomingMessage
+import org.thoughtcrime.securesms.mms.OutgoingMessage
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import java.util.Collections
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * End-to-end UI test of the unread divider. Seeds a thread with many unread messages and opens it via the notification
+ * path (which enters the conversation with no explicit jump point — functionally "open a chat with X unread"), then
+ * verifies the real pipeline (repository -> view model -> fragment -> decoration) anchors the divider to the oldest
+ * unread message and scrolls there rather than opening at the bottom.
+ *
+ * The launch harness mirrors [org.thoughtcrime.securesms.main.MainNavigationLaunchTest]: ActivityScenario can't track
+ * MainActivity launched with a custom-action intent, so we start it via Application#startActivity and observe lifecycle
+ * callbacks instead.
+ */
+@RunWith(AndroidJUnit4::class)
+class UnreadDividerInstrumentationTest {
+
+  @get:Rule
+  val harness = SignalActivityRule(othersCount = 2)
+
+  @Test
+  fun opensScrolledToOldestUnreadWithCorrectDividerState() {
+    val recipientId = harness.others.first()
+    SignalDatabase.recipients.setProfileSharing(recipientId, true)
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    val totalUnread = 50
+    val oldestSentTime = 1000L
+    var oldestUnreadId = -1L
+    for (i in 0 until totalUnread) {
+      val id = insertIncoming(threadId, recipientId, time = oldestSentTime + i, body = "unread $i")
+      if (i == 0) {
+        oldestUnreadId = id
+      }
+    }
+
+    // Derive expectations from the DB the same way the app does, so the test is robust to any extra system rows.
+    val expectedUnreadCount = SignalDatabase.messages.getUnreadCount(threadId)
+    val firstUnreadPosition = SignalDatabase.messages.getMessagePositionByDateReceivedTimestamp(threadId, oldestSentTime, false)
+
+    launch(recipientId).use { launched ->
+      val result = await(timeoutMs = 20_000, description = "conversation scrolled to oldest unread") {
+        val fragment = launched.latestConversationFragment() ?: return@await null
+        val recycler = fragment.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler) ?: return@await null
+        val decoration = recycler.conversationItemDecorations() ?: return@await null
+        val state = decoration.unreadStateForTesting as? ConversationItemDecorations.UnreadState.CompleteUnreadState ?: return@await null
+        val view = recycler.layoutManager?.findViewByPosition(firstUnreadPosition) ?: return@await null
+        Observed(state.unreadCount, state.firstUnreadId, view.top, recycler.height)
+      }
+
+      assertThat(result.unreadCount).isEqualTo(expectedUnreadCount)
+      assertThat(result.firstUnreadId).isEqualTo(oldestUnreadId)
+      // The oldest unread is laid out in the top half -> we scrolled up to it instead of opening at the bottom (where,
+      // with this many messages, it would be off-screen above and findViewByPosition would have returned null).
+      assertThat(result.firstUnreadTop).isGreaterThanOrEqualTo(0)
+      assertThat(result.firstUnreadTop).isLessThan(result.recyclerHeight / 2)
+    }
+  }
+
+  @Test
+  fun fullyReadConversationOpensAtBottomWithoutDivider() {
+    val recipientId = harness.others.first()
+    SignalDatabase.recipients.setProfileSharing(recipientId, true)
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    val total = 50
+    for (i in 0 until total) {
+      insertIncoming(threadId, recipientId, time = 1000L + i, body = "read $i")
+    }
+    SignalDatabase.threads.setRead(threadId)
+    // Precondition: nothing is unread, so there should be no divider.
+    assertThat(SignalDatabase.messages.getUnreadCount(threadId)).isEqualTo(0)
+
+    launch(recipientId).use { launched ->
+      val result = await(timeoutMs = 20_000, description = "fully-read conversation opened at the bottom") {
+        val fragment = launched.latestConversationFragment() ?: return@await null
+        val recycler = fragment.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler) ?: return@await null
+        val decoration = recycler.conversationItemDecorations() ?: return@await null
+        // The newest message is position 0; if it's laid out, the list loaded and settled at the bottom.
+        val newest = recycler.layoutManager?.findViewByPosition(0) ?: return@await null
+        BottomObserved(decoration.unreadStateForTesting, newest.bottom, recycler.height)
+      }
+
+      assertThat(result.unreadState).isEqualTo(ConversationItemDecorations.UnreadState.None)
+      // Newest message sits in the lower half -> opened at the bottom (with this many messages it would be off-screen
+      // below if we'd opened at the top).
+      assertThat(result.newestBottom).isGreaterThan(result.recyclerHeight / 2)
+    }
+  }
+
+  @Test
+  fun outgoingMessageNewerThanUnreadClearsDivider() {
+    val recipientId = harness.others.first()
+    SignalDatabase.recipients.setProfileSharing(recipientId, true)
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    // A few unread incoming messages, then a newer outgoing reply. Kept small so all rows load in the initial page.
+    insertIncoming(threadId, recipientId, time = 1000L, body = "unread 0")
+    insertIncoming(threadId, recipientId, time = 1001L, body = "unread 1")
+    insertIncoming(threadId, recipientId, time = 1002L, body = "unread 2")
+    val outgoing = OutgoingMessage.text(
+      threadRecipient = Recipient.resolved(recipientId),
+      body = "my reply",
+      expiresIn = 0,
+      sentTimeMillis = 1003L
+    )
+    SignalDatabase.messages.insertMessageOutbox(outgoing, threadId)
+
+    // Precondition: the messages are still unread at the DB level, so the divider would show if it weren't for the
+    // newer outgoing message clearing it.
+    assertThat(SignalDatabase.messages.getUnreadCount(threadId)).isGreaterThan(0)
+
+    launch(recipientId).use { launched ->
+      val cleared = await(timeoutMs = 20_000, description = "divider cleared by newer outgoing message") {
+        val fragment = launched.latestConversationFragment() ?: return@await null
+        val recycler = fragment.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler) ?: return@await null
+        val decoration = recycler.conversationItemDecorations() ?: return@await null
+        // Wait until the list has loaded (outgoing at position 0 laid out) before reading the resolved state.
+        recycler.layoutManager?.findViewByPosition(0) ?: return@await null
+        if (decoration.unreadStateForTesting == ConversationItemDecorations.UnreadState.None) true else null
+      }
+
+      assertThat(cleared).isEqualTo(true)
+    }
+  }
+
+  @Test
+  fun scrollingToBottomMarksEverythingReadAndDrainsUnreadCount() {
+    val recipientId = harness.others.first()
+    SignalDatabase.recipients.setProfileSharing(recipientId, true)
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    val total = 50
+    for (i in 0 until total) {
+      insertIncoming(threadId, recipientId, time = 1000L + i, body = "unread $i")
+    }
+
+    launch(recipientId).use { launched ->
+      // getUnreadCount is the shared source for the chat-list badge and the scroll-to-bottom button's count, so
+      // asserting on it verifies the number the user sees updating as they scroll.
+      await(timeoutMs = 20_000, description = "conversation loaded") {
+        val recycler = launched.latestConversationFragment()?.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler)
+        if ((recycler?.childCount ?: 0) > 0) true else null
+      }
+      assertThat(SignalDatabase.messages.getUnreadCount(threadId)).isGreaterThan(0)
+
+      // Jump to the newest message; revealing it marks every earlier message read (MarkReadHelper.onViewsRevealed).
+      runOnMain {
+        launched.latestConversationFragment()?.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler)?.scrollToPosition(0)
+      }
+
+      // Scrolling through the thread drains the unread count to 0.
+      await(timeoutMs = 20_000, description = "unread count reaches 0 after scrolling to the bottom") {
+        if (SignalDatabase.messages.getUnreadCount(threadId) == 0) true else null
+      }
+    }
+  }
+
+  @Test
+  fun scrollingPartwayLeavesExactlyTheUnreadMessagesBelowTheViewport() {
+    val recipientId = harness.others.first()
+    SignalDatabase.recipients.setProfileSharing(recipientId, true)
+    val threadId = SignalDatabase.threads.getOrCreateThreadIdFor(Recipient.resolved(recipientId))
+
+    val total = 50
+    for (i in 0 until total) {
+      insertIncoming(threadId, recipientId, time = 1000L + i, body = "unread $i")
+    }
+
+    launch(recipientId).use { launched ->
+      await(timeoutMs = 20_000, description = "conversation loaded") {
+        val recycler = launched.latestConversationFragment()?.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler)
+        if ((recycler?.childCount ?: 0) > 0) true else null
+      }
+
+      // The chat opens at the oldest unread (near the top); scroll down to roughly the middle.
+      runOnMain {
+        val recycler = launched.latestConversationFragment()?.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler)
+        (recycler?.layoutManager as? LinearLayoutManager)?.scrollToPositionWithOffset(total / 2, 0)
+      }
+
+      // Once mark-read settles, the unread count must equal the index of the newest visible message — i.e. exactly the
+      // messages still below the viewport (reverse layout: position 0 = newest, so index N = N newer messages). This is
+      // the number the scroll-to-bottom button and chat-list badge show; it must not over- or under-count mid-scroll.
+      val stableCount = awaitStableUnreadCount(threadId)
+      val newestVisiblePosition = await(timeoutMs = 5_000, description = "newest visible position") {
+        val recycler = launched.latestConversationFragment()?.view?.findViewById<RecyclerView>(R.id.conversation_item_recycler)
+        (recycler?.layoutManager as? LinearLayoutManager)?.findFirstVisibleItemPosition()?.takeIf { it >= 0 }
+      }
+
+      assertThat(stableCount).isEqualTo(newestVisiblePosition)
+      // Sanity: we exercised a genuine mid-scroll point, not the very top or bottom.
+      assertThat(stableCount).isGreaterThan(0)
+      assertThat(stableCount).isLessThan(total)
+    }
+  }
+
+  /** Polls [MessageTable.getUnreadCount] until it holds steady (mark-read is debounced + async), then returns it. */
+  private fun awaitStableUnreadCount(threadId: Long, timeoutMs: Long = 20_000): Int {
+    val deadline = System.currentTimeMillis() + timeoutMs
+    var last = Int.MIN_VALUE
+    var stableSince = System.currentTimeMillis()
+    while (System.currentTimeMillis() < deadline) {
+      val current = SignalDatabase.messages.getUnreadCount(threadId)
+      if (current == last) {
+        if (System.currentTimeMillis() - stableSince >= 500) {
+          return current
+        }
+      } else {
+        last = current
+        stableSince = System.currentTimeMillis()
+      }
+      Thread.sleep(100)
+    }
+    throw AssertionError("Unread count never stabilized (last observed = $last)")
+  }
+
+  private data class BottomObserved(
+    val unreadState: ConversationItemDecorations.UnreadState,
+    val newestBottom: Int,
+    val recyclerHeight: Int
+  )
+
+  private fun insertIncoming(threadId: Long, from: RecipientId, time: Long, body: String): Long {
+    val message = IncomingMessage(
+      type = MessageType.NORMAL,
+      from = from,
+      sentTimeMillis = time,
+      serverTimeMillis = time,
+      receivedTimeMillis = time,
+      body = body
+    )
+    return SignalDatabase.messages.insertMessageInbox(message, threadId).get().messageId
+  }
+
+  private data class Observed(
+    val unreadCount: Int,
+    val firstUnreadId: Long,
+    val firstUnreadTop: Int,
+    val recyclerHeight: Int
+  )
+
+  private fun RecyclerView.conversationItemDecorations(): ConversationItemDecorations? {
+    for (i in 0 until itemDecorationCount) {
+      val decoration = getItemDecorationAt(i)
+      if (decoration is ConversationItemDecorations) {
+        return decoration
+      }
+    }
+    return null
+  }
+
+  private fun runOnMain(block: () -> Unit) {
+    InstrumentationRegistry.getInstrumentation().runOnMainSync { block() }
+  }
+
+  /** Polls [block] on the main thread until it returns non-null, failing after [timeoutMs]. */
+  private fun <T> await(timeoutMs: Long, pollMs: Long = 100, description: String, block: () -> T?): T {
+    val deadline = System.currentTimeMillis() + timeoutMs
+    while (System.currentTimeMillis() < deadline) {
+      var value: T? = null
+      InstrumentationRegistry.getInstrumentation().runOnMainSync { value = block() }
+      if (value != null) {
+        return value!!
+      }
+      Thread.sleep(pollMs)
+    }
+    throw AssertionError("Timed out after ${timeoutMs}ms waiting for $description")
+  }
+
+  private fun launch(recipientId: RecipientId): Launched {
+    val app = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
+    val resumed = CountDownLatch(1)
+    val conversationFragments: MutableList<ConversationFragment> = Collections.synchronizedList(mutableListOf())
+    val allActivities: MutableList<Activity> = Collections.synchronizedList(mutableListOf())
+
+    val fragmentCallbacks = object : FragmentManager.FragmentLifecycleCallbacks() {
+      override fun onFragmentCreated(fm: FragmentManager, f: Fragment, savedInstanceState: Bundle?) {
+        if (f is ConversationFragment) {
+          conversationFragments.add(f)
+        }
+      }
+
+      override fun onFragmentDestroyed(fm: FragmentManager, f: Fragment) {
+        if (f is ConversationFragment) {
+          conversationFragments.remove(f)
+        }
+      }
+    }
+
+    val activityCallbacks = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        allActivities.add(activity)
+        if (activity is MainActivity) {
+          activity.supportFragmentManager.registerFragmentLifecycleCallbacks(fragmentCallbacks, true)
+        }
+      }
+
+      override fun onActivityResumed(activity: Activity) {
+        if (activity is MainActivity) {
+          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) {
+        allActivities.remove(activity)
+      }
+    }
+    app.registerActivityLifecycleCallbacks(activityCallbacks)
+
+    // Open the conversation the way a notification tap does: a conversation intent with no starting position.
+    val conversationIntent = ConversationIntents.createBuilder(harness.context, recipientId, -1L).blockingGet().build()
+    val intent = Intent(harness.context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+      // Application#startActivity from a non-Activity context requires a new task.
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    try {
+      app.startActivity(intent)
+    } catch (t: Throwable) {
+      app.unregisterActivityLifecycleCallbacks(activityCallbacks)
+      throw t
+    }
+
+    if (!resumed.await(15, TimeUnit.SECONDS)) {
+      app.unregisterActivityLifecycleCallbacks(activityCallbacks)
+      throw AssertionError("MainActivity did not reach RESUMED within 15s")
+    }
+
+    return Launched(conversationFragments, app, activityCallbacks, allActivities)
+  }
+
+  private class Launched(
+    private val conversationFragments: List<ConversationFragment>,
+    private val app: Application,
+    private val callbacks: Application.ActivityLifecycleCallbacks,
+    private val allActivities: MutableList<Activity>
+  ) : AutoCloseable {
+
+    fun latestConversationFragment(): ConversationFragment? = synchronized(conversationFragments) { conversationFragments.lastOrNull() }
+
+    override fun close() {
+      val toFinish = synchronized(allActivities) { allActivities.toList() }
+      if (toFinish.isNotEmpty()) {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+          toFinish.forEach { it.finish() }
+        }
+      }
+      app.unregisterActivityLifecycleCallbacks(callbacks)
+    }
+  }
+}

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

@@ -20,22 +20,22 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.core.models.backup.MediaName
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.models.media.TransformProperties
 import org.signal.core.util.Base64
 import org.signal.core.util.Base64.decodeBase64OrThrow
 import org.signal.core.util.copyTo
 import org.signal.core.util.stream.NullOutputStream
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.attachments.ArchivedAttachment
 import org.thoughtcrime.securesms.attachments.Attachment
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.PointerAttachment
 import org.thoughtcrime.securesms.attachments.UriAttachment
 import org.thoughtcrime.securesms.backup.v2.ArchivedMediaObject
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.mms.IncomingMessage
 import org.thoughtcrime.securesms.mms.MediaStream
-import org.thoughtcrime.securesms.mms.SentMediaQuality
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.MediaUtil
 import org.whispersystems.signalservice.api.crypto.AttachmentCipherOutputStream
@@ -67,7 +67,7 @@ class AttachmentTableTest {
 
   @Test
   fun givenABlob_whenIInsert2AttachmentsForPreUpload_thenIExpectDistinctIdsButSameFileName() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val attachment = SignalDatabase.attachments.insertAttachmentForPreUpload(highQualityImage)
@@ -80,7 +80,7 @@ class AttachmentTableTest {
   @FlakyTest
   @Test
   fun givenABlobAndDifferentTransformQuality_whenIInsert2AttachmentsForPreUpload_thenIExpectDifferentFileInfos() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val lowQualityImage = createAttachment(1, blob, TransformProperties.empty())
@@ -107,7 +107,7 @@ class AttachmentTableTest {
   @Ignore("test is flaky")
   @Test
   fun givenIdenticalAttachmentsInsertedForPreUpload_whenIUpdateAttachmentDataAndSpecifyOnlyModifyThisAttachment_thenIExpectDifferentFileInfos() {
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val highQualityProperties = createHighQualityTransformProperties()
     val highQualityImage = createAttachment(1, blob, highQualityProperties)
     val attachment = SignalDatabase.attachments.insertAttachmentForPreUpload(highQualityImage)
@@ -143,9 +143,9 @@ class AttachmentTableTest {
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
     val compressedData = byteArrayOf(1, 2, 3)
 
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
 
-    val previousAttachment = createAttachment(1, BlobProvider.getInstance().forData(compressedData).createForSingleSessionInMemory(), TransformProperties.empty())
+    val previousAttachment = createAttachment(1, AppDependencies.blobs.forData(compressedData).createForSingleSessionInMemory(), TransformProperties.empty())
     val previousDatabaseAttachmentId: AttachmentId = SignalDatabase.attachments.insertAttachmentsForMessage(1, listOf(previousAttachment), emptyList()).values.first()
 
     val standardQualityPreUpload = createAttachment(1, blobUncompressed, TransformProperties.empty())
@@ -178,7 +178,7 @@ class AttachmentTableTest {
   fun doNotDedupedFileIfUsedByAnotherAttachmentWithADifferentTransformProperties() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
 
     val standardQualityPreUpload = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val standardDatabaseAttachment = SignalDatabase.attachments.insertAttachmentForPreUpload(standardQualityPreUpload)
@@ -204,7 +204,7 @@ class AttachmentTableTest {
   @Test
   fun resetArchiveTransferStateByPlaintextHashAndRemoteKey_singleMatch() {
     // Given an attachment with some plaintextHash+remoteKey
-    val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
+    val blob = AppDependencies.blobs.forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blob, TransformProperties.empty())
     val attachmentId = SignalDatabase.attachments.insertAttachmentsForMessage(-1L, listOf(attachment), emptyList()).values.first()
     SignalDatabase.attachments.finalizeAttachmentAfterUpload(attachmentId, AttachmentTableTestUtil.createUploadResult(attachmentId))
@@ -259,7 +259,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageThatExpiresIn5Minutes_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoNotExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.minutes)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -278,7 +278,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageThatExpiresIn5Days_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.days)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -297,7 +297,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithAMessageWithExpirationStartedThatExpiresIn5Days_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty())
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment, expiresIn = 5.days)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()
@@ -317,7 +317,7 @@ class AttachmentTableTest {
   fun givenAnAttachmentWithALongTextAttachment_whenIGetAttachmentsThatNeedArchiveUpload_thenIDoNotExpectThatAttachment() {
     // GIVEN
     val uncompressData = byteArrayOf(1, 2, 3, 4, 5)
-    val blobUncompressed = BlobProvider.getInstance().forData(uncompressData).createForSingleSessionInMemory()
+    val blobUncompressed = AppDependencies.blobs.forData(uncompressData).createForSingleSessionInMemory()
     val attachment = createAttachment(1, blobUncompressed, TransformProperties.empty(), contentType = MediaUtil.LONG_TEXT)
     val message = createIncomingMessage(serverTime = 0.days, attachment = attachment)
     val messageId = SignalDatabase.messages.insertMessageInbox(message).map { it.messageId }.get()

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

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

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

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

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

@@ -431,7 +431,7 @@ class CallTableTest {
 
     val call = SignalDatabase.calls.getCallById(callId, groupRecipientId)
     assertNotNull(call)
-    assertEquals(CallTable.Event.GENERIC_GROUP_CALL, call?.event)
+    assertEquals(CallTable.Event.MISSED, call?.event)
     assertEquals(1L, call?.timestamp)
   }
 

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

@@ -1,50 +0,0 @@
-/*
- * Copyright 2024 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.database
-
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import assertk.assertThat
-import assertk.assertions.isEqualTo
-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.database.model.databaseprotos.InAppPaymentData
-import org.thoughtcrime.securesms.testing.SignalActivityRule
-
-@RunWith(AndroidJUnit4::class)
-class InAppPaymentTableTest {
-  @get:Rule
-  val harness = SignalActivityRule()
-
-  @Before
-  fun setUp() {
-    SignalDatabase.inAppPayments.writableDatabase.deleteAll(InAppPaymentTable.TABLE_NAME)
-  }
-
-  @Test
-  fun givenACreatedInAppPayment_whenIUpdateToPending_thenIExpectPendingPayment() {
-    val inAppPaymentId = SignalDatabase.inAppPayments.insert(
-      type = InAppPaymentType.ONE_TIME_DONATION,
-      state = InAppPaymentTable.State.CREATED,
-      subscriberId = null,
-      endOfPeriod = null,
-      inAppPaymentData = InAppPaymentData()
-    )
-
-    val paymentBeforeUpdate = SignalDatabase.inAppPayments.getById(inAppPaymentId)
-    assertThat(paymentBeforeUpdate?.state).isEqualTo(InAppPaymentTable.State.CREATED)
-
-    SignalDatabase.inAppPayments.update(
-      inAppPayment = paymentBeforeUpdate!!.copy(state = InAppPaymentTable.State.PENDING)
-    )
-
-    val paymentAfterUpdate = SignalDatabase.inAppPayments.getById(inAppPaymentId)
-    assertThat(paymentAfterUpdate?.state).isEqualTo(InAppPaymentTable.State.PENDING)
-  }
-}

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

@@ -1,174 +0,0 @@
-package org.thoughtcrime.securesms.database
-
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import assertk.assertThat
-import assertk.assertions.containsExactlyInAnyOrder
-import assertk.assertions.isEmpty
-import assertk.assertions.isEqualTo
-import assertk.assertions.isFalse
-import okio.ByteString.Companion.toByteString
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotEquals
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.signal.core.models.ServiceId.ACI
-import org.signal.core.util.UuidUtil
-import org.signal.core.util.deleteAll
-import org.thoughtcrime.securesms.conversation.colors.AvatarColor
-import org.thoughtcrime.securesms.notifications.profiles.NotificationProfile
-import org.thoughtcrime.securesms.notifications.profiles.NotificationProfileId
-import org.thoughtcrime.securesms.notifications.profiles.NotificationProfileSchedule
-import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.storage.StorageSyncHelper
-import org.thoughtcrime.securesms.testing.SignalActivityRule
-import org.whispersystems.signalservice.api.storage.SignalNotificationProfileRecord
-import org.whispersystems.signalservice.api.storage.StorageId
-import java.time.DayOfWeek
-import java.util.UUID
-import org.whispersystems.signalservice.internal.storage.protos.NotificationProfile as RemoteNotificationProfile
-import org.whispersystems.signalservice.internal.storage.protos.Recipient as RemoteRecipient
-
-@RunWith(AndroidJUnit4::class)
-class NotificationProfileTablesTest {
-
-  @get:Rule
-  val harness = SignalActivityRule()
-
-  private lateinit var alice: RecipientId
-  private lateinit var profile1: NotificationProfile
-
-  @Before
-  fun setUp() {
-    alice = SignalDatabase.recipients.getOrInsertFromServiceId(ACI.from(UUID.randomUUID()))
-
-    profile1 = NotificationProfile(
-      id = 1,
-      name = "profile1",
-      emoji = "",
-      createdAt = 1000L,
-      schedule = NotificationProfileSchedule(id = 1),
-      allowedMembers = setOf(alice),
-      notificationProfileId = NotificationProfileId.generate(),
-      deletedTimestampMs = 0,
-      storageServiceId = StorageId.forNotificationProfile(byteArrayOf(1, 2, 3))
-    )
-
-    SignalDatabase.notificationProfiles.writableDatabase.deleteAll(NotificationProfileTables.NotificationProfileTable.TABLE_NAME)
-    SignalDatabase.notificationProfiles.writableDatabase.deleteAll(NotificationProfileTables.NotificationProfileScheduleTable.TABLE_NAME)
-    SignalDatabase.notificationProfiles.writableDatabase.deleteAll(NotificationProfileTables.NotificationProfileAllowedMembersTable.TABLE_NAME)
-  }
-
-  @Test
-  fun givenARemoteProfile_whenIInsertLocally_thenIExpectAListWithThatProfile() {
-    val remoteRecord =
-      SignalNotificationProfileRecord(
-        profile1.storageServiceId!!,
-        RemoteNotificationProfile(
-          id = UuidUtil.toByteArray(profile1.notificationProfileId.uuid).toByteString(),
-          name = "profile1",
-          emoji = "",
-          color = profile1.color.colorInt(),
-          createdAtMs = 1000L,
-          allowedMembers = listOf(RemoteRecipient(RemoteRecipient.Contact(Recipient.resolved(alice).serviceId.get().toString()))),
-          allowAllMentions = false,
-          allowAllCalls = true,
-          scheduleEnabled = false,
-          scheduleStartTime = 900,
-          scheduleEndTime = 1700,
-          scheduleDaysEnabled = emptyList(),
-          deletedAtTimestampMs = 0
-        )
-      )
-
-    SignalDatabase.notificationProfiles.insertNotificationProfileFromStorageSync(remoteRecord)
-    val actualProfiles = SignalDatabase.notificationProfiles.getProfiles()
-
-    assertEquals(listOf(profile1), actualProfiles)
-  }
-
-  @Test
-  fun givenAProfile_whenIDeleteIt_thenIExpectAnEmptyList() {
-    val profile: NotificationProfile = SignalDatabase.notificationProfiles.createProfile(
-      name = "Profile",
-      emoji = "avatar",
-      color = AvatarColor.A210,
-      createdAt = 1000L
-    ).profile
-
-    SignalDatabase.notificationProfiles.deleteProfile(profile.id)
-
-    assertThat(SignalDatabase.notificationProfiles.getProfiles()).isEmpty()
-    assertThat(SignalDatabase.notificationProfiles.getProfile(profile.id))
-  }
-
-  @Test
-  fun givenADeletedProfile_whenIGetIt_thenIExpectItToStillHaveASchedule() {
-    val profile: NotificationProfile = SignalDatabase.notificationProfiles.createProfile(
-      name = "Profile",
-      emoji = "avatar",
-      color = AvatarColor.A210,
-      createdAt = 1000L
-    ).profile
-
-    SignalDatabase.notificationProfiles.deleteProfile(profile.id)
-
-    val deletedProfile = SignalDatabase.notificationProfiles.getProfile(profile.id)!!
-    assertThat(deletedProfile.schedule.enabled).isFalse()
-    assertThat(deletedProfile.schedule.start).isEqualTo(900)
-    assertThat(deletedProfile.schedule.end).isEqualTo(1700)
-    assertThat(deletedProfile.schedule.daysEnabled, "Contains correct default days")
-      .containsExactlyInAnyOrder(DayOfWeek.MONDAY, DayOfWeek.TUESDAY, DayOfWeek.WEDNESDAY, DayOfWeek.THURSDAY, DayOfWeek.FRIDAY)
-  }
-
-  @Test
-  fun givenNotificationProfiles_whenIUpdateTheirStorageSyncIds_thenIExpectAnUpdatedList() {
-    SignalDatabase.notificationProfiles.createProfile(
-      name = "Profile1",
-      emoji = "avatar",
-      color = AvatarColor.A210,
-      createdAt = 1000L
-    )
-    SignalDatabase.notificationProfiles.createProfile(
-      name = "Profile2",
-      emoji = "avatar",
-      color = AvatarColor.A210,
-      createdAt = 2000L
-    )
-
-    val existingMap = SignalDatabase.notificationProfiles.getStorageSyncIdsMap()
-    existingMap.forEach { (id, _) ->
-      SignalDatabase.notificationProfiles.applyStorageIdUpdate(id, StorageId.forNotificationProfile(StorageSyncHelper.generateKey()))
-    }
-    val updatedMap = SignalDatabase.notificationProfiles.getStorageSyncIdsMap()
-
-    existingMap.forEach { (id, storageId) ->
-      assertNotEquals(storageId, updatedMap[id])
-    }
-  }
-
-  @Test
-  fun givenAProfileDeletedOver30Days_whenICleanUp_thenIExpectItToNotHaveAStorageId() {
-    val remoteRecord =
-      SignalNotificationProfileRecord(
-        profile1.storageServiceId!!,
-        RemoteNotificationProfile(
-          id = UuidUtil.toByteArray(profile1.notificationProfileId.uuid).toByteString(),
-          name = "profile1",
-          emoji = "",
-          color = profile1.color.colorInt(),
-          createdAtMs = 1000L,
-          deletedAtTimestampMs = 1000L
-        )
-      )
-
-    SignalDatabase.notificationProfiles.insertNotificationProfileFromStorageSync(remoteRecord)
-    SignalDatabase.notificationProfiles.removeStorageIdsFromOldDeletedProfiles(System.currentTimeMillis())
-    assertThat(SignalDatabase.notificationProfiles.getStorageSyncIds()).isEmpty()
-  }
-
-  private val NotificationProfileTables.NotificationProfileChangeResult.profile: NotificationProfile
-    get() = (this as NotificationProfileTables.NotificationProfileChangeResult.Success).notificationProfile
-}

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

@@ -8,10 +8,17 @@ package org.thoughtcrime.securesms.database
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import assertk.assertThat
 import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNotEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
 import assertk.assertions.isTrue
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.signal.core.models.ServiceId.ACI
+import org.signal.core.models.ServiceId.PNI
+import org.signal.core.util.nullIfBlank
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.storage.StorageRecordUpdate
@@ -19,8 +26,11 @@ import org.thoughtcrime.securesms.storage.StorageSyncModels
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.MessageTableTestUtils
 import org.whispersystems.signalservice.api.storage.SignalContactRecord
+import org.whispersystems.signalservice.api.storage.signalAci
+import org.whispersystems.signalservice.api.storage.signalPni
 import org.whispersystems.signalservice.api.storage.toSignalContactRecord
 import org.whispersystems.signalservice.internal.storage.protos.ContactRecord
+import java.util.UUID
 
 @Suppress("ClassName")
 @RunWith(AndroidJUnit4::class)
@@ -60,4 +70,46 @@ class RecipientTableTest_applyStorageSyncContactUpdate {
     val messages = MessageTableTestUtils.getMessages(SignalDatabase.threads.getThreadIdFor(other.id)!!)
     assertThat(messages.first().isIdentityDefault).isTrue()
   }
+
+  @Test
+  fun givenAnAlreadySyncedContact_whenMarkedUnregistered_thenItSplitsAndPublishesTheSplit() {
+    // GIVEN a registered contact with aci+pni+e164 that is already in storage service (has a storageId)
+    val aci = ACI.from(UUID.randomUUID())
+    val pni = PNI.from(UUID.randomUUID())
+    val e164 = "+13334445555"
+
+    val id = SignalDatabase.recipients.getAndPossiblyMerge(aci, pni, e164)
+    SignalDatabase.recipients.markRegistered(id, aci)
+
+    val originalStorageId: ByteArray? = SignalDatabase.recipients.getRecord(id).storageId
+    assertThat(originalStorageId).isNotNull()
+
+    // Sanity: the record it currently publishes is whole + registered.
+    val before = StorageSyncModels.localToRemoteRecord(SignalDatabase.recipients.getRecordForSync(id)!!).proto.contact!!
+    assertThat(before.signalAci).isEqualTo(aci)
+    assertThat(before.signalPni).isEqualTo(pni)
+    assertThat(before.unregisteredAtTimestamp).isEqualTo(0L)
+
+    // WHEN it is marked unregistered (which strips its pni/e164 and splits it)
+    SignalDatabase.recipients.markUnregistered(id)
+
+    // THEN its storageId rotates
+    val updatedStorageId: ByteArray? = SignalDatabase.recipients.getRecord(id).storageId
+    assertThat(updatedStorageId).isNotNull()
+    assertThat(originalStorageId!!.contentEquals(updatedStorageId!!)).isFalse()
+
+    // THEN the published record is now ACI-only + unregistered
+    val after = StorageSyncModels.localToRemoteRecord(SignalDatabase.recipients.getRecordForSync(id)!!).proto.contact!!
+    assertThat(after.signalAci).isEqualTo(aci)
+    assertThat(after.signalPni).isNull()
+    assertThat(after.e164.nullIfBlank()).isNull()
+    assertThat(after.unregisteredAtTimestamp > 0L).isTrue()
+
+    // THEN the number now lives on a separate PNI-only recipient, so no whole aci+pni+e164 record remains.
+    val byPni = SignalDatabase.recipients.getByPni(pni).get()
+    assertThat(byPni).isNotEqualTo(id)
+    val pniRecord = StorageSyncModels.localToRemoteRecord(SignalDatabase.recipients.getRecordForSync(byPni)!!).proto.contact!!
+    assertThat(pniRecord.signalAci).isNull()
+    assertThat(pniRecord.signalPni).isEqualTo(pni)
+  }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/database/helpers/migration/MyStoryMigrationTest.kt

@@ -1,120 +0,0 @@
-package org.thoughtcrime.securesms.database.helpers.migration
-
-import android.app.Application
-import androidx.core.content.contentValuesOf
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Assert.assertEquals
-import org.junit.Assert.fail
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.signal.core.util.SqlUtil
-import org.thoughtcrime.securesms.database.DistributionListTables
-import org.thoughtcrime.securesms.database.SignalDatabase
-import org.thoughtcrime.securesms.database.model.DistributionListId
-import org.thoughtcrime.securesms.testing.SignalDatabaseRule
-import org.whispersystems.signalservice.api.push.DistributionId
-import java.util.UUID
-import org.thoughtcrime.securesms.database.SQLiteDatabase as SignalSQLiteDatabase
-
-@RunWith(AndroidJUnit4::class)
-class MyStoryMigrationTest {
-
-  @get:Rule val harness = SignalDatabaseRule(deleteAllThreadsOnEachRun = false)
-
-  @Test
-  fun givenAValidMyStory_whenIMigrate_thenIExpectMyStoryToBeValid() {
-    // GIVEN
-    assertValidMyStoryExists()
-
-    // WHEN
-    runMigration()
-
-    // THEN
-    assertValidMyStoryExists()
-  }
-
-  @Test
-  fun givenNoMyStory_whenIMigrate_thenIExpectMyStoryToBeCreated() {
-    // GIVEN
-    deleteMyStory()
-
-    // WHEN
-    runMigration()
-
-    // THEN
-    assertValidMyStoryExists()
-  }
-
-  @Test
-  fun givenA00000000DistributionIdForMyStory_whenIMigrate_thenIExpectMyStoryToBeCreated() {
-    // GIVEN
-    setMyStoryDistributionId("0000-0000")
-
-    // WHEN
-    runMigration()
-
-    // THEN
-    assertValidMyStoryExists()
-  }
-
-  @Test
-  fun givenARandomDistributionIdForMyStory_whenIMigrate_thenIExpectMyStoryToBeCreated() {
-    // GIVEN
-    setMyStoryDistributionId(UUID.randomUUID().toString())
-
-    // WHEN
-    runMigration()
-
-    // THEN
-    assertValidMyStoryExists()
-  }
-
-  private fun setMyStoryDistributionId(serializedId: String) {
-    SignalDatabase.rawDatabase.update(
-      DistributionListTables.LIST_TABLE_NAME,
-      contentValuesOf(
-        DistributionListTables.DISTRIBUTION_ID to serializedId
-      ),
-      "_id = ?",
-      SqlUtil.buildArgs(DistributionListId.MY_STORY)
-    )
-  }
-
-  private fun deleteMyStory() {
-    SignalDatabase.rawDatabase.delete(
-      DistributionListTables.LIST_TABLE_NAME,
-      "_id = ?",
-      SqlUtil.buildArgs(DistributionListId.MY_STORY)
-    )
-  }
-
-  private fun assertValidMyStoryExists() {
-    SignalDatabase.rawDatabase.query(
-      DistributionListTables.LIST_TABLE_NAME,
-      SqlUtil.COUNT,
-      "_id = ? AND ${DistributionListTables.DISTRIBUTION_ID} = ?",
-      SqlUtil.buildArgs(DistributionListId.MY_STORY, DistributionId.MY_STORY.toString()),
-      null,
-      null,
-      null
-    ).use {
-      if (it.moveToNext()) {
-        val count = it.getInt(0)
-        assertEquals("assertValidMyStoryExists: Query produced an unexpected count.", 1, count)
-      } else {
-        fail("assertValidMyStoryExists: Query did not produce a count.")
-      }
-    }
-  }
-
-  private fun runMigration() {
-    V151_MyStoryMigration.migrate(
-      InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application,
-      SignalSQLiteDatabase(SignalDatabase.rawDatabase),
-      0,
-      1
-    )
-  }
-}

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

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

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

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

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

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

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

@@ -32,8 +32,8 @@ import org.thoughtcrime.securesms.conversation.ConversationIntents
 import org.thoughtcrime.securesms.conversation.v2.ConversationFragment
 import org.thoughtcrime.securesms.conversationlist.ConversationListArchiveFragment
 import org.thoughtcrime.securesms.conversationlist.ConversationListFragment
+import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.mediasend.v2.MediaSelectionActivity
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.stories.landing.StoriesLandingFragment
@@ -348,11 +348,13 @@ class MainNavigationLaunchTest {
       await(description = "no new ConversationFragment after Empty detail intent") {
         recorder.createdArgs.size == baseline
       }
-      // The user-visible signal that we're "back on the list" is the chat list fragment
-      // being attached, not just the VM saying CHATS.
-      awaitListFragment(launched, MainNavigationListLocation.CHATS)
 
       val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+
+      await(description = "conversation cleared from chats back stack after Empty detail intent") {
+        vm.chatsBackStackEntries.none { it is MainNavigationDetailLocation.Conversation }
+      }
+
       check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
         "Expected CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
       }
@@ -569,7 +571,7 @@ class MainNavigationLaunchTest {
   }
 
   private fun realBlob(bytes: ByteArray, mimeType: String): Uri {
-    return BlobProvider.getInstance()
+    return AppDependencies.blobs
       .forData(bytes)
       .withMimeType(mimeType)
       .createForSingleSessionInMemory()

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

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

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

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

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

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

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

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

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

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

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

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

app/src/main/AndroidManifest.xml

@@ -1371,7 +1371,7 @@
 
         <service
             android:name=".gcm.FcmReceiveService"
-            android:exported="true">
+            android:exported="false">
             <intent-filter>
                 <action android:name="com.google.firebase.MESSAGING_EVENT" />
             </intent-filter>

app/src/main/java/androidx/recyclerview/widget/ConversationLayoutManager.kt

@@ -24,6 +24,11 @@ class ConversationLayoutManager(context: Context) : LinearLayoutManager(context,
 
   private var afterScroll: (() -> Unit)? = null
 
+  // Backing state for scrollToPositionTopAligned; alignTopCorrected guards the one-shot corrective re-scroll.
+  private var alignTopPosition: Int = RecyclerView.NO_POSITION
+  private var alignTopInset: Int = 0
+  private var alignTopCorrected: Boolean = false
+
   override fun supportsPredictiveItemAnimations(): Boolean {
     return false
   }
@@ -34,9 +39,23 @@ class ConversationLayoutManager(context: Context) : LinearLayoutManager(context,
    */
   fun scrollToPositionWithOffset(position: Int, offset: Int, afterScroll: () -> Unit) {
     this.afterScroll = afterScroll
+    alignTopPosition = RecyclerView.NO_POSITION
     super.scrollToPositionWithOffset(position, offset)
   }
 
+  /**
+   * Scroll so [position]'s decorated top (including any top decoration, e.g. the unread divider) lands [topInset] px
+   * below the top of the recycler. [afterScroll] fires once the alignment settles.
+   */
+  fun scrollToPositionTopAligned(position: Int, topInset: Int, afterScroll: () -> Unit) {
+    this.afterScroll = afterScroll
+    alignTopPosition = position
+    alignTopInset = topInset
+    alignTopCorrected = false
+    // Rough first pass: the exact offset needs the item's height, which isn't known until it's laid out (see onLayoutCompleted).
+    super.scrollToPositionWithOffset(position, height - topInset)
+  }
+
   /**
    * If a scroll to position request is made and a layout pass occurs prior to the list being populated with via the data source,
    * the base implementation clears the request as if it was never made.
@@ -64,10 +83,26 @@ class ConversationLayoutManager(context: Context) : LinearLayoutManager(context,
       } else {
         scrollToPosition(pendingScrollPosition)
       }
-    } else {
-      afterScroll?.invoke()
-      afterScroll = null
+      return
     }
+
+    // The target is now laid out, so its height is known. Correct the offset once so the decorated top sits at the
+    // requested inset, then let the next layout settle before notifying via afterScroll.
+    if (alignTopPosition != RecyclerView.NO_POSITION && !alignTopCorrected) {
+      val target = findViewByPosition(alignTopPosition)
+      if (target != null) {
+        alignTopCorrected = true
+        if (getDecoratedTop(target) != alignTopInset) {
+          val correctedOffset = (height - paddingBottom) - alignTopInset - getDecoratedMeasuredHeight(target)
+          super.scrollToPositionWithOffset(alignTopPosition, correctedOffset)
+          return
+        }
+      }
+    }
+
+    afterScroll?.invoke()
+    afterScroll = null
+    alignTopPosition = RecyclerView.NO_POSITION
   }
 
   companion object {

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

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

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

@@ -39,6 +39,7 @@ import org.signal.core.util.MemoryTracker;
 import org.signal.core.util.Util;
 import org.signal.core.util.concurrent.AnrDetector;
 import org.signal.core.util.concurrent.SignalExecutors;
+import org.signal.core.util.crypto.AttachmentSecretProvider;
 import org.signal.core.util.logging.AndroidLogger;
 import org.signal.core.util.logging.Log;
 import org.signal.core.util.logging.Scrubber;
@@ -46,14 +47,15 @@ import org.signal.core.util.tracing.Tracer;
 import org.signal.glide.SignalGlideCodecs;
 import org.signal.libsignal.net.ChatServiceException;
 import org.signal.libsignal.protocol.logging.SignalProtocolLoggerProvider;
+import org.signal.registration.RegistrationDependencies;
 import org.signal.ringrtc.CallManager;
 import org.thoughtcrime.securesms.apkupdate.ApkUpdateRefreshListener;
 import org.thoughtcrime.securesms.avatar.AvatarPickerStorage;
 import org.thoughtcrime.securesms.backup.v2.BackupRepository;
-import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider;
+import org.thoughtcrime.securesms.conversation.drafts.DraftBlobs;
+import org.thoughtcrime.securesms.crypto.AppAttachmentSecretStore;
 import org.thoughtcrime.securesms.crypto.DatabaseSecretProvider;
 import org.thoughtcrime.securesms.database.LogDatabase;
-import org.thoughtcrime.securesms.database.SQLiteDatabase;
 import org.thoughtcrime.securesms.database.SignalDatabase;
 import org.thoughtcrime.securesms.database.SqlCipherLibraryLoader;
 import org.thoughtcrime.securesms.dependencies.AppDependencies;
@@ -98,10 +100,11 @@ import org.thoughtcrime.securesms.messageprocessingalarm.RoutineMessageFetchRece
 import org.thoughtcrime.securesms.messages.IncomingMessageObserver;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrations;
 import org.thoughtcrime.securesms.mms.SignalGlideModule;
-import org.thoughtcrime.securesms.providers.BlobProvider;
 import org.thoughtcrime.securesms.ratelimit.RateLimitUtil;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.registration.util.RegistrationUtil;
+import org.thoughtcrime.securesms.registration.v2.AppRegistrationNetworkController;
+import org.thoughtcrime.securesms.registration.v2.AppRegistrationStorageController;
 import org.thoughtcrime.securesms.ringrtc.RingRtcLogger;
 import org.thoughtcrime.securesms.service.AnalyzeDatabaseAlarmListener;
 import org.thoughtcrime.securesms.service.DirectoryRefreshListener;
@@ -114,6 +117,7 @@ import org.thoughtcrime.securesms.service.webrtc.ActiveCallManager;
 import org.thoughtcrime.securesms.service.webrtc.AndroidTelecomUtil;
 import org.thoughtcrime.securesms.storage.StorageSyncHelper;
 import org.thoughtcrime.securesms.util.AppStartup;
+import org.thoughtcrime.securesms.util.BatterySnapshotTracker;
 import org.thoughtcrime.securesms.util.DeviceProperties;
 import org.thoughtcrime.securesms.util.DynamicTheme;
 import org.thoughtcrime.securesms.util.Environment;
@@ -171,7 +175,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
                 SqlCipherLibraryLoader.load();
                 SignalDatabase.init(this,
                                     DatabaseSecretProvider.getOrCreateDatabaseSecret(this),
-                                    AttachmentSecretProvider.getInstance(this).getOrCreateAttachmentSecret());
+                                    AttachmentSecretProvider.getInstance(this, AppAttachmentSecretStore.INSTANCE).getOrCreateAttachmentSecret());
                 Logger.setTarget(SqlCipherLogTarget.INSTANCE);
               })
               .addBlocking("signal-store", () -> SignalStore.init(this))
@@ -259,6 +263,8 @@ public class ApplicationContext extends Application implements AppForegroundObse
     long startTime = System.currentTimeMillis();
     Log.i(TAG, "App is now visible. Battery: " + DeviceProperties.getBatteryLevel(this) + "% (charging: " + DeviceProperties.isCharging(this) + ")");
 
+    BatterySnapshotTracker.emit(this, "foreground");
+
     AppDependencies.getFrameRateTracker().start();
     AppDependencies.getMegaphoneRepository().onAppForegrounded();
     AppDependencies.getDeadlockDetector().start();
@@ -278,7 +284,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
       checkFreeDiskSpace();
       MemoryTracker.start();
       BackupSubscriptionCheckJob.enqueueIfAble();
-      CheckKeyTransparencyJob.enqueueIfNecessary(true);
+      CheckKeyTransparencyJob.enqueueIfNecessary(true, false);
       AppDependencies.getAuthWebSocket().registerKeepAliveToken(SignalWebSocket.FOREGROUND_KEEPALIVE);
       AppDependencies.getUnauthWebSocket().registerKeepAliveToken(SignalWebSocket.FOREGROUND_KEEPALIVE);
 
@@ -299,6 +305,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
   @Override
   public void onBackground() {
     Log.i(TAG, "App is no longer visible.");
+    BatterySnapshotTracker.emit(this, "background");
     KeyCachingService.onAppBackgrounded(this);
     AppDependencies.getMessageNotifier().clearVisibleThread();
     AppDependencies.getFrameRateTracker().stop();
@@ -417,10 +424,10 @@ public class ApplicationContext extends Application implements AppForegroundObse
   }
 
   private void initializeRegistrationDependencies() {
-    org.signal.registration.RegistrationDependencies.Companion.provide(
-      new org.signal.registration.RegistrationDependencies(
-        new org.thoughtcrime.securesms.registration.v2.AppRegistrationNetworkController(this, AppDependencies.getPushServiceSocket()),
-        new org.thoughtcrime.securesms.registration.v2.AppRegistrationStorageController(this),
+    RegistrationDependencies.provide(
+      new RegistrationDependencies(
+        new AppRegistrationNetworkController(this, AppDependencies.getPushServiceSocket()),
+        new AppRegistrationStorageController(this),
         Environment.IS_LINK_AND_SYNC_AVAILABLE,
         null,
         context -> {
@@ -512,8 +519,6 @@ public class ApplicationContext extends Application implements AppForegroundObse
     if (RemoteConfig.internalUser()) {
       Tracer.getInstance().setMaxBufferSize(35_000);
     }
-
-    SQLiteDatabase.setSlowWriteLoggingEnabled(RemoteConfig.slowDatabaseNotifications());
   }
 
   private void initializePeriodicTasks() {
@@ -573,7 +578,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
 
   @WorkerThread
   private void initializeBlobProvider() {
-    BlobProvider.getInstance().initialize(this);
+    AppDependencies.getBlobs().initialize(this, DraftBlobs.INSTANCE::deleteOrphanedDraftFiles);
   }
 
   @WorkerThread

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

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

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

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

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

@@ -5,7 +5,6 @@
 
 package org.thoughtcrime.securesms
 
-import android.Manifest
 import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
@@ -15,7 +14,6 @@ import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
-import android.widget.Toast
 import androidx.activity.SystemBarStyle
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.setContent
@@ -72,6 +70,8 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.createSavedStateHandle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.ui.NavDisplay
 import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import io.reactivex.rxjava3.subjects.PublishSubject
@@ -85,6 +85,7 @@ import kotlinx.coroutines.withContext
 import org.signal.core.ui.BottomSheetUtil
 import org.signal.core.ui.compose.Snackbars
 import org.signal.core.ui.compose.theme.SignalTheme
+import org.signal.core.ui.navigation.TransitionSpecs
 import org.signal.core.ui.permissions.Permissions
 import org.signal.core.ui.rememberIsSplitPane
 import org.signal.core.util.AppForegroundObserver
@@ -105,6 +106,8 @@ import org.thoughtcrime.securesms.calls.log.CallLogFragment
 import org.thoughtcrime.securesms.calls.new.NewCallActivity
 import org.thoughtcrime.securesms.calls.quality.CallQuality
 import org.thoughtcrime.securesms.calls.quality.CallQualityBottomSheetFragment
+import org.thoughtcrime.securesms.chats.ConversationTransitionState
+import org.thoughtcrime.securesms.chats.chatsNavEntries
 import org.thoughtcrime.securesms.components.DebugLogsPromptDialogFragment
 import org.thoughtcrime.securesms.components.PromptBatterySaverDialogFragment
 import org.thoughtcrime.securesms.components.compose.ConnectivityWarningBottomSheet
@@ -134,7 +137,6 @@ import org.thoughtcrime.securesms.devicetransfer.olddevice.OldDeviceExitActivity
 import org.thoughtcrime.securesms.groups.ui.creategroup.CreateGroupActivity
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.lock.v2.CreateSvrPinActivity
-import org.thoughtcrime.securesms.main.ChatNavGraphState
 import org.thoughtcrime.securesms.main.DetailsScreenNavHost
 import org.thoughtcrime.securesms.main.MainBottomChrome
 import org.thoughtcrime.securesms.main.MainBottomChromeCallback
@@ -143,7 +145,6 @@ import org.thoughtcrime.securesms.main.MainContentLayoutData
 import org.thoughtcrime.securesms.main.MainMegaphoneState
 import org.thoughtcrime.securesms.main.MainNavigationBar
 import org.thoughtcrime.securesms.main.MainNavigationDetailLocation
-import org.thoughtcrime.securesms.main.MainNavigationDetailLocationEffect
 import org.thoughtcrime.securesms.main.MainNavigationListLocation
 import org.thoughtcrime.securesms.main.MainNavigationRail
 import org.thoughtcrime.securesms.main.MainNavigationRouter
@@ -157,12 +158,10 @@ import org.thoughtcrime.securesms.main.MainToolbarState
 import org.thoughtcrime.securesms.main.MainToolbarViewModel
 import org.thoughtcrime.securesms.main.Material3OnScrollHelperBinder
 import org.thoughtcrime.securesms.main.callNavGraphBuilder
-import org.thoughtcrime.securesms.main.chatNavGraphBuilder
 import org.thoughtcrime.securesms.main.navigateToDetailLocation
 import org.thoughtcrime.securesms.main.rememberDetailNavHostController
 import org.thoughtcrime.securesms.main.rememberFocusRequester
 import org.thoughtcrime.securesms.main.storiesNavGraphBuilder
-import org.thoughtcrime.securesms.mediasend.camerax.CameraXRemoteConfig
 import org.thoughtcrime.securesms.mediasend.v2.MediaSelectionActivity
 import org.thoughtcrime.securesms.mediasend.v3.mediaSendLauncher
 import org.thoughtcrime.securesms.megaphone.Megaphone
@@ -197,7 +196,6 @@ import org.thoughtcrime.securesms.window.NavigationType
 import org.thoughtcrime.securesms.window.rememberThreePaneScaffoldNavigatorDelegate
 import org.whispersystems.signalservice.api.websocket.WebSocketConnectionState
 import kotlin.time.Duration.Companion.minutes
-import org.signal.core.ui.R as CoreUiR
 
 class MainActivity :
   PassphraseRequiredActivity(),
@@ -498,18 +496,15 @@ class MainActivity :
           }
         }
 
-        val chatNavGraphState = ChatNavGraphState.remember(isSplitPane)
+        val convoTransitionState = ConversationTransitionState.remember(isSplitPane)
         val mutableInteractionSource = remember { MutableInteractionSource() }
-        MainNavigationDetailLocationEffect(mainNavigationViewModel, chatNavGraphState::writeGraphicsLayerToBitmap)
 
-        val chatsNavHostController = rememberDetailNavHostController(
-          onRequestFocus = rememberFocusRequester(
-            mainNavigationViewModel = mainNavigationViewModel,
-            currentListLocation = mainNavigationState.currentListLocation,
-            isTargetListLocation = { it in listOf(MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE) }
-          )
-        ) {
-          chatNavGraphBuilder(chatNavGraphState)
+        LaunchedEffect(convoTransitionState) {
+          mainNavigationViewModel.setChatListSnapshotCaptureProvider { convoTransitionState.writeGraphicsLayerToBitmap() }
+        }
+
+        LaunchedEffect(isSplitPane) {
+          mainNavigationViewModel.onSplitPaneChanged(isSplitPane)
         }
 
         val callsNavHostController = rememberDetailNavHostController(
@@ -531,22 +526,23 @@ class MainActivity :
         }
 
         LaunchedEffect(Unit) {
-          suspend fun navigateToLocation(location: MainNavigationDetailLocation) {
+          fun navigateToLocation(location: MainNavigationDetailLocation) {
             when (location) {
               is MainNavigationDetailLocation.Empty -> {
                 when (mainNavigationState.currentListLocation) {
-                  MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> chatsNavHostController
+                  MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> {
+                    throw IllegalStateException("Navigation to ${mainNavigationState.currentListLocation} should be handled by ChatsBackStack.")
+                  }
+
                   MainNavigationListLocation.CALLS -> callsNavHostController
                   MainNavigationListLocation.STORIES -> storiesNavHostController
                 }.navigateToDetailLocation(location)
               }
 
-              is MainNavigationDetailLocation.Conversation -> {
-                chatNavGraphState.writeGraphicsLayerToBitmap()
-                chatsNavHostController.navigateToDetailLocation(location)
+              is MainNavigationDetailLocation.Conversation, is MainNavigationDetailLocation.Chats -> {
+                throw IllegalStateException("Navigation to $location should be handled by ChatsBackStack.")
               }
 
-              is MainNavigationDetailLocation.Chats -> chatsNavHostController.navigateToDetailLocation(location)
               is MainNavigationDetailLocation.CallLinkDetails -> callsNavHostController.navigateToDetailLocation(location)
               is MainNavigationDetailLocation.Calls -> callsNavHostController.navigateToDetailLocation(location)
               is MainNavigationDetailLocation.Stories -> storiesNavHostController.navigateToDetailLocation(location)
@@ -560,7 +556,9 @@ class MainActivity :
         }
 
         val scope = rememberCoroutineScope()
+
         BackHandler(paneExpansionState.currentAnchor == detailOnlyAnchor) {
+          mainNavigationViewModel.goTo(MainNavigationDetailLocation.Empty)
           scope.launch {
             paneExpansionState.animateTo(listOnlyAnchor)
           }
@@ -619,7 +617,7 @@ class MainActivity :
 
         AppScaffold(
           navigator = wrappedNavigator,
-          modifier = chatNavGraphState.writeContentToGraphicsLayer(),
+          modifier = convoTransitionState.writeContentToGraphicsLayer(),
           paneExpansionState = paneExpansionState,
           contentWindowInsets = WindowInsets(),
           snackbarHost = {
@@ -730,9 +728,13 @@ class MainActivity :
           primaryContent = {
             when (mainNavigationState.currentListLocation) {
               MainNavigationListLocation.CHATS, MainNavigationListLocation.ARCHIVE -> {
-                DetailsScreenNavHost(
-                  navHostController = chatsNavHostController,
-                  contentLayoutData = contentLayoutData
+                NavDisplay(
+                  backStack = mainNavigationViewModel.chatsBackStackEntries,
+                  onBack = { mainNavigationViewModel.popChatsDetailLocation() },
+                  transitionSpec = TransitionSpecs.HorizontalSlide.transitionSpec,
+                  popTransitionSpec = TransitionSpecs.HorizontalSlide.popTransitionSpec,
+                  predictivePopTransitionSpec = TransitionSpecs.HorizontalSlide.predictivePopTransitionSpec,
+                  entryProvider = entryProvider { chatsNavEntries(convoTransitionState) }
                 )
               }
 
@@ -761,7 +763,7 @@ class MainActivity :
           } else {
             null
           },
-          animatorFactory = if (mainNavigationState.currentListLocation == MainNavigationListLocation.CHATS || mainNavigationState.currentListLocation == MainNavigationListLocation.ARCHIVE) {
+          animatorFactory = if (mainNavigationState.currentListLocation.isChatsTab) {
             noEnterTransitionFactory
           } else {
             AppScaffoldAnimationStateFactory.Default
@@ -1052,6 +1054,13 @@ class MainActivity :
 
   private fun handleConversationIntent(intent: Intent) {
     if (ConversationIntents.isConversationIntent(intent)) {
+      if (!isTrustedConversationIntent(intent)) {
+        Log.w(TAG, "Received a conversation intent through an exported entry point. Ignoring its extras.")
+        intent.action = null
+        setIntent(intent)
+        return
+      }
+
       mainNavigationViewModel.goTo(MainNavigationListLocation.CHATS)
       mainNavigationViewModel.goTo(MainNavigationDetailLocation.Conversation(ConversationIntents.readArgsFromBundle(intent.extras!!)))
       intent.action = null
@@ -1059,6 +1068,14 @@ class MainActivity :
     }
   }
 
+  /**
+   * While MainActivity isn't exporting, we have launcher aliases that are, so we verify that someone isn't launching us through those befre
+   * respecting various intent attributes.
+   */
+  private fun isTrustedConversationIntent(intent: Intent): Boolean {
+    return intent.component?.className == MainActivity::class.java.name
+  }
+
   private fun handleGroupLinkInIntent(intent: Intent) {
     intent.data?.let { data ->
       CommunicationActions.handlePotentialGroupLinkUrl(this, data.toString())
@@ -1160,24 +1177,7 @@ class MainActivity :
       }
     }
 
-    if (CameraXRemoteConfig.isSupported()) {
-      onGranted()
-    } else {
-      Permissions.with(this@MainActivity)
-        .request(Manifest.permission.CAMERA)
-        .ifNecessary()
-        .withRationaleDialog(getString(R.string.CameraXFragment_allow_access_camera), getString(R.string.CameraXFragment_to_capture_photos_and_video_allow_camera), CoreUiR.drawable.symbol_camera_24)
-        .withPermanentDenialDialog(
-          getString(R.string.CameraXFragment_signal_needs_camera_access_capture_photos),
-          null,
-          R.string.CameraXFragment_allow_access_camera,
-          R.string.CameraXFragment_to_capture_photos_videos,
-          supportFragmentManager
-        )
-        .onAllGranted(onGranted)
-        .onAnyDenied { Toast.makeText(this@MainActivity, R.string.CameraXFragment_signal_needs_camera_access_capture_photos, Toast.LENGTH_LONG).show() }
-        .execute()
-    }
+    onGranted()
   }
 
   inner class ToolbarCallback : MainToolbarCallback {

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

@@ -135,12 +135,8 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
     Intent    intent           = getIntentForState(applicationState);
     if (intent != null) {
       Log.d(TAG, "routeApplicationState(), intent: " + intent.getComponent());
-      if (applicationState == STATE_WELCOME_PUSH_SCREEN && Environment.USE_NEW_REGISTRATION) {
-        startActivity(intent);
-      } else {
         startActivity(intent);
         finish();
-      }
     }
   }
 
@@ -227,7 +223,7 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
 
   private Intent getPushRegistrationIntent() {
     if (Environment.USE_NEW_REGISTRATION) {
-      return org.signal.registration.RegistrationActivity.createIntent(this);
+      return org.signal.registration.RegistrationActivity.createIntent(this, MainActivity.clearTop(this));
     } else {
       return RegistrationActivity.newIntentForNewRegistration(this, getIntent());
     }

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

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

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

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

app/src/main/java/org/thoughtcrime/securesms/apkupdate/ApkUpdateInstaller.kt

@@ -61,21 +61,36 @@ object ApkUpdateInstaller {
       return
     }
 
-    if (!isMatchingDigest(context, downloadId, digest)) {
-      Log.w(TAG, "DownloadId matches, but digest does not! Bad download or inconsistent state. Failing and clearing state.")
-      SignalStore.apkUpdate.clearDownloadAttributes()
-      ApkUpdateNotifications.showInstallFailed(context, ApkUpdateNotifications.FailureReason.UNKNOWN)
-      return
-    }
-
     if (!userInitiated && !shouldAutoUpdate()) {
+      if (!isMatchingDigest(context, downloadId, digest)) {
+        Log.w(TAG, "DownloadId matches, but digest does not! Bad download or inconsistent state. Failing and clearing state.")
+        SignalStore.apkUpdate.clearDownloadAttributes()
+        ApkUpdateNotifications.showInstallFailed(context, ApkUpdateNotifications.FailureReason.UNKNOWN)
+        return
+      }
+
       Log.w(TAG, "Not user-initiated and not eligible for auto-update. Prompting. (API=${Build.VERSION.SDK_INT}, Foreground=${AppForegroundObserver.isForegrounded()}, AutoUpdate=${SignalStore.apkUpdate.autoUpdate})")
       ApkUpdateNotifications.showInstallPrompt(context, downloadId)
       return
     }
 
     try {
-      installApk(context, downloadId, userInitiated)
+      context
+        .getDownloadManager()
+        .openDownloadedFile(downloadId)
+        .use { parcelFileDescriptor ->
+          val stream = FileInputStream(parcelFileDescriptor.fileDescriptor)
+
+          if (!MessageDigest.isEqual(FileUtils.getFileDigest(stream), digest)) {
+            Log.w(TAG, "DownloadId matches, but digest does not! Bad download or inconsistent state. Failing and clearing state.")
+            SignalStore.apkUpdate.clearDownloadAttributes()
+            ApkUpdateNotifications.showInstallFailed(context, ApkUpdateNotifications.FailureReason.UNKNOWN)
+            return
+          }
+
+          stream.channel.position(0)
+          installApk(context, downloadId, stream, userInitiated)
+        }
     } catch (e: IOException) {
       Log.w(TAG, "Hit IOException when trying to install APK!", e)
       SignalStore.apkUpdate.clearDownloadAttributes()
@@ -88,17 +103,13 @@ object ApkUpdateInstaller {
   }
 
   @Throws(IOException::class, SecurityException::class)
-  private fun installApk(context: Context, downloadId: Long, userInitiated: Boolean) {
-    val apkInputStream: InputStream? = getDownloadedApkInputStream(context, downloadId)
-    if (apkInputStream == null) {
-      Log.w(TAG, "Could not open download APK input stream!")
-      return
-    }
-
+  private fun installApk(context: Context, downloadId: Long, apkInputStream: InputStream, userInitiated: Boolean) {
     Log.d(TAG, "Beginning APK install...")
     val packageInstaller: PackageInstaller = context.packageManager.packageInstaller
 
     val sessionParams = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL).apply {
+      // Reject the session if the APK's declared package name doesn't match ours.
+      setAppPackageName(context.packageName)
       // At this point, we always want to set this if possible, since we've already prompted the user with our own notification when necessary.
       // This lets us skip the system-generated notification.
       if (Build.VERSION.SDK_INT >= 31) {
@@ -133,15 +144,6 @@ object ApkUpdateInstaller {
     session.commit(installerPendingIntent.intentSender)
   }
 
-  private fun getDownloadedApkInputStream(context: Context, downloadId: Long): InputStream? {
-    return try {
-      FileInputStream(context.getDownloadManager().openDownloadedFile(downloadId).fileDescriptor)
-    } catch (e: IOException) {
-      Log.w(TAG, e)
-      null
-    }
-  }
-
   private fun isDownloadSuccessful(context: Context, downloadId: Long): Boolean {
     val query = DownloadManager.Query().setFilterById(downloadId)
     val cursor = context.getDownloadManager().query(query)

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

@@ -41,12 +41,16 @@ enum class Cdn(private val value: Int) {
     }
 
     fun fromCdnNumber(cdnNumber: Int): Cdn {
+      return fromCdnNumberOrNull(cdnNumber) ?: throw UnsupportedOperationException("Invalid CDN number: $cdnNumber")
+    }
+
+    fun fromCdnNumberOrNull(cdnNumber: Int): Cdn? {
       return when (cdnNumber) {
         -1 -> S3
         0 -> CDN_0
         2 -> CDN_2
         3 -> CDN_3
-        else -> throw UnsupportedOperationException("Invalid CDN number: $cdnNumber")
+        else -> null
       }
     }
   }

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

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

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

@@ -5,6 +5,7 @@ import android.os.Parcel
 import androidx.annotation.VisibleForTesting
 import org.signal.blurhash.BlurHash
 import org.signal.core.util.Base64
+import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.stickers.StickerLocator
 import org.whispersystems.signalservice.api.InvalidMessageStructureException
@@ -76,6 +77,8 @@ class PointerAttachment : Attachment {
   override val thumbnailUri: Uri? = null
 
   companion object {
+    private val TAG = Log.tag(PointerAttachment::class)
+
     @JvmStatic
     fun forPointers(pointers: Optional<List<SignalServiceAttachment>>): List<Attachment> {
       if (!pointers.isPresent) {
@@ -102,6 +105,13 @@ class PointerAttachment : Attachment {
         return Optional.empty()
       }
 
+      val cdnNumber = pointer.get().asPointer().cdnNumber
+      val cdn = Cdn.fromCdnNumberOrNull(cdnNumber)
+      if (cdn == null) {
+        Log.w(TAG, "Encountered an attachment pointer with an unsupported CDN number ($cdnNumber). Skipping attachment.")
+        return Optional.empty()
+      }
+
       val encodedKey: String? = pointer.get().asPointer().key?.let { Base64.encodeWithPadding(it) }
 
       return Optional.of(
@@ -110,7 +120,7 @@ class PointerAttachment : Attachment {
           transferState = transferState,
           size = pointer.get().asPointer().size.orElse(0).toLong(),
           fileName = pointer.get().asPointer().fileName.orElse(null),
-          cdn = Cdn.fromCdnNumber(pointer.get().asPointer().cdnNumber),
+          cdn = cdn,
           location = pointer.get().asPointer().remoteId.toString(),
           key = encodedKey,
           iv = null,
@@ -145,7 +155,13 @@ class PointerAttachment : Attachment {
         return Optional.empty()
       }
 
-      val cdn = Cdn.fromCdnNumber(thumbnail?.asPointer()?.cdnNumber ?: 0)
+      val cdnNumber = thumbnail?.asPointer()?.cdnNumber ?: 0
+      val cdn = Cdn.fromCdnNumberOrNull(cdnNumber)
+      if (cdn == null) {
+        Log.w(TAG, "Encountered a quote thumbnail with an unsupported CDN number ($cdnNumber). Skipping attachment.")
+        return Optional.empty()
+      }
+
       if (cdn == Cdn.S3) {
         return Optional.empty()
       }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -19,11 +19,11 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.withContext
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.bytes
 import org.signal.core.util.logging.Log
 import org.signal.core.util.throttleLatest
 import org.thoughtcrime.securesms.BuildConfig
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.dependencies.AppDependencies

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

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

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

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

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

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

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

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

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

@@ -16,13 +16,13 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.update
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.bytes
 import org.signal.core.util.concurrent.SignalExecutors
 import org.signal.core.util.logging.Log
 import org.signal.core.util.safeUnregisterReceiver
 import org.signal.core.util.throttleLatest
 import org.thoughtcrime.securesms.BuildConfig
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.RestoreState
 import org.thoughtcrime.securesms.database.DatabaseObserver
 import org.thoughtcrime.securesms.database.SignalDatabase

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

@@ -34,6 +34,7 @@ import org.signal.core.models.backup.BackupId
 import org.signal.core.models.backup.MediaName
 import org.signal.core.models.backup.MediaRootBackupKey
 import org.signal.core.models.backup.MessageBackupKey
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Base64
 import org.signal.core.util.Base64.decodeBase64OrThrow
 import org.signal.core.util.CursorUtil
@@ -46,6 +47,7 @@ import org.signal.core.util.bytes
 import org.signal.core.util.concurrent.LimitedWorker
 import org.signal.core.util.concurrent.SignalDispatchers
 import org.signal.core.util.concurrent.SignalExecutors
+import org.signal.core.util.crypto.AttachmentSecretProvider
 import org.signal.core.util.decodeOrNull
 import org.signal.core.util.forceForeignKeyConstraintsEnabled
 import org.signal.core.util.fullWalCheckpoint
@@ -72,9 +74,7 @@ import org.signal.network.NetworkResult
 import org.signal.network.StatusCodeErrorAction
 import org.signal.network.api.SvrBApi
 import org.signal.network.exceptions.NonSuccessfulResponseCodeException
-import org.signal.network.rest.toNetworkResult
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.Cdn
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.backup.ArchiveUploadProgress
@@ -94,7 +94,7 @@ import org.thoughtcrime.securesms.backup.v2.ui.BackupAlert
 import org.thoughtcrime.securesms.backup.v2.ui.subscription.MessageBackupsType
 import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
 import org.thoughtcrime.securesms.components.settings.app.subscription.RecurringInAppPaymentRepository
-import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider
+import org.thoughtcrime.securesms.crypto.AppAttachmentSecretStore
 import org.thoughtcrime.securesms.crypto.DatabaseSecretProvider
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.BackupMediaSnapshotTable.ArchiveMediaItem
@@ -141,7 +141,6 @@ import org.thoughtcrime.securesms.logsubmit.SubmitDebugLogRepository
 import org.thoughtcrime.securesms.net.SignalNetwork
 import org.thoughtcrime.securesms.notifications.NotificationChannels
 import org.thoughtcrime.securesms.notifications.NotificationIds
-import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.service.BackupMediaRestoreService
@@ -718,7 +717,7 @@ object BackupRepository {
       SignalDatabase(
         context = context,
         databaseSecret = DatabaseSecretProvider.getOrCreateDatabaseSecret(context),
-        attachmentSecret = AttachmentSecretProvider.getInstance(context).getOrCreateAttachmentSecret(),
+        attachmentSecret = AttachmentSecretProvider.getInstance(context, AppAttachmentSecretStore).getOrCreateAttachmentSecret(),
         name = "$baseName.db"
       )
     }
@@ -2236,7 +2235,7 @@ object BackupRepository {
     }
 
     Log.i(TAG, "[remoteRestore] Downloading backup")
-    val tempBackupFile = BlobProvider.getInstance().forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
+    val tempBackupFile = AppDependencies.blobs.forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
     when (val result = downloadBackupFile(tempBackupFile, progressListener)) {
       is NetworkResult.Success -> Log.i(TAG, "[remoteRestore] Download successful")
       else -> {
@@ -2356,7 +2355,7 @@ object BackupRepository {
     }
 
     Log.i(TAG, "[restoreLinkAndSyncBackup] Downloading backup")
-    val tempBackupFile = BlobProvider.getInstance().forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
+    val tempBackupFile = AppDependencies.blobs.forNonAutoEncryptingSingleSessionOnDisk(AppDependencies.application)
     when (val result = AppDependencies.signalServiceMessageReceiver.retrieveLinkAndSyncBackup(response.cdn, response.key, tempBackupFile, progressListener)) {
       is NetworkResult.Success -> Log.i(TAG, "[restoreLinkAndSyncBackup] Download successful")
       else -> {
@@ -2559,6 +2558,9 @@ enum class BackupMode {
 
   val isLocalBackup: Boolean
     get() = this == LOCAL
+
+  val isPlaintextExport: Boolean
+    get() = this == PLAINTEXT_EXPORT
 }
 
 /**

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

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

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

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

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

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

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

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

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

@@ -42,6 +42,7 @@ import org.signal.archive.proto.Text
 import org.signal.archive.proto.ThreadMergeChatUpdate
 import org.signal.archive.proto.ViewOnceMessage
 import org.signal.core.models.ServiceId
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Base64
 import org.signal.core.util.EventTimer
 import org.signal.core.util.Hex
@@ -68,7 +69,6 @@ import org.signal.core.util.requireLong
 import org.signal.core.util.requireLongOrNull
 import org.signal.core.util.requireString
 import org.signal.core.util.toByteArray
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.backup.v2.BackupMode
 import org.thoughtcrime.securesms.backup.v2.ExportOddities
@@ -435,7 +435,7 @@ class ChatItemArchiveExporter(
 
         else -> {
           val attachments = extraData.attachmentsById[record.id]
-          val sticker = attachments?.firstOrNull { dbAttachment -> dbAttachment.isSticker }
+          val sticker = attachments?.firstOrNull { dbAttachment -> dbAttachment.isSticker && !dbAttachment.quote }
 
           if (sticker?.stickerLocator != null) {
             builder.stickerMessage = sticker.toRemoteStickerMessage(sentTimestamp = record.dateSent, reactions = extraData.reactionsById[id], exportState = exportState)
@@ -647,15 +647,22 @@ private fun BackupMessageRecord.toBasicChatItemBuilder(selfRecipientId: Recipien
     }
   }
 
-  if (!MessageTypes.isExpirationTimerUpdate(record.type) && builder.expiresInMs != null && builder.expireStartDate != null) {
-    val cutoffDuration = ChatItemArchiveExporter.EXPIRATION_CUTOFF.inWholeMilliseconds
-    val expiresAt = builder.expireStartDate!! + builder.expiresInMs!!
-    val threshold = if (exportState.backupMode.isLinkAndSync) backupStartTime else backupStartTime + cutoffDuration
-
-    if (expiresAt < threshold || (builder.expiresInMs!! <= cutoffDuration && !exportState.backupMode.isLinkAndSync)) {
+  if (!MessageTypes.isExpirationTimerUpdate(record.type) && builder.expiresInMs != null) {
+    if (exportState.backupMode.isPlaintextExport) {
       Log.w(TAG, ExportSkips.messageExpiresTooSoon(record.dateSent))
       return null
     }
+
+    if (builder.expireStartDate != null) {
+      val cutoffDuration = ChatItemArchiveExporter.EXPIRATION_CUTOFF.inWholeMilliseconds
+      val expiresAt = builder.expireStartDate!! + builder.expiresInMs!!
+      val threshold = if (exportState.backupMode.isLinkAndSync) backupStartTime else backupStartTime + cutoffDuration
+
+      if (expiresAt < threshold || (builder.expiresInMs!! <= cutoffDuration && !exportState.backupMode.isLinkAndSync)) {
+        Log.w(TAG, ExportSkips.messageExpiresTooSoon(record.dateSent))
+        return null
+      }
+    }
   }
 
   if (builder.expireStartDate != null && builder.expiresInMs == null) {
@@ -852,8 +859,8 @@ private fun BackupMessageRecord.toRemotePaymentNotificationUpdate(db: SignalData
     PaymentNotification()
   } else {
     PaymentNotification(
-      amountMob = payment.amount.serializeAmountString(),
-      feeMob = payment.fee.serializeAmountString(),
+      amountMob = payment.amount.requireMobileCoin().amountDecimalString,
+      feeMob = payment.fee.requireMobileCoin().amountDecimalString,
       note = payment.note.takeUnless { it.isEmpty() },
       transactionDetails = payment.toRemoteTransactionDetails()
     )

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

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

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

@@ -60,7 +60,6 @@ import org.thoughtcrime.securesms.database.documents.NetworkFailureSet
 import org.thoughtcrime.securesms.database.model.GroupCallUpdateDetailsUtil
 import org.thoughtcrime.securesms.database.model.Mention
 import org.thoughtcrime.securesms.database.model.databaseprotos.BodyRangeList
-import org.thoughtcrime.securesms.database.model.databaseprotos.CryptoValue
 import org.thoughtcrime.securesms.database.model.databaseprotos.GV2UpdateDescription
 import org.thoughtcrime.securesms.database.model.databaseprotos.GiftBadge
 import org.thoughtcrime.securesms.database.model.databaseprotos.MessageExtras
@@ -85,7 +84,7 @@ import org.thoughtcrime.securesms.util.Environment
 import org.thoughtcrime.securesms.util.MessageUtil
 import org.whispersystems.signalservice.api.payments.Money
 import org.whispersystems.signalservice.internal.push.DataMessage
-import java.math.BigInteger
+import java.math.BigDecimal
 import java.sql.SQLException
 import java.util.Optional
 import java.util.UUID
@@ -1064,8 +1063,8 @@ class ChatItemArchiveImporter(
 
   private fun ContentValues.addPaymentTombstoneNoMetadata(paymentNotification: PaymentNotification) {
     put(MessageTable.TYPE, getAsLong(MessageTable.TYPE) or MessageTypes.SPECIAL_TYPE_PAYMENTS_TOMBSTONE)
-    val amount = tryParseCryptoValue(paymentNotification.amountMob)
-    val fee = tryParseCryptoValue(paymentNotification.feeMob)
+    val amount = paymentNotification.amountMob?.tryParseMoney()?.let { CryptoValueUtil.moneyToCryptoValue(it) }
+    val fee = paymentNotification.feeMob?.tryParseMoney()?.let { CryptoValueUtil.moneyToCryptoValue(it) }
     put(
       MessageTable.MESSAGE_EXTRAS,
       MessageExtras(
@@ -1119,26 +1118,15 @@ class ChatItemArchiveImporter(
       return null
     }
 
-    val amountCryptoValue = tryParseCryptoValue(this)
-    return if (amountCryptoValue != null) {
-      CryptoValueUtil.cryptoValueToMoney(amountCryptoValue)
-    } else {
+    return try {
+      Money.mobileCoin(BigDecimal(this))
+    } catch (e: NumberFormatException) {
+      null
+    } catch (e: ArithmeticException) {
       null
     }
   }
 
-  private fun tryParseCryptoValue(bigIntegerString: String?): CryptoValue? {
-    if (bigIntegerString == null) {
-      return null
-    }
-    val amount = try {
-      BigInteger(bigIntegerString).toString()
-    } catch (e: NumberFormatException) {
-      return null
-    }
-    return CryptoValue(mobileCoinValue = CryptoValue.MobileCoinValue(picoMobileCoin = amount))
-  }
-
   private fun ContentValues.addQuote(quote: Quote) {
     this.put(MessageTable.QUOTE_ID, quote.targetSentTimestamp ?: MessageTable.QUOTE_TARGET_MISSING_ID)
     this.put(MessageTable.QUOTE_AUTHOR, importState.requireLocalRecipientId(quote.authorId).serialize())

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

@@ -16,6 +16,7 @@ import org.signal.archive.stream.EncryptedBackupReader
 import org.signal.core.models.backup.BackupId
 import org.signal.core.models.backup.MediaName
 import org.signal.core.models.backup.MessageBackupKey
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.Stopwatch
 import org.signal.core.util.StreamUtil
 import org.signal.core.util.Util
@@ -23,7 +24,6 @@ import org.signal.core.util.logging.Log
 import org.signal.core.util.readFully
 import org.signal.core.util.toJson
 import org.signal.libsignal.crypto.Aes256Ctr32
-import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.backup.LocalExportProgress
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.database.AttachmentTable

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

@@ -12,11 +12,12 @@ import org.signal.archive.proto.AccountData
 import org.signal.archive.proto.ChatStyle
 import org.signal.archive.proto.Frame
 import org.signal.archive.stream.BackupFrameEmitter
+import org.signal.core.models.database.AttachmentId
 import org.signal.core.util.UuidUtil
 import org.signal.core.util.logging.Log
 import org.signal.core.util.toByteArray
 import org.signal.libsignal.zkgroup.backups.BackupLevel
-import org.thoughtcrime.securesms.attachments.AttachmentId
+import org.signal.mediasend.SentMediaQuality
 import org.thoughtcrime.securesms.backup.v2.ExportState
 import org.thoughtcrime.securesms.backup.v2.ImportState
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
@@ -471,19 +472,19 @@ object AccountDataArchiveProcessor {
     }
   }
 
-  private fun org.thoughtcrime.securesms.mms.SentMediaQuality.toRemoteSentMediaQuality(): AccountData.SentMediaQuality {
+  private fun SentMediaQuality.toRemoteSentMediaQuality(): AccountData.SentMediaQuality {
     return when (this) {
-      org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD -> AccountData.SentMediaQuality.STANDARD
-      org.thoughtcrime.securesms.mms.SentMediaQuality.HIGH -> AccountData.SentMediaQuality.HIGH
+      SentMediaQuality.STANDARD -> AccountData.SentMediaQuality.STANDARD
+      SentMediaQuality.HIGH -> AccountData.SentMediaQuality.HIGH
     }
   }
 
-  private fun AccountData.SentMediaQuality?.toLocalSentMediaQuality(): org.thoughtcrime.securesms.mms.SentMediaQuality {
+  private fun AccountData.SentMediaQuality?.toLocalSentMediaQuality(): SentMediaQuality {
     return when (this) {
-      AccountData.SentMediaQuality.HIGH -> org.thoughtcrime.securesms.mms.SentMediaQuality.HIGH
-      AccountData.SentMediaQuality.STANDARD -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
-      AccountData.SentMediaQuality.UNKNOWN_QUALITY -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
-      null -> org.thoughtcrime.securesms.mms.SentMediaQuality.STANDARD
+      AccountData.SentMediaQuality.HIGH -> SentMediaQuality.HIGH
+      AccountData.SentMediaQuality.STANDARD -> SentMediaQuality.STANDARD
+      AccountData.SentMediaQuality.UNKNOWN_QUALITY -> SentMediaQuality.STANDARD
+      null -> SentMediaQuality.STANDARD
     }
   }
 

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

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

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

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

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

@@ -53,6 +53,7 @@ import kotlin.time.Duration.Companion.seconds
 class MessageBackupsFlowViewModel(
   private val initialTierSelection: MessageBackupTier?,
   googlePlayApiAvailability: Int,
+  private val isCredentialManagerSupported: Boolean,
   startScreen: MessageBackupsStage = if (SignalStore.backup.backupTier == null) MessageBackupsStage.EDUCATION else MessageBackupsStage.TYPE_SELECTION
 ) : ViewModel(), BackupKeyCredentialManagerHandler {
 
@@ -238,8 +239,9 @@ class MessageBackupsFlowViewModel(
       when (it.stage) {
         MessageBackupsStage.CANCEL -> error("Unsupported state transition from terminal state CANCEL")
         MessageBackupsStage.EDUCATION -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_EDUCATION)
-        MessageBackupsStage.BACKUP_KEY_EDUCATION -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_RECORD)
-        MessageBackupsStage.BACKUP_KEY_RECORD -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_VERIFY)
+        MessageBackupsStage.BACKUP_KEY_EDUCATION -> it.copy(stage = if (isCredentialManagerSupported) MessageBackupsStage.BACKUP_KEY_RECORD else MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY)
+        MessageBackupsStage.BACKUP_KEY_RECORD -> it.copy(stage = MessageBackupsStage.TYPE_SELECTION)
+        MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY -> it.copy(stage = MessageBackupsStage.BACKUP_KEY_VERIFY)
         MessageBackupsStage.BACKUP_KEY_VERIFY -> it.copy(stage = MessageBackupsStage.TYPE_SELECTION)
         MessageBackupsStage.TYPE_SELECTION -> validateTypeAndUpdateState(it)
         MessageBackupsStage.CHECKOUT_SHEET -> it.copy(stage = MessageBackupsStage.PROCESS_PAYMENT)
@@ -262,7 +264,8 @@ class MessageBackupsFlowViewModel(
           MessageBackupsStage.EDUCATION -> MessageBackupsStage.CANCEL
           MessageBackupsStage.BACKUP_KEY_EDUCATION -> MessageBackupsStage.EDUCATION
           MessageBackupsStage.BACKUP_KEY_RECORD -> MessageBackupsStage.BACKUP_KEY_EDUCATION
-          MessageBackupsStage.BACKUP_KEY_VERIFY -> MessageBackupsStage.BACKUP_KEY_RECORD
+          MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY -> if (isCredentialManagerSupported) MessageBackupsStage.BACKUP_KEY_RECORD else MessageBackupsStage.BACKUP_KEY_EDUCATION
+          MessageBackupsStage.BACKUP_KEY_VERIFY -> MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY
           MessageBackupsStage.TYPE_SELECTION -> MessageBackupsStage.BACKUP_KEY_RECORD
           MessageBackupsStage.CHECKOUT_SHEET -> MessageBackupsStage.TYPE_SELECTION
           MessageBackupsStage.CREATING_IN_APP_PAYMENT -> MessageBackupsStage.CREATING_IN_APP_PAYMENT
@@ -277,6 +280,12 @@ class MessageBackupsFlowViewModel(
     }
   }
 
+  fun goToRecordManually() {
+    internalStateFlow.update {
+      it.copy(stage = MessageBackupsStage.BACKUP_KEY_RECORD_MANUALLY)
+    }
+  }
+
   fun onMessageBackupTierUpdated(messageBackupTier: MessageBackupTier) {
     internalStateFlow.update {
       it.copy(

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.backup.v2.ui.warning
+
+import org.signal.core.models.AccountEntropyPool
+
+/**
+ * Detects whether a block of text contains the user's own [AccountEntropyPool] (recovery key).
+ *
+ * We scan anywhere within the text and try to match the key in as many forms as possible:
+ * upper/lowercase, with or without grouping spaces, and with or without the display characters
+ * (e.g. '#'/'=') used to disambiguate 'O'/'0'. Matching against the user's actual key (rather than
+ * just the AEP shape) avoids false positives on any 64-character in-alphabet string.
+ */
+object RecoveryKeyDetector {
+
+  /**
+   * @param text the text to scan
+   * @param recoveryKey the user's own recovery key, or null if they don't have one yet
+   * @return true if [text] contains [recoveryKey] in any of its accepted forms. Always false when
+   * [recoveryKey] is null, so callers can bypass the check entirely for users without a key.
+   */
+  fun containsRecoveryKey(text: String?, recoveryKey: AccountEntropyPool?): Boolean {
+    if (recoveryKey == null || text.isNullOrBlank() || text.length < AccountEntropyPool.LENGTH) {
+      return false
+    }
+
+    val normalized = AccountEntropyPool.removeIllegalCharacters(AccountEntropyPool.formatForStorage(text)).lowercase()
+
+    return normalized.contains(recoveryKey.value)
+  }
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.backup.v2.ui.warning
+
+import androidx.fragment.app.Fragment
+import org.thoughtcrime.securesms.components.ComposeText
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+
+/**
+ * Wires this [ComposeText] so that pasting the user's own recovery key first shows
+ * [RecoveryKeyPasteWarningFragment], warning against sharing it. The paste only completes if the
+ * user explicitly confirms via that warning.
+ *
+ * Must be called once the [host]'s view has been created, as it registers a fragment result
+ * listener scoped to the host's view lifecycle.
+ *
+ * @param onWarningShown invoked just before the warning is shown. Hosts that auto-dismiss when the
+ * keyboard hides (e.g. [org.thoughtcrime.securesms.components.KeyboardEntryDialogFragment]) can use
+ * this to suppress that behavior while the warning is up.
+ * @param onWarningDismissed invoked when the warning is dismissed by any path, after the paste (if
+ * any) has been applied. Hosts can use this to restore the suppressed state and re-focus the input.
+ */
+fun ComposeText.guardAgainstRecoveryKeyPaste(
+  host: Fragment,
+  onWarningShown: () -> Unit = {},
+  onWarningDismissed: () -> Unit = {}
+) {
+  var pendingPaste: CharSequence? = null
+
+  host.childFragmentManager.setFragmentResultListener(RecoveryKeyPasteWarningFragment.REQUEST_KEY, host.viewLifecycleOwner) { _, bundle ->
+    if (bundle.getBoolean(RecoveryKeyPasteWarningFragment.REQUEST_KEY)) {
+      pendingPaste?.let { insertText(it) }
+    }
+    pendingPaste = null
+    onWarningDismissed()
+  }
+
+  setOnPasteListener { pasteText ->
+    if (RecoveryKeyDetector.containsRecoveryKey(pasteText?.toString(), SignalStore.account.accountEntropyPoolOrNull)) {
+      pendingPaste = pasteText
+      onWarningShown()
+      RecoveryKeyPasteWarningFragment().show(host.childFragmentManager, null)
+      true
+    } else {
+      false
+    }
+  }
+}

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

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.backup.v2.ui.warning
+
+import android.content.DialogInterface
+import android.os.Bundle
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.fragment.app.setFragmentResult
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.backup.v2.ui.warning.RecoveryKeyPasteWarningFragment.Companion.REQUEST_KEY
+import org.thoughtcrime.securesms.util.CommunicationActions
+
+/**
+ * Displayed via the [org.thoughtcrime.securesms.components.settings.conversation.ConversationSettingsFragment] whenever the user
+ * attempts to paste their recovery key into the input field.
+ *
+ * A result is always delivered to [REQUEST_KEY] when this fragment is dismissed, with the boolean
+ * indicating whether the user chose to proceed with the paste. The host can rely on this firing for
+ * every dismissal path (paste, decline, or cancel) to restore its own state.
+ */
+class RecoveryKeyPasteWarningFragment : ComposeBottomSheetDialogFragment() {
+
+  companion object {
+    const val REQUEST_KEY = "recovery_key_request"
+  }
+
+  private var shouldPaste = false
+
+  override fun onDismiss(dialog: DialogInterface) {
+    setFragmentResult(
+      REQUEST_KEY,
+      Bundle().apply {
+        putBoolean(REQUEST_KEY, shouldPaste)
+      }
+    )
+
+    super.onDismiss(dialog)
+  }
+
+  @Composable
+  override fun SheetContent() {
+    val context = LocalContext.current
+    val url = stringResource(R.string.recovery_key_phishing_support_url)
+
+    val eventHandler: (RecoveryKeyWarningSheetEvent) -> Unit = {
+      when (it) {
+        RecoveryKeyWarningSheetEvent.DoNotShareClick -> {
+          dismissAllowingStateLoss()
+        }
+
+        RecoveryKeyWarningSheetEvent.GotItClick -> {
+          error("Not supported for paste")
+        }
+
+        RecoveryKeyWarningSheetEvent.LearnMoreClick -> {
+          CommunicationActions.openBrowserLink(context, url)
+          dismissAllowingStateLoss()
+        }
+
+        RecoveryKeyWarningSheetEvent.ShareKeyClick -> {
+          shouldPaste = true
+          dismissAllowingStateLoss()
+        }
+      }
+    }
+
+    RecoveryKeyWarningSheetContent(
+      clipStage = ClipStage.PASTE,
+      events = eventHandler
+    )
+  }
+}

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

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.backup.v2.ui.warning
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+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.TextLinkStyles
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withLink
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.dp
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.signal.core.ui.compose.horizontalGutters
+import org.thoughtcrime.securesms.R
+
+@Composable
+fun RecoveryKeyWarningSheetContent(
+  clipStage: ClipStage,
+  events: (RecoveryKeyWarningSheetEvent) -> Unit,
+  modifier: Modifier = Modifier
+) {
+  Column(
+    modifier = modifier.horizontalGutters(),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    Icon(
+      imageVector = ImageVector.vectorResource(R.drawable.ic_warning_40),
+      tint = MaterialTheme.colorScheme.error,
+      contentDescription = null,
+      modifier = Modifier
+        .padding(top = 20.dp, bottom = 16.dp)
+        .size(80.dp)
+        .background(color = MaterialTheme.colorScheme.errorContainer, shape = CircleShape)
+        .padding(20.dp)
+    )
+
+    Text(
+      text = stringResource(R.string.RecoveryKeyWarningSheetContent__do_not_share_your_recovery_key),
+      style = MaterialTheme.typography.titleLarge,
+      textAlign = TextAlign.Center,
+      modifier = Modifier.padding(bottom = 12.dp)
+    )
+
+    Text(
+      text = buildAnnotatedString {
+        withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+          append(stringResource(R.string.RecoveryKeyWarningSheetContent__signal_will_never_message_you))
+        }
+
+        append(" ")
+        append(stringResource(R.string.RecoveryKeyWarningSheetContent__for_your_recovery_key_never_respond))
+
+        if (clipStage == ClipStage.PASTE) {
+          append(" ")
+          withLink(
+            link = LinkAnnotation.Clickable(
+              tag = "learn-more",
+              styles = TextLinkStyles(
+                style = SpanStyle(
+                  color = MaterialTheme.colorScheme.primary
+                )
+              )
+            ) {
+              events(RecoveryKeyWarningSheetEvent.LearnMoreClick)
+            }
+          ) {
+            append(stringResource(R.string.RecoveryKeyWarningSheetContent__learn_more_period))
+          }
+        }
+      },
+      textAlign = TextAlign.Center,
+      color = MaterialTheme.colorScheme.onSurfaceVariant,
+      modifier = Modifier.padding(bottom = 75.dp)
+    )
+
+    when (clipStage) {
+      ClipStage.COPY -> CopyActionButtons(events = events)
+      ClipStage.PASTE -> PasteActionButtons(events = events)
+    }
+
+    Spacer(modifier = Modifier.size(16.dp))
+  }
+}
+
+@Composable
+fun CopyActionButtons(events: (RecoveryKeyWarningSheetEvent) -> Unit) {
+  Buttons.LargeTonal(onClick = {
+    events(RecoveryKeyWarningSheetEvent.GotItClick)
+  }) {
+    Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__got_it))
+  }
+
+  TextButton(onClick = {
+    events(RecoveryKeyWarningSheetEvent.LearnMoreClick)
+  }) {
+    Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__learn_more))
+  }
+}
+
+@Composable
+fun PasteActionButtons(events: (RecoveryKeyWarningSheetEvent) -> Unit) {
+  Buttons.LargeTonal(onClick = {
+    events(RecoveryKeyWarningSheetEvent.DoNotShareClick)
+  }) {
+    Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__do_not_share_key))
+  }
+
+  TextButton(
+    colors = ButtonDefaults.textButtonColors(
+      contentColor = MaterialTheme.colorScheme.error
+    ),
+    onClick = {
+      events(RecoveryKeyWarningSheetEvent.ShareKeyClick)
+    }
+  ) {
+    Text(text = stringResource(R.string.RecoveryKeyWarningSheetContent__share_key))
+  }
+}
+
+enum class ClipStage {
+  COPY,
+  PASTE
+}
+
+@DayNightPreviews
+@Composable
+private fun RecoveryKeyWarningSheetContentCopyPreview() {
+  Previews.BottomSheetPreview {
+    RecoveryKeyWarningSheetContent(
+      clipStage = ClipStage.COPY,
+      events = {},
+      modifier = Modifier.fillMaxSize()
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun RecoveryKeyWarningSheetContentPastePreview() {
+  Previews.BottomSheetPreview {
+    RecoveryKeyWarningSheetContent(
+      clipStage = ClipStage.PASTE,
+      events = {},
+      modifier = Modifier.fillMaxSize()
+    )
+  }
+}

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.backup.v2.ui.warning
+
+sealed interface RecoveryKeyWarningSheetEvent {
+  data object DoNotShareClick : RecoveryKeyWarningSheetEvent
+  data object ShareKeyClick : RecoveryKeyWarningSheetEvent
+  data object GotItClick : RecoveryKeyWarningSheetEvent
+  data object LearnMoreClick : RecoveryKeyWarningSheetEvent
+}

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

@@ -11,6 +11,7 @@ import org.signal.archive.proto.FilePointer
 import org.signal.core.util.Base64
 import org.signal.core.util.UuidUtil
 import org.signal.core.util.isNotNullOrBlank
+import org.signal.core.util.logging.Log
 import org.signal.core.util.nullIfBlank
 import org.signal.core.util.orNull
 import org.signal.libsignal.usernames.BaseUsernameException
@@ -32,6 +33,8 @@ import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemo
 import java.util.Optional
 import org.signal.archive.proto.AvatarColor as RemoteAvatarColor
 
+private const val TAG = "ArchiveConverter"
+
 /**
  * Converts a [FilePointer] to a local [Attachment] object for inserting into the database.
  */
@@ -58,10 +61,16 @@ fun FilePointer?.toLocalAttachment(
 
   return when (attachmentType) {
     AttachmentType.ARCHIVE -> {
+      val cdnNumber = locatorInfo.transitCdnNumber ?: Cdn.CDN_0.cdnNumber
+      if (Cdn.fromCdnNumberOrNull(cdnNumber) == null) {
+        Log.w(TAG, "Encountered an archived attachment with an unsupported CDN number ($cdnNumber). Skipping attachment.")
+        return null
+      }
+
       ArchivedAttachment(
         contentType = contentType,
         size = locatorInfo.size.toLong(),
-        cdn = locatorInfo.transitCdnNumber ?: Cdn.CDN_0.cdnNumber,
+        cdn = cdnNumber,
         uploadTimestamp = locatorInfo.transitTierUploadTimestamp ?: 0,
         key = locatorInfo.key.toByteArray(),
         cdnKey = locatorInfo.transitCdnKey?.nullIfBlank(),

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

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

app/src/main/java/org/thoughtcrime/securesms/badges/gifts/flow/GiftFlowConfirmationFragment.kt

@@ -306,7 +306,5 @@ class GiftFlowConfirmationFragment :
 
   override fun navigateToDonationPending(inAppPayment: InAppPaymentTable.InAppPayment) = error("Not supported for gifts")
 
-  override fun exitCheckoutFlow() {
-    requireActivity().finishAfterTransition()
-  }
+  override fun exitCheckoutFlow() = Unit
 }

app/src/main/java/org/thoughtcrime/securesms/badges/gifts/flow/GiftFlowRecipientSelectionFragment.kt

@@ -4,7 +4,6 @@ import android.graphics.Color
 import android.os.Bundle
 import android.view.View
 import android.view.ViewGroup
-import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import androidx.navigation.fragment.findNavController
@@ -19,29 +18,25 @@ import org.thoughtcrime.securesms.conversation.mutiselect.forward.SearchConfigur
 import org.thoughtcrime.securesms.database.RecipientTable
 import org.thoughtcrime.securesms.util.activityViewModel
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
-import org.thoughtcrime.securesms.util.viewModel
-import kotlin.getValue
 
 /**
  * Allows the user to select a recipient to send a gift to.
  */
-class GiftFlowRecipientSelectionFragment : Fragment(R.layout.gift_flow_recipient_selection_fragment), MultiselectForwardFragment.Callback, SearchConfigurationProvider {
+class GiftFlowRecipientSelectionFragment : Fragment(R.layout.multiselect_forward_activity), MultiselectForwardFragment.Callback, SearchConfigurationProvider {
 
   private val viewModel: GiftFlowViewModel by activityViewModel {
     GiftFlowViewModel()
   }
 
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-    val toolbar = view.findViewById<Toolbar>(R.id.toolbar)
-    toolbar.setNavigationOnClickListener { requireActivity().onBackPressed() }
-
     if (savedInstanceState == null) {
       childFragmentManager.beginTransaction()
         .replace(
-          R.id.multiselect_container,
+          R.id.fragment_container,
           MultiselectForwardFragment.create(
             MultiselectForwardFragmentArgs(
               multiShareArgs = emptyList(),
+              title = R.string.GiftFlowRecipientSelectionFragment__choose_recipient,
               forceDisableAddMessage = true,
               selectSingleRecipient = true
             )
@@ -79,6 +74,10 @@ class GiftFlowRecipientSelectionFragment : Fragment(R.layout.gift_flow_recipient
 
   override fun exitFlow() = Unit
 
+  override fun navigateUp() {
+    requireActivity().onBackPressedDispatcher.onBackPressed()
+  }
+
   override fun onSearchInputFocused() = Unit
 
   override fun setResult(bundle: Bundle) {

app/src/main/java/org/thoughtcrime/securesms/billing/upgrade/UpgradeToPaidTierBottomSheet.kt

@@ -34,6 +34,7 @@ import org.thoughtcrime.securesms.backup.v2.ui.subscription.MessageBackupsType
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.InAppPaymentCheckoutDelegate
 import org.thoughtcrime.securesms.database.InAppPaymentTable
 import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.util.storage.AndroidCredentialRepository
 import org.thoughtcrime.securesms.util.viewModel
 
 /**
@@ -61,6 +62,7 @@ abstract class UpgradeToPaidTierBottomSheet : ComposeBottomSheetDialogFragment()
     MessageBackupsFlowViewModel(
       initialTierSelection = MessageBackupTier.PAID,
       googlePlayApiAvailability = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(requireContext()),
+      isCredentialManagerSupported = AndroidCredentialRepository.isCredentialManagerSupported(requireContext()),
       startScreen = MessageBackupsStage.TYPE_SELECTION
     )
   }

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

@@ -221,7 +221,7 @@ fun CallLinkDetailsScreen(
         )
       }
 
-      if (state.callLink.credentials?.adminPassBytes != null) {
+      if (state.callLink.canModify) {
         item {
           Rows.TextRow(
             text = stringResource(
@@ -273,13 +273,15 @@ fun CallLinkDetailsScreen(
         )
       }
 
-      item {
-        Rows.TextRow(
-          text = stringResource(id = R.string.CallLinkDetailsFragment__delete_call_link),
-          icon = SignalIcons.Trash.imageVector,
-          foregroundTint = MaterialTheme.colorScheme.error,
-          onClick = callback::onDeleteClicked
-        )
+      if (state.callLink.canModify) {
+        item {
+          Rows.TextRow(
+            text = stringResource(id = R.string.CallLinkDetailsFragment__delete_call_link),
+            icon = SignalIcons.Trash.imageVector,
+            foregroundTint = MaterialTheme.colorScheme.error,
+            onClick = callback::onDeleteClicked
+          )
+        }
       }
     }
 

app/src/main/java/org/thoughtcrime/securesms/chats/ChatsBackStack.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.chats
+
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.snapshots.SnapshotStateList
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.viewmodel.compose.SavedStateHandleSaveableApi
+import androidx.lifecycle.viewmodel.compose.saveable
+import org.thoughtcrime.securesms.main.MainNavigationDetailLocation
+import org.thoughtcrime.securesms.recipients.RecipientId
+
+/**
+ * Controls the navigation stack used by the chats screen.
+ */
+@OptIn(SavedStateHandleSaveableApi::class)
+class ChatsBackStack(savedStateHandle: SavedStateHandle) {
+
+  companion object {
+    private const val KEY = "chats_back_stack"
+
+    val saver: Saver<SnapshotStateList<MainNavigationDetailLocation>, ArrayList<MainNavigationDetailLocation>> = Saver(
+      save = { ArrayList(it) },
+      restore = { mutableStateListOf(*it.toTypedArray()) }
+    )
+  }
+
+  val entries: SnapshotStateList<MainNavigationDetailLocation> = savedStateHandle.saveable(
+    key = KEY,
+    saver = saver
+  ) {
+    mutableStateListOf(MainNavigationDetailLocation.Empty)
+  }
+
+  val activeRecipientId: RecipientId?
+    get() = entries.asReversed().firstNotNullOfOrNull {
+      when (it) {
+        is MainNavigationDetailLocation.Conversation -> it.conversationArgs.recipientId
+        is MainNavigationDetailLocation.Chats -> it.controllerKey
+        else -> null
+      }
+    }
+
+  val isEmpty: Boolean
+    get() = entries.singleOrNull() is MainNavigationDetailLocation.Empty
+
+  /**
+   * Pushes an entry onto the stack.
+   */
+  fun push(location: MainNavigationDetailLocation) {
+    when (location) {
+      is MainNavigationDetailLocation.Empty, entries.lastOrNull() -> Unit
+
+      is MainNavigationDetailLocation.Conversation -> {
+        entries.removeAll { it !is MainNavigationDetailLocation.Empty }
+        entries.add(location)
+      }
+
+      else -> entries.add(location)
+    }
+  }
+
+  /**
+   * Pops the top entry off the stack. Returns true if something was popped, false if the stack is already at its root.
+   */
+  fun pop(): Boolean {
+    if (entries.size <= 1) return false
+    entries.removeAt(entries.lastIndex)
+    return true
+  }
+
+  /**
+   * Resets the stack to its base empty state.
+   */
+  fun reset() {
+    entries.removeAll { it !is MainNavigationDetailLocation.Empty }
+    if (entries.isEmpty()) {
+      entries.add(MainNavigationDetailLocation.Empty)
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/chats/ChatsNavigation.kt

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.chats
+
+import android.os.Bundle
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.fragment.compose.AndroidFragment
+import androidx.fragment.compose.rememberFragmentState
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.navigation3.runtime.EntryProviderScope
+import androidx.navigation3.runtime.NavKey
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+import org.signal.core.ui.navigation.TransitionSpecs
+import org.thoughtcrime.securesms.MainNavigator
+import org.thoughtcrime.securesms.components.settings.conversation.ConversationSettingsNavHostFragment
+import org.thoughtcrime.securesms.compose.FragmentBackHandler
+import org.thoughtcrime.securesms.compose.FragmentBackPressedState
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.conversation.v2.ConversationFragment
+import org.thoughtcrime.securesms.main.EmptyDetailScreen
+import org.thoughtcrime.securesms.main.MainNavigationDetailLocation
+import org.thoughtcrime.securesms.messagedetails.MessageDetailsFragment
+
+fun EntryProviderScope<NavKey>.chatsNavEntries(
+  transitionState: ConversationTransitionState
+) {
+  entry<MainNavigationDetailLocation.Empty> {
+    NoConvoSelectedEntry()
+  }
+
+  entry<MainNavigationDetailLocation.Conversation>(
+    // disable slide animation - it's unnecessary in split pane mode and is handled by ConversationLoadingMask for single pane mode.
+    metadata = TransitionSpecs.None.metadata
+  ) { route ->
+    ConversationEntry(route, transitionState)
+  }
+
+  entry<MainNavigationDetailLocation.Chats.MessageDetails> { route ->
+    MessageDetailsEntry(route)
+  }
+
+  entry<MainNavigationDetailLocation.Chats.ConversationSettings> { route ->
+    ConversationSettingsEntry(route)
+  }
+}
+
+@Composable
+private fun NoConvoSelectedEntry() {
+  EmptyDetailScreen()
+}
+
+@Composable
+private fun ConversationEntry(
+  route: MainNavigationDetailLocation.Conversation,
+  transitionState: ConversationTransitionState
+) {
+  val context = LocalContext.current
+  val navigatorProvider = context as? MainNavigator.NavigatorProvider
+  val fragmentState = key(route) { rememberFragmentState() }
+  val arguments = requireNotNull(ConversationIntents.createBuilderSync(context, route.conversationArgs).build().extras) {
+    "Handed null Conversation intent arguments."
+  }
+
+  val fragmentContentReady = remember { MutableStateFlow(false) }
+  val backPressedState = remember { FragmentBackPressedState() }
+  FragmentBackHandler(backPressedState)
+
+  ConversationLoadingMask(
+    transitionState = transitionState,
+    contentReady = fragmentContentReady,
+    onFirstRender = { navigatorProvider?.onFirstRender() }
+  ) { modifier ->
+    AndroidFragment(
+      clazz = ConversationFragment::class.java,
+      fragmentState = fragmentState,
+      arguments = arguments,
+      modifier = modifier
+        .background(MaterialTheme.colorScheme.background)
+        .fillMaxSize()
+    ) { fragment ->
+      backPressedState.attach(fragment)
+
+      fragment.viewLifecycleOwner.lifecycleScope.launch {
+        fragment.repeatOnLifecycle(Lifecycle.State.STARTED) {
+          fragment.didFirstFrameRender.collectLatest { fragmentContentReady.value = it }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun MessageDetailsEntry(route: MainNavigationDetailLocation.Chats.MessageDetails) {
+  val navigatorProvider = LocalContext.current as? MainNavigator.NavigatorProvider
+  val fragmentState = key(route) { rememberFragmentState() }
+
+  LaunchedEffect(Unit) {
+    navigatorProvider?.onFirstRender()
+  }
+
+  AndroidFragment(
+    clazz = MessageDetailsFragment::class.java,
+    fragmentState = fragmentState,
+    arguments = MessageDetailsFragment.args(route.recipientId, route.messageId),
+    modifier = Modifier
+      .fillMaxSize()
+      .background(MaterialTheme.colorScheme.background)
+      .statusBarsPadding()
+      .navigationBarsPadding()
+  )
+}
+
+@Composable
+private fun ConversationSettingsEntry(route: MainNavigationDetailLocation.Chats.ConversationSettings) {
+  val navigatorProvider = LocalContext.current as? MainNavigator.NavigatorProvider
+  val fragmentState = key(route) { rememberFragmentState() }
+  val arguments: Bundle? by produceState(null, route.recipientId) {
+    value = ConversationSettingsNavHostFragment.createArgs(route.recipientId)
+  }
+
+  LaunchedEffect(Unit) {
+    navigatorProvider?.onFirstRender()
+  }
+
+  arguments?.let { args ->
+    val backPressedState = remember { FragmentBackPressedState() }
+    FragmentBackHandler(backPressedState)
+
+    AndroidFragment(
+      clazz = ConversationSettingsNavHostFragment::class.java,
+      fragmentState = fragmentState,
+      arguments = args,
+      modifier = Modifier
+        .fillMaxSize()
+        .background(MaterialTheme.colorScheme.background)
+        .statusBarsPadding()
+        .navigationBarsPadding()
+    ) { fragment ->
+      backPressedState.attach(fragment)
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/chats/ConversationLoadingMask.kt

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.chats
+
+import androidx.compose.animation.core.Transition
+import androidx.compose.animation.core.animateDp
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withTimeoutOrNull
+import org.thoughtcrime.securesms.window.AppScaffoldAnimationDefaults
+import org.thoughtcrime.securesms.window.AppScaffoldAnimationState
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Wraps [content] with an animation that crossfades a snapshotted chat list bitmap over the conversation fragment while it loads its first frame.
+ *
+ * @param contentReady emits when the fragment's first frame has been rendered.
+ * @param onFirstRender signals that this composable has content ready to display, so the parent activity can proceed with its first draw.
+ * @param content will be animated in as the overlay fades out.
+ */
+@Composable
+fun ConversationLoadingMask(
+  transitionState: ConversationTransitionState,
+  contentReady: StateFlow<Boolean>,
+  onFirstRender: () -> Unit,
+  content: @Composable (chatModifier: Modifier) -> Unit
+) {
+  // it can take a long time to load content, so we use a "fake" chat list image to delay displaying the fragment
+  // and prevent pop-in. When there's no bitmap (e.g. returning from a sub-route), skip the animation.
+  var shouldDisplayFragment by remember {
+    val hasBitmap = transitionState.chatBitmap != null
+    mutableStateOf(!hasBitmap)
+  }
+  val transition: Transition<Boolean> = updateTransition(shouldDisplayFragment)
+  val bitmap = transitionState.chatBitmap
+
+  val fakeChatListAnimationState = transition.fakeChatListAnimationState()
+  val chatAnimationState = transition.chatAnimationState(hasFake = bitmap != null)
+
+  LaunchedEffect(transition.currentState, transition.isRunning) {
+    if (transition.currentState && !transition.isRunning) {
+      transitionState.clearBitmap()
+    }
+  }
+
+  LaunchedEffect(shouldDisplayFragment) {
+    onFirstRender()
+  }
+
+  LaunchedEffect(contentReady) {
+    if (!shouldDisplayFragment) {
+      withTimeoutOrNull(5.seconds) {
+        contentReady.first { it }
+      }
+      shouldDisplayFragment = true
+    }
+  }
+
+  val chatModifier = Modifier.graphicsLayer {
+    with(chatAnimationState) { applyChildValues() }
+  }
+
+  Box(modifier = Modifier.fillMaxSize()) {
+    content(chatModifier)
+
+    if (bitmap != null) {
+      Image(
+        bitmap = bitmap,
+        contentDescription = null,
+        modifier = Modifier
+          .graphicsLayer {
+            with(fakeChatListAnimationState) { applyChildValues() }
+          }
+          .fillMaxSize()
+      )
+    }
+  }
+}
+
+@Composable
+private fun Transition<Boolean>.fakeChatListAnimationState(): AppScaffoldAnimationState {
+  val alpha = animateFloat(transitionSpec = { AppScaffoldAnimationDefaults.tween() }) { if (it) 0f else 1f }
+  val offset = animateDp(transitionSpec = { AppScaffoldAnimationDefaults.tween() }) { if (it) (-48).dp else 0.dp }
+  return remember {
+    AppScaffoldAnimationState(
+      offset = offset,
+      alpha = alpha
+    )
+  }
+}
+
+@Composable
+private fun Transition<Boolean>.chatAnimationState(hasFake: Boolean): AppScaffoldAnimationState {
+  val alpha = animateFloat(transitionSpec = { AppScaffoldAnimationDefaults.tween() }) { if (it) 1f else 0f }
+  return if (!hasFake) {
+    remember {
+      AppScaffoldAnimationState(
+        offset = mutableStateOf(0.dp),
+        alpha = alpha
+      )
+    }
+  } else {
+    val offset = animateDp(transitionSpec = { AppScaffoldAnimationDefaults.tween() }) { if (it) 0.dp else 48.dp }
+    remember {
+      AppScaffoldAnimationState(
+        offset = offset,
+        alpha = alpha
+      )
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/chats/ConversationTransitionState.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.chats
+
+import android.os.Build
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.layer.GraphicsLayer
+import androidx.compose.ui.graphics.layer.drawLayer
+import androidx.compose.ui.graphics.rememberGraphicsLayer
+
+/**
+ * Allows the setting of a "fake" bitmap driven by a graphics layer to coordinate delayed animations
+ * in lieu of proper support for postponing enter transitions.
+ */
+@Stable
+class ConversationTransitionState private constructor(
+  val isSplitPane: Boolean,
+  val graphicsLayer: GraphicsLayer
+) {
+  companion object {
+    @Composable
+    fun remember(isSplitPane: Boolean): ConversationTransitionState {
+      val graphicsLayer = rememberGraphicsLayer()
+
+      return remember(isSplitPane) {
+        ConversationTransitionState(isSplitPane, graphicsLayer)
+      }
+    }
+  }
+
+  var chatBitmap: ImageBitmap? by mutableStateOf(null)
+    private set
+
+  private var hasWrittenToGraphicsLayer: Boolean by mutableStateOf(false)
+
+  suspend fun writeGraphicsLayerToBitmap() {
+    // toImageBitmap() uses LayerSnapshot which has format compatibility issues on Android 7 and below
+    if (Build.VERSION.SDK_INT >= 26 && !isSplitPane && hasWrittenToGraphicsLayer) {
+      chatBitmap = graphicsLayer.toImageBitmap()
+    }
+  }
+
+  fun writeContentToGraphicsLayer(): Modifier {
+    if (isSplitPane) return Modifier
+
+    return Modifier.drawWithContent {
+      graphicsLayer.record {
+        this@drawWithContent.drawContent()
+        hasWrittenToGraphicsLayer = true
+      }
+
+      drawLayer(graphicsLayer)
+    }
+  }
+
+  fun clearBitmap() {
+    chatBitmap = null
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/color/ViewColorSet.kt

@@ -20,8 +20,8 @@ data class ViewColorSet(
 ) : Parcelable {
   companion object {
     val PRIMARY = ViewColorSet(
-      foreground = ViewColor.ColorResource(CoreUiR.color.signal_colorOnPrimary),
-      background = ViewColor.ColorResource(CoreUiR.color.signal_colorPrimary)
+      foreground = ViewColor.ColorResource(CoreUiR.color.signal_light_colorOnPrimary),
+      background = ViewColor.ColorResource(CoreUiR.color.signal_light_colorPrimary)
     )
 
     fun forCustomColor(@ColorInt customColor: Int): ViewColorSet {

app/src/main/java/org/thoughtcrime/securesms/components/AlbumThumbnailView.java

@@ -21,6 +21,7 @@ import com.bumptech.glide.RequestManager;
 import org.signal.core.ui.view.Stub;
 import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.components.transfercontrols.TransferControlView;
+import org.thoughtcrime.securesms.components.transfercontrols.TransferControls;
 import org.thoughtcrime.securesms.mms.Slide;
 import org.thoughtcrime.securesms.mms.SlideClickListener;
 import org.thoughtcrime.securesms.mms.SlidesClickedListener;
@@ -263,7 +264,7 @@ public class AlbumThumbnailView extends FrameLayout {
   }
 
   private void showSlides(@NonNull RequestManager requestManager, @NonNull List<Slide> slides) {
-    boolean showControls = TransferControlView.containsPlayableSlides(slides);
+    boolean showControls = TransferControls.containsPlayableSlides(slides);
     setSlide(requestManager, slides.get(0), R.id.album_cell_1, showControls);
     setSlide(requestManager, slides.get(1), R.id.album_cell_2, showControls);
 

app/src/main/java/org/thoughtcrime/securesms/components/AudioView.java

@@ -39,6 +39,7 @@ import org.thoughtcrime.securesms.audio.AudioWaveForms;
 import org.thoughtcrime.securesms.components.voice.VoiceNotePlaybackState;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.events.PartProgressEvent;
+import org.thoughtcrime.securesms.jobs.AttachmentBackfill;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.mms.AudioSlide;
 import org.thoughtcrime.securesms.mms.SlideClickListener;
@@ -82,9 +83,11 @@ public final class AudioView extends FrameLayout {
             private boolean            isPlaying;
             private long               durationMillis;
             private AudioSlide         audioSlide;
+            private boolean            showControls;
             private Callbacks          callbacks;
 
-            private Disposable disposable = Disposable.disposed();
+  private Disposable disposable         = Disposable.disposed();
+  private Disposable awaitingDisposable = Disposable.disposed();
 
   private final Observer<VoiceNotePlaybackState> playbackStateObserver = this::onPlaybackState;
 
@@ -159,6 +162,12 @@ public final class AudioView extends FrameLayout {
   protected void onAttachedToWindow() {
     super.onAttachedToWindow();
     if (!EventBus.getDefault().isRegistered(this)) EventBus.getDefault().register(this);
+
+    awaitingDisposable = AttachmentBackfill.awaitingChanges()
+                                           .observeOn(AndroidSchedulers.mainThread())
+                                           .subscribe(ignored -> {
+                                             if (audioSlide != null) presentTransferControls(audioSlide, showControls);
+                                           }, t -> Log.w(TAG, "Error observing backfill awaiting state.", t));
   }
 
   @Override
@@ -166,6 +175,7 @@ public final class AudioView extends FrameLayout {
     super.onDetachedFromWindow();
     EventBus.getDefault().unregister(this);
     disposable.dispose();
+    awaitingDisposable.dispose();
   }
 
   public void setProgressAndPlayBackgroundTint(@ColorInt int color) {
@@ -197,27 +207,8 @@ public final class AudioView extends FrameLayout {
       }
     }
 
-    if (showControls && audio.isPendingDownload()) {
-      controlToggle.displayQuick(downloadContainer);
-      seekBar.setEnabled(false);
-      downloadButton.setOnClickListener(new DownloadClickedListener(audio));
-      if (circleProgress != null) {
-        if (circleProgress.isSpinning()) circleProgress.stopSpinning();
-        circleProgress.setVisibility(View.GONE);
-      }
-    } else if (showControls && audio.getTransferState() == AttachmentTable.TRANSFER_PROGRESS_STARTED) {
-      controlToggle.displayQuick(progressAndPlay);
-      seekBar.setEnabled(false);
-      showPlayButton();
-      if (circleProgress != null) {
-        circleProgress.setVisibility(View.VISIBLE);
-        circleProgress.spin();
-      }
-    } else {
-      seekBar.setEnabled(true);
-      if (circleProgress != null && circleProgress.isSpinning()) circleProgress.stopSpinning();
-      showPlayButton();
-    }
+    this.showControls = showControls;
+    presentTransferControls(audio, showControls);
 
     if (seekBar instanceof WaveFormSeekBarView) {
       WaveFormSeekBarView waveFormView = (WaveFormSeekBarView) seekBar;
@@ -263,6 +254,38 @@ public final class AudioView extends FrameLayout {
     }
   }
 
+  private void presentTransferControls(@NonNull AudioSlide audio, boolean showControls) {
+    DatabaseAttachment dbAttachment = audio.asAttachment() instanceof DatabaseAttachment ? (DatabaseAttachment) audio.asAttachment() : null;
+
+    if (dbAttachment != null && dbAttachment.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE && AttachmentBackfill.isAwaitingBackfill(dbAttachment.attachmentId)) {
+      AttachmentBackfill.onAttachmentTerminal(dbAttachment.attachmentId, dbAttachment.mmsId);
+    }
+
+    boolean awaitingBackfill = dbAttachment != null && AttachmentBackfill.isAwaitingBackfill(dbAttachment.attachmentId);
+
+    if (showControls && audio.isPendingDownload() && !awaitingBackfill) {
+      controlToggle.displayQuick(downloadContainer);
+      seekBar.setEnabled(false);
+      downloadButton.setOnClickListener(new DownloadClickedListener(audio));
+      if (circleProgress != null) {
+        if (circleProgress.isSpinning()) circleProgress.stopSpinning();
+        circleProgress.setVisibility(View.GONE);
+      }
+    } else if (showControls && (audio.getTransferState() == AttachmentTable.TRANSFER_PROGRESS_STARTED || awaitingBackfill)) {
+      controlToggle.displayQuick(progressAndPlay);
+      seekBar.setEnabled(false);
+      showPlayButton();
+      if (circleProgress != null) {
+        circleProgress.setVisibility(View.VISIBLE);
+        if (!circleProgress.isSpinning()) circleProgress.spin();
+      }
+    } else {
+      seekBar.setEnabled(true);
+      if (circleProgress != null && circleProgress.isSpinning()) circleProgress.stopSpinning();
+      showPlayButton();
+    }
+  }
+
   public void setDownloadClickListener(@Nullable SlideClickListener listener) {
     this.downloadListener = listener;
   }

app/src/main/java/org/thoughtcrime/securesms/components/ComposeText.java

@@ -1,5 +1,6 @@
 package org.thoughtcrime.securesms.components;
 
+import android.content.ClipData;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Canvas;
@@ -19,6 +20,7 @@ import android.view.Menu;
 import android.view.MenuItem;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputConnectionWrapper;
 
 import androidx.annotation.IdRes;
 import androidx.annotation.NonNull;
@@ -26,6 +28,7 @@ import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.core.content.ContextCompat;
 
+import org.signal.core.util.ServiceUtil;
 import org.signal.core.util.StringUtil;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.R;
@@ -68,6 +71,7 @@ public class ComposeText extends EmojiEditText {
   @Nullable private CursorPositionChangedListener cursorPositionChangedListener;
   @Nullable private InlineQueryChangedListener    inlineQueryChangedListener;
   @Nullable private StylingChangedListener        stylingChangedListener;
+  @Nullable private OnPasteListener               onPasteListener;
 
   public ComposeText(Context context) {
     super(context);
@@ -213,6 +217,41 @@ public class ComposeText extends EmojiEditText {
     stylingChangedListener = listener;
   }
 
+  public void setOnPasteListener(@Nullable OnPasteListener listener) {
+    onPasteListener = listener;
+  }
+
+  /**
+   * Inserts the given text at the current selection (replacing any selected text), as if pasted.
+   * This goes directly through the underlying {@link Editable}, so it does not pass through the
+   * {@link OnPasteListener}. Used to complete a paste the listener previously intercepted, replaying
+   * the exact text that was intercepted rather than re-reading the clipboard — the intercepted text
+   * may have come from an IME suggestion (e.g. the keyboard's clipboard chip) that is not the
+   * current clipboard contents.
+   */
+  public void insertText(@NonNull CharSequence text) {
+    Editable editable = getText();
+    if (editable == null) {
+      return;
+    }
+
+    int selectionStart = getSelectionStart();
+    int selectionEnd   = getSelectionEnd();
+
+    int start;
+    int end;
+    if (selectionStart < 0 || selectionEnd < 0) {
+      start = editable.length();
+      end   = editable.length();
+    } else {
+      start = Math.min(selectionStart, selectionEnd);
+      end   = Math.max(selectionStart, selectionEnd);
+    }
+
+    editable.replace(start, end, text);
+    setSelection(start + text.length());
+  }
+
   private boolean isLandscape() {
     return getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
   }
@@ -242,7 +281,19 @@ public class ComposeText extends EmojiEditText {
       editorInfo.imeOptions &= ~EditorInfo.IME_FLAG_NO_ENTER_ACTION;
     }
 
-    return inputConnection;
+    if (inputConnection == null) {
+      return null;
+    }
+
+    return new InputConnectionWrapper(inputConnection, true) {
+      @Override
+      public boolean commitText(CharSequence text, int newCursorPosition) {
+        if (onPasteListener != null && text != null && onPasteListener.onPaste(text)) {
+          return true;
+        }
+        return super.commitText(text, newCursorPosition);
+      }
+    };
   }
 
   public boolean hasMentions() {
@@ -479,6 +530,20 @@ public class ComposeText extends EmojiEditText {
     return true;
   }
 
+  @Override
+  public boolean onTextContextMenuItem(int id) {
+    if ((id == android.R.id.paste || id == android.R.id.pasteAsPlainText) && onPasteListener != null) {
+      ClipData     clipData  = ServiceUtil.getClipboardManager(getContext()).getPrimaryClip();
+      CharSequence pasteText = clipData != null && clipData.getItemCount() > 0 ? clipData.getItemAt(0).coerceToText(getContext()) : null;
+
+      if (onPasteListener.onPaste(pasteText)) {
+        return true;
+      }
+    }
+
+    return super.onTextContextMenuItem(id);
+  }
+
   /**
    * Return true if we think the user may be inputting a time.
    */
@@ -576,4 +641,15 @@ public class ComposeText extends EmojiEditText {
   public interface StylingChangedListener {
     void onStylingChanged();
   }
+
+  public interface OnPasteListener {
+    /**
+     * Invoked before a paste is applied to the field, giving an observer the chance to intercept it.
+     *
+     * @param pasteText the text currently on the clipboard, or {@code null} if it could not be read
+     * @return true to consume the paste (the listener will handle it, e.g. by prompting the user),
+     *         or false to let the paste proceed normally
+     */
+    boolean onPaste(@Nullable CharSequence pasteText);
+  }
 }

app/src/main/java/org/thoughtcrime/securesms/components/DocumentView.java

@@ -28,6 +28,7 @@ import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.events.PartProgressEvent;
+import org.thoughtcrime.securesms.jobs.AttachmentBackfill;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.mms.Slide;
 import org.thoughtcrime.securesms.mms.SlideClickListener;
@@ -36,6 +37,9 @@ import org.whispersystems.signalservice.api.util.OptionalUtil;
 
 import java.util.Collections;
 
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
+import io.reactivex.rxjava3.disposables.Disposable;
+
 public class DocumentView extends FrameLayout {
 
   private static final String TAG = Log.tag(DocumentView.class);
@@ -55,6 +59,9 @@ public class DocumentView extends FrameLayout {
   private @Nullable SlidesClickedListener cancelTransferClickListener;
   private @Nullable SlidesClickedListener resendTransferClickListener;
   private @Nullable Slide                 documentSlide;
+  private           boolean               showControls;
+
+  private Disposable awaitingDisposable = Disposable.disposed();
 
   public DocumentView(@NonNull Context context) {
     this(context, null);
@@ -98,12 +105,19 @@ public class DocumentView extends FrameLayout {
     if (!EventBus.getDefault().isRegistered(this)) {
       EventBus.getDefault().register(this);
     }
+
+    awaitingDisposable = AttachmentBackfill.awaitingChanges()
+                                           .observeOn(AndroidSchedulers.mainThread())
+                                           .subscribe(ignored -> {
+                                             if (documentSlide != null) presentTransferControls(documentSlide, showControls);
+                                           }, t -> Log.w(TAG, "Error observing backfill awaiting state.", t));
   }
 
   @Override
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();
     EventBus.getDefault().unregister(this);
+    awaitingDisposable.dispose();
   }
 
   public void setDownloadClickListener(@Nullable SlideClickListener listener) {
@@ -126,22 +140,8 @@ public class DocumentView extends FrameLayout {
                           final boolean showControls,
                           final boolean showSingleLineFilename)
   {
-    if (showControls && documentSlide.getTransferState() == AttachmentTable.TRANSFER_PROGRESS_STARTED) {
-      controlToggle.displayQuick(stopUploadButton);
-      downloadProgress.spin();
-      stopUploadButton.setOnClickListener(new CancelTransferListener(documentSlide));
-    } else if (showControls && documentSlide.getUri() != null && documentSlide.isPendingDownload()) {
-      controlToggle.displayQuick(uploadButton);
-      uploadButton.setOnClickListener(new ResendTransferClickListener(documentSlide));
-      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
-    } else if (showControls && documentSlide.getUri() == null && documentSlide.isPendingDownload()) {
-      controlToggle.displayQuick(downloadButton);
-      downloadButton.setOnClickListener(new DownloadClickedListener(documentSlide));
-      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
-    } else {
-      controlToggle.displayQuick(iconContainer);
-      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
-    }
+    this.showControls = showControls;
+    presentTransferControls(documentSlide, showControls);
 
     this.documentSlide = documentSlide;
 
@@ -172,6 +172,33 @@ public class DocumentView extends FrameLayout {
     }
   }
 
+  private void presentTransferControls(@NonNull Slide documentSlide, boolean showControls) {
+    DatabaseAttachment dbAttachment = documentSlide.asAttachment() instanceof DatabaseAttachment ? (DatabaseAttachment) documentSlide.asAttachment() : null;
+
+    if (dbAttachment != null && dbAttachment.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE && AttachmentBackfill.isAwaitingBackfill(dbAttachment.attachmentId)) {
+      AttachmentBackfill.onAttachmentTerminal(dbAttachment.attachmentId, dbAttachment.mmsId);
+    }
+
+    boolean awaitingBackfill = dbAttachment != null && AttachmentBackfill.isAwaitingBackfill(dbAttachment.attachmentId);
+
+    if (showControls && (documentSlide.getTransferState() == AttachmentTable.TRANSFER_PROGRESS_STARTED || awaitingBackfill)) {
+      controlToggle.displayQuick(stopUploadButton);
+      if (!downloadProgress.isSpinning()) downloadProgress.spin();
+      stopUploadButton.setOnClickListener(awaitingBackfill ? null : new CancelTransferListener(documentSlide));
+    } else if (showControls && documentSlide.getUri() != null && documentSlide.isPendingDownload()) {
+      controlToggle.displayQuick(uploadButton);
+      uploadButton.setOnClickListener(new ResendTransferClickListener(documentSlide));
+      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
+    } else if (showControls && documentSlide.getUri() == null && documentSlide.isPendingDownload()) {
+      controlToggle.displayQuick(downloadButton);
+      downloadButton.setOnClickListener(new DownloadClickedListener(documentSlide));
+      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
+    } else {
+      controlToggle.displayQuick(iconContainer);
+      if (downloadProgress.isSpinning()) downloadProgress.stopSpinning();
+    }
+  }
+
   @Override
   public void setFocusable(boolean focusable) {
     super.setFocusable(focusable);

app/src/main/java/org/thoughtcrime/securesms/components/SharedContactView.java

@@ -5,7 +5,6 @@ import android.content.res.TypedArray;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.net.Uri;
-import android.os.Build;
 import android.util.AttributeSet;
 import android.view.View;
 import android.widget.ImageView;
@@ -69,7 +68,7 @@ public class SharedContactView extends LinearLayout implements RecipientForeverO
     initialize(attrs);
   }
 
-  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+  @RequiresApi(api = 21)
   public SharedContactView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
     super(context, attrs, defStyleAttr, defStyleRes);
     initialize(attrs);

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

@@ -37,7 +37,7 @@ class SignalProgressDialog private constructor(
 
   var progress: Int
     get() = progressBar.progress
-    set(value) = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+    set(value) = if (Build.VERSION.SDK_INT >= 24) {
       progressBar.setProgress(value, true)
     } else {
       progressBar.setProgress(value)

app/src/main/java/org/thoughtcrime/securesms/components/ThumbnailView.java

@@ -48,6 +48,7 @@ import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.attachments.Attachment;
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment;
 import org.thoughtcrime.securesms.components.transfercontrols.TransferControlView;
+import org.thoughtcrime.securesms.components.transfercontrols.TransferControls;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.glide.targets.GlideBitmapListeningTarget;
 import org.thoughtcrime.securesms.glide.targets.GlideDrawableListeningTarget;
@@ -384,7 +385,7 @@ public class ThumbnailView extends FrameLayout {
       }
       transferControlViewStub.get().setSlides(List.of(slide));
     }
-    int transferState = TransferControlView.getTransferState(List.of(slide));
+    int     transferState    = TransferControls.getTransferState(List.of(slide));
     boolean isOffloadedImage = (transferState == AttachmentTable.TRANSFER_RESTORE_OFFLOADED && MediaUtil.isImageType(slide.getContentType())) && AttachmentUtil.isRestoreOnOpenPermitted(getContext(), slide.asAttachment());
 
     if (!showControls ||

app/src/main/java/org/thoughtcrime/securesms/components/ZoomingImageView.java

@@ -27,7 +27,7 @@ import org.thoughtcrime.securesms.components.subsampling.AttachmentRegionDecoder
 import org.signal.glide.decryptableuri.DecryptableUri;
 import org.thoughtcrime.securesms.mms.PartAuthority;
 import org.thoughtcrime.securesms.util.ActionRequestListener;
-import org.thoughtcrime.securesms.util.BitmapUtil;
+import org.signal.core.util.bitmaps.BitmapUtil;
 import org.thoughtcrime.securesms.util.MediaUtil;
 
 import java.io.IOException;

app/src/main/java/org/thoughtcrime/securesms/components/emoji/SystemEmojiDrawable.kt

@@ -48,7 +48,7 @@ class SystemEmojiDrawable(emoji: CharSequence) : Drawable() {
   companion object {
     private val textPaint: TextPaint = TextPaint()
 
-    private fun getStaticLayout(emoji: CharSequence): StaticLayout = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+    private fun getStaticLayout(emoji: CharSequence): StaticLayout = if (Build.VERSION.SDK_INT >= 23) {
       StaticLayout.Builder.obtain(emoji, 0, emoji.length, textPaint, Int.MAX_VALUE).build()
     } else {
       @Suppress("DEPRECATION")

app/src/main/java/org/thoughtcrime/securesms/components/registration/VerificationPinKeyboard.java

@@ -3,7 +3,6 @@ package org.thoughtcrime.securesms.components.registration;
 
 import android.content.Context;
 import android.graphics.PorterDuff;
-import android.os.Build;
 import android.util.AttributeSet;
 import android.view.View;
 import android.view.animation.Animation;
@@ -49,7 +48,7 @@ public class VerificationPinKeyboard extends FrameLayout {
     initialize();
   }
 
-  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+  @RequiresApi(api = 21)
   public VerificationPinKeyboard(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
     super(context, attrs, defStyleAttr, defStyleRes);
     initialize();

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

@@ -25,12 +25,12 @@ open class DSLSettingsActivity : PassphraseRequiredActivity() {
     setContentView(R.layout.dsl_settings_activity)
 
     if (savedInstanceState == null) {
-      val navGraphId = intent.getIntExtra(ARG_NAV_GRAPH, -1)
+      val navGraphId = resolveNavGraphId()
       if (navGraphId == -1) {
         throw IllegalStateException("No navgraph id was passed to activity")
       }
 
-      val fragment: NavHostFragment = NavHostFragment.create(navGraphId, intent.getBundleExtra(ARG_START_BUNDLE))
+      val fragment: NavHostFragment = NavHostFragment.create(navGraphId, resolveStartBundle())
 
       supportFragmentManager.beginTransaction()
         .replace(R.id.nav_host_fragment, fragment)
@@ -64,6 +64,10 @@ open class DSLSettingsActivity : PassphraseRequiredActivity() {
 
   protected open fun onWillFinish() {}
 
+  protected open fun resolveNavGraphId(): Int = intent.getIntExtra(ARG_NAV_GRAPH, -1)
+
+  protected open fun resolveStartBundle(): Bundle? = intent.getBundleExtra(ARG_START_BUNDLE)
+
   companion object {
     const val ARG_NAV_GRAPH = "nav_graph"
     const val ARG_START_BUNDLE = "start_bundle"