Bump version to 8.13.2

2026-06-16 12:16:03 +01:00 · 2026-06-03 15:35:01 -03:00
693 changed files with 9914 additions and 37151 deletions
@@ -5,7 +5,7 @@ on:
  push:
    branches:
    - 'main'
-    - '8.**'
+    - '7.**'

 permissions:
  contents: read # to fetch code (actions/checkout)
@@ -16,7 +16,7 @@ jobs:
    runs-on: ubuntu-latest-8-cores

    steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
      # gh api repos/actions/checkout/commits/v6 --jq '.sha'
      with:
          submodules: true
@@ -27,29 +27,14 @@ jobs:
      with:
        distribution: temurin
        java-version: 17
+        cache: gradle

    - name: Validate Gradle Wrapper
      uses: gradle/actions/wrapper-validation@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
      # gh api repos/gradle/actions/commits/v6 --jq '.sha'

-    - name: Set up Gradle
-      uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # 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.
-        cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/8.') }}
-        # 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 ${{ github.event_name == 'pull_request' && 'ci' || 'qa' }}
+      run: ./gradlew qa

    - name: Archive reports for failed build
      if: ${{ failure() }}
@@ -16,7 +16,7 @@ jobs:
    runs-on: ubuntu-latest-8-cores

    steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
      # gh api repos/actions/checkout/commits/v6 --jq '.sha'
      with:
        submodules: true
@@ -28,15 +28,7 @@ jobs:
      with:
        distribution: temurin
        java-version: 17
-
-    - name: Set up Gradle
-      uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6
-      # gh api repos/gradle/actions/commits/v6 --jq '.sha'
-      with:
-        # PR-only workflow: always read from the cache, never write.
-        cache-read-only: true
-        # Required to read the Gradle configuration cache persisted by 8.** builds.
-        cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
+        cache: gradle

    - name: Install NDK
      run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;${{ env.NDK_VERSION }}"
@@ -61,7 +53,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@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
      # gh api repos/actions/checkout/commits/v6 --jq '.sha'
      with:
        submodules: true
@@ -11,7 +11,7 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
        # gh api repos/actions/checkout/commits/v6 --jq '.sha'
      - name: Build image
        run: |
@@ -14,7 +14,7 @@ jobs:
      actions: write

    steps:
-      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10
+      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10
        # gh api repos/actions/stale/commits/v10 --jq '.sha'
        with:
          days-before-stale: 60
@@ -27,9 +27,9 @@ plugins {
 val staticIps = Properties().apply { file("static-ips.properties").reader().use { load(it) } }
 staticIps.stringPropertyNames().forEach { rootProject.extra[it] = staticIps.getProperty(it) }

-val canonicalVersionCode = 1706
-val canonicalVersionName = "8.15.2"
-val currentHotfixVersion = 0
+val canonicalVersionCode = 1699
+val canonicalVersionName = "8.13.2"
+val currentHotfixVersion = 1
 val maxHotfixVersions = 100

 // We don't want versions to ever end in 0 so that they don't conflict with nightly versions
@@ -138,7 +138,7 @@ class ConversationItemPreviewer {
  private fun attachment(): SignalServiceAttachmentPointer {
    return SignalServiceAttachmentPointer(
      Cdn.CDN_3.cdnNumber,
-      SignalServiceAttachmentRemoteId.from("", Cdn.CDN_3.cdnNumber),
+      SignalServiceAttachmentRemoteId.from(""),
      "image/webp",
      null,
      Optional.empty(),
@@ -1,393 +0,0 @@
-/*
- * 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)
-    }
-  }
-}
@@ -1,29 +1,23 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
+import androidx.media3.common.util.Util
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.util.count
 import org.signal.core.util.readToSingleInt
 import org.thoughtcrime.securesms.backup.v2.ArchivedMediaObject
 import org.thoughtcrime.securesms.database.BackupMediaSnapshotTable.MediaEntry
-import org.thoughtcrime.securesms.testutil.MockAppDependenciesRule
-import org.thoughtcrime.securesms.testutil.SignalDatabaseRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
+@RunWith(AndroidJUnit4::class)
 class BackupMediaSnapshotTableTest {

  @get:Rule
-  val appDependencies = MockAppDependenciesRule()
-
-  @get:Rule
-  val signalDatabaseRule = SignalDatabaseRule()
+  val harness = SignalActivityRule()

  @Test
  fun givenAnEmptyTable_whenIWriteToTable_thenIExpectEmptyTable() {
@@ -308,21 +302,12 @@ class BackupMediaSnapshotTableTest {
    return MediaEntry(
      mediaId = mediaId(seed, thumbnail),
      cdn = cdn,
-      plaintextHash = intToByteArray(seed),
-      remoteKey = intToByteArray(seed),
+      plaintextHash = Util.toByteArray(seed),
+      remoteKey = Util.toByteArray(seed),
      isThumbnail = thumbnail
    )
  }

-  private fun intToByteArray(value: Int): ByteArray {
-    return byteArrayOf(
-      (value shr 24).toByte(),
-      (value shr 16).toByte(),
-      (value shr 8).toByte(),
-      value.toByte()
-    )
-  }
-
  private fun createArchiveMediaObject(seed: Int, thumbnail: Boolean = false, cdn: Int = 0): ArchivedMediaObject {
    return ArchivedMediaObject(
      mediaId = mediaId(seed, thumbnail),
@@ -431,7 +431,7 @@ class CallTableTest {

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

@@ -1,28 +1,17 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
 import org.junit.Assert
 import org.junit.Before
-import org.junit.Rule
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.models.ServiceId.ACI
 import org.thoughtcrime.securesms.database.model.DistributionListId
 import org.thoughtcrime.securesms.database.model.DistributionListRecord
 import org.thoughtcrime.securesms.database.model.StoryType
 import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.testutil.RecipientTestRule
 import java.util.UUID

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
 class DistributionListTablesTest {

-  @get:Rule
-  val recipients = RecipientTestRule()
-
  private lateinit var distributionDatabase: DistributionListTables

  @Before
@@ -38,7 +27,8 @@ class DistributionListTablesTest {

  @Test
  fun getList_returnCorrectList() {
-    val members: List<RecipientId> = createRecipients(3)
+    createRecipients(3)
+    val members: List<RecipientId> = recipientList(1, 2, 3)

    val id: DistributionListId? = distributionDatabase.createList("test", members)
    Assert.assertNotNull(id)
@@ -52,7 +42,8 @@ class DistributionListTablesTest {

  @Test
  fun getMembers_returnsCorrectMembers() {
-    val members: List<RecipientId> = createRecipients(3)
+    createRecipients(3)
+    val members: List<RecipientId> = recipientList(1, 2, 3)

    val id: DistributionListId? = distributionDatabase.createList("test", members)
    Assert.assertNotNull(id)
@@ -86,8 +77,8 @@ class DistributionListTablesTest {
    Assert.fail("Expected an assertion error.")
  }

-  private fun createRecipients(count: Int): List<RecipientId> {
-    return (0 until count).map {
+  private fun createRecipients(count: Int) {
+    for (i in 0 until count) {
      SignalDatabase.recipients.getOrInsertFromServiceId(ACI.from(UUID.randomUUID()))
    }
  }
@@ -1,6 +1,5 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
 import android.database.sqlite.SQLiteConstraintException
 import assertk.assertThat
 import assertk.assertions.isEqualTo
@@ -9,34 +8,20 @@ import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.util.count
 import org.signal.core.util.deleteAll
 import org.signal.core.util.readToSingleInt
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
 import org.thoughtcrime.securesms.database.model.databaseprotos.InAppPaymentData
-import org.thoughtcrime.securesms.testutil.MockAppDependenciesRule
-import org.thoughtcrime.securesms.testutil.MockSignalStoreRule
-import org.thoughtcrime.securesms.testutil.SignalDatabaseRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.whispersystems.signalservice.api.storage.IAPSubscriptionId
 import org.whispersystems.signalservice.api.subscriptions.SubscriberId
 import java.util.Currency

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
 class InAppPaymentSubscriberTableTest {
-
  @get:Rule
-  val signalStore = MockSignalStoreRule()
-
-  @get:Rule
-  val appDependencies = MockAppDependenciesRule()
-
-  @get:Rule
-  val signalDatabaseRule = SignalDatabaseRule()
+  val harness = SignalActivityRule()

  @Before
  fun setUp() {
@@ -0,0 +1,50 @@
+/*
+ * 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)
+  }
+}
@@ -5,43 +5,20 @@

 package org.thoughtcrime.securesms.database

-import android.app.Application
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
-import org.junit.Rule
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
-import org.signal.core.models.ServiceId
 import org.signal.core.models.ServiceId.ACI
 import org.signal.core.models.ServiceId.PNI
-import org.signal.core.util.readToSingleObject
-import org.signal.core.util.requireLongOrNull
-import org.signal.core.util.select
-import org.signal.core.util.update
 import org.signal.libsignal.protocol.ReusedBaseKeyException
-import org.signal.libsignal.protocol.ecc.ECKeyPair
-import org.signal.libsignal.protocol.ecc.ECPublicKey
-import org.signal.libsignal.protocol.kem.KEMKeyPair
-import org.signal.libsignal.protocol.kem.KEMKeyType
-import org.signal.libsignal.protocol.state.KyberPreKeyRecord
-import org.thoughtcrime.securesms.testutil.MockAppDependenciesRule
-import org.thoughtcrime.securesms.testutil.SignalDatabaseRule
-import java.security.SecureRandom
+import org.thoughtcrime.securesms.util.KyberPreKeysTestUtil.generateECPublicKey
+import org.thoughtcrime.securesms.util.KyberPreKeysTestUtil.getStaleTime
+import org.thoughtcrime.securesms.util.KyberPreKeysTestUtil.insertTestRecord
 import java.util.UUID

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
 class KyberPreKeyTableTest {

-  @get:Rule
-  val appDependencies = MockAppDependenciesRule()
-
-  @get:Rule
-  val signalDatabaseRule = SignalDatabaseRule()
-
  private val aci: ACI = ACI.from(UUID.randomUUID())
  private val pni: PNI = PNI.from(UUID.randomUUID())

@@ -153,7 +130,7 @@ class KyberPreKeyTableTest {
    insertTestRecord(aci, id = 2, staleTime = 10, lastResort = true)
    insertTestRecord(aci, id = 3, staleTime = 10, lastResort = true)

-    SignalDatabase.kyberPreKeys.deleteAllStaleBefore(aci, threshold = 11, minCount = 0)
+    SignalDatabase.oneTimePreKeys.deleteAllStaleBefore(aci, threshold = 11, minCount = 0)

    assertNotNull(getStaleTime(aci, 1))
    assertNotNull(getStaleTime(aci, 2))
@@ -199,50 +176,4 @@ class KyberPreKeyTableTest {
      baseKey = publicKey
    )
  }
-
-  private fun insertTestRecord(account: ServiceId, id: Int, staleTime: Long = 0, lastResort: Boolean = false) {
-    val kemKeyPair = KEMKeyPair.generate(KEMKeyType.KYBER_1024)
-    SignalDatabase.kyberPreKeys.insert(
-      serviceId = account,
-      keyId = id,
-      record = KyberPreKeyRecord(
-        id,
-        System.currentTimeMillis(),
-        kemKeyPair,
-        ECKeyPair.generate().privateKey.calculateSignature(kemKeyPair.publicKey.serialize())
-      ),
-      lastResort = lastResort
-    )
-
-    val count = SignalDatabase.writableDatabase
-      .update(KyberPreKeyTable.TABLE_NAME)
-      .values(KyberPreKeyTable.STALE_TIMESTAMP to staleTime)
-      .where("${KyberPreKeyTable.ACCOUNT_ID} = ? AND ${KyberPreKeyTable.KEY_ID} = $id", account.toAccountId())
-      .run()
-
-    assertEquals(1, count)
-  }
-
-  private fun getStaleTime(account: ServiceId, id: Int): Long? {
-    return SignalDatabase.writableDatabase
-      .select(KyberPreKeyTable.STALE_TIMESTAMP)
-      .from(KyberPreKeyTable.TABLE_NAME)
-      .where("${KyberPreKeyTable.ACCOUNT_ID} = ? AND ${KyberPreKeyTable.KEY_ID} = $id", account.toAccountId())
-      .run()
-      .readToSingleObject { it.requireLongOrNull(KyberPreKeyTable.STALE_TIMESTAMP) }
-  }
-
-  private fun generateECPublicKey(): ECPublicKey {
-    val byteArray = ByteArray(ECPublicKey.KEY_SIZE - 1)
-    SecureRandom().nextBytes(byteArray)
-
-    return ECPublicKey.fromPublicKeyBytes(byteArray)
-  }
-
-  private fun ServiceId.toAccountId(): String {
-    return when (this) {
-      is ACI -> this.toString()
-      is PNI -> KyberPreKeyTable.PNI_ACCOUNT_ID
-    }
-  }
 }
@@ -1,37 +1,38 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Before
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.models.ServiceId.ACI
+import org.signal.core.models.ServiceId.PNI
 import org.thoughtcrime.securesms.database.model.databaseprotos.GiftBadge
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.testutil.RecipientTestRule
 import java.util.UUID

@Suppress("ClassName")
-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
+@RunWith(AndroidJUnit4::class)
 class MessageTableTest_gifts {
-
-  @get:Rule
-  val recipientTestRule = RecipientTestRule()
-
  private lateinit var mms: MessageTable

+  private val localAci = ACI.from(UUID.randomUUID())
+  private val localPni = PNI.from(UUID.randomUUID())
+
  private lateinit var recipients: List<RecipientId>

  @Before
  fun setUp() {
    mms = SignalDatabase.messages

+    mms.deleteAllThreads()
+
+    SignalStore.account.setAci(localAci)
+    SignalStore.account.setPni(localPni)
+
    recipients = (0 until 5).map { SignalDatabase.recipients.getOrInsertFromServiceId(ACI.from(UUID.randomUUID())) }
  }

@@ -0,0 +1,174 @@
+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
+}
@@ -5,15 +5,10 @@

 package org.thoughtcrime.securesms.database

-import android.app.Application
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
-import org.junit.Rule
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.models.ServiceId
 import org.signal.core.models.ServiceId.ACI
 import org.signal.core.models.ServiceId.PNI
@@ -23,20 +18,10 @@ import org.signal.core.util.select
 import org.signal.core.util.update
 import org.signal.libsignal.protocol.ecc.ECKeyPair
 import org.signal.libsignal.protocol.state.PreKeyRecord
-import org.thoughtcrime.securesms.testutil.MockAppDependenciesRule
-import org.thoughtcrime.securesms.testutil.SignalDatabaseRule
 import java.util.UUID

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
 class OneTimePreKeyTableTest {

-  @get:Rule
-  val appDependencies = MockAppDependenciesRule()
-
-  @get:Rule
-  val signalDatabaseRule = SignalDatabaseRule()
-
  private val aci: ACI = ACI.from(UUID.randomUUID())
  private val pni: PNI = PNI.from(UUID.randomUUID())

@@ -132,7 +117,7 @@ class OneTimePreKeyTableTest {
      record = PreKeyRecord(id, ECKeyPair.generate())
    )

-    val count = SignalDatabase.writableDatabase
+    val count = SignalDatabase.rawDatabase
      .update(OneTimePreKeyTable.TABLE_NAME)
      .values(OneTimePreKeyTable.STALE_TIMESTAMP to staleTime)
      .where("${OneTimePreKeyTable.ACCOUNT_ID} = ? AND ${OneTimePreKeyTable.KEY_ID} = $id", account.toAccountId())
@@ -142,7 +127,7 @@ class OneTimePreKeyTableTest {
  }

  private fun getStaleTime(account: ServiceId, id: Int): Long? {
-    return SignalDatabase.writableDatabase
+    return SignalDatabase.rawDatabase
      .select(OneTimePreKeyTable.STALE_TIMESTAMP)
      .from(OneTimePreKeyTable.TABLE_NAME)
      .where("${OneTimePreKeyTable.ACCOUNT_ID} = ? AND ${OneTimePreKeyTable.KEY_ID} = $id", account.toAccountId())
@@ -1,14 +1,12 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.util.deleteAll
 import org.thoughtcrime.securesms.database.model.MessageId
 import org.thoughtcrime.securesms.mms.IncomingMessage
@@ -16,18 +14,15 @@ import org.thoughtcrime.securesms.polls.PollOption
 import org.thoughtcrime.securesms.polls.PollRecord
 import org.thoughtcrime.securesms.polls.Voter
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.testutil.RecipientTestRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
+@RunWith(AndroidJUnit4::class)
 class PollTablesTest {

  @get:Rule
-  val recipients = RecipientTestRule()
+  val harness = SignalActivityRule()

  private lateinit var poll1: PollRecord
-  private lateinit var other0: RecipientId

  @Before
  fun setUp() {
@@ -49,9 +44,8 @@ class PollTablesTest {
    SignalDatabase.polls.writableDatabase.deleteAll(PollTables.PollOptionTable.TABLE_NAME)
    SignalDatabase.polls.writableDatabase.deleteAll(PollTables.PollVoteTable.TABLE_NAME)

-    other0 = recipients.createRecipient("Buddy #0")
-    val message = IncomingMessage(type = MessageType.NORMAL, from = other0, sentTimeMillis = 100, serverTimeMillis = 100, receivedTimeMillis = 100)
-    SignalDatabase.messages.insertMessageInbox(message, SignalDatabase.threads.getOrCreateThreadIdFor(other0, isGroup = false))
+    val message = IncomingMessage(type = MessageType.NORMAL, from = harness.others[0], sentTimeMillis = 100, serverTimeMillis = 100, receivedTimeMillis = 100)
+    SignalDatabase.messages.insertMessageInbox(message, SignalDatabase.threads.getOrCreateThreadIdFor(harness.others[0], isGroup = false))
  }

  @Test
@@ -8,17 +8,10 @@ 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
@@ -26,11 +19,8 @@ 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)
@@ -70,46 +60,4 @@ 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)
-  }
 }
@@ -1,17 +1,13 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNull
 import assertk.assertions.isPresent
-import io.mockk.every
 import org.junit.Before
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.models.ServiceId.ACI
 import org.signal.core.models.ServiceId.PNI
 import org.signal.core.util.Hex
@@ -30,18 +26,12 @@ import org.thoughtcrime.securesms.isAbsent
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.mms.IncomingMessage
 import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.testutil.RecipientTestRule
-import org.whispersystems.signalservice.api.push.ServiceIds
 import java.util.UUID

@Suppress("ClassName", "TestFunctionName")
-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
+@RunWith(AndroidJUnit4::class)
 class SmsDatabaseTest_collapseJoinRequestEventsIfPossible {

-  @get:Rule
-  val recipientRule = RecipientTestRule()
-
  private lateinit var recipients: RecipientTable
  private lateinit var sms: MessageTable

@@ -58,7 +48,8 @@ class SmsDatabaseTest_collapseJoinRequestEventsIfPossible {
    recipients = SignalDatabase.recipients
    sms = SignalDatabase.messages

-    every { recipientRule.signalStore.account.getServiceIds() } returns ServiceIds(localAci, localPni)
+    SignalStore.account.setAci(localAci)
+    SignalStore.account.setPni(localPni)

    alice = recipients.getOrInsertFromServiceId(aliceServiceId)
    bob = recipients.getOrInsertFromServiceId(bobServiceId)
@@ -1,6 +1,6 @@
 package org.thoughtcrime.securesms.database

-import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import assertk.assertThat
 import assertk.assertions.containsExactlyInAnyOrder
 import assertk.assertions.hasSize
@@ -16,23 +16,20 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
 import org.signal.core.models.ServiceId.ACI
 import org.thoughtcrime.securesms.database.model.DistributionListId
 import org.thoughtcrime.securesms.database.model.StoryType
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.testutil.RecipientTestRule
+import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.whispersystems.signalservice.api.push.DistributionId
 import java.util.UUID

-@RunWith(RobolectricTestRunner::class)
-@Config(manifest = Config.NONE, application = Application::class)
+@RunWith(AndroidJUnit4::class)
 class StorySendTableTest {

  @get:Rule
-  val recipients = RecipientTestRule()
+  val harness = SignalActivityRule(othersCount = 0, createGroup = false)

  private val distributionId1 = DistributionId.from(UUID.randomUUID())
  private val distributionId2 = DistributionId.from(UUID.randomUUID())
@@ -0,0 +1,120 @@
+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
+    )
+  }
+}
@@ -139,7 +139,7 @@ class SignalActivityRule(private val othersCount: Int = 4, private val createGro
      val recipientId = RecipientId.from(SignalServiceAddress(aci, "+15555551%03d".format(i)))
      SignalDatabase.recipients.setProfileName(recipientId, ProfileName.fromParts("Buddy", "#$i"))
      SignalDatabase.recipients.setProfileKeyIfAbsent(recipientId, ProfileKeyUtil.createNew())
-      SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true, true))
+      SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true))
      SignalDatabase.recipients.setProfileSharing(recipientId, true)
      SignalDatabase.recipients.markRegistered(recipientId, aci)
      val otherIdentity = IdentityKeyPair.generate()
@@ -146,7 +146,7 @@ object TestMessages {
  private fun imageAttachment(): SignalServiceAttachmentPointer {
    return SignalServiceAttachmentPointer(
      Cdn.S3.cdnNumber,
-      SignalServiceAttachmentRemoteId.from("", Cdn.S3.cdnNumber),
+      SignalServiceAttachmentRemoteId.from(""),
      "image/webp",
      null,
      Optional.empty(),
@@ -170,7 +170,7 @@ object TestMessages {
  private fun voiceAttachment(): SignalServiceAttachmentPointer {
    return SignalServiceAttachmentPointer(
      Cdn.S3.cdnNumber,
-      SignalServiceAttachmentRemoteId.from("", Cdn.S3.cdnNumber),
+      SignalServiceAttachmentRemoteId.from(""),
      "audio/aac",
      null,
      Optional.empty(),
@@ -133,7 +133,7 @@ object TestUsers {
        val recipientId = RecipientId.from(SignalServiceAddress(aci, "+15555551%03d".format(i)))
        SignalDatabase.recipients.setProfileName(recipientId, ProfileName.fromParts("Buddy", "#$i"))
        SignalDatabase.recipients.setProfileKeyIfAbsent(recipientId, ProfileKeyUtil.createNew())
-        SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true, true))
+        SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true))
        SignalDatabase.recipients.setProfileSharing(recipientId, true)
        SignalDatabase.recipients.markRegistered(recipientId, aci)
        val otherIdentity = IdentityKeyPair.generate()
@@ -157,7 +157,7 @@ object TestUsers {
        val recipientId = RecipientId.from(SignalServiceAddress(otherClient.serviceId, otherClient.e164))
        SignalDatabase.recipients.setProfileName(recipientId, ProfileName.fromParts("Buddy", "#$i"))
        SignalDatabase.recipients.setProfileKeyIfAbsent(recipientId, otherClient.profileKey)
-        SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true, true))
+        SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true))
        SignalDatabase.recipients.setProfileSharing(recipientId, true)
        SignalDatabase.recipients.markRegistered(recipientId, otherClient.serviceId)
        AppDependencies.protocolStore.aci().saveIdentity(SignalProtocolAddress(otherClient.serviceId.toString(), 1), otherClient.identityKeyPair.publicKey)
@@ -1371,7 +1371,7 @@

        <service
            android:name=".gcm.FcmReceiveService"
-            android:exported="false">
+            android:exported="true">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
@@ -24,11 +24,6 @@ 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
  }
@@ -39,23 +34,9 @@ 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.
@@ -83,26 +64,10 @@ class ConversationLayoutManager(context: Context) : LinearLayoutManager(context,
      } else {
        scrollToPosition(pendingScrollPosition)
      }
-      return
+    } else {
+      afterScroll?.invoke()
+      afterScroll = null
    }
-
-    // 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 {
@@ -13,8 +13,7 @@ object AppCapabilities {
      storage = storageCapable,
      versionedExpirationTimer = true,
      attachmentBackfill = true,
-      spqr = true,
-      usernameChangeSyncMessage = false // TODO(michelle): Turn on once all clients support it and add a migration
+      spqr = true
    )
  }
 }
@@ -33,10 +33,8 @@ import net.zetetic.database.Logger;
 import org.conscrypt.ConscryptSignal;
 import org.greenrobot.eventbus.EventBus;
 import org.signal.aesgcmprovider.AesGcmProvider;
-import org.signal.core.util.AppForegroundObserver;
 import org.signal.core.util.DiskUtil;
 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.logging.AndroidLogger;
@@ -53,7 +51,6 @@ import org.thoughtcrime.securesms.backup.v2.BackupRepository;
 import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider;
 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;
@@ -62,7 +59,6 @@ import org.thoughtcrime.securesms.emoji.EmojiSource;
 import org.thoughtcrime.securesms.emoji.JumboEmoji;
 import org.thoughtcrime.securesms.gcm.FcmFetchManager;
 import org.thoughtcrime.securesms.glide.SignalGlideComponents;
-import org.thoughtcrime.securesms.jobmanager.impl.SealedSenderConstraint;
 import org.thoughtcrime.securesms.jobs.AccountConsistencyWorkerJob;
 import org.thoughtcrime.securesms.jobs.BackupRefreshJob;
 import org.thoughtcrime.securesms.jobs.BackupSubscriptionCheckJob;
@@ -79,7 +75,6 @@ import org.thoughtcrime.securesms.jobs.GroupV2UpdateSelfProfileKeyJob;
 import org.thoughtcrime.securesms.jobs.InAppPaymentAuthCheckJob;
 import org.thoughtcrime.securesms.jobs.InAppPaymentKeepAliveJob;
 import org.thoughtcrime.securesms.jobs.LinkedDeviceInactiveCheckJob;
-import org.thoughtcrime.securesms.jobs.MessageSendLogCleanupJob;
 import org.thoughtcrime.securesms.jobs.MultiDeviceContactUpdateJob;
 import org.thoughtcrime.securesms.jobs.PreKeysSyncJob;
 import org.thoughtcrime.securesms.jobs.ProfileUploadJob;
@@ -88,6 +83,7 @@ import org.thoughtcrime.securesms.jobs.RefreshSvrCredentialsJob;
 import org.thoughtcrime.securesms.jobs.RestoreOptimizedMediaJob;
 import org.thoughtcrime.securesms.jobs.RetrieveProfileJob;
 import org.thoughtcrime.securesms.jobs.RetrieveRemoteAnnouncementsJob;
+import org.thoughtcrime.securesms.jobmanager.impl.SealedSenderConstraint;
 import org.thoughtcrime.securesms.jobs.StoryOnboardingDownloadJob;
 import org.thoughtcrime.securesms.keyvalue.KeepMessagesDuration;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
@@ -111,8 +107,10 @@ import org.thoughtcrime.securesms.service.MessageBackupListener;
 import org.thoughtcrime.securesms.service.RotateSenderCertificateListener;
 import org.thoughtcrime.securesms.service.RotateSignedPreKeyListener;
 import org.thoughtcrime.securesms.service.webrtc.ActiveCallManager;
+import org.thoughtcrime.securesms.service.webrtc.CallingAssets;
 import org.thoughtcrime.securesms.service.webrtc.AndroidTelecomUtil;
 import org.thoughtcrime.securesms.storage.StorageSyncHelper;
+import org.signal.core.util.AppForegroundObserver;
 import org.thoughtcrime.securesms.util.AppStartup;
 import org.thoughtcrime.securesms.util.DeviceProperties;
 import org.thoughtcrime.securesms.util.DynamicTheme;
@@ -123,6 +121,7 @@ import org.thoughtcrime.securesms.util.SignalLocalMetrics;
 import org.thoughtcrime.securesms.util.SignalUncaughtExceptionHandler;
 import org.thoughtcrime.securesms.util.SqlCipherLogTarget;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
+import org.signal.core.util.Util;
 import org.thoughtcrime.securesms.util.VersionTracker;
 import org.thoughtcrime.securesms.util.dynamiclanguage.DynamicLanguageContextWrapper;
 import org.whispersystems.signalservice.api.websocket.SignalWebSocket;
@@ -230,7 +229,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
              .addPostRender(RefreshSvrCredentialsJob::enqueueIfNecessary)
              .addPostRender(() -> DownloadLatestEmojiDataJob.scheduleIfNecessary(this))
              .addPostRender(EmojiSearchIndexDownloadJob::scheduleIfNecessary)
-              .addPostRender(MessageSendLogCleanupJob::enqueue)
+              .addPostRender(() -> SignalDatabase.messageLog().trimOldMessages(System.currentTimeMillis(), RemoteConfig.retryRespondMaxAge()))
              .addPostRender(() -> JumboEmoji.updateCurrentVersion(this))
              .addPostRender(RetrieveRemoteAnnouncementsJob::enqueue)
              .addPostRender(AndroidTelecomUtil::registerPhoneAccount)
@@ -278,7 +277,7 @@ public class ApplicationContext extends Application implements AppForegroundObse
      checkFreeDiskSpace();
      MemoryTracker.start();
      BackupSubscriptionCheckJob.enqueueIfAble();
-      CheckKeyTransparencyJob.enqueueIfNecessary(true, false);
+      CheckKeyTransparencyJob.enqueueIfNecessary(true);
      AppDependencies.getAuthWebSocket().registerKeepAliveToken(SignalWebSocket.FOREGROUND_KEEPALIVE);
      AppDependencies.getUnauthWebSocket().registerKeepAliveToken(SignalWebSocket.FOREGROUND_KEEPALIVE);

@@ -421,7 +420,6 @@ public class ApplicationContext extends Application implements AppForegroundObse
      new org.signal.registration.RegistrationDependencies(
        new org.thoughtcrime.securesms.registration.v2.AppRegistrationNetworkController(this, AppDependencies.getPushServiceSocket()),
        new org.thoughtcrime.securesms.registration.v2.AppRegistrationStorageController(this),
-        Environment.IS_LINK_AND_SYNC_AVAILABLE,
        null,
        context -> {
          context.startActivity(new Intent(context, SubmitDebugLogActivity.class));
@@ -281,8 +281,7 @@ public final class ContactSelectionListFragment extends LoggingFragment {
            new ContactSelectionListAdapter.ArbitraryRepository(),
            new SearchRepository(requireContext().getString(R.string.note_to_self)),
            new ContactSearchPagedDataSourceRepository(requireContext()),
-            fixedContacts,
-            false
+            fixedContacts
        )
    ).get(ContactSearchViewModel.class);

@@ -1052,13 +1052,6 @@ 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
@@ -1066,14 +1059,6 @@ 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())
@@ -61,36 +61,21 @@ object ApkUpdateInstaller {
      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
-      }
+    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()) {
      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 {
-      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)
-        }
+      installApk(context, downloadId, userInitiated)
    } catch (e: IOException) {
      Log.w(TAG, "Hit IOException when trying to install APK!", e)
      SignalStore.apkUpdate.clearDownloadAttributes()
@@ -103,13 +88,17 @@ object ApkUpdateInstaller {
  }

  @Throws(IOException::class, SecurityException::class)
-  private fun installApk(context: Context, downloadId: Long, apkInputStream: InputStream, userInitiated: Boolean) {
+  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
+    }
+
    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) {
@@ -144,6 +133,15 @@ 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)
@@ -31,7 +31,7 @@ fun Attachment.toAttachmentPointer(context: Context): AttachmentPointer? {
  }

  try {
-    val remoteId = SignalServiceAttachmentRemoteId.from(attachment.remoteLocation!!, attachment.cdn.cdnNumber)
+    val remoteId = SignalServiceAttachmentRemoteId.from(attachment.remoteLocation!!)

    var attachmentWidth = attachment.width
    var attachmentHeight = attachment.height
@@ -41,16 +41,12 @@ 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 -> null
+        else -> throw UnsupportedOperationException("Invalid CDN number: $cdnNumber")
      }
    }
  }
@@ -5,7 +5,6 @@ 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
@@ -77,8 +76,6 @@ 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) {
@@ -105,13 +102,6 @@ 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(
@@ -120,7 +110,7 @@ class PointerAttachment : Attachment {
          transferState = transferState,
          size = pointer.get().asPointer().size.orElse(0).toLong(),
          fileName = pointer.get().asPointer().fileName.orElse(null),
-          cdn = cdn,
+          cdn = Cdn.fromCdnNumber(pointer.get().asPointer().cdnNumber),
          location = pointer.get().asPointer().remoteId.toString(),
          key = encodedKey,
          iv = null,
@@ -155,13 +145,7 @@ class PointerAttachment : Attachment {
        return Optional.empty()
      }

-      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()
-      }
-
+      val cdn = Cdn.fromCdnNumber(thumbnail?.asPointer()?.cdnNumber ?: 0)
      if (cdn == Cdn.S3) {
        return Optional.empty()
      }
@@ -38,8 +38,8 @@ object AvatarPickerStorage {
      .getAllAvatars()
      .filterIsInstance<Avatar.Photo>()

-    val inDatabaseFileNames = photoAvatars.mapTo(mutableSetOf()) { PartAuthority.getAvatarPickerFilename(it.uri) }
-    val onDiskFileNames = avatarFiles.mapTo(mutableSetOf()) { it.name }
+    val inDatabaseFileNames = photoAvatars.map { PartAuthority.getAvatarPickerFilename(it.uri) }
+    val onDiskFileNames = avatarFiles.map { it.name }

    val inDatabaseButNotOnDisk = inDatabaseFileNames - onDiskFileNames
    val onDiskButNotInDatabase = onDiskFileNames - inDatabaseFileNames
@@ -6,18 +6,14 @@
 package org.thoughtcrime.securesms.backup

 import androidx.annotation.WorkerThread
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
-import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.withContext
 import org.signal.core.util.bytes
 import org.signal.core.util.logging.Log
@@ -50,8 +46,6 @@ object ArchiveUploadProgress {

  private val TAG = Log.tag(ArchiveUploadProgress::class)

-  private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-
  private val _progress: MutableSharedFlow<Unit> = MutableSharedFlow(replay = 1)

  private var uploadProgress: ArchiveUploadProgressState = SignalStore.backup.archiveUploadState ?: ArchiveUploadProgressState(
@@ -67,7 +61,7 @@ object ArchiveUploadProgress {
  /**
   * Observe this to get updates on the current upload progress.
   */
-  val progress: SharedFlow<ArchiveUploadProgressState> = _progress
+  val progress: Flow<ArchiveUploadProgressState> = _progress
    .throttleLatest(500.milliseconds) {
      uploadProgress.state == ArchiveUploadProgressState.State.None ||
        (uploadProgress.state == ArchiveUploadProgressState.State.UploadBackupFile && uploadProgress.backupFileUploadedBytes == 0L) ||
@@ -120,11 +114,6 @@ object ArchiveUploadProgress {
    }
    .onStart { emit(uploadProgress) }
    .flowOn(Dispatchers.IO)
-    .shareIn(scope, SharingStarted.Eagerly, replay = 1)
-
-  init {
-    _progress.tryEmit(Unit)
-  }

  val inProgress
    get() = uploadProgress.state != ArchiveUploadProgressState.State.None && uploadProgress.state != ArchiveUploadProgressState.State.UserCanceled
@@ -31,9 +31,6 @@ import org.thoughtcrime.securesms.jobmanager.impl.BatteryNotLowConstraint
 import org.thoughtcrime.securesms.jobmanager.impl.DiskSpaceNotLowConstraint
 import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint
 import org.thoughtcrime.securesms.jobmanager.impl.WifiConstraint
-import org.thoughtcrime.securesms.jobs.CheckRestoreMediaLeftJob
-import org.thoughtcrime.securesms.jobs.RestoreAttachmentJob
-import org.thoughtcrime.securesms.jobs.RestoreLocalAttachmentJob
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicInteger
@@ -160,22 +157,6 @@ object ArchiveRestoreProgress {
    update()
  }

-  /**
-   * Self-heal hook for restores that appear active (banner showing, media still remaining) but have no jobs left actually working on them.
-   */
-  fun checkForStalledRestore() {
-    SignalExecutors.BOUNDED.execute {
-      val stalled = SignalStore.backup.restoreState.isMediaRestoreOperation &&
-        SignalDatabase.attachments.getRemainingRestorableAttachmentSize() > 0L &&
-        AppDependencies.jobManager.areFactoriesEmpty(setOf(RestoreAttachmentJob.KEY, RestoreLocalAttachmentJob.KEY, CheckRestoreMediaLeftJob.KEY))
-
-      if (stalled) {
-        Log.w(TAG, "Detected a stalled media restore with no active jobs. Enqueueing a check job to recover.")
-        CheckRestoreMediaLeftJob.enqueueStalledRecoveryCheck()
-      }
-    }
-  }
-
  fun clearLocalRestoreDirectoryError() {
    SignalStore.backup.localRestoreDirectoryError = false
    update()
@@ -1465,7 +1465,6 @@ object BackupRepository {
    }

    SignalDatabase.remappedRecords.clearCache()
-    SignalDatabase.remappedRecords.trimStaleMappings()
    AppDependencies.recipientCache.clear()
    AppDependencies.recipientCache.warmUp()
    SignalDatabase.threads.clearCache()
@@ -123,7 +123,7 @@ fun DatabaseAttachment.createArchiveAttachmentPointer(useArchiveCdn: Boolean): S
        throw InvalidAttachmentException("empty content id")
      }

-      SignalServiceAttachmentRemoteId.from(remoteLocation, cdn.cdnNumber) to cdn.cdnNumber
+      SignalServiceAttachmentRemoteId.from(remoteLocation) to cdn.cdnNumber
    }

    val key = Base64.decode(remoteKey)
@@ -435,7 +435,7 @@ class ChatItemArchiveExporter(

        else -> {
          val attachments = extraData.attachmentsById[record.id]
-          val sticker = attachments?.firstOrNull { dbAttachment -> dbAttachment.isSticker && !dbAttachment.quote }
+          val sticker = attachments?.firstOrNull { dbAttachment -> dbAttachment.isSticker }

          if (sticker?.stickerLocator != null) {
            builder.stickerMessage = sticker.toRemoteStickerMessage(sentTimestamp = record.dateSent, reactions = extraData.reactionsById[id], exportState = exportState)
@@ -852,8 +852,8 @@ private fun BackupMessageRecord.toRemotePaymentNotificationUpdate(db: SignalData
    PaymentNotification()
  } else {
    PaymentNotification(
-      amountMob = payment.amount.requireMobileCoin().amountDecimalString,
-      feeMob = payment.fee.requireMobileCoin().amountDecimalString,
+      amountMob = payment.amount.serializeAmountString(),
+      feeMob = payment.fee.serializeAmountString(),
      note = payment.note.takeUnless { it.isEmpty() },
      transactionDetails = payment.toRemoteTransactionDetails()
    )
@@ -60,6 +60,7 @@ 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
@@ -84,7 +85,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.BigDecimal
+import java.math.BigInteger
 import java.sql.SQLException
 import java.util.Optional
 import java.util.UUID
@@ -1063,8 +1064,8 @@ class ChatItemArchiveImporter(

  private fun ContentValues.addPaymentTombstoneNoMetadata(paymentNotification: PaymentNotification) {
    put(MessageTable.TYPE, getAsLong(MessageTable.TYPE) or MessageTypes.SPECIAL_TYPE_PAYMENTS_TOMBSTONE)
-    val amount = paymentNotification.amountMob?.tryParseMoney()?.let { CryptoValueUtil.moneyToCryptoValue(it) }
-    val fee = paymentNotification.feeMob?.tryParseMoney()?.let { CryptoValueUtil.moneyToCryptoValue(it) }
+    val amount = tryParseCryptoValue(paymentNotification.amountMob)
+    val fee = tryParseCryptoValue(paymentNotification.feeMob)
    put(
      MessageTable.MESSAGE_EXTRAS,
      MessageExtras(
@@ -1118,15 +1119,26 @@ class ChatItemArchiveImporter(
      return null
    }

-    return try {
-      Money.mobileCoin(BigDecimal(this))
-    } catch (e: NumberFormatException) {
-      null
-    } catch (e: ArithmeticException) {
+    val amountCryptoValue = tryParseCryptoValue(this)
+    return if (amountCryptoValue != null) {
+      CryptoValueUtil.cryptoValueToMoney(amountCryptoValue)
+    } else {
      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())
@@ -48,7 +48,6 @@ 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 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
@@ -60,15 +59,11 @@ 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
@@ -125,7 +120,6 @@ 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,
@@ -151,38 +145,6 @@ fun MessageBackupsKeyRecordScreen(
    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
-      )
-    }
-  }
-
  Scaffolds.Settings(
    title = "",
    navigationIcon = SignalIcons.ArrowStart.imageVector,
@@ -265,13 +227,7 @@ fun MessageBackupsKeyRecordScreen(

          item {
            Buttons.Small(
-              onClick = {
-                if (mode is MessageBackupsKeyRecordMode.CreateNewKey) {
-                  displayRecoveryKeyCopyWarning = true
-                } else {
-                  onCopyToClipboardClick(backupKeyString)
-                }
-              }
+              onClick = { onCopyToClipboardClick(backupKeyString) }
            ) {
              Text(
                text = stringResource(R.string.MessageBackupsKeyRecordScreen__copy_to_clipboard)
@@ -1,35 +0,0 @@
-/*
- * 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)
-  }
-}
@@ -1,51 +0,0 @@
-/*
- * 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
-    }
-  }
-}
@@ -1,78 +0,0 @@
-/*
- * 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
-    )
-  }
-}
@@ -1,172 +0,0 @@
-/*
- * 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()
-    )
-  }
-}
@@ -1,13 +0,0 @@
-/*
- * 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
-}
@@ -11,7 +11,6 @@ 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
@@ -33,8 +32,6 @@ 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.
 */
@@ -61,16 +58,10 @@ 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 = cdnNumber,
+        cdn = locatorInfo.transitCdnNumber ?: Cdn.CDN_0.cdnNumber,
        uploadTimestamp = locatorInfo.transitTierUploadTimestamp ?: 0,
        key = locatorInfo.key.toByteArray(),
        cdnKey = locatorInfo.transitCdnKey?.nullIfBlank(),
@@ -96,7 +87,7 @@ fun FilePointer?.toLocalAttachment(
    AttachmentType.TRANSIT -> {
      val signalAttachmentPointer = SignalServiceAttachmentPointer(
        cdnNumber = locatorInfo.transitCdnNumber ?: Cdn.CDN_0.cdnNumber,
-        remoteId = SignalServiceAttachmentRemoteId.from(locatorInfo.transitCdnKey!!, locatorInfo.transitCdnNumber ?: Cdn.CDN_0.cdnNumber),
+        remoteId = SignalServiceAttachmentRemoteId.from(locatorInfo.transitCdnKey!!),
        contentType = contentType,
        key = locatorInfo.key.toByteArray(),
        size = Optional.ofNullable(locatorInfo.size),
@@ -306,5 +306,7 @@ class GiftFlowConfirmationFragment :

  override fun navigateToDonationPending(inAppPayment: InAppPaymentTable.InAppPayment) = error("Not supported for gifts")

-  override fun exitCheckoutFlow() = Unit
+  override fun exitCheckoutFlow() {
+    requireActivity().finishAfterTransition()
+  }
 }
@@ -4,6 +4,7 @@ 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
@@ -18,25 +19,29 @@ 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.multiselect_forward_activity), MultiselectForwardFragment.Callback, SearchConfigurationProvider {
+class GiftFlowRecipientSelectionFragment : Fragment(R.layout.gift_flow_recipient_selection_fragment), 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.fragment_container,
+          R.id.multiselect_container,
          MultiselectForwardFragment.create(
            MultiselectForwardFragmentArgs(
              multiShareArgs = emptyList(),
-              title = R.string.GiftFlowRecipientSelectionFragment__choose_recipient,
              forceDisableAddMessage = true,
              selectSingleRecipient = true
            )
@@ -74,10 +79,6 @@ class GiftFlowRecipientSelectionFragment : Fragment(R.layout.multiselect_forward

  override fun exitFlow() = Unit

-  override fun navigateUp() {
-    requireActivity().onBackPressedDispatcher.onBackPressed()
-  }
-
  override fun onSearchInputFocused() = Unit

  override fun setResult(bundle: Bundle) {
@@ -10,7 +10,6 @@ import androidx.compose.runtime.Composable
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.onStart
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgress
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgressState
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgressState.RestoreStatus
@@ -26,7 +25,6 @@ class ArchiveRestoreStatusBanner(private val listener: RestoreProgressBannerList
  override val dataFlow: Flow<ArchiveRestoreProgressState> by lazy {
    ArchiveRestoreProgress
      .stateFlow
-      .onStart { ArchiveRestoreProgress.checkForStalledRestore() }
      .filter {
        it.restoreStatus != RestoreStatus.NONE && (it.restoreState.isMediaRestoreOperation || it.restoreStatus == RestoreStatus.FINISHED)
      }
@@ -21,7 +21,6 @@ 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;
@@ -264,7 +263,7 @@ public class AlbumThumbnailView extends FrameLayout {
  }

  private void showSlides(@NonNull RequestManager requestManager, @NonNull List<Slide> slides) {
-    boolean showControls = TransferControls.containsPlayableSlides(slides);
+    boolean showControls = TransferControlView.containsPlayableSlides(slides);
    setSlide(requestManager, slides.get(0), R.id.album_cell_1, showControls);
    setSlide(requestManager, slides.get(1), R.id.album_cell_2, showControls);

@@ -1,6 +1,5 @@
 package org.thoughtcrime.securesms.components;

-import android.content.ClipData;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Canvas;
@@ -20,7 +19,6 @@ 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;
@@ -28,7 +26,6 @@ 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;
@@ -71,7 +68,6 @@ 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);
@@ -217,41 +213,6 @@ 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;
  }
@@ -281,19 +242,7 @@ public class ComposeText extends EmojiEditText {
      editorInfo.imeOptions &= ~EditorInfo.IME_FLAG_NO_ENTER_ACTION;
    }

-    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);
-      }
-    };
+    return inputConnection;
  }

  public boolean hasMentions() {
@@ -530,20 +479,6 @@ 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.
   */
@@ -641,15 +576,4 @@ 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);
-  }
 }
@@ -38,12 +38,10 @@ import com.bumptech.glide.RequestManager;
 import com.bumptech.glide.load.engine.DiskCacheStrategy;
 import com.google.android.material.dialog.MaterialAlertDialogBuilder;

-import org.signal.core.ui.view.Stub;
 import org.signal.core.util.ThreadUtil;
 import org.signal.core.util.concurrent.ListenableFuture;
 import org.signal.core.util.concurrent.SettableFuture;
 import org.signal.core.util.logging.Log;
-import org.signal.glide.decryptableuri.DecryptableUri;
 import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.animation.AnimationCompleteListener;
 import org.thoughtcrime.securesms.animation.AnimationStartListener;
@@ -65,6 +63,7 @@ import org.thoughtcrime.securesms.database.model.StickerRecord;
 import org.thoughtcrime.securesms.keyboard.KeyboardPage;
 import org.thoughtcrime.securesms.linkpreview.LinkPreview;
 import org.thoughtcrime.securesms.linkpreview.LinkPreviewRepository;
+import org.signal.glide.decryptableuri.DecryptableUri;
 import org.thoughtcrime.securesms.mms.QuoteModel;
 import org.thoughtcrime.securesms.mms.Slide;
 import org.thoughtcrime.securesms.mms.SlideDeck;
@@ -92,33 +91,32 @@ public class InputPanel extends ConstraintLayout
  private static final long QUOTE_REVEAL_DURATION_MILLIS = 150;
  private static final int  FADE_TIME                    = 150;

-  private RecyclerView          stickerSuggestion;
-  private Stub<QuoteView>       quoteViewStub;
-  private Stub<LinkPreviewView> linkPreviewStub;
-  private EmojiToggle           mediaKeyboard;
-  private ComposeText           composeText;
-  private ImageButton           quickCameraToggle;
-  private ImageButton           quickAudioToggle;
-  private AnimatingToggle       buttonToggle;
-  private SendButton            sendButton;
-  private View                  recordingContainer;
-  private View                  recordLockCancel;
-  private View                  composeContainer;
-  private View                  editMessageCancel;
-  private ImageView             editMessageThumbnail;
-  private View                  editMessageTitle;
-  private FrameLayout           composeTextContainer;
+  private RecyclerView    stickerSuggestion;
+  private QuoteView       quoteView;
+  private LinkPreviewView linkPreview;
+  private EmojiToggle     mediaKeyboard;
+  private ComposeText     composeText;
+  private ImageButton     quickCameraToggle;
+  private ImageButton     quickAudioToggle;
+  private AnimatingToggle buttonToggle;
+  private SendButton      sendButton;
+  private View            recordingContainer;
+  private View            recordLockCancel;
+  private View            composeContainer;
+  private View            editMessageCancel;
+  private ImageView       editMessageThumbnail;
+  private View            editMessageTitle;
+  private FrameLayout     composeTextContainer;

-  private MicrophoneRecorderView   microphoneRecorderView;
-  private SlideToCancel            slideToCancel;
-  private RecordTime               recordTime;
-  private ValueAnimator            quoteAnimator;
-  private ValueAnimator            editMessageAnimator;
-  private Stub<VoiceNoteDraftView> voiceNoteDraftViewStub;
+  private MicrophoneRecorderView microphoneRecorderView;
+  private SlideToCancel          slideToCancel;
+  private RecordTime             recordTime;
+  private ValueAnimator          quoteAnimator;
+  private ValueAnimator          editMessageAnimator;
+  private VoiceNoteDraftView     voiceNoteDraftView;

  private @Nullable Listener listener;
  private           boolean  emojiVisible;
-  private           boolean  wallpaperEnabled;

  private boolean hideForMessageRequestState;
  private boolean hideForGroupState;
@@ -129,12 +127,6 @@ public class InputPanel extends ConstraintLayout
  private ConversationStickerSuggestionAdapter stickerSuggestionAdapter;
  private MessageRecord                        messageToEdit;

-  private final Observer<VoiceNotePlaybackState> playbackStateObserverProxy = state -> {
-    if (voiceNoteDraftViewStub.resolved()) {
-      voiceNoteDraftViewStub.get().getPlaybackStateObserver().onChanged(state);
-    }
-  };
-
  public InputPanel(Context context) {
    super(context);
  }
@@ -151,10 +143,12 @@ public class InputPanel extends ConstraintLayout
  public void onFinishInflate() {
    super.onFinishInflate();

+    View quoteDismiss = findViewById(R.id.quote_dismiss_stub);
+
    this.composeContainer       = findViewById(R.id.compose_bubble);
    this.stickerSuggestion      = findViewById(R.id.input_panel_sticker_suggestion);
-    this.quoteViewStub          = new Stub<>(findViewById(R.id.quote_view));
-    this.linkPreviewStub        = new Stub<>(findViewById(R.id.link_preview));
+    this.quoteView              = findViewById(R.id.quote_view);
+    this.linkPreview            = findViewById(R.id.link_preview);
    this.mediaKeyboard          = findViewById(R.id.emoji_toggle);
    this.composeText            = findViewById(R.id.embedded_text_editor);
    this.composeTextContainer   = findViewById(R.id.embedded_text_editor_container);
@@ -164,7 +158,7 @@ public class InputPanel extends ConstraintLayout
    this.sendButton             = findViewById(R.id.send_button);
    this.recordingContainer     = findViewById(R.id.recording_container);
    this.recordLockCancel       = findViewById(R.id.record_cancel);
-    this.voiceNoteDraftViewStub = new Stub<>(findViewById(R.id.voice_note_draft_view_stub));
+    this.voiceNoteDraftView     = findViewById(R.id.voice_note_draft_view);
    this.slideToCancel          = new SlideToCancel(findViewById(R.id.slide_to_cancel));
    this.microphoneRecorderView = findViewById(R.id.recorder_view);
    this.microphoneRecorderView.setHandler(this);
@@ -181,6 +175,14 @@ public class InputPanel extends ConstraintLayout
    mediaKeyboard.setVisibility(View.VISIBLE);
    emojiVisible = true;

+    quoteDismiss.setOnClickListener(v -> clearQuote());
+
+    linkPreview.setCloseClickedListener(() -> {
+      if (listener != null) {
+        listener.onLinkPreviewCanceled();
+      }
+    });
+
    stickerSuggestionAdapter = new ConversationStickerSuggestionAdapter(Glide.with(this), this);

    stickerSuggestion.setLayoutManager(new LinearLayoutManager(getContext(), LinearLayoutManager.HORIZONTAL, false));
@@ -195,6 +197,7 @@ public class InputPanel extends ConstraintLayout
    this.listener = listener;

    mediaKeyboard.setOnClickListener(v -> listener.onEmojiToggle());
+    voiceNoteDraftView.setListener(listener);

    if (Camera.getNumberOfCameras() > 0) {
      quickCameraToggle.setOnClickListener(v -> listener.onQuickCameraToggleClicked());
@@ -211,35 +214,34 @@ public class InputPanel extends ConstraintLayout
                       @NonNull SlideDeck attachments,
                       @NonNull QuoteModel.Type quoteType)
  {
-    QuoteView quoteView = requireQuoteView();
-
-    quoteView.setQuote(requestManager, id, author, body, false, attachments, null, quoteType, true, null);
+    this.quoteView.setQuote(requestManager, id, author, body, false, attachments, null, quoteType, true, null);
    if (listener != null) {
-      quoteView.setOnClickListener(v -> listener.onQuoteClicked(id, author.getId()));
+      this.quoteView.setOnClickListener(v -> listener.onQuoteClicked(id, author.getId()));
    }

-    int originalHeight = quoteView.getVisibility() == VISIBLE ? quoteView.getMeasuredHeight() : 0;
+    int originalHeight = this.quoteView.getVisibility() == VISIBLE ? this.quoteView.getMeasuredHeight()
+                                                                   : 0;

-    quoteView.setVisibility(VISIBLE);
+    this.quoteView.setVisibility(VISIBLE);

    int maxWidth = composeContainer.getWidth();
    if (quoteView.getLayoutParams() instanceof MarginLayoutParams) {
      MarginLayoutParams layoutParams = (MarginLayoutParams) quoteView.getLayoutParams();
      maxWidth -= layoutParams.leftMargin + layoutParams.rightMargin;
    }
-    quoteView.measure(MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.AT_MOST), 0);
+    this.quoteView.measure(MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.AT_MOST), 0);

    if (quoteAnimator != null) {
      quoteAnimator.cancel();
    }

-    quoteAnimator = createHeightAnimator(quoteView, originalHeight, quoteView.getMeasuredHeight(), null);
+    quoteAnimator = createHeightAnimator(quoteView, originalHeight, this.quoteView.getMeasuredHeight(), null);

    quoteAnimator.start();

-    if (linkPreviewStub.getVisibility() == View.VISIBLE) {
+    if (this.linkPreview.getVisibility() == View.VISIBLE) {
      int cornerRadius = readDimen(R.dimen.message_corner_collapse_radius);
-      linkPreviewStub.get().setCorners(cornerRadius, cornerRadius);
+      this.linkPreview.setCorners(cornerRadius, cornerRadius);
    }

    if (listener != null) {
@@ -248,12 +250,6 @@ public class InputPanel extends ConstraintLayout
  }

  public void clearQuote() {
-    if (!quoteViewStub.resolved()) {
-      return;
-    }
-
-    QuoteView quoteView = quoteViewStub.get();
-
    if (quoteAnimator != null) {
      quoteAnimator.cancel();
    }
@@ -263,9 +259,9 @@ public class InputPanel extends ConstraintLayout
      public void onAnimationEnd(Animator animation) {
        quoteView.dismiss();

-        if (linkPreviewStub.getVisibility() == View.VISIBLE) {
+        if (linkPreview.getVisibility() == View.VISIBLE) {
          int cornerRadius = readDimen(R.dimen.message_corner_radius);
-          linkPreviewStub.get().setCorners(cornerRadius, cornerRadius);
+          linkPreview.setCorners(cornerRadius, cornerRadius);
        }
      }
    });
@@ -277,20 +273,6 @@ public class InputPanel extends ConstraintLayout
    }
  }

-  private @NonNull QuoteView requireQuoteView() {
-    boolean   wasResolved = quoteViewStub.resolved();
-    QuoteView quoteView   = quoteViewStub.get();
-    if (!wasResolved) {
-      quoteView.setWallpaperEnabled(wallpaperEnabled);
-      View quoteDismiss = quoteView.findViewById(R.id.quote_dismiss_stub);
-      if (quoteDismiss != null) {
-        quoteDismiss.setOnClickListener(v -> clearQuote());
-      }
-    }
-
-    return quoteView;
-  }
-
  private static ValueAnimator createHeightAnimator(@NonNull View view,
                                                    int originalHeight,
                                                    int finalHeight,
@@ -312,12 +294,11 @@ public class InputPanel extends ConstraintLayout
    return animator;
  }

-  public Optional<QuoteModel> getQuote() {
-    if (!quoteViewStub.resolved()) {
-      return Optional.empty();
-    }
+  public boolean hasSaveableContent() {
+    return getQuote().isPresent() || voiceNoteDraftView.getDraft() != null;
+  }

-    QuoteView quoteView = quoteViewStub.get();
+  public Optional<QuoteModel> getQuote() {
    if (quoteView.getQuoteId() > 0 && quoteView.getVisibility() == View.VISIBLE) {
      return Optional.of(new QuoteModel(quoteView.getQuoteId(),
                                        quoteView.getAuthor().getId(),
@@ -333,53 +314,41 @@ public class InputPanel extends ConstraintLayout
  }

  public boolean hasLinkPreview() {
-    return linkPreviewStub.getVisibility() == View.VISIBLE;
+    return linkPreview.getVisibility() == View.VISIBLE;
  }

  public void setLinkPreviewLoading() {
-    LinkPreviewView linkPreview = requireLinkPreview();
-    linkPreview.setVisibility(View.VISIBLE);
-    linkPreview.setLoading();
+    this.linkPreview.setVisibility(View.VISIBLE);
+    this.linkPreview.setLoading();
  }

  public void setLinkPreviewNoPreview(@Nullable LinkPreviewRepository.Error customError) {
-    LinkPreviewView linkPreview = requireLinkPreview();
-    linkPreview.setVisibility(View.VISIBLE);
-    linkPreview.setNoPreview(customError);
+    this.linkPreview.setVisibility(View.VISIBLE);
+    this.linkPreview.setNoPreview(customError);
  }

  public void setLinkPreview(@NonNull RequestManager requestManager, @NonNull Optional<LinkPreview> preview) {
    if (preview.isPresent()) {
-      LinkPreviewView linkPreview = requireLinkPreview();
-      linkPreview.setVisibility(View.VISIBLE);
-      linkPreview.setLinkPreview(requestManager, preview.get(), true);
+      this.linkPreview.setVisibility(View.VISIBLE);
+      this.linkPreview.setLinkPreview(requestManager, preview.get(), true);
    } else {
-      linkPreviewStub.setVisibility(View.GONE);
+      this.linkPreview.setVisibility(View.GONE);
    }

-    if (linkPreviewStub.resolved()) {
-      int cornerRadius = quoteViewStub.getVisibility() == VISIBLE ? readDimen(R.dimen.message_corner_collapse_radius) : readDimen(R.dimen.message_corner_radius);
-      linkPreviewStub.get().setCorners(cornerRadius, cornerRadius);
-    }
-  }
+    int cornerRadius = quoteView.getVisibility() == VISIBLE ? readDimen(R.dimen.message_corner_collapse_radius)
+                                                            : readDimen(R.dimen.message_corner_radius);

-  private @NonNull LinkPreviewView requireLinkPreview() {
-    boolean         wasResolved = linkPreviewStub.resolved();
-    LinkPreviewView view        = linkPreviewStub.get();
-
-    if (!wasResolved) {
-      view.setCloseClickedListener(() -> {
-        if (listener != null) listener.onLinkPreviewCanceled();
-      });
-    }
-
-    return view;
+    this.linkPreview.setCorners(cornerRadius, cornerRadius);
  }

  public void clickOnComposeInput() {
    composeText.performClick();
  }

+  public void setMediaKeyboard(@NonNull MediaKeyboard mediaKeyboard) {
+    this.mediaKeyboard.attach(mediaKeyboard);
+  }
+
  public void setStickerSuggestions(@NonNull List<StickerRecord> stickers) {
    stickerSuggestion.setVisibility(stickers.isEmpty() ? View.GONE : View.VISIBLE);
    stickerSuggestionAdapter.setStickers(stickers);
@@ -434,10 +403,7 @@ public class InputPanel extends ConstraintLayout
    quickCameraToggle.setColorFilter(iconTint);
    composeText.setTextColor(textColor);
    composeText.setHintTextColor(textHintColor);
-    wallpaperEnabled = enabled;
-    if (quoteViewStub.resolved()) {
-      quoteViewStub.get().setWallpaperEnabled(enabled);
-    }
+    quoteView.setWallpaperEnabled(enabled);
  }

  public void enterEditModeIfPossible(@NonNull RequestManager requestManager, @NonNull ConversationMessage conversationMessageToEdit, boolean fromDraft, boolean clearQuote) {
@@ -527,9 +493,7 @@ public class InputPanel extends ConstraintLayout
    if (messageToEdit != null) {
      composeText.setText("");
      messageToEdit = null;
-      if (quoteViewStub.resolved()) {
-        quoteViewStub.get().setMessageType(QuoteView.MessageType.PREVIEW);
-      }
+      quoteView.setMessageType(QuoteView.MessageType.PREVIEW);
      clearQuote();
    }
    updateEditModeUi();
@@ -683,7 +647,7 @@ public class InputPanel extends ConstraintLayout
  }

  public @NonNull Observer<VoiceNotePlaybackState> getPlaybackStateObserver() {
-    return playbackStateObserverProxy;
+    return voiceNoteDraftView.getPlaybackStateObserver();
  }

  public void setEnabled(boolean enabled) {
@@ -702,7 +666,7 @@ public class InputPanel extends ConstraintLayout
    future.addListener(new AssertedSuccessListener<Void>() {
      @Override
      public void onSuccess(Void result) {
-        if (!voiceNoteDraftViewStub.resolved() || voiceNoteDraftViewStub.get().getDraft() == null) {
+        if (voiceNoteDraftView.getDraft() == null) {
          fadeInNormalComposeViews();
        }
      }
@@ -716,6 +680,10 @@ public class InputPanel extends ConstraintLayout
    mediaKeyboard.setToMedia();
  }

+  public void setToIme() {
+    mediaKeyboard.setToIme();
+  }
+
  @Override
  public void onKeyEvent(KeyEvent keyEvent) {
    composeText.dispatchKeyEvent(keyEvent);
@@ -747,35 +715,20 @@ public class InputPanel extends ConstraintLayout

  public void setVoiceNoteDraft(@Nullable DraftTable.Draft voiceNoteDraft) {
    if (voiceNoteDraft != null) {
-      VoiceNoteDraftView voiceNoteDraftView = requireVoiceNoteDraft();
      voiceNoteDraftView.setDraft(voiceNoteDraft);
      voiceNoteDraftView.setVisibility(VISIBLE);
      hideNormalComposeViews();
      fadeIn(buttonToggle);
      buttonToggle.displayQuick(sendButton);
    } else {
-      if (voiceNoteDraftViewStub.resolved()) {
-        VoiceNoteDraftView voiceNoteDraftView = voiceNoteDraftViewStub.get();
-        voiceNoteDraftView.clearDraft();
-        ViewUtil.fadeOut(voiceNoteDraftView, FADE_TIME);
-      }
+      voiceNoteDraftView.clearDraft();
+      ViewUtil.fadeOut(voiceNoteDraftView, FADE_TIME);
      fadeInNormalComposeViews();
    }
  }

  public @Nullable DraftTable.Draft getVoiceNoteDraft() {
-    if (!voiceNoteDraftViewStub.resolved()) return null;
-    return voiceNoteDraftViewStub.get().getDraft();
-  }
-
-  private @NonNull VoiceNoteDraftView requireVoiceNoteDraft() {
-    boolean            wasResolved        = voiceNoteDraftViewStub.resolved();
-    VoiceNoteDraftView voiceNoteDraftView = voiceNoteDraftViewStub.get();
-    if (!wasResolved) {
-      voiceNoteDraftView.setListener(listener);
-    }
-
-    return voiceNoteDraftView;
+    return voiceNoteDraftView.getDraft();
  }

  private void hideNormalComposeViews() {
@@ -4,6 +4,8 @@ import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Canvas;
 import android.graphics.Color;
+import android.os.Bundle;
+import android.os.Parcelable;
 import android.util.AttributeSet;
 import android.view.View;
 import android.view.ViewGroup;
@@ -41,6 +43,9 @@ import okhttp3.HttpUrl;
 */
 public class LinkPreviewView extends FrameLayout {

+  private static final String STATE_ROOT = "linkPreviewView.state.root";
+  private static final String STATE_STATE = "linkPreviewView.state.state";
+
  private static final int TYPE_CONVERSATION = 0;
  private static final int TYPE_COMPOSE      = 1;

@@ -109,6 +114,30 @@ public class LinkPreviewView extends FrameLayout {
    setWillNotDraw(false);
  }

+  @Override
+  protected @NonNull Parcelable onSaveInstanceState() {
+    Parcelable root   = super.onSaveInstanceState();
+    Bundle     bundle = new Bundle();
+
+    bundle.putParcelable(STATE_ROOT, root);
+    bundle.putParcelable(STATE_STATE, thumbnailState);
+
+    return bundle;
+  }
+
+  @Override
+  protected void onRestoreInstanceState(Parcelable state) {
+    if (state instanceof Bundle) {
+      Parcelable root = ((Bundle) state).getParcelable(STATE_ROOT);
+      thumbnailState = ((Bundle) state).getParcelable(STATE_STATE);
+
+      thumbnailState.applyState(thumbnail);
+      super.onRestoreInstanceState(root);
+    } else {
+      super.onRestoreInstanceState(state);
+    }
+  }
+
  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(canvas);
@@ -222,7 +251,7 @@ public class LinkPreviewView extends FrameLayout {
      thumbnailState.applyState(thumbnail);
    } else {
      cornerMask.setRadii(topStart, topEnd, 0, 0);
-      thumbnailState = thumbnailState.copy(
+      thumbnailState.copy(
          topStart,
          defaultRadius,
          defaultRadius,
@@ -434,7 +434,6 @@ public class QuoteView extends ConstraintLayout implements RecipientForeverObser

    if (TextUtils.isEmpty(quoteTargetContentType)) {
      thumbnailView.setVisibility(GONE);
-      attachmentVideoOVerlayStub.setVisibility(GONE);
      attachmentNameViewStub.setVisibility(GONE);

      if (dismissStub.resolved()) {
@@ -5,6 +5,7 @@ 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;
@@ -68,7 +69,7 @@ public class SharedContactView extends LinearLayout implements RecipientForeverO
    initialize(attrs);
  }

-  @RequiresApi(api = 21)
+  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
  public SharedContactView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    initialize(attrs);
@@ -37,7 +37,7 @@ class SignalProgressDialog private constructor(

  var progress: Int
    get() = progressBar.progress
-    set(value) = if (Build.VERSION.SDK_INT >= 24) {
+    set(value) = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
      progressBar.setProgress(value, true)
    } else {
      progressBar.setProgress(value)
@@ -48,7 +48,6 @@ 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;
@@ -385,7 +384,7 @@ public class ThumbnailView extends FrameLayout {
      }
      transferControlViewStub.get().setSlides(List.of(slide));
    }
-    int     transferState    = TransferControls.getTransferState(List.of(slide));
+    int transferState = TransferControlView.getTransferState(List.of(slide));
    boolean isOffloadedImage = (transferState == AttachmentTable.TRANSFER_RESTORE_OFFLOADED && MediaUtil.isImageType(slide.getContentType())) && AttachmentUtil.isRestoreOnOpenPermitted(getContext(), slide.asAttachment());

    if (!showControls ||
@@ -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 >= 23) {
+    private fun getStaticLayout(emoji: CharSequence): StaticLayout = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
      StaticLayout.Builder.obtain(emoji, 0, emoji.length, textPaint, Int.MAX_VALUE).build()
    } else {
      @Suppress("DEPRECATION")
@@ -3,6 +3,7 @@ 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;
@@ -48,7 +49,7 @@ public class VerificationPinKeyboard extends FrameLayout {
    initialize();
  }

-  @RequiresApi(api = 21)
+  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
  public VerificationPinKeyboard(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    initialize();
@@ -25,12 +25,12 @@ open class DSLSettingsActivity : PassphraseRequiredActivity() {
    setContentView(R.layout.dsl_settings_activity)

    if (savedInstanceState == null) {
-      val navGraphId = resolveNavGraphId()
+      val navGraphId = intent.getIntExtra(ARG_NAV_GRAPH, -1)
      if (navGraphId == -1) {
        throw IllegalStateException("No navgraph id was passed to activity")
      }

-      val fragment: NavHostFragment = NavHostFragment.create(navGraphId, resolveStartBundle())
+      val fragment: NavHostFragment = NavHostFragment.create(navGraphId, intent.getBundleExtra(ARG_START_BUNDLE))

      supportFragmentManager.beginTransaction()
        .replace(R.id.nav_host_fragment, fragment)
@@ -64,10 +64,6 @@ 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"
@@ -2,15 +2,12 @@ package org.thoughtcrime.securesms.components.settings.app

 import android.content.Context
 import android.content.Intent
-import android.os.Build
 import android.os.Bundle
-import android.os.Process
 import androidx.navigation.NavDirections
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import io.reactivex.rxjava3.subjects.PublishSubject
 import io.reactivex.rxjava3.subjects.Subject
 import org.signal.core.util.getParcelableExtraCompat
-import org.signal.core.util.logging.Log
 import org.signal.donations.InAppPaymentType
 import org.thoughtcrime.securesms.MainActivity
 import org.thoughtcrime.securesms.R
@@ -37,21 +34,20 @@ private const val EXTRA_PERFORM_ACTION_ON_CREATE = "extra_perform_action_on_crea

 class AppSettingsActivity : DSLSettingsActivity(), GooglePayComponent {

-  private val TAG = Log.tag(AppSettingsActivity::class)
-
  private var wasConfigurationUpdated = false

  override val googlePayRepository: GooglePayRepository by lazy { GooglePayRepository(this) }
  override val googlePayResultPublisher: Subject<GooglePayComponent.GooglePayResult> = PublishSubject.create()

  override fun onCreate(savedInstanceState: Bundle?, ready: Boolean) {
+    if (intent?.hasExtra(ARG_NAV_GRAPH) != true) {
+      intent?.putExtra(ARG_NAV_GRAPH, R.navigation.app_settings_with_change_number)
+    }
+
    super.onCreate(savedInstanceState, ready)

    val startingAction: NavDirections? = if (intent?.categories?.contains(NOTIFICATION_CATEGORY) == true) {
      AppSettingsFragmentDirections.actionDirectToNotificationsSettingsFragment()
-    } else if (Build.VERSION.SDK_INT >= 34 && getLaunchedFromUid() != Process.myUid()) {
-      Log.w(TAG, "Settings was launched by an external process. Ignoring starting route.")
-      null
    } else {
      when (val appSettingsRoute: AppSettingsRoute? = intent?.getParcelableExtraCompat(START_ROUTE, AppSettingsRoute::class.java)) {
        AppSettingsRoute.Empty -> null
@@ -148,10 +144,6 @@ class AppSettingsActivity : DSLSettingsActivity(), GooglePayComponent {
    }
  }

-  override fun resolveNavGraphId(): Int = R.navigation.app_settings_with_change_number
-
-  override fun resolveStartBundle(): Bundle? = null
-
  @Suppress("DEPRECATION")
  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
@@ -81,7 +81,6 @@ import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.CommunicationActions
 import org.thoughtcrime.securesms.util.SignalE164Util
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
-import org.signal.core.ui.R as CoreUiR

 class AppSettingsFragment : ComposeFragment(), Callbacks {

@@ -296,7 +295,7 @@ private fun AppSettingsContent(
          item {
            Rows.TextRow(
              text = stringResource(R.string.AccountSettingsFragment__account),
-              icon = painterResource(CoreUiR.drawable.symbol_person_circle_24),
+              icon = painterResource(R.drawable.symbol_person_circle_24),
              onClick = {
                callbacks.navigate(AppSettingsRoute.AccountRoute.Account)
              }
@@ -306,7 +305,7 @@ private fun AppSettingsContent(
          item {
            Rows.TextRow(
              text = stringResource(R.string.preferences__linked_devices),
-              icon = painterResource(CoreUiR.drawable.symbol_devices_24),
+              icon = painterResource(R.drawable.symbol_devices_24),
              onClick = {
                callbacks.navigate(AppSettingsRoute.LinkDeviceRoute.LinkDevice)
              },
@@ -242,7 +242,7 @@ private fun BackupsSettingsContent(
      item {
        Rows.TextRow(
          text = stringResource(R.string.RemoteBackupsSettingsFragment__on_device_backups),
-          icon = ImageVector.vectorResource(CoreUiR.drawable.symbol_device_phone_24),
+          icon = ImageVector.vectorResource(R.drawable.symbol_device_phone_24),
          label = stringResource(R.string.RemoteBackupsSettingsFragment__save_your_backups_to),
          onClick = onOnDeviceBackupsRowClick
        )
@@ -6,12 +6,9 @@ import android.content.Context
 import android.content.DialogInterface
 import android.os.Build
 import android.os.Bundle
-import android.view.MenuItem
 import android.view.View
 import android.widget.EditText
 import android.widget.Toast
-import androidx.appcompat.widget.SearchView
-import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.setFragmentResultListener
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.lifecycleScope
@@ -77,10 +74,8 @@ import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.registration.data.QuickstartCredentialExporter
 import org.thoughtcrime.securesms.storage.StorageSyncHelper
 import org.thoughtcrime.securesms.util.ConversationUtil
-import org.thoughtcrime.securesms.util.TextSecurePreferences
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
-import org.thoughtcrime.securesms.util.setIncognitoKeyboardEnabled
 import org.whispersystems.signalservice.api.push.UsernameLinkComponents
 import java.util.Optional
 import java.util.UUID
@@ -89,14 +84,13 @@ import kotlin.math.max
 import kotlin.random.Random
 import kotlin.time.Duration.Companion.milliseconds

-class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__internal_preferences, R.menu.internal_settings) {
+class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__internal_preferences) {

  companion object {
    private val TAG = Log.tag(InternalSettingsFragment::class.java)
  }

  private lateinit var viewModel: InternalSettingsViewModel
-  private var searchMenuItem: MenuItem? = null

  private var scrollToPosition: Int = 0
  private val layoutManager: LinearLayoutManager?
@@ -113,7 +107,6 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    scrollToPosition = SignalStore.internal.lastScrollPosition
-    initializeSearch(view)

    setFragmentResultListener(CallQualityBottomSheetFragment.REQUEST_KEY) { _, bundle ->
      if (bundle.getBoolean(CallQualityBottomSheetFragment.REQUEST_KEY, false)) {
@@ -132,11 +125,8 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
    viewModel = ViewModelProvider(this, factory)[InternalSettingsViewModel::class.java]

    viewModel.state.observe(viewLifecycleOwner) {
-      val mappingModelList = getConfiguration(it).toMappingModelList()
-      val filteredList = viewModel.filterPreferences(requireContext(), mappingModelList, it.searchQuery)
-
-      adapter.submitList(filteredList) {
-        if (scrollToPosition != 0 && it.searchQuery.isBlank()) {
+      adapter.submitList(getConfiguration(it).toMappingModelList()) {
+        if (scrollToPosition != 0) {
          layoutManager?.scrollToPositionWithOffset(scrollToPosition, 0)
          scrollToPosition = 0
        }
@@ -144,56 +134,6 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
    }
  }

-  override fun onToolbarNavigationClicked() {
-    if (searchMenuItem?.isActionViewExpanded == true) {
-      searchMenuItem?.collapseActionView()
-    } else {
-      super.onToolbarNavigationClicked()
-    }
-  }
-
-  private fun initializeSearch(view: View) {
-    val toolbar: Toolbar = view.findViewById(R.id.toolbar)
-    searchMenuItem = toolbar.menu.findItem(R.id.menu_search)
-
-    val searchView: SearchView = searchMenuItem?.actionView as? SearchView ?: return
-    val queryListener = object : SearchView.OnQueryTextListener {
-      override fun onQueryTextSubmit(query: String?): Boolean {
-        searchView.clearFocus()
-        viewModel.setSearchQuery(query.orEmpty())
-        return true
-      }
-
-      override fun onQueryTextChange(newText: String?): Boolean {
-        viewModel.setSearchQuery(newText.orEmpty())
-        return true
-      }
-    }
-
-    searchView.maxWidth = Integer.MAX_VALUE
-    searchView.queryHint = getString(R.string.CameraContacts__menu_search)
-
-    searchMenuItem?.setOnActionExpandListener(object : MenuItem.OnActionExpandListener {
-      override fun onMenuItemActionExpand(item: MenuItem): Boolean {
-        searchView.setIncognitoKeyboardEnabled(TextSecurePreferences.isIncognitoKeyboardEnabled(requireContext()))
-        searchView.setOnQueryTextListener(queryListener)
-        return true
-      }
-
-      override fun onMenuItemActionCollapse(item: MenuItem): Boolean {
-        searchView.setOnQueryTextListener(null)
-        searchView.setQuery("", false)
-        viewModel.setSearchQuery("")
-        return true
-      }
-    })
-
-    val currentQuery = viewModel.state.value?.searchQuery.orEmpty()
-    if (currentQuery.isNotBlank() && searchMenuItem?.expandActionView() == true) {
-      searchView.setQuery(currentQuery, false)
-    }
-  }
-
  private fun getConfiguration(state: InternalSettingsState): DSLConfiguration {
    return configure {
      sectionHeaderPref(DSLSettingsText.from("Account"))
@@ -256,14 +196,6 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
        }
      )

-      clickPref(
-        title = DSLSettingsText.from("App Issues"),
-        summary = DSLSettingsText.from("View recorded app issues, like slow reads and writes."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalIssuesFragment())
-        }
-      )
-
      switchPref(
        title = DSLSettingsText.from("Disable internal user flag"),
        summary = DSLSettingsText.from("Experience life as a non-internal user. Force-stop the app to be an internal user again."),
@@ -275,50 +207,6 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter

      dividerPref()

-      sectionHeaderPref(DSLSettingsText.from("Playgrounds"))
-
-      clickPref(
-        title = DSLSettingsText.from("SQLite Playground"),
-        summary = DSLSettingsText.from("Run raw SQLite queries."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalSqlitePlaygroundFragment())
-        }
-      )
-
-      clickPref(
-        title = DSLSettingsText.from("Backup Playground"),
-        summary = DSLSettingsText.from("Test backup import/export."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalBackupPlaygroundFragment())
-        }
-      )
-
-      clickPref(
-        title = DSLSettingsText.from("Storage Service Playground"),
-        summary = DSLSettingsText.from("Test and view storage service stuff."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalStorageServicePlaygroundFragment())
-        }
-      )
-
-      clickPref(
-        title = DSLSettingsText.from("SVR Playground"),
-        summary = DSLSettingsText.from("Quickly test various SVR options and error conditions."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalSvrPlaygroundFragment())
-        }
-      )
-
-      clickPref(
-        title = DSLSettingsText.from("Data Seeding Playground"),
-        summary = DSLSettingsText.from("Seed conversations with media files from a folder."),
-        onClick = {
-          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToDataSeedingPlaygroundFragment())
-        }
-      )
-
-      dividerPref()
-
      sectionHeaderPref(DSLSettingsText.from("App UI"))

      switchPref(
@@ -367,6 +255,50 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter

      dividerPref()

+      sectionHeaderPref(DSLSettingsText.from("Playgrounds"))
+
+      clickPref(
+        title = DSLSettingsText.from("SQLite Playground"),
+        summary = DSLSettingsText.from("Run raw SQLite queries."),
+        onClick = {
+          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalSqlitePlaygroundFragment())
+        }
+      )
+
+      clickPref(
+        title = DSLSettingsText.from("Backup Playground"),
+        summary = DSLSettingsText.from("Test backup import/export."),
+        onClick = {
+          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalBackupPlaygroundFragment())
+        }
+      )
+
+      clickPref(
+        title = DSLSettingsText.from("Storage Service Playground"),
+        summary = DSLSettingsText.from("Test and view storage service stuff."),
+        onClick = {
+          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalStorageServicePlaygroundFragment())
+        }
+      )
+
+      clickPref(
+        title = DSLSettingsText.from("SVR Playground"),
+        summary = DSLSettingsText.from("Quickly test various SVR options and error conditions."),
+        onClick = {
+          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToInternalSvrPlaygroundFragment())
+        }
+      )
+
+      clickPref(
+        title = DSLSettingsText.from("Data Seeding Playground"),
+        summary = DSLSettingsText.from("Seed conversations with media files from a folder."),
+        onClick = {
+          findNavController().safeNavigate(InternalSettingsFragmentDirections.actionInternalSettingsFragmentToDataSeedingPlaygroundFragment())
+        }
+      )
+
+      dividerPref()
+
      sectionHeaderPref(DSLSettingsText.from("Miscellaneous"))

      clickPref(
@@ -446,7 +378,8 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
        title = DSLSettingsText.from("Run self-check key transparency"),
        summary = DSLSettingsText.from("Automatically enqueues a job to run KT against yourself without waiting for the elapsed time."),
        onClick = {
-          CheckKeyTransparencyJob.enqueueIfNecessary(addDelay = false, force = true)
+          SignalStore.misc.lastKeyTransparencyTime = 0
+          CheckKeyTransparencyJob.enqueueIfNecessary(addDelay = false)
        }
      )

@@ -32,6 +32,5 @@ data class InternalSettingsState(
  val forceSplitPane: Boolean,
  val forceSinglePane: Boolean,
  val useNewMediaActivity: Boolean,
-  val disableInternalUser: Boolean,
-  val searchQuery: String = ""
+  val disableInternalUser: Boolean
 )
@@ -1,14 +1,10 @@
 package org.thoughtcrime.securesms.components.settings.app.internal

-import android.content.Context
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import io.reactivex.rxjava3.core.Observable
 import org.signal.ringrtc.CallManager
-import org.thoughtcrime.securesms.components.settings.DividerPreference
-import org.thoughtcrime.securesms.components.settings.PreferenceModel
-import org.thoughtcrime.securesms.components.settings.SectionHeaderPreference
 import org.thoughtcrime.securesms.database.model.RemoteMegaphoneRecord
 import org.thoughtcrime.securesms.jobs.StoryOnboardingDownloadJob
 import org.thoughtcrime.securesms.keyvalue.InternalValues
@@ -16,10 +12,7 @@ import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.stories.Stories
 import org.thoughtcrime.securesms.util.RemoteConfig
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingModelList
 import org.thoughtcrime.securesms.util.livedata.Store
-import java.util.Locale

 class InternalSettingsViewModel(private val repository: InternalSettingsRepository) : ViewModel() {
  private val preferenceDataStore = SignalStore.getPreferenceDataStore()
@@ -174,47 +167,7 @@ class InternalSettingsViewModel(private val repository: InternalSettingsReposito
  }

  fun refresh() {
-    store.update { getState().copy(emojiVersion = it.emojiVersion, searchQuery = it.searchQuery) }
-  }
-
-  fun setSearchQuery(query: String) {
-    store.update {
-      if (it.searchQuery == query) {
-        it
-      } else {
-        it.copy(searchQuery = query)
-      }
-    }
-  }
-
-  fun filterPreferences(context: Context, items: MappingModelList, query: String): MappingModelList {
-    val normalizedQuery = query.trim().lowercase(Locale.getDefault())
-    if (normalizedQuery.isBlank()) {
-      return items
-    }
-
-    val groups = buildSearchGroups(items)
-    val filtered = MappingModelList()
-
-    groups.forEach { group ->
-      val headerMatches = group.header?.searchableText(context)?.contains(normalizedQuery) == true
-      val matchingItems = if (headerMatches) {
-        group.items
-      } else {
-        group.items.filter { it.searchableText(context)?.contains(normalizedQuery) == true }
-      }
-
-      if (headerMatches || matchingItems.isNotEmpty()) {
-        if (filtered.isNotEmpty() && group.divider != null) {
-          filtered.add(group.divider)
-        }
-
-        group.header?.let { filtered.add(it) }
-        filtered.addAll(matchingItems)
-      }
-    }
-
-    return filtered
+    store.update { getState().copy(emojiVersion = it.emojiVersion) }
  }

  private fun getState() = InternalSettingsState(
@@ -272,57 +225,6 @@ class InternalSettingsViewModel(private val repository: InternalSettingsReposito
    refresh()
  }

-  private fun buildSearchGroups(items: MappingModelList): List<SearchGroup> {
-    val groups = mutableListOf<SearchGroup>()
-    var divider: DividerPreference? = null
-    var header: SectionHeaderPreference? = null
-    var groupItems = mutableListOf<MappingModel<*>>()
-
-    fun flush() {
-      if (header != null || groupItems.isNotEmpty()) {
-        groups.add(SearchGroup(divider, header, groupItems))
-      }
-
-      divider = null
-      header = null
-      groupItems = mutableListOf()
-    }
-
-    items.forEach { item ->
-      when (item) {
-        is DividerPreference -> {
-          flush()
-          divider = item
-        }
-        is SectionHeaderPreference -> {
-          flush()
-          header = item
-        }
-        else -> groupItems.add(item)
-      }
-    }
-
-    flush()
-
-    return groups
-  }
-
-  private fun MappingModel<*>.searchableText(context: Context): String? {
-    return if (this is PreferenceModel<*>) {
-      listOfNotNull(title, summary)
-        .joinToString(separator = " ") { it.resolve(context).toString() }
-        .lowercase(Locale.getDefault())
-    } else {
-      null
-    }
-  }
-
-  private data class SearchGroup(
-    val divider: DividerPreference?,
-    val header: SectionHeaderPreference?,
-    val items: List<MappingModel<*>>
-  )
-
  class Factory(private val repository: InternalSettingsRepository) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
      return requireNotNull(modelClass.cast(InternalSettingsViewModel(repository)))
@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.settings.app.internal.issues
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.fragment.app.viewModels
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.fragment.findNavController
-import org.signal.core.ui.compose.ComposeFragment
-
-class InternalIssuesFragment : ComposeFragment() {
-
-  private val viewModel: InternalIssuesViewModel by viewModels()
-
-  @Composable
-  override fun FragmentContent() {
-    val state by viewModel.state.collectAsStateWithLifecycle()
-
-    LaunchedEffect(Unit) {
-      viewModel.onEvent(InternalIssuesScreenEvent.Load)
-    }
-
-    InternalIssuesScreen(
-      state = state,
-      onEvent = viewModel::onEvent,
-      onBack = { findNavController().popBackStack() }
-    )
-  }
-}
@@ -1,344 +0,0 @@
-/*
- * Copyright 2026 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.settings.app.internal.issues
-
-import android.widget.Toast
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
-import androidx.compose.material3.Text
-import androidx.compose.material3.rememberModalBottomSheetState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalClipboardManager
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import org.signal.core.ui.compose.DayNightPreviews
-import org.signal.core.ui.compose.Dialogs
-import org.signal.core.ui.compose.Previews
-import org.signal.core.ui.compose.Rows
-import org.signal.core.ui.compose.Scaffolds
-import org.signal.core.ui.compose.SignalIcons
-import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.database.LogDatabase.IssueTable.IssueRecord
-import org.thoughtcrime.securesms.database.model.IssuePriority
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun InternalIssuesScreen(
-  state: InternalIssuesState,
-  onEvent: (InternalIssuesScreenEvent) -> Unit = {},
-  onBack: () -> Unit = {}
-) {
-  var showFilterSheet by remember { mutableStateOf(false) }
-  var showSortSheet by remember { mutableStateOf(false) }
-  var showClearDialog by remember { mutableStateOf(false) }
-
-  Scaffolds.Settings(
-    title = "App Issues",
-    onNavigationClick = onBack,
-    navigationIcon = SignalIcons.ArrowStart.imageVector,
-    snackbarHost = {},
-    actions = {
-      if (state.names.isNotEmpty()) {
-        IconButton(onClick = { showFilterSheet = true }) {
-          Icon(painter = painterResource(R.drawable.symbol_filter_24), contentDescription = "Filter")
-        }
-        IconButton(onClick = { showSortSheet = true }) {
-          Icon(painter = painterResource(R.drawable.symbol_list_bullet_24), contentDescription = "Sort")
-        }
-        IconButton(onClick = { showClearDialog = true }) {
-          Icon(painter = SignalIcons.Trash.painter, contentDescription = "Clear")
-        }
-      }
-    }
-  ) { paddingValues ->
-    Column(
-      modifier = Modifier
-        .fillMaxSize()
-        .padding(paddingValues)
-    ) {
-      Rows.RadioListRow(
-        text = "Notification priority threshold",
-        labels = IssuePriority.entries.map { it.label }.toTypedArray(),
-        values = IssuePriority.entries.map { it.name }.toTypedArray(),
-        selectedValue = state.notificationPriority.name,
-        onSelected = { onEvent(InternalIssuesScreenEvent.SetNotificationPriority(IssuePriority.valueOf(it))) }
-      )
-
-      HorizontalDivider()
-
-      if (!state.loading && state.issues.isEmpty()) {
-        Column(
-          modifier = Modifier
-            .fillMaxWidth()
-            .weight(1f),
-          horizontalAlignment = Alignment.CenterHorizontally,
-          verticalArrangement = Arrangement.Center
-        ) {
-          Text(
-            text = if (state.nameFilter != null) "No issues match this filter." else "No issues recorded.",
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-          )
-        }
-      } else {
-        LazyColumn(
-          modifier = Modifier
-            .fillMaxWidth()
-            .weight(1f)
-        ) {
-          items(state.issues, key = { it.id }) { issue ->
-            IssueRow(
-              issue = issue,
-              expanded = state.expandedIds.contains(issue.id),
-              onClick = { onEvent(InternalIssuesScreenEvent.ToggleExpanded(issue.id)) }
-            )
-            HorizontalDivider()
-          }
-        }
-      }
-    }
-  }
-
-  if (showFilterSheet) {
-    ModalBottomSheet(
-      onDismissRequest = { showFilterSheet = false },
-      sheetState = rememberModalBottomSheetState()
-    ) {
-      SheetTitle("Filter by name")
-      SelectionRow(
-        text = "All",
-        selected = state.nameFilter == null,
-        onClick = {
-          onEvent(InternalIssuesScreenEvent.SetNameFilter(null))
-          showFilterSheet = false
-        }
-      )
-      state.names.forEach { name ->
-        SelectionRow(
-          text = name,
-          selected = state.nameFilter == name,
-          onClick = {
-            onEvent(InternalIssuesScreenEvent.SetNameFilter(name))
-            showFilterSheet = false
-          }
-        )
-      }
-      Spacer(modifier = Modifier.size(16.dp))
-    }
-  }
-
-  if (showSortSheet) {
-    ModalBottomSheet(
-      onDismissRequest = { showSortSheet = false },
-      sheetState = rememberModalBottomSheetState()
-    ) {
-      SheetTitle("Sort by")
-      IssueSortOrder.entries.forEach { order ->
-        SelectionRow(
-          text = order.label,
-          selected = state.sortOrder == order,
-          onClick = {
-            onEvent(InternalIssuesScreenEvent.SetSortOrder(order))
-            showSortSheet = false
-          }
-        )
-      }
-      Spacer(modifier = Modifier.size(16.dp))
-    }
-  }
-
-  if (showClearDialog) {
-    Dialogs.SimpleAlertDialog(
-      title = "Clear all issues?",
-      body = "This will permanently delete all recorded app issues.",
-      confirm = "Clear",
-      dismiss = "Cancel",
-      onConfirm = { onEvent(InternalIssuesScreenEvent.ClearAll) },
-      onDismiss = { showClearDialog = false }
-    )
-  }
-}
-
-@Composable
-private fun SheetTitle(text: String) {
-  Text(
-    text = text,
-    style = MaterialTheme.typography.titleMedium,
-    modifier = Modifier.padding(horizontal = 24.dp, vertical = 12.dp)
-  )
-}
-
-@Composable
-private fun SelectionRow(
-  text: String,
-  selected: Boolean,
-  onClick: () -> Unit
-) {
-  Row(
-    modifier = Modifier
-      .fillMaxWidth()
-      .clickable(onClick = onClick)
-      .padding(horizontal = 24.dp, vertical = 16.dp),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Text(
-      text = text,
-      style = MaterialTheme.typography.bodyLarge,
-      modifier = Modifier.weight(1f)
-    )
-    if (selected) {
-      Icon(
-        painter = SignalIcons.Check.painter,
-        contentDescription = null,
-        tint = MaterialTheme.colorScheme.primary
-      )
-    }
-  }
-}
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-private fun IssueRow(
-  issue: IssueRecord,
-  expanded: Boolean,
-  onClick: () -> Unit
-) {
-  val clipboardManager = LocalClipboardManager.current
-  val context = LocalContext.current
-
-  Column(
-    modifier = Modifier
-      .fillMaxWidth()
-      .combinedClickable(
-        onClick = onClick,
-        onLongClick = {
-          clipboardManager.setText(AnnotatedString(issue.toCopyText()))
-          Toast.makeText(context, "Copied", Toast.LENGTH_SHORT).show()
-        }
-      )
-      .padding(horizontal = 16.dp, vertical = 12.dp)
-  ) {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      Text(
-        text = issue.name,
-        style = MaterialTheme.typography.titleMedium,
-        fontWeight = FontWeight.Bold,
-        modifier = Modifier.weight(1f)
-      )
-      Text(
-        text = issue.priority.label,
-        style = MaterialTheme.typography.labelMedium,
-        color = priorityColor(issue.priority),
-        fontWeight = FontWeight.Bold
-      )
-    }
-
-    Text(
-      text = buildString {
-        append(formatTimestamp(issue.createdAt))
-        append("  •  v")
-        append(issue.version)
-        issue.duration?.let { append("  •  ${it}ms") }
-      },
-      style = MaterialTheme.typography.bodySmall,
-      color = MaterialTheme.colorScheme.onSurfaceVariant
-    )
-
-    Text(
-      text = issue.description,
-      style = MaterialTheme.typography.bodyMedium,
-      maxLines = if (expanded) Int.MAX_VALUE else 2
-    )
-
-    if (expanded && !issue.stackTrace.isNullOrBlank()) {
-      Text(
-        text = issue.stackTrace,
-        style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Monospace),
-        color = MaterialTheme.colorScheme.onSurfaceVariant,
-        modifier = Modifier.padding(top = 4.dp)
-      )
-    }
-  }
-}
-
-private fun IssueRecord.toCopyText(): String {
-  return buildString {
-    append(name)
-    append(" (")
-    append(priority.label)
-    append(")\n")
-    append(formatTimestamp(createdAt))
-    append("  •  v")
-    append(version)
-    duration?.let { append("  •  ${it}ms") }
-    append("\n")
-    append(description)
-    if (!stackTrace.isNullOrBlank()) {
-      append("\n")
-      append(stackTrace)
-    }
-  }
-}
-
-@Composable
-private fun priorityColor(priority: IssuePriority): Color {
-  return when (priority) {
-    IssuePriority.HIGH -> MaterialTheme.colorScheme.error
-    IssuePriority.MEDIUM -> MaterialTheme.colorScheme.tertiary
-    IssuePriority.LOW -> MaterialTheme.colorScheme.onSurfaceVariant
-  }
-}
-
-private fun formatTimestamp(time: Long): String {
-  return SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US).format(Date(time))
-}
-
-@DayNightPreviews
-@Composable
-private fun InternalIssuesScreenPreview() {
-  Previews.Preview {
-    InternalIssuesScreen(
-      state = InternalIssuesState(
-        loading = false,
-        names = listOf("Slow Database Read", "Slow Database Write"),
-        issues = listOf(
-          IssueRecord(1, System.currentTimeMillis(), "7.42.1", "Slow Database Write", "Took 812ms. query=transaction hold", "java.lang.Throwable\n\tat Foo.bar(Foo.java:1)", IssuePriority.HIGH, 812),
-          IssueRecord(2, System.currentTimeMillis(), "7.42.1", "Slow Database Read", "Took 1043ms. query=SELECT * FROM message", null, IssuePriority.LOW, 1043)
-        )
-      )
-    )
-  }
-}
@@ -1,37 +0,0 @@
-/*
- * Copyright 2026 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.settings.app.internal.issues
-
-import org.thoughtcrime.securesms.database.LogDatabase.IssueTable.IssueRecord
-import org.thoughtcrime.securesms.database.model.IssuePriority
-
-data class InternalIssuesState(
-  val loading: Boolean = true,
-  val issues: List<IssueRecord> = emptyList(),
-  val names: List<String> = emptyList(),
-  val nameFilter: String? = null,
-  val sortOrder: IssueSortOrder = IssueSortOrder.CREATED_DESC,
-  val expandedIds: Set<Long> = emptySet(),
-  val notificationPriority: IssuePriority = IssuePriority.HIGH
-)
-
-enum class IssueSortOrder(val label: String) {
-  CREATED_DESC("Newest first"),
-  CREATED_ASC("Oldest first"),
-  DURATION_DESC("Longest duration"),
-  DURATION_ASC("Shortest duration"),
-  PRIORITY_DESC("Highest priority"),
-  PRIORITY_ASC("Lowest priority")
-}
-
-sealed interface InternalIssuesScreenEvent {
-  data object Load : InternalIssuesScreenEvent
-  data object ClearAll : InternalIssuesScreenEvent
-  data class ToggleExpanded(val id: Long) : InternalIssuesScreenEvent
-  data class SetNotificationPriority(val priority: IssuePriority) : InternalIssuesScreenEvent
-  data class SetNameFilter(val name: String?) : InternalIssuesScreenEvent
-  data class SetSortOrder(val order: IssueSortOrder) : InternalIssuesScreenEvent
-}
@@ -1,88 +0,0 @@
-/*
- * Copyright 2026 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.settings.app.internal.issues
-
-import android.app.Application
-import androidx.lifecycle.AndroidViewModel
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.thoughtcrime.securesms.database.LogDatabase
-import org.thoughtcrime.securesms.database.LogDatabase.IssueTable.IssueRecord
-import org.thoughtcrime.securesms.database.model.IssuePriority
-import org.thoughtcrime.securesms.keyvalue.SignalStore
-
-class InternalIssuesViewModel(application: Application) : AndroidViewModel(application) {
-
-  private val _state = MutableStateFlow(InternalIssuesState())
-  val state: StateFlow<InternalIssuesState> = _state.asStateFlow()
-
-  private val issues = LogDatabase.getInstance(application).issues
-
-  private var allIssues: List<IssueRecord> = emptyList()
-
-  fun onEvent(event: InternalIssuesScreenEvent) {
-    when (event) {
-      InternalIssuesScreenEvent.Load -> load()
-      InternalIssuesScreenEvent.ClearAll -> clearAll()
-      is InternalIssuesScreenEvent.ToggleExpanded -> toggleExpanded(event.id)
-      is InternalIssuesScreenEvent.SetNotificationPriority -> setNotificationPriority(event.priority)
-      is InternalIssuesScreenEvent.SetNameFilter -> _state.update { it.copy(nameFilter = event.name).withVisibleIssues() }
-      is InternalIssuesScreenEvent.SetSortOrder -> _state.update { it.copy(sortOrder = event.order).withVisibleIssues() }
-    }
-  }
-
-  private fun load() {
-    viewModelScope.launch {
-      allIssues = withContext(Dispatchers.IO) { issues.getRecent() }
-      _state.update { it.copy(loading = false, notificationPriority = SignalStore.internal.issueNotificationPriority).withVisibleIssues() }
-    }
-  }
-
-  private fun setNotificationPriority(priority: IssuePriority) {
-    SignalStore.internal.issueNotificationPriority = priority
-    _state.update { it.copy(notificationPriority = priority) }
-  }
-
-  private fun clearAll() {
-    viewModelScope.launch {
-      withContext(Dispatchers.IO) { issues.clear() }
-      allIssues = emptyList()
-      _state.update { it.copy(nameFilter = null, expandedIds = emptySet()).withVisibleIssues() }
-    }
-  }
-
-  private fun toggleExpanded(id: Long) {
-    _state.update {
-      val expanded = if (it.expandedIds.contains(id)) it.expandedIds - id else it.expandedIds + id
-      it.copy(expandedIds = expanded)
-    }
-  }
-
-  private fun InternalIssuesState.withVisibleIssues(): InternalIssuesState {
-    val visible = allIssues
-      .filter { nameFilter == null || it.name == nameFilter }
-      .sortedWith(sortOrder.comparator())
-
-    return copy(issues = visible, names = allIssues.map { it.name }.distinct().sorted())
-  }
-
-  private fun IssueSortOrder.comparator(): Comparator<IssueRecord> {
-    return when (this) {
-      IssueSortOrder.CREATED_DESC -> compareByDescending { it.createdAt }
-      IssueSortOrder.CREATED_ASC -> compareBy { it.createdAt }
-      IssueSortOrder.DURATION_DESC -> compareByDescending { it.duration ?: Long.MIN_VALUE }
-      IssueSortOrder.DURATION_ASC -> compareBy { it.duration ?: Long.MAX_VALUE }
-      IssueSortOrder.PRIORITY_DESC -> compareByDescending { it.priority.value }
-      IssueSortOrder.PRIORITY_ASC -> compareBy { it.priority.value }
-    }
-  }
-}
@@ -70,12 +70,6 @@ object InAppPaymentsRepository {
  private const val JOB_PREFIX = "InAppPayments__"
  private val TAG = Log.tag(InAppPaymentsRepository::class.java)

-  /**
-   * Upper bound on how long we'll wait for the donations configuration before surfacing a retryable
-   * failure rather than leaving the user on an indefinite loading spinner (e.g. on a slow VPN).
-   */
-  const val DONATIONS_CONFIGURATION_TIMEOUT_SECONDS = 30L
-
  private val backupExpirationTimeout = 30.days
  private val backupExpirationDeletion = 60.days

@@ -20,7 +20,6 @@ import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import java.util.Currency
 import java.util.Locale
-import java.util.concurrent.TimeUnit

 /**
 * Shared one-time payment methods that apply to both Stripe and PayPal payments.
@@ -78,7 +77,6 @@ object OneTimeInAppPaymentRepository {
  fun getBoosts(): Single<Map<Currency, List<Boost>>> {
    return Single.fromCallable { AppDependencies.donationsService.getDonationsConfiguration(Locale.getDefault()) }
      .subscribeOn(Schedulers.io())
-      .timeout(InAppPaymentsRepository.DONATIONS_CONFIGURATION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
      .flatMap { it.flattenResult() }
      .map { config ->
        config.getBoostAmounts().mapValues { (_, value) ->
@@ -99,7 +97,6 @@ object OneTimeInAppPaymentRepository {
          .getDonationsConfiguration(Locale.getDefault())
      }
      .subscribeOn(Schedulers.io())
-      .timeout(InAppPaymentsRepository.DONATIONS_CONFIGURATION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
      .flatMap { it.flattenResult() }
      .map { it.getBoostBadges().first() }
  }
@@ -110,9 +107,8 @@ object OneTimeInAppPaymentRepository {
   */
  fun getMinimumDonationAmounts(): Single<Map<Currency, FiatMoney>> {
    return Single.fromCallable { AppDependencies.donationsService.getDonationsConfiguration(Locale.getDefault()) }
-      .subscribeOn(Schedulers.io())
-      .timeout(InAppPaymentsRepository.DONATIONS_CONFIGURATION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
      .flatMap { it.flattenResult() }
+      .subscribeOn(Schedulers.io())
      .map { it.getMinimumDonationAmounts() }
  }

@@ -39,7 +39,6 @@ import org.whispersystems.signalservice.internal.ServiceResponse
 import org.whispersystems.signalservice.internal.push.SubscriptionsConfiguration
 import java.math.BigDecimal
 import java.util.Locale
-import java.util.concurrent.TimeUnit
 import kotlin.time.Duration.Companion.milliseconds

 /**
@@ -110,7 +109,6 @@ object RecurringInAppPaymentRepository {
    return Single
      .fromCallable { donationsService.getDonationsConfiguration(Locale.getDefault()) }
      .subscribeOn(Schedulers.io())
-      .timeout(InAppPaymentsRepository.DONATIONS_CONFIGURATION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
      .flatMap { it.flattenResult() }
      .map { config ->
        config.getSubscriptionLevels().map { (level, levelConfig) ->
@@ -18,7 +18,6 @@ import org.signal.core.util.money.PlatformCurrencyUtil
 import org.signal.core.util.orNull
 import org.signal.donations.InAppPaymentType
 import org.thoughtcrime.securesms.badges.Badges
-import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.components.settings.app.subscription.DonationSerializationHelper.toFiatValue
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.OneTimeInAppPaymentRepository
@@ -266,6 +265,15 @@ class DonateToSignalViewModel(
        store.update { it.copy(oneTimeDonationState = it.oneTimeDonationState.copy(pendingOneTimeDonation = pendingOneTimeDonation.orNull())) }
      }

+    oneTimeDonationDisposables += oneTimeInAppPaymentRepository.getBoostBadge().subscribeBy(
+      onSuccess = { badge ->
+        store.update { it.copy(oneTimeDonationState = it.oneTimeDonationState.copy(badge = badge)) }
+      },
+      onError = {
+        Log.w(TAG, "Could not load boost badge", it)
+      }
+    )
+
    oneTimeDonationDisposables += oneTimeInAppPaymentRepository.getMinimumDonationAmounts().subscribeBy(
      onSuccess = { amountMap ->
        store.update { it.copy(oneTimeDonationState = it.oneTimeDonationState.copy(minimumDonationAmounts = amountMap)) }
@@ -275,14 +283,10 @@ class DonateToSignalViewModel(
      }
    )

-    val boostsAndBadge: Observable<Pair<Map<Currency, List<Boost>>, Badge>> = Single.zip(
-      oneTimeInAppPaymentRepository.getBoosts(),
-      oneTimeInAppPaymentRepository.getBoostBadge()
-    ) { boosts, badge -> boosts to badge }.toObservable()
-
+    val boosts: Observable<Map<Currency, List<Boost>>> = oneTimeInAppPaymentRepository.getBoosts().toObservable()
    val oneTimeCurrency: Observable<Currency> = SignalStore.inAppPayments.observableOneTimeCurrency

-    oneTimeDonationDisposables += Observable.combineLatest(boostsAndBadge, oneTimeCurrency) { (boostMap, badge), currency ->
+    oneTimeDonationDisposables += Observable.combineLatest(boosts, oneTimeCurrency) { boostMap, currency ->
      val boostList = if (currency in boostMap) {
        boostMap[currency]!!
      } else {
@@ -290,13 +294,12 @@ class DonateToSignalViewModel(
        listOf()
      }

-      OneTimeConfiguration(boostList, badge, currency, boostMap.keys)
+      Triple(boostList, currency, boostMap.keys)
    }.subscribeBy(
-      onNext = { (boostList, badge, currency, availableCurrencies) ->
+      onNext = { (boostList, currency, availableCurrencies) ->
        store.update { state ->
          state.copy(
            oneTimeDonationState = state.oneTimeDonationState.copy(
-              badge = badge,
              boosts = boostList,
              selectedBoost = null,
              selectedCurrency = currency,
@@ -318,13 +321,6 @@ class DonateToSignalViewModel(
    )
  }

-  private data class OneTimeConfiguration(
-    val boosts: List<Boost>,
-    val badge: Badge,
-    val currency: Currency,
-    val availableCurrencies: Set<Currency>
-  )
-
  private fun initializeMonthlyDonationState(subscriptionsRepository: RecurringInAppPaymentRepository) {
    monitorLevelUpdateProcessing()

@@ -162,18 +162,11 @@ class ManageDonationsViewModel : ViewModel() {
  private fun deriveRedemptionState(status: DonationRedemptionJobStatus, latestPayment: InAppPaymentTable.InAppPayment?): ManageDonationsState.RedemptionState {
    return when (status) {
      DonationRedemptionJobStatus.None -> ManageDonationsState.RedemptionState.NONE
+      DonationRedemptionJobStatus.PendingKeepAlive -> ManageDonationsState.RedemptionState.SUBSCRIPTION_REFRESH
      DonationRedemptionJobStatus.FailedSubscription -> ManageDonationsState.RedemptionState.FAILED

-      DonationRedemptionJobStatus.PendingKeepAlive -> {
-        if (latestPayment.isPendingBankTransfer()) {
-          ManageDonationsState.RedemptionState.IS_PENDING_BANK_TRANSFER
-        } else {
-          ManageDonationsState.RedemptionState.SUBSCRIPTION_REFRESH
-        }
-      }
-
      is DonationRedemptionJobStatus.PendingExternalVerification -> {
-        if (latestPayment.isPendingBankTransfer()) {
+        if (latestPayment != null && (latestPayment.data.paymentMethodType == InAppPaymentData.PaymentMethodType.SEPA_DEBIT || latestPayment.data.paymentMethodType == InAppPaymentData.PaymentMethodType.IDEAL)) {
          ManageDonationsState.RedemptionState.IS_PENDING_BANK_TRANSFER
        } else {
          ManageDonationsState.RedemptionState.IN_PROGRESS
@@ -185,10 +178,6 @@ class ManageDonationsViewModel : ViewModel() {
    }
  }

-  private fun InAppPaymentTable.InAppPayment?.isPendingBankTransfer(): Boolean {
-    return this != null && (data.paymentMethodType == InAppPaymentData.PaymentMethodType.SEPA_DEBIT || data.paymentMethodType == InAppPaymentData.PaymentMethodType.IDEAL)
-  }
-
  private fun InAppPaymentTable.InAppPayment.toPendingOneTimeDonation(): PendingOneTimeDonation? {
    if (type.recurring || data.amount == null || data.badge == null) {
      return null
@@ -26,7 +26,6 @@ import org.thoughtcrime.securesms.components.settings.conversation.preferences.C
 import org.thoughtcrime.securesms.components.settings.conversation.preferences.LegacyGroupPreference
 import org.thoughtcrime.securesms.database.MediaTable
 import org.thoughtcrime.securesms.database.RecipientTable
-import org.thoughtcrime.securesms.database.RxDatabaseObserver
 import org.thoughtcrime.securesms.database.model.StoryViewState
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.groups.GroupId
@@ -80,6 +79,10 @@ sealed class ConversationSettingsViewModel(
      } ?: emptyList()
    }

+    store.update(repository.getCallEvents(callMessageIds).toObservable()) { callRecords, state ->
+      state.copy(calls = callRecords.map { (call, messageRecord) -> CallPreference.Model(call, messageRecord) })
+    }
+
    store.update(sharedMedia) { mediaRecords, state ->
      if (!cleared) {
        state.copy(
@@ -98,17 +101,6 @@ sealed class ConversationSettingsViewModel(
    sharedMediaUpdateTrigger.postValue(Unit)
  }

-  fun observeConversationForCallUpdates(threadId: Long) {
-    disposable += RxDatabaseObserver.conversation(threadId)
-      .toObservable()
-      .switchMapSingle { repository.getCallEvents(callMessageIds) }
-      .subscribe { callRecords ->
-        store.update { state ->
-          state.copy(calls = callRecords.map { (call, messageRecord) -> CallPreference.Model(call, messageRecord) })
-        }
-      }
-  }
-
  fun onReportSpam(): Maybe<Unit> {
    return if (store.state.threadId > 0 && store.state.recipient != Recipient.UNKNOWN) {
      messageRequestRepository.reportSpamMessageRequest(store.state.recipient.id, store.state.threadId)
@@ -226,7 +218,6 @@ sealed class ConversationSettingsViewModel(
        store.update { state ->
          state.copy(threadId = threadId)
        }
-        observeConversationForCallUpdates(threadId)
      }

      if (recipientId != Recipient.self().id) {
@@ -353,7 +344,6 @@ sealed class ConversationSettingsViewModel(
        store.update { state ->
          state.copy(threadId = threadId)
        }
-        observeConversationForCallUpdates(threadId)
      }

      store.update(liveGroup.selfCanEditGroupAttributes()) { selfCanEditGroupAttributes, state ->
@@ -7,12 +7,7 @@ package org.thoughtcrime.securesms.components.settings.conversation

 import androidx.annotation.WorkerThread
 import androidx.compose.runtime.Immutable
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.withStyle
 import org.signal.core.util.Base64
 import org.signal.core.util.Hex
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
@@ -103,18 +98,18 @@ data class InternalConversationSettingsState(
        val capabilities: RecipientRecord.Capabilities? = SignalDatabase.recipients.getCapabilities(recipient.id)
        if (capabilities != null) {
          AnnotatedString("No capabilities right now.")
-          // Always leave one as an example in case we add one in the future
-          val style: SpanStyle = when (capabilities.usernameSyncMessages) {
-            Recipient.Capability.SUPPORTED -> SpanStyle(color = Color(0, 150, 0))
-            Recipient.Capability.NOT_SUPPORTED -> SpanStyle(color = Color.Red)
-            Recipient.Capability.UNKNOWN -> SpanStyle(fontStyle = FontStyle.Italic)
-          }
-
-          buildAnnotatedString {
-            withStyle(style = style) {
-              append("usernameSyncMessages")
-            }
-          }
+          // Left as an example in case we add one in the future
+//          val style: SpanStyle = when (capabilities.storageServiceEncryptionV2) {
+//            Recipient.Capability.SUPPORTED -> SpanStyle(color = Color(0, 150, 0))
+//            Recipient.Capability.NOT_SUPPORTED -> SpanStyle(color = Color.Red)
+//            Recipient.Capability.UNKNOWN -> SpanStyle(fontStyle = FontStyle.Italic)
+//          }
+//
+//          buildAnnotatedString {
+//            withStyle(style = style) {
+//              append("SSREv2")
+//            }
+//          }
        } else {
          AnnotatedString("Recipient not found!")
        }
@@ -7,13 +7,11 @@ import org.thoughtcrime.securesms.database.CallTable
 import org.thoughtcrime.securesms.database.MessageTypes
 import org.thoughtcrime.securesms.database.model.MessageRecord
 import org.thoughtcrime.securesms.databinding.ConversationSettingsCallPreferenceItemBinding
-import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.util.DateUtils
 import org.thoughtcrime.securesms.util.adapter.mapping.BindingFactory
 import org.thoughtcrime.securesms.util.adapter.mapping.BindingViewHolder
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
-import org.thoughtcrime.securesms.util.visible

 /**
 * Renders a single call preference row when displaying call info.
@@ -43,25 +41,6 @@ object CallPreference {
      binding.callIcon.setImageResource(getCallIcon(model.call))
      binding.callType.text = getCallType(model.call)
      binding.callTime.text = getCallTime(model.record)
-      presentTimer(model.record)
-    }
-
-    private fun presentTimer(messageRecord: MessageRecord) {
-      if (messageRecord.expiresIn > 0 && messageRecord.expireStarted > 0) {
-        binding.callTimer.visible = true
-        binding.callTimer.setPercentComplete(0f)
-
-        if (messageRecord.expireStarted > 0) {
-          binding.callTimer.setExpirationTime(messageRecord.expireStarted, messageRecord.expiresIn)
-          binding.callTimer.startAnimation()
-
-          if (messageRecord.expireStarted + messageRecord.expiresIn <= System.currentTimeMillis()) {
-            AppDependencies.expiringMessageManager.checkSchedule()
-          }
-        }
-      } else {
-        binding.callTimer.visible = false
-      }
    }

    @DrawableRes
@@ -105,7 +105,7 @@ object RecipientPreference {
      } else {
        if (recipient.isSystemContact) {
          SpannableStringBuilder(recipient.getDisplayName(context)).apply {
-            val drawable = context.requireDrawable(CoreUiR.drawable.symbol_person_circle_24).apply {
+            val drawable = context.requireDrawable(R.drawable.symbol_person_circle_24).apply {
              setTint(ContextCompat.getColor(context, CoreUiR.color.signal_colorOnSurface))
            }
            SpanUtil.appendCenteredImageSpan(this, drawable, 16, 16)
@@ -5,68 +5,53 @@
 package org.thoughtcrime.securesms.components.transfercontrols

 import android.content.Context
+import android.os.Build
+import android.text.StaticLayout
 import android.util.AttributeSet
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.platform.AbstractComposeView
-import androidx.compose.ui.platform.ViewCompositionStrategy
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.constraintlayout.widget.ConstraintLayout
+import androidx.core.view.children
+import androidx.core.view.updateLayoutParams
 import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
-import org.signal.core.ui.compose.theme.SignalTheme
 import org.signal.core.util.ByteSize
 import org.signal.core.util.ThrottledDebouncer
 import org.signal.core.util.bytes
 import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.attachments.Attachment
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.components.RecyclerViewParentTransitionController
 import org.thoughtcrime.securesms.database.AttachmentTable
+import org.thoughtcrime.securesms.databinding.TransferControlsViewBinding
 import org.thoughtcrime.securesms.events.PartProgressEvent
 import org.thoughtcrime.securesms.mms.Slide
 import org.thoughtcrime.securesms.util.MediaUtil
+import org.thoughtcrime.securesms.util.ViewUtil
+import org.thoughtcrime.securesms.util.visible
 import java.util.UUID
+import kotlin.math.ceil
+import kotlin.math.roundToInt

-/**
- * Displays the start/cancel/progress controls that overlay an attachment thumbnail.
- */
-class TransferControlView @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) : AbstractComposeView(context, attrs, defStyleAttr) {
-
-  companion object {
-    private val TAG = Log.tag(TransferControlView::class.java)
-
-    /** Flip to true locally to trace a single view's render transitions and ignored progress events. */
-    private const val VERBOSE_DEVELOPMENT_LOGGING = false
-  }
+class TransferControlView @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) : ConstraintLayout(context, attrs, defStyleAttr) {
+  private val uuid = UUID.randomUUID().toString()
+  private val binding: TransferControlsViewBinding

  private var state = TransferControlViewState()
+  private val progressUpdateDebouncer: ThrottledDebouncer = ThrottledDebouncer(100)

-  /** Throttled observable flow of [state] */
-  private var renderState by mutableStateOf<TransferControlsRenderState>(TransferControlsRenderState.Gone)
-
-  private val progressUpdateDebouncer = ThrottledDebouncer(100)
-
-  /** Per-instance id so a single recycled view can be isolated in logcat when [VERBOSE_DEVELOPMENT_LOGGING] is on. */
-  private val viewId by lazy { UUID.randomUUID().toString().take(8) }
+  private var mode: Mode = Mode.GONE

  init {
-    setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnDetachedFromWindowOrReleasedFromPool)
+    tag = uuid
+    binding = TransferControlsViewBinding.inflate(LayoutInflater.from(context), this)
+    visibility = GONE
    isLongClickable = false
-    addOnAttachStateChangeListener(RecyclerViewParentTransitionController(child = this))
-  }

-  @Composable
-  override fun Content() {
-    SignalTheme {
-      TransferControls(
-        state = renderState,
-        onStartClick = { state.startTransferClickListener?.onClick(this) },
-        onCancelClick = { state.cancelTransferClickedListener?.onClick(this) },
-        onPlayClick = { state.instantPlaybackClickListener?.onClick(this) }
-      )
-    }
+    addOnAttachStateChangeListener(RecyclerViewParentTransitionController(child = this))
  }

  override fun onAttachedToWindow() {
@@ -79,43 +64,466 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
    EventBus.getDefault().unregister(this)
  }

-  fun isGone(): Boolean {
-    return TransferControls.deriveRenderState(state) is TransferControlsRenderState.Gone
+  private fun updateState(stateFactory: (TransferControlViewState) -> TransferControlViewState) {
+    val newState = stateFactory.invoke(state)
+    val oldMode = deriveMode(state)
+    val newMode = deriveMode(newState)
+    if ((newState != state || oldMode != newMode) && !(oldMode == Mode.GONE && newMode == Mode.GONE)) {
+      progressUpdateDebouncer.publish {
+        applyState(newState)
+      }
+    }
+    state = newState
  }

-  private fun updateState(stateFactory: (TransferControlViewState) -> TransferControlViewState) {
-    val newState = stateFactory(state)
+  fun isGone(): Boolean {
+    return mode == Mode.GONE
+  }

-    val oldRender = TransferControls.deriveRenderState(state)
-    val newRender = TransferControls.deriveRenderState(newState)
-    state = newState
+  private fun applyState(currentState: TransferControlViewState) {
+    val mode = deriveMode(currentState)
+    verboseLog("New state applying, mode = $mode")

-    if (oldRender == newRender) {
-      return
+    children.forEach {
+      it.clearAnimation()
    }

-    verboseLog { "render $oldRender -> $newRender slides=[${slidesAsLogString(newState.slides)}]" }
+    when (mode) {
+      Mode.PENDING_GALLERY -> displayPendingGallery(currentState)
+      Mode.PENDING_GALLERY_CONTAINS_PLAYABLE -> displayPendingGalleryWithPlayable(currentState)
+      Mode.PENDING_SINGLE_ITEM -> displayPendingSingleItem(currentState)
+      Mode.PENDING_VIDEO_PLAYABLE -> displayPendingPlayableVideo(currentState)
+      Mode.DOWNLOADING_GALLERY -> displayDownloadingGallery(currentState)
+      Mode.DOWNLOADING_SINGLE_ITEM -> displayDownloadingSingleItem(currentState)
+      Mode.DOWNLOADING_VIDEO_PLAYABLE -> displayDownloadingPlayableVideo(currentState)
+      Mode.UPLOADING_GALLERY -> displayUploadingGallery(currentState)
+      Mode.UPLOADING_SINGLE_ITEM -> displayUploadingSingleItem(currentState)
+      Mode.RETRY_DOWNLOADING -> displayRetry(currentState, false)
+      Mode.RETRY_UPLOADING -> displayRetry(currentState, true)
+      Mode.GONE -> displayChildrenAsGone()
+    }
+    this.mode = mode
+  }

-    if (oldRender is TransferControlsRenderState.InProgress && oldRender.isProgressOnlyDifference(newRender)) {
-      progressUpdateDebouncer.publish {
-        renderState = newRender
-        visibility = VISIBLE
+  private fun deriveMode(currentState: TransferControlViewState): Mode {
+    if (currentState.slides.isEmpty()) {
+      verboseLog("Setting empty slide deck to GONE")
+      return Mode.GONE
+    }
+
+    if (currentState.slides.all { it.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE }) {
+      verboseLog("Setting slide deck that's finished to GONE\n\t${slidesAsListOfTimestamps(currentState.slides)}")
+      return Mode.GONE
+    }
+
+    if (currentState.isVisible) {
+      if (currentState.slides.size == 1) {
+        val slide = currentState.slides.first()
+        if (slide.hasVideo()) {
+          if (currentState.isUpload) {
+            return when (slide.transferState) {
+              AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
+                Mode.UPLOADING_SINGLE_ITEM
+              }
+
+              AttachmentTable.TRANSFER_PROGRESS_PENDING -> {
+                Mode.PENDING_SINGLE_ITEM
+              }
+
+              else -> {
+                Mode.RETRY_UPLOADING
+              }
+            }
+          } else {
+            return when (slide.transferState) {
+              AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
+                if (currentState.playableWhileDownloading) {
+                  Mode.DOWNLOADING_VIDEO_PLAYABLE
+                } else {
+                  Mode.DOWNLOADING_SINGLE_ITEM
+                }
+              }
+
+              AttachmentTable.TRANSFER_PROGRESS_FAILED -> {
+                Mode.RETRY_DOWNLOADING
+              }
+
+              else -> {
+                if (currentState.playableWhileDownloading) {
+                  Mode.PENDING_VIDEO_PLAYABLE
+                } else {
+                  Mode.PENDING_SINGLE_ITEM
+                }
+              }
+            }
+          }
+        } else {
+          return if (currentState.isUpload) {
+            when (slide.transferState) {
+              AttachmentTable.TRANSFER_PROGRESS_FAILED -> {
+                Mode.RETRY_UPLOADING
+              }
+
+              AttachmentTable.TRANSFER_PROGRESS_PENDING -> {
+                Mode.PENDING_SINGLE_ITEM
+              }
+
+              else -> {
+                Mode.UPLOADING_SINGLE_ITEM
+              }
+            }
+          } else {
+            return when (slide.transferState) {
+              AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
+                Mode.DOWNLOADING_SINGLE_ITEM
+              }
+
+              AttachmentTable.TRANSFER_PROGRESS_FAILED -> {
+                Mode.RETRY_DOWNLOADING
+              }
+
+              else -> {
+                Mode.PENDING_SINGLE_ITEM
+              }
+            }
+          }
+        }
+      } else {
+        when (getTransferState(currentState.slides)) {
+          AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
+            return if (currentState.isUpload) {
+              Mode.UPLOADING_GALLERY
+            } else {
+              Mode.DOWNLOADING_GALLERY
+            }
+          }
+
+          AttachmentTable.TRANSFER_PROGRESS_PENDING -> {
+            return if (containsPlayableSlides(currentState.slides)) {
+              Mode.PENDING_GALLERY_CONTAINS_PLAYABLE
+            } else {
+              Mode.PENDING_GALLERY
+            }
+          }
+
+          AttachmentTable.TRANSFER_PROGRESS_FAILED -> {
+            return if (currentState.isUpload) {
+              Mode.RETRY_UPLOADING
+            } else {
+              Mode.RETRY_DOWNLOADING
+            }
+          }
+
+          AttachmentTable.TRANSFER_PROGRESS_DONE -> {
+            verboseLog("[Case 2] Setting slide deck that's finished to GONE\t${slidesAsListOfTimestamps(currentState.slides)}")
+            return Mode.GONE
+          }
+        }
      }
    } else {
-      progressUpdateDebouncer.clear()
-      renderState = newRender
-      if (newRender !is TransferControlsRenderState.Gone) {
-        visibility = VISIBLE
+      verboseLog("Setting slide deck to GONE because isVisible is false:\t${slidesAsListOfTimestamps(currentState.slides)}")
+      return Mode.GONE
+    }
+
+    Log.i(TAG, "[$uuid] Hit default mode case, this should not happen.")
+    return Mode.GONE
+  }
+
+  private fun displayPendingGallery(currentState: TransferControlViewState) {
+    binding.primaryProgressView.startClickListener = currentState.startTransferClickListener
+    applyFocusableAndClickable(
+      currentState,
+      listOf(binding.primaryProgressView, binding.primaryDetailsText, binding.primaryBackground),
+      listOf(binding.secondaryProgressView, binding.playVideoButton)
+    )
+    binding.primaryProgressView.setStopped(false)
+    showAllViews(
+      playVideoButton = false,
+      secondaryProgressView = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    binding.primaryDetailsText.setOnClickListener(currentState.startTransferClickListener)
+    binding.primaryBackground.setOnClickListener(currentState.startTransferClickListener)
+
+    binding.primaryDetailsText.translationX = if (ViewUtil.isLtr(this)) {
+      ViewUtil.dpToPx(-PRIMARY_TEXT_OFFSET_DP).toFloat()
+    } else {
+      ViewUtil.dpToPx(PRIMARY_TEXT_OFFSET_DP).toFloat()
+    }
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayPendingGalleryWithPlayable(currentState: TransferControlViewState) {
+    binding.secondaryProgressView.startClickListener = currentState.startTransferClickListener
+    binding.secondaryDetailsText.setOnClickListener(currentState.startTransferClickListener)
+    binding.secondaryBackground.setOnClickListener(currentState.startTransferClickListener)
+    super.setClickable(false)
+    binding.secondaryProgressView.isClickable = currentState.showSecondaryText
+    binding.secondaryProgressView.isFocusable = currentState.showSecondaryText
+    binding.secondaryDetailsText.isClickable = currentState.showSecondaryText
+    binding.secondaryDetailsText.isFocusable = currentState.showSecondaryText
+    binding.secondaryBackground.isClickable = currentState.showSecondaryText
+    binding.secondaryBackground.isFocusable = currentState.showSecondaryText
+    binding.primaryProgressView.isClickable = false
+    binding.primaryProgressView.isFocusable = false
+    showAllViews(
+      playVideoButton = false,
+      primaryProgressView = false,
+      primaryDetailsText = false,
+      secondaryProgressView = currentState.showSecondaryText,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    binding.secondaryProgressView.setStopped(false)
+    setSecondaryDetailsText(currentState)
+    binding.secondaryDetailsText.translationX = if (ViewUtil.isLtr(this)) {
+      ViewUtil.dpToPx(-SECONDARY_TEXT_OFFSET_DP).toFloat()
+    } else {
+      ViewUtil.dpToPx(SECONDARY_TEXT_OFFSET_DP).toFloat()
+    }
+  }
+
+  private fun displayPendingSingleItem(currentState: TransferControlViewState) {
+    binding.primaryProgressView.startClickListener = currentState.startTransferClickListener
+    applyFocusableAndClickable(currentState, listOf(binding.primaryProgressView), listOf(binding.secondaryProgressView, binding.playVideoButton))
+    binding.primaryProgressView.setStopped(false)
+    showAllViews(
+      playVideoButton = false,
+      primaryDetailsText = false,
+      secondaryProgressView = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayPendingPlayableVideo(currentState: TransferControlViewState) {
+    binding.secondaryProgressView.startClickListener = currentState.startTransferClickListener
+    binding.secondaryDetailsText.setOnClickListener(currentState.startTransferClickListener)
+    binding.secondaryBackground.setOnClickListener(currentState.startTransferClickListener)
+    binding.playVideoButton.setOnClickListener(currentState.instantPlaybackClickListener)
+    applyFocusableAndClickable(
+      currentState,
+      listOf(binding.secondaryProgressView, binding.secondaryDetailsText, binding.secondaryBackground, binding.playVideoButton),
+      listOf(binding.primaryProgressView)
+    )
+    binding.secondaryProgressView.setStopped(false)
+    showAllViews(
+      primaryProgressView = false,
+      primaryDetailsText = false,
+      secondaryDetailsText = currentState.showSecondaryText,
+      secondaryProgressView = currentState.showSecondaryText
+    )
+    setSecondaryDetailsText(currentState)
+    binding.secondaryDetailsText.translationX = if (ViewUtil.isLtr(this)) {
+      ViewUtil.dpToPx(-SECONDARY_TEXT_OFFSET_DP).toFloat()
+    } else {
+      ViewUtil.dpToPx(SECONDARY_TEXT_OFFSET_DP).toFloat()
+    }
+  }
+
+  private fun displayDownloadingGallery(currentState: TransferControlViewState) {
+    applyFocusableAndClickable(currentState, listOf(binding.secondaryProgressView), listOf(binding.primaryProgressView, binding.playVideoButton))
+    showAllViews(
+      playVideoButton = false,
+      primaryProgressView = false,
+      primaryDetailsText = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    val progress = calculateProgress(currentState)
+    if (progress == 0f) {
+      binding.secondaryProgressView.setProgress(progress)
+    } else {
+      binding.secondaryProgressView.cancelClickListener = currentState.cancelTransferClickedListener
+      binding.secondaryProgressView.setProgress(progress)
+    }
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayDownloadingSingleItem(currentState: TransferControlViewState) {
+    binding.primaryProgressView.cancelClickListener = currentState.cancelTransferClickedListener
+    applyFocusableAndClickable(currentState, listOf(binding.primaryProgressView), listOf(binding.secondaryProgressView, binding.playVideoButton))
+    showAllViews(
+      playVideoButton = false,
+      primaryDetailsText = false,
+      secondaryProgressView = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    val progress = calculateProgress(currentState)
+    if (progress == 0f) {
+      binding.primaryProgressView.setProgress(progress)
+    } else {
+      binding.primaryProgressView.setProgress(progress)
+    }
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayDownloadingPlayableVideo(currentState: TransferControlViewState) {
+    binding.secondaryProgressView.cancelClickListener = currentState.cancelTransferClickedListener
+    applyFocusableAndClickable(currentState, listOf(binding.secondaryProgressView, binding.playVideoButton), listOf(binding.primaryProgressView))
+    showAllViews(
+      primaryDetailsText = false,
+      secondaryProgressView = currentState.showSecondaryText,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    binding.playVideoButton.setOnClickListener(currentState.instantPlaybackClickListener)
+
+    val progress = calculateProgress(currentState)
+    if (progress == 0f) {
+      binding.secondaryProgressView.setProgress(progress)
+    } else {
+      binding.secondaryProgressView.setProgress(progress)
+    }
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayUploadingSingleItem(currentState: TransferControlViewState) {
+    binding.secondaryProgressView.cancelClickListener = currentState.cancelTransferClickedListener
+    applyFocusableAndClickable(currentState, listOf(binding.secondaryProgressView), listOf(binding.primaryProgressView, binding.playVideoButton))
+    showAllViews(
+      playVideoButton = false,
+      primaryProgressView = false,
+      primaryDetailsText = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+
+    val progress = calculateProgress(currentState)
+    binding.secondaryProgressView.setProgress(progress)
+
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayUploadingGallery(currentState: TransferControlViewState) {
+    binding.secondaryProgressView.cancelClickListener = currentState.cancelTransferClickedListener
+    applyFocusableAndClickable(currentState, listOf(binding.secondaryProgressView), listOf(binding.primaryProgressView, binding.playVideoButton))
+    showAllViews(
+      playVideoButton = false,
+      primaryProgressView = false,
+      primaryDetailsText = false
+    )
+
+    val progress = calculateProgress(currentState)
+    binding.secondaryProgressView.setProgress(progress)
+
+    binding.secondaryDetailsText.translationX = 0f
+    setSecondaryDetailsText(currentState)
+  }
+
+  private fun displayRetry(currentState: TransferControlViewState, isUploading: Boolean) {
+    if (currentState.startTransferClickListener == null) {
+      Log.w(TAG, "No click listener set for retry!")
+    }
+
+    binding.secondaryProgressView.startClickListener = currentState.startTransferClickListener
+    applyFocusableAndClickable(
+      currentState,
+      listOf(binding.secondaryProgressView, binding.secondaryDetailsText, binding.secondaryBackground),
+      listOf(binding.primaryProgressView, binding.playVideoButton)
+    )
+    showAllViews(
+      playVideoButton = false,
+      primaryProgressView = false,
+      primaryDetailsText = false,
+      secondaryDetailsText = currentState.showSecondaryText
+    )
+    binding.secondaryBackground.setOnClickListener(currentState.startTransferClickListener)
+    binding.secondaryDetailsText.setOnClickListener(currentState.startTransferClickListener)
+    binding.secondaryProgressView.setStopped(isUploading)
+    setSecondaryDetailsText(currentState)
+    binding.secondaryDetailsText.translationX = if (ViewUtil.isLtr(this)) {
+      ViewUtil.dpToPx(-RETRY_SECONDARY_TEXT_OFFSET_DP).toFloat()
+    } else {
+      ViewUtil.dpToPx(RETRY_SECONDARY_TEXT_OFFSET_DP).toFloat()
+    }
+  }
+
+  private fun displayChildrenAsGone() {
+    children.forEach {
+      if (it.visible && it.animation == null) {
+        ViewUtil.fadeOut(it, 250)
      }
    }
  }

+  /**
+   * Shows all views by defaults, but allows individual views to be overridden to not be shown.
+   *
+   * @param root
+   * @param playVideoButton
+   * @param primaryProgressView
+   * @param primaryDetailsText
+   * @param secondaryProgressView
+   * @param secondaryDetailsText
+   */
+  private fun showAllViews(
+    root: Boolean = true,
+    playVideoButton: Boolean = true,
+    primaryProgressView: Boolean = true,
+    primaryDetailsText: Boolean = true,
+    secondaryProgressView: Boolean = true,
+    secondaryDetailsText: Boolean = true
+  ) {
+    this.visible = root
+    binding.playVideoButton.visible = playVideoButton
+    binding.primaryProgressView.visibility = if (primaryProgressView) View.VISIBLE else View.INVISIBLE
+    binding.primaryDetailsText.visible = primaryDetailsText
+    binding.primaryBackground.visible = primaryProgressView || primaryDetailsText || playVideoButton
+    binding.secondaryProgressView.visible = secondaryProgressView
+    binding.secondaryDetailsText.visible = secondaryDetailsText
+    binding.secondaryBackground.visible = secondaryProgressView || secondaryDetailsText
+    val textPadding = if (secondaryProgressView) {
+      context.resources.getDimensionPixelSize(R.dimen.transfer_control_view_progressbar_to_textview_margin)
+    } else {
+      context.resources.getDimensionPixelSize(R.dimen.transfer_control_view_parent_to_textview_margin)
+    }
+    ViewUtil.setPaddingStart(binding.secondaryDetailsText, textPadding)
+    if (ViewUtil.isLtr(binding.secondaryDetailsText)) {
+      (binding.secondaryDetailsText.layoutParams as MarginLayoutParams).leftMargin = textPadding
+    } else {
+      (binding.secondaryDetailsText.layoutParams as MarginLayoutParams).rightMargin = textPadding
+    }
+  }
+
+  private fun applyFocusableAndClickable(currentState: TransferControlViewState, activeViews: List<View>, inactiveViews: List<View>) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val focusIntDef = if (currentState.isFocusable) View.FOCUSABLE else View.NOT_FOCUSABLE
+      activeViews.forEach { it.focusable = focusIntDef }
+      inactiveViews.forEach { it.focusable = View.NOT_FOCUSABLE }
+    }
+    activeViews.forEach { it.isClickable = currentState.isClickable }
+    inactiveViews.forEach {
+      it.setOnClickListener(null)
+      it.isClickable = false
+    }
+  }
+
+  override fun setFocusable(focusable: Boolean) {
+    super.setFocusable(false)
+    verboseLog("setFocusable update: $focusable")
+    updateState { it.copy(isFocusable = focusable) }
+  }
+
+  override fun setClickable(clickable: Boolean) {
+    super.setClickable(false)
+    verboseLog("setClickable update: $clickable")
+    updateState { it.copy(isClickable = clickable) }
+  }
+
  @Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
  fun onEventAsync(event: PartProgressEvent) {
    val attachment = event.attachment
    updateState {
+      verboseLog("onEventAsync update")
      if (!it.networkProgress.containsKey(attachment)) {
-        verboseLog { "Ignoring progress event for an attachment not in this view's slide set (likely a recycled view). ts=${attachment.uploadTimestamp}" }
+        verboseLog("onEventAsync update ignored")
        return@updateState it
      }

@@ -128,6 +536,7 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
        } else if (updateEvent.completed < 0.bytes) {
          mutableMap.remove(attachment)
        }
+        verboseLog("onEventAsync compression update")
        return@updateState it.copy(compressionProgress = mutableMap.toMap())
      } else {
        val mutableMap = it.networkProgress.toMutableMap()
@@ -138,14 +547,16 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
        } else if (updateEvent.completed < 0.bytes) {
          mutableMap.remove(attachment)
        }
+        verboseLog("onEventAsync network update")
        return@updateState it.copy(networkProgress = mutableMap.toMap())
      }
    }
  }

  fun setSlides(slides: List<Slide>) {
-    require(slides.isNotEmpty()) { "Must provide at least one slide." }
+    require(slides.isNotEmpty()) { "[$uuid] Must provide at least one slide." }
    updateState { state ->
+      verboseLog("State update for new slides: ${slidesAsListOfTimestamps(slides)}")
      val isNewSlideSet = !isUpdateToExistingSet(state, slides)
      val networkProgress: MutableMap<Attachment, Progress> = if (isNewSlideSet) HashMap() else state.networkProgress.toMutableMap()
      if (isNewSlideSet) {
@@ -166,14 +577,25 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
        (it.asAttachment() as? DatabaseAttachment)?.hasData == true
      }

-      state.copy(
+      val result = state.copy(
        slides = slides,
        networkProgress = networkProgress,
        compressionProgress = compressionProgress,
        playableWhileDownloading = playableWhileDownloading,
        isUpload = isUpload
      )
+      verboseLog("New state calculated and being returned for new slides: ${slidesAsListOfTimestamps(slides)}\n$result")
+      return@updateState result
    }
+    verboseLog("End of setSlides() for ${slidesAsListOfTimestamps(slides)}")
+  }
+
+  private fun slidesAsListOfTimestamps(slides: List<Slide>): String {
+    if (!VERBOSE_DEVELOPMENT_LOGGING) {
+      return ""
+    }
+
+    return slides.map { it.asAttachment().uploadTimestamp }.joinToString()
  }

  private fun isUpdateToExistingSet(currentState: TransferControlViewState, slides: List<Slide>): Boolean {
@@ -189,52 +611,171 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
  }

  fun setTransferClickListener(listener: OnClickListener) {
-    updateState { it.copy(startTransferClickListener = listener) }
+    verboseLog("transferClickListener update")
+    updateState {
+      it.copy(
+        startTransferClickListener = listener
+      )
+    }
  }

  fun setCancelClickListener(listener: OnClickListener) {
-    updateState { it.copy(cancelTransferClickedListener = listener) }
+    verboseLog("cancelClickListener update")
+    updateState {
+      it.copy(
+        cancelTransferClickedListener = listener
+      )
+    }
  }

  fun setInstantPlaybackClickListener(listener: OnClickListener) {
-    updateState { it.copy(instantPlaybackClickListener = listener) }
+    verboseLog("instantPlaybackClickListener update")
+    updateState {
+      it.copy(
+        instantPlaybackClickListener = listener
+      )
+    }
  }

  fun clear() {
+    clearAnimation()
    visibility = GONE
    updateState { TransferControlViewState() }
  }

  fun setShowSecondaryText(showSecondaryText: Boolean) {
-    updateState { it.copy(showSecondaryText = showSecondaryText) }
-  }
-
-  fun setVisible(isVisible: Boolean) {
-    updateState { it.copy(isVisible = isVisible) }
-  }
-
-  fun setAwaitingPrimaryResponse(awaiting: Boolean) {
-    updateState { it.copy(awaitingPrimaryResponse = awaiting) }
-  }
-
-  override fun setFocusable(focusable: Boolean) {
-    super.setFocusable(false)
-    updateState { it.copy(isFocusable = focusable) }
-  }
-
-  override fun setClickable(clickable: Boolean) {
-    super.setClickable(false)
-    updateState { it.copy(isClickable = clickable) }
-  }
-
-  private inline fun verboseLog(message: () -> String) {
-    if (VERBOSE_DEVELOPMENT_LOGGING) {
-      Log.d(TAG, "[$viewId] ${message()}")
+    verboseLog("showSecondaryText update: $showSecondaryText")
+    updateState {
+      it.copy(
+        showSecondaryText = showSecondaryText
+      )
    }
  }

-  private fun slidesAsLogString(slides: List<Slide>): String {
-    return slides.joinToString { "ts=${it.asAttachment().uploadTimestamp},xfer=${it.transferState}" }
+  fun setVisible(isVisible: Boolean) {
+    verboseLog("showSecondaryText update: $isVisible")
+    updateState {
+      it.copy(
+        isVisible = isVisible
+      )
+    }
+  }
+
+  private fun isCompressing(state: TransferControlViewState): Boolean {
+    val total = state.compressionProgress.sumTotal()
+    return total > 0.bytes && state.compressionProgress.sumCompleted().percentageOf(total) < 0.99f
+  }
+
+  private fun calculateProgress(state: TransferControlViewState): Float {
+    val totalCompressionProgress: Float = state.compressionProgress.values.map { it.completed.percentageOf(it.total) }.sum()
+    val totalDownloadProgress: Float = state.networkProgress.values.map { it.completed.percentageOf(it.total) }.sum()
+    val weightedProgress = UPLOAD_TASK_WEIGHT * totalDownloadProgress + COMPRESSION_TASK_WEIGHT * totalCompressionProgress
+    val weightedTotal = (UPLOAD_TASK_WEIGHT * state.networkProgress.size + COMPRESSION_TASK_WEIGHT * state.compressionProgress.size).toFloat()
+    return weightedProgress / weightedTotal
+  }
+
+  private fun setSecondaryDetailsText(currentState: TransferControlViewState) {
+    when (deriveMode(currentState)) {
+      Mode.PENDING_GALLERY -> {
+        binding.secondaryDetailsText.updateLayoutParams {
+          width = ViewGroup.LayoutParams.WRAP_CONTENT
+        }
+        val remainingSlides = currentState.slides.filterNot { it.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE }
+        val downloadCount = remainingSlides.size
+        binding.primaryDetailsText.text = context.resources.getQuantityString(R.plurals.TransferControlView_n_items, downloadCount, downloadCount)
+        val size = currentState.networkProgress.sumTotal() - currentState.networkProgress.sumCompleted()
+        binding.secondaryDetailsText.text = size.toUnitString()
+      }
+
+      Mode.PENDING_GALLERY_CONTAINS_PLAYABLE -> {
+        binding.secondaryDetailsText.updateLayoutParams {
+          width = ViewGroup.LayoutParams.WRAP_CONTENT
+        }
+        val size = currentState.networkProgress.sumTotal() - currentState.networkProgress.sumCompleted()
+        binding.secondaryDetailsText.text = size.toUnitString()
+      }
+
+      Mode.PENDING_SINGLE_ITEM, Mode.PENDING_VIDEO_PLAYABLE -> {
+        binding.secondaryDetailsText.updateLayoutParams {
+          width = ViewGroup.LayoutParams.WRAP_CONTENT
+        }
+        val size: ByteSize = (currentState.slides.sumOf { it.asAttachment().size }).bytes
+        binding.secondaryDetailsText.text = size.toUnitString()
+      }
+
+      Mode.DOWNLOADING_GALLERY, Mode.DOWNLOADING_SINGLE_ITEM, Mode.DOWNLOADING_VIDEO_PLAYABLE, Mode.UPLOADING_GALLERY, Mode.UPLOADING_SINGLE_ITEM -> {
+        if (currentState.isUpload && (currentState.networkProgress.sumCompleted() == 0.bytes || isCompressing(currentState))) {
+          binding.secondaryDetailsText.updateLayoutParams {
+            width = ViewGroup.LayoutParams.WRAP_CONTENT
+          }
+          binding.secondaryDetailsText.text = context.getString(R.string.TransferControlView__processing)
+        } else {
+          val progressMiB = currentState.networkProgress.sumCompleted().toUnitString()
+          val totalMiB = currentState.networkProgress.sumTotal().toUnitString()
+          val completedLabel = context.resources.getString(R.string.TransferControlView__download_progress_s_s, totalMiB, totalMiB)
+          val desiredWidth = StaticLayout.getDesiredWidth(completedLabel, binding.secondaryDetailsText.paint)
+          binding.secondaryDetailsText.text = context.resources.getString(R.string.TransferControlView__download_progress_s_s, progressMiB, totalMiB)
+          val roundedWidth = ceil(desiredWidth.toDouble()).roundToInt() + binding.secondaryDetailsText.compoundPaddingLeft + binding.secondaryDetailsText.compoundPaddingRight
+          binding.secondaryDetailsText.updateLayoutParams {
+            width = roundedWidth
+          }
+        }
+      }
+
+      Mode.RETRY_DOWNLOADING, Mode.RETRY_UPLOADING -> {
+        binding.secondaryDetailsText.text = resources.getString(R.string.NetworkFailure__retry)
+        binding.secondaryDetailsText.updateLayoutParams {
+          width = ViewGroup.LayoutParams.WRAP_CONTENT
+        }
+      }
+
+      Mode.GONE -> Unit
+    }
+  }
+
+  /**
+   * This is an extremely chatty logging mode for local development. Each view is assigned a UUID so that you can filter by view inside a conversation.
+   */
+  private fun verboseLog(message: String) {
+    if (VERBOSE_DEVELOPMENT_LOGGING) {
+      Log.d(TAG, "[$uuid] $message")
+    }
+  }
+
+  companion object {
+    private const val TAG = "TransferControlView"
+    private const val VERBOSE_DEVELOPMENT_LOGGING = false
+    private const val UPLOAD_TASK_WEIGHT = 1
+    private const val SECONDARY_TEXT_OFFSET_DP = 6
+    private const val RETRY_SECONDARY_TEXT_OFFSET_DP = 6
+    private const val PRIMARY_TEXT_OFFSET_DP = 4
+
+    /**
+     * A weighting compared to [UPLOAD_TASK_WEIGHT]
+     */
+    private const val COMPRESSION_TASK_WEIGHT = 3
+
+    @JvmStatic
+    fun getTransferState(slides: List<Slide>): Int {
+      var transferState = AttachmentTable.TRANSFER_PROGRESS_DONE
+      var allFailed = true
+      for (slide in slides) {
+        if (slide.transferState != AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE) {
+          allFailed = false
+          transferState = if (slide.transferState == AttachmentTable.TRANSFER_PROGRESS_PENDING && transferState == AttachmentTable.TRANSFER_PROGRESS_DONE) {
+            slide.transferState
+          } else {
+            transferState.coerceAtLeast(slide.transferState)
+          }
+        }
+      }
+      return if (allFailed) AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE else transferState
+    }
+
+    @JvmStatic
+    fun containsPlayableSlides(slides: List<Slide>): Boolean {
+      return slides.any { MediaUtil.isInstantVideoSupported(it) }
+    }
  }

  data class Progress(val completed: ByteSize, val total: ByteSize) {
@@ -244,4 +785,27 @@ class TransferControlView @JvmOverloads constructor(context: Context, attrs: Att
      }
    }
  }
+
+  private fun Map<Attachment, Progress>.sumCompleted(): ByteSize {
+    return this.values.sumOf { it.completed.inWholeBytes }.bytes
+  }
+
+  private fun Map<Attachment, Progress>.sumTotal(): ByteSize {
+    return this.values.sumOf { it.total.inWholeBytes }.bytes
+  }
+
+  enum class Mode {
+    PENDING_GALLERY,
+    PENDING_GALLERY_CONTAINS_PLAYABLE,
+    PENDING_SINGLE_ITEM,
+    PENDING_VIDEO_PLAYABLE,
+    DOWNLOADING_GALLERY,
+    DOWNLOADING_SINGLE_ITEM,
+    DOWNLOADING_VIDEO_PLAYABLE,
+    UPLOADING_GALLERY,
+    UPLOADING_SINGLE_ITEM,
+    RETRY_DOWNLOADING,
+    RETRY_UPLOADING,
+    GONE
+  }
 }
@@ -21,6 +21,5 @@ data class TransferControlViewState(
  val networkProgress: Map<Attachment, TransferControlView.Progress> = HashMap(),
  val compressionProgress: Map<Attachment, TransferControlView.Progress> = HashMap(),
  val playableWhileDownloading: Boolean = false,
-  val isUpload: Boolean = false,
-  val awaitingPrimaryResponse: Boolean = false
+  val isUpload: Boolean = false
 )
@@ -1,331 +0,0 @@
-/*
- * Copyright 2025 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.transfercontrols
-
-import org.signal.core.util.ByteSize
-import org.signal.core.util.bytes
-import org.thoughtcrime.securesms.attachments.Attachment
-import org.thoughtcrime.securesms.database.AttachmentTable
-import org.thoughtcrime.securesms.mms.Slide
-import org.thoughtcrime.securesms.util.MediaUtil
-
-/**
- * Pure, Android-View-free logic for the transfer controls UI.
- *
- * [deriveRenderState] maps a [TransferControlViewState] to a [TransferControlsRenderState], which is a small, fully-resolved
- * description of what should be drawn. It carries semantic data (counts, byte sizes) rather than formatted strings so that it
- * can be unit tested on the JVM; string formatting happens in the composable.
- */
-object TransferControls {
-
-  /**
-   * Where the active transfer control (start button / progress indicator) is positioned.
-   *
-   * [CENTER] is the large, centered control used for single-item downloads.
-   * [CORNER] is the small control tucked in the corner, used for galleries, playable video, all uploads, and retries.
-   */
-  enum class Placement {
-    CENTER,
-    CORNER
-  }
-
-  sealed interface ProgressLabel {
-    /** Attachment processing taking place, like transcoding */
-    data object Processing : ProgressLabel
-
-    /** Uploading/downloading progress */
-    data class Bytes(val completed: ByteSize, val total: ByteSize) : ProgressLabel
-  }
-
-  fun deriveRenderState(state: TransferControlViewState): TransferControlsRenderState {
-    if (state.slides.isEmpty()) {
-      return TransferControlsRenderState.Gone
-    }
-
-    if (state.slides.all { it.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE }) {
-      return TransferControlsRenderState.Gone
-    }
-
-    if (!state.isVisible) {
-      return TransferControlsRenderState.Gone
-    }
-
-    if (state.awaitingPrimaryResponse) {
-      return TransferControlsRenderState.InProgress(
-        isUpload = false,
-        placement = if (state.slides.size == 1) Placement.CENTER else Placement.CORNER,
-        progress = null,
-        showPlayButton = false,
-        cancelable = false,
-        label = null
-      )
-    }
-
-    return when (deriveMode(state)) {
-      Mode.PENDING_GALLERY -> TransferControlsRenderState.Pending(
-        isUpload = state.isUpload,
-        placement = Placement.CENTER,
-        showPlayButton = false,
-        itemCount = state.slides.count { it.transferState != AttachmentTable.TRANSFER_PROGRESS_DONE },
-        sizeBytes = if (state.showSecondaryText) state.networkProgress.sumTotal() - state.networkProgress.sumCompleted() else null
-      )
-
-      Mode.PENDING_GALLERY_CONTAINS_PLAYABLE -> TransferControlsRenderState.Pending(
-        isUpload = state.isUpload,
-        placement = Placement.CORNER,
-        showPlayButton = false,
-        sizeBytes = if (state.showSecondaryText) state.networkProgress.sumTotal() - state.networkProgress.sumCompleted() else null
-      )
-
-      Mode.PENDING_SINGLE_ITEM -> TransferControlsRenderState.Pending(
-        isUpload = state.isUpload,
-        placement = Placement.CENTER,
-        showPlayButton = false,
-        sizeBytes = if (state.showSecondaryText) state.slides.sumOf { it.asAttachment().size }.bytes else null
-      )
-
-      Mode.PENDING_VIDEO_PLAYABLE -> TransferControlsRenderState.Pending(
-        isUpload = state.isUpload,
-        placement = Placement.CORNER,
-        showPlayButton = true,
-        sizeBytes = if (state.showSecondaryText) state.slides.sumOf { it.asAttachment().size }.bytes else null
-      )
-
-      Mode.DOWNLOADING_GALLERY -> TransferControlsRenderState.InProgress(
-        isUpload = false,
-        placement = Placement.CORNER,
-        progress = calculateProgress(state),
-        showPlayButton = false,
-        cancelable = calculateProgress(state) != 0f,
-        label = progressLabel(state)
-      )
-
-      Mode.DOWNLOADING_SINGLE_ITEM -> TransferControlsRenderState.InProgress(
-        isUpload = false,
-        placement = Placement.CENTER,
-        progress = calculateProgress(state),
-        showPlayButton = false,
-        cancelable = true,
-        label = progressLabel(state)
-      )
-
-      Mode.DOWNLOADING_VIDEO_PLAYABLE -> TransferControlsRenderState.InProgress(
-        isUpload = false,
-        placement = Placement.CORNER,
-        progress = calculateProgress(state),
-        showPlayButton = true,
-        cancelable = true,
-        label = progressLabel(state)
-      )
-
-      Mode.UPLOADING_SINGLE_ITEM -> TransferControlsRenderState.InProgress(
-        isUpload = true,
-        placement = Placement.CORNER,
-        progress = calculateProgress(state),
-        showPlayButton = false,
-        cancelable = true,
-        label = progressLabel(state)
-      )
-
-      Mode.UPLOADING_GALLERY -> TransferControlsRenderState.InProgress(
-        isUpload = true,
-        placement = Placement.CORNER,
-        progress = calculateProgress(state),
-        showPlayButton = false,
-        cancelable = true,
-        // Note: the legacy view always showed this label for uploading galleries, regardless of showSecondaryText.
-        label = progressLabel(state)
-      )
-
-      Mode.RETRY_DOWNLOADING -> TransferControlsRenderState.Retry(isUpload = false)
-      Mode.RETRY_UPLOADING -> TransferControlsRenderState.Retry(isUpload = true)
-      Mode.GONE -> TransferControlsRenderState.Gone
-    }
-  }
-
-  private fun progressLabel(state: TransferControlViewState): ProgressLabel {
-    return if (state.isUpload && (state.networkProgress.sumCompleted() == 0L.bytes || isCompressing(state))) {
-      ProgressLabel.Processing
-    } else if (state.isUpload) {
-      ProgressLabel.Bytes(state.networkProgress.sumCompleted(), state.networkProgress.sumTotal())
-    } else {
-      val total = state.slides.sumOf { it.fileSize }.bytes
-      val completed = state.networkProgress.sumCompleted().let { if (it > total) total else it }
-      ProgressLabel.Bytes(completed, total)
-    }
-  }
-
-  private fun isCompressing(state: TransferControlViewState): Boolean {
-    val total = state.compressionProgress.sumTotal()
-    return total > 0L.bytes && state.compressionProgress.sumCompleted().percentageOf(total) < 0.99f
-  }
-
-  private fun calculateProgress(state: TransferControlViewState): Float {
-    val totalCompressionProgress: Float = state.compressionProgress.values.map { it.completed.percentageOf(it.total) }.sum()
-    val totalDownloadProgress: Float = state.networkProgress.values.map { it.completed.percentageOf(it.total) }.sum()
-    val weightedProgress = UPLOAD_TASK_WEIGHT * totalDownloadProgress + COMPRESSION_TASK_WEIGHT * totalCompressionProgress
-    val weightedTotal = (UPLOAD_TASK_WEIGHT * state.networkProgress.size + COMPRESSION_TASK_WEIGHT * state.compressionProgress.size).toFloat()
-    return weightedProgress / weightedTotal
-  }
-
-  /**
-   * Internal, view-free mirror of the legacy state machine. Kept verbatim from the original view to preserve behavior; the
-   * resulting [Mode] is mapped to a [TransferControlsRenderState] by [deriveRenderState].
-   */
-  private fun deriveMode(state: TransferControlViewState): Mode {
-    if (state.slides.isEmpty()) {
-      return Mode.GONE
-    }
-
-    if (state.slides.all { it.transferState == AttachmentTable.TRANSFER_PROGRESS_DONE }) {
-      return Mode.GONE
-    }
-
-    if (state.isVisible) {
-      if (state.slides.size == 1) {
-        val slide = state.slides.first()
-        if (slide.hasVideo()) {
-          if (state.isUpload) {
-            return when (slide.transferState) {
-              AttachmentTable.TRANSFER_PROGRESS_STARTED -> Mode.UPLOADING_SINGLE_ITEM
-              AttachmentTable.TRANSFER_PROGRESS_PENDING -> Mode.PENDING_SINGLE_ITEM
-              else -> Mode.RETRY_UPLOADING
-            }
-          } else {
-            return when (slide.transferState) {
-              AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
-                if (state.playableWhileDownloading) Mode.DOWNLOADING_VIDEO_PLAYABLE else Mode.DOWNLOADING_SINGLE_ITEM
-              }
-
-              AttachmentTable.TRANSFER_PROGRESS_FAILED -> Mode.RETRY_DOWNLOADING
-              else -> {
-                if (state.playableWhileDownloading) Mode.PENDING_VIDEO_PLAYABLE else Mode.PENDING_SINGLE_ITEM
-              }
-            }
-          }
-        } else {
-          return if (state.isUpload) {
-            when (slide.transferState) {
-              AttachmentTable.TRANSFER_PROGRESS_FAILED -> Mode.RETRY_UPLOADING
-              AttachmentTable.TRANSFER_PROGRESS_PENDING -> Mode.PENDING_SINGLE_ITEM
-              else -> Mode.UPLOADING_SINGLE_ITEM
-            }
-          } else {
-            when (slide.transferState) {
-              AttachmentTable.TRANSFER_PROGRESS_STARTED -> Mode.DOWNLOADING_SINGLE_ITEM
-              AttachmentTable.TRANSFER_PROGRESS_FAILED -> Mode.RETRY_DOWNLOADING
-              else -> Mode.PENDING_SINGLE_ITEM
-            }
-          }
-        }
-      } else {
-        when (getTransferState(state.slides)) {
-          AttachmentTable.TRANSFER_PROGRESS_STARTED -> {
-            return if (state.isUpload) Mode.UPLOADING_GALLERY else Mode.DOWNLOADING_GALLERY
-          }
-
-          AttachmentTable.TRANSFER_PROGRESS_PENDING -> {
-            return if (containsPlayableSlides(state.slides)) Mode.PENDING_GALLERY_CONTAINS_PLAYABLE else Mode.PENDING_GALLERY
-          }
-
-          AttachmentTable.TRANSFER_PROGRESS_FAILED -> {
-            return if (state.isUpload) Mode.RETRY_UPLOADING else Mode.RETRY_DOWNLOADING
-          }
-
-          AttachmentTable.TRANSFER_PROGRESS_DONE -> return Mode.GONE
-        }
-      }
-    } else {
-      return Mode.GONE
-    }
-
-    return Mode.GONE
-  }
-
-  @JvmStatic
-  fun getTransferState(slides: List<Slide>): Int {
-    var transferState = AttachmentTable.TRANSFER_PROGRESS_DONE
-    var allFailed = true
-    for (slide in slides) {
-      if (slide.transferState != AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE) {
-        allFailed = false
-        transferState = if (slide.transferState == AttachmentTable.TRANSFER_PROGRESS_PENDING && transferState == AttachmentTable.TRANSFER_PROGRESS_DONE) {
-          slide.transferState
-        } else {
-          transferState.coerceAtLeast(slide.transferState)
-        }
-      }
-    }
-    return if (allFailed) AttachmentTable.TRANSFER_PROGRESS_PERMANENT_FAILURE else transferState
-  }
-
-  @JvmStatic
-  fun containsPlayableSlides(slides: List<Slide>): Boolean {
-    return slides.any { MediaUtil.isInstantVideoSupported(it) }
-  }
-
-  private fun Map<Attachment, TransferControlView.Progress>.sumCompleted(): ByteSize {
-    return this.values.sumOf { it.completed.inWholeBytes }.bytes
-  }
-
-  private fun Map<Attachment, TransferControlView.Progress>.sumTotal(): ByteSize {
-    return this.values.sumOf { it.total.inWholeBytes }.bytes
-  }
-
-  private const val UPLOAD_TASK_WEIGHT = 1
-
-  /**
-   * A weighting compared to [UPLOAD_TASK_WEIGHT]
-   */
-  private const val COMPRESSION_TASK_WEIGHT = 3
-
-  private enum class Mode {
-    PENDING_GALLERY,
-    PENDING_GALLERY_CONTAINS_PLAYABLE,
-    PENDING_SINGLE_ITEM,
-    PENDING_VIDEO_PLAYABLE,
-    DOWNLOADING_GALLERY,
-    DOWNLOADING_SINGLE_ITEM,
-    DOWNLOADING_VIDEO_PLAYABLE,
-    UPLOADING_GALLERY,
-    UPLOADING_SINGLE_ITEM,
-    RETRY_DOWNLOADING,
-    RETRY_UPLOADING,
-    GONE
-  }
-}
-
-/**
- * A fully-resolved description of what the transfer controls should display. Produced by [TransferControls.deriveRenderState].
- */
-sealed interface TransferControlsRenderState {
-  data object Gone : TransferControlsRenderState
-
-  data class Pending(
-    val isUpload: Boolean,
-    val placement: TransferControls.Placement,
-    val showPlayButton: Boolean,
-    val itemCount: Int? = null,
-    val sizeBytes: ByteSize? = null
-  ) : TransferControlsRenderState
-
-  data class InProgress(
-    val isUpload: Boolean,
-    val placement: TransferControls.Placement,
-    val progress: Float?,
-    val showPlayButton: Boolean,
-    val cancelable: Boolean,
-    val label: TransferControls.ProgressLabel?
-  ) : TransferControlsRenderState {
-    fun isProgressOnlyDifference(other: TransferControlsRenderState): Boolean {
-      return other is InProgress && copy(progress = other.progress, label = other.label) == other
-    }
-  }
-
-  data class Retry(
-    val isUpload: Boolean
-  ) : TransferControlsRenderState
-}
@@ -1,415 +0,0 @@
-/*
- * Copyright 2025 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.thoughtcrime.securesms.components.transfercontrols
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.RowScope
-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.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.res.pluralStringResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.text.PlatformTextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import org.signal.core.ui.compose.DayNightPreviews
-import org.signal.core.ui.compose.Previews
-import org.signal.core.ui.compose.clickableContainer
-import org.signal.core.util.bytes
-import org.thoughtcrime.securesms.R
-import org.signal.core.ui.R as CoreUiR
-
-private val CENTER_CONTROL_SIZE = 44.dp
-private val NO_FONT_PADDING = PlatformTextStyle(includeFontPadding = false)
-
-/**
- * Compose rendering of the attachment transfer controls (start/cancel/progress) that overlay a media thumbnail.
- *
- * This renders a [TransferControlsRenderState] produced by [TransferControls.deriveRenderState]. All state derivation lives in
- * [TransferControls]; this function is purely presentational so the various visual states can be previewed and tested directly.
- */
-@Composable
-fun TransferControls(
-  state: TransferControlsRenderState,
-  modifier: Modifier = Modifier,
-  onStartClick: () -> Unit = {},
-  onCancelClick: () -> Unit = {},
-  onPlayClick: () -> Unit = {}
-) {
-  Box(modifier = modifier.fillMaxSize()) {
-    when (state) {
-      is TransferControlsRenderState.Gone -> Unit
-
-      is TransferControlsRenderState.Pending -> Content(
-        control = TransferProgressState.Ready(
-          icon = arrowIcon(state.isUpload),
-          startButtonContentDesc = startContentDescription(state.isUpload),
-          startButtonOnClickLabel = startContentDescription(state.isUpload),
-          onStartClick = onStartClick
-        ),
-        placement = state.placement,
-        showPlayButton = state.showPlayButton,
-        centerLabel = state.itemCount?.let { pluralStringResource(R.plurals.TransferControlView_n_items, it, it) },
-        cornerText = state.sizeBytes?.toUnitString(),
-        onPlayClick = onPlayClick
-      )
-
-      is TransferControlsRenderState.Retry -> Content(
-        control = TransferProgressState.Ready(
-          icon = arrowIcon(state.isUpload),
-          startButtonContentDesc = startContentDescription(state.isUpload),
-          startButtonOnClickLabel = startContentDescription(state.isUpload),
-          onStartClick = onStartClick
-        ),
-        placement = TransferControls.Placement.CORNER,
-        showPlayButton = false,
-        centerLabel = null,
-        cornerText = stringResource(R.string.NetworkFailure__retry),
-        onPlayClick = onPlayClick
-      )
-
-      is TransferControlsRenderState.InProgress -> {
-        val cancelLabel = stringResource(android.R.string.cancel)
-        val label = state.label
-        val progressFormat = stringResource(R.string.TransferControlView__download_progress_s_s)
-        val cornerTextReserveWidthFor = (label as? TransferControls.ProgressLabel.Bytes)?.let { byteLabel ->
-          val unit = byteLabel.total.getLargestNonZeroSize()
-          val widestCompleted = byteLabel.total.toUnitString(unit, padDecimals = true, withUnit = false)
-          val totalText = byteLabel.total.toUnitString(unit)
-          progressFormat.format(widestCompleted, totalText)
-        }
-
-        Content(
-          control = TransferProgressState.InProgress(
-            progress = state.progress,
-            cancelAction = if (state.cancelable) {
-              TransferProgressState.InProgress.CancelAction(
-                contentDesc = cancelLabel,
-                onClickLabel = cancelLabel,
-                onClick = onCancelClick
-              )
-            } else {
-              null
-            }
-          ),
-          placement = state.placement,
-          showPlayButton = state.showPlayButton,
-          centerLabel = null,
-          cornerText = label?.let { progressLabelText(it) },
-          cornerTextReserveWidthFor = cornerTextReserveWidthFor,
-          onPlayClick = onPlayClick
-        )
-      }
-    }
-  }
-}
-
-@Composable
-private fun BoxScope.Content(
-  control: TransferProgressState,
-  placement: TransferControls.Placement,
-  showPlayButton: Boolean,
-  centerLabel: String?,
-  cornerText: String?,
-  onPlayClick: () -> Unit,
-  cornerTextReserveWidthFor: String? = null
-) {
-  val controlInCenter = placement == TransferControls.Placement.CENTER
-  val controlInCorner = placement == TransferControls.Placement.CORNER
-
-  if (controlInCenter || showPlayButton || centerLabel != null) {
-    Pill(
-      modifier = Modifier.align(Alignment.Center),
-      cornerRadius = 24.dp
-    ) {
-      if (controlInCenter) {
-        OnMediaIndicator(control, CENTER_CONTROL_SIZE)
-      }
-
-      if (showPlayButton) {
-        PlayButton(onPlayClick)
-      }
-
-      if (centerLabel != null) {
-        Text(
-          text = centerLabel,
-          style = MaterialTheme.typography.bodyLarge.copy(platformStyle = NO_FONT_PADDING),
-          color = colorResource(CoreUiR.color.signal_colorOnCustom),
-          maxLines = 1,
-          modifier = Modifier.padding(end = 12.dp)
-        )
-      }
-    }
-  }
-
-  if (controlInCorner || cornerText != null) {
-    Pill(
-      modifier = Modifier
-        .align(Alignment.TopStart)
-        .padding(4.dp),
-      cornerRadius = 16.dp
-    ) {
-      if (controlInCorner) {
-        OnMediaIndicator(control, 32.dp)
-      }
-
-      if (cornerText != null) {
-        if (!controlInCorner) {
-          Spacer(modifier = Modifier.width(8.dp))
-        }
-
-        CornerText(
-          text = cornerText,
-          reserveWidthFor = cornerTextReserveWidthFor
-        )
-      }
-    }
-  }
-}
-
-@Composable
-private fun Pill(
-  modifier: Modifier = Modifier,
-  cornerRadius: Dp,
-  content: @Composable RowScope.() -> Unit
-) {
-  Row(
-    modifier = modifier
-      .clip(RoundedCornerShape(cornerRadius))
-      .background(colorResource(CoreUiR.color.signal_colorTransparentInverse4)),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    content()
-  }
-}
-
-/**
- * Wraps [TransferProgressIndicator] in a color scheme override so it adopts the on-media ("OnCustom") palette rather than the
- * default surface palette, matching the legacy view's appearance over thumbnails.
- */
-@Composable
-private fun OnMediaIndicator(state: TransferProgressState, size: Dp) {
-  MaterialTheme(
-    colorScheme = MaterialTheme.colorScheme.copy(
-      onSurface = colorResource(CoreUiR.color.signal_colorOnCustom),
-      surfaceContainerHighest = colorResource(CoreUiR.color.signal_colorTransparent2)
-    )
-  ) {
-    TransferProgressIndicator(state = state, size = size)
-  }
-}
-
-@Composable
-private fun PlayButton(onPlayClick: () -> Unit) {
-  val description = stringResource(R.string.ThumbnailView_Play_video_description)
-  Icon(
-    imageVector = ImageVector.vectorResource(R.drawable.triangle_right),
-    contentDescription = description,
-    tint = colorResource(CoreUiR.color.signal_colorOnCustom),
-    modifier = Modifier
-      .size(CENTER_CONTROL_SIZE)
-      .clickableContainer(
-        contentDescription = description,
-        onClickLabel = description,
-        onClick = onPlayClick
-      )
-      .padding(10.dp)
-  )
-}
-
-@Composable
-private fun CornerText(
-  text: String,
-  reserveWidthFor: String?
-) {
-  val reserving = reserveWidthFor != null
-  val style = MaterialTheme.typography.labelSmall.copy(
-    fontWeight = FontWeight.Light,
-    platformStyle = NO_FONT_PADDING
-  )
-  val effectiveStyle = if (reserving) style.copy(fontFeatureSettings = "tnum") else style
-
-  val widthModifier = if (reserving) {
-    val measurer = rememberTextMeasurer()
-    val density = LocalDensity.current
-    val reservedWidth = remember(reserveWidthFor, effectiveStyle, density) {
-      with(density) { measurer.measure(reserveWidthFor, effectiveStyle).size.width.toDp() }
-    }
-    Modifier.width(reservedWidth)
-  } else {
-    Modifier
-  }
-
-  Text(
-    text = text,
-    style = effectiveStyle,
-    color = colorResource(CoreUiR.color.signal_colorOnCustom),
-    maxLines = 1,
-    textAlign = if (reserving) TextAlign.End else null,
-    modifier = Modifier
-      .padding(end = 8.dp, top = 8.dp, bottom = 8.dp)
-      .then(widthModifier)
-  )
-}
-
-@Composable
-private fun arrowIcon(isUpload: Boolean): ImageVector {
-  return ImageVector.vectorResource(if (isUpload) R.drawable.symbol_arrow_up_24 else R.drawable.symbol_arrow_down_24)
-}
-
-@Composable
-private fun startContentDescription(isUpload: Boolean): String {
-  return stringResource(if (isUpload) R.string.TransferControlView__upload else R.string.TransferControlView__download)
-}
-
-@Composable
-private fun progressLabelText(label: TransferControls.ProgressLabel): String {
-  return when (label) {
-    is TransferControls.ProgressLabel.Processing -> stringResource(R.string.TransferControlView__processing)
-    is TransferControls.ProgressLabel.Bytes -> {
-      val unit = label.total.getLargestNonZeroSize()
-      stringResource(
-        R.string.TransferControlView__download_progress_s_s,
-        label.completed.toUnitString(unit, padDecimals = true, withUnit = false),
-        label.total.toUnitString(unit)
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsPendingSinglePreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.Pending(
-          isUpload = false,
-          placement = TransferControls.Placement.CENTER,
-          showPlayButton = false,
-          sizeBytes = (2 * 1024 * 1024L).bytes
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsPendingGalleryPreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.Pending(
-          isUpload = false,
-          placement = TransferControls.Placement.CENTER,
-          showPlayButton = false,
-          itemCount = 3,
-          sizeBytes = (6 * 1024 * 1024L).bytes
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsPendingPlayableVideoPreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.Pending(
-          isUpload = false,
-          placement = TransferControls.Placement.CORNER,
-          showPlayButton = true,
-          sizeBytes = (12 * 1024 * 1024L).bytes
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsDownloadingSinglePreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.InProgress(
-          isUpload = false,
-          placement = TransferControls.Placement.CORNER,
-          progress = 0.45f,
-          showPlayButton = false,
-          cancelable = true,
-          label = TransferControls.ProgressLabel.Bytes((1024 * 1024L).bytes, (2 * 1024 * 1024L).bytes)
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsAwaitingPrimaryPreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.InProgress(
-          isUpload = false,
-          placement = TransferControls.Placement.CENTER,
-          progress = null,
-          showPlayButton = false,
-          cancelable = false,
-          label = null
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferControlsRetryPreview() {
-  Previews.Preview {
-    PreviewSurface {
-      TransferControls(
-        state = TransferControlsRenderState.Retry(isUpload = false)
-      )
-    }
-  }
-}
-
-@Composable
-private fun PreviewSurface(content: @Composable () -> Unit) {
-  Box(
-    modifier = Modifier
-      .size(150.dp)
-      .background(colorResource(CoreUiR.color.signal_colorTransparent2))
-  ) {
-    content()
-  }
-}
@@ -13,32 +13,20 @@ import androidx.compose.animation.fadeOut
 import androidx.compose.animation.scaleIn
 import androidx.compose.animation.scaleOut
 import androidx.compose.animation.togetherWith
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import org.signal.core.ui.compose.DayNightPreviews
-import org.signal.core.ui.compose.Previews
 import org.signal.core.ui.compose.clickableContainer
-import org.thoughtcrime.securesms.R
-import org.signal.core.ui.R as CoreUiR

 /**
 * A button that can be used to start, cancel, show progress, and show completion of a data transfer.
@@ -46,19 +34,10 @@ import org.signal.core.ui.R as CoreUiR
@Composable
 fun TransferProgressIndicator(
  state: TransferProgressState,
-  modifier: Modifier = Modifier,
-  size: Dp = 48.dp
+  modifier: Modifier = Modifier.size(48.dp)
 ) {
-  // Internal paddings are tuned for a 48dp control; scale them with [size] so the icon/ring proportions are preserved at
-  // other sizes. At 48dp this is a no-op, so existing callers are unaffected.
-  val scale = size / 48.dp
-  val sizedModifier = modifier.size(size)
-
  AnimatedContent(
    targetState = state,
-    // Key on the state type, not the value, so that progress updates within InProgress recompose in place instead of
-    // re-triggering the enter/exit transition on every tick (which would prevent the determinate fill from ever settling).
-    contentKey = { it::class },
    transitionSpec = {
      val startDelay = 200
      val enterTransition = fadeIn(tween(delayMillis = startDelay, durationMillis = 500)) + scaleIn(tween(delayMillis = startDelay, durationMillis = 400))
@@ -69,9 +48,9 @@ fun TransferProgressIndicator(
    }
  ) { targetState ->
    when (targetState) {
-      is TransferProgressState.Ready -> StartTransferButton(targetState, sizedModifier, scale)
-      is TransferProgressState.InProgress -> ProgressIndicator(targetState, sizedModifier, scale)
-      is TransferProgressState.Complete -> CompleteIcon(targetState, sizedModifier, scale)
+      is TransferProgressState.Ready -> StartTransferButton(targetState, modifier)
+      is TransferProgressState.InProgress -> ProgressIndicator(targetState, modifier)
+      is TransferProgressState.Complete -> CompleteIcon(targetState, modifier)
    }
  }
 }
@@ -79,8 +58,7 @@ fun TransferProgressIndicator(
@Composable
 private fun StartTransferButton(
  state: TransferProgressState.Ready,
-  modifier: Modifier = Modifier,
-  scale: Float = 1f
+  modifier: Modifier = Modifier
 ) {
  Box(
    modifier = modifier
@@ -96,7 +74,7 @@ private fun StartTransferButton(
      contentDescription = null,
      modifier = Modifier
        .matchParentSize()
-        .padding(12.dp * scale)
+        .padding(12.dp)
    )
  }
 }
@@ -104,8 +82,7 @@ private fun StartTransferButton(
@Composable
 private fun ProgressIndicator(
  state: TransferProgressState.InProgress,
-  modifier: Modifier = Modifier,
-  scale: Float = 1f
+  modifier: Modifier = Modifier
 ) {
  Box(
    modifier = modifier
@@ -120,7 +97,7 @@ private fun ProgressIndicator(
          Modifier
        }
      )
-      .padding(10.dp * scale)
+      .padding(10.dp)
  ) {
    state.icon?.let { icon ->
      Icon(
@@ -129,7 +106,7 @@ private fun ProgressIndicator(
        contentDescription = null,
        modifier = Modifier
          .matchParentSize()
-          .padding(6.dp * scale)
+          .padding(6.dp)
      )
    }

@@ -164,32 +141,19 @@ private fun ProgressIndicator(
        modifier = indicatorModifier
      )
    }
-
-    // When cancelable, draw the filled "stop" square in the center of the ring (matches the legacy view's
-    // IN_PROGRESS_CANCELABLE state). Sized as a fraction of the control so it scales with center/corner placements.
-    if (state.cancelAction != null) {
-      Box(
-        modifier = Modifier
-          .align(Alignment.Center)
-          .fillMaxSize(0.3f)
-          .clip(RoundedCornerShape(percent = 15))
-          .background(MaterialTheme.colorScheme.onSurface)
-      )
-    }
  }
 }

@Composable
 private fun CompleteIcon(
  state: TransferProgressState.Complete,
-  modifier: Modifier = Modifier,
-  scale: Float = 1f
+  modifier: Modifier = Modifier
 ) {
  Icon(
    imageVector = state.icon,
    tint = MaterialTheme.colorScheme.onSurface,
    contentDescription = state.iconContentDesc,
-    modifier = modifier.padding(12.dp * scale)
+    modifier = modifier.padding(12.dp)
  )
 }

@@ -219,97 +183,3 @@ sealed interface TransferProgressState {
    val iconContentDesc: String
  ) : TransferProgressState
 }
-
-@DayNightPreviews
-@Composable
-private fun TransferProgressIndicatorReadyPreview() {
-  Previews.Preview {
-    PreviewBackdrop {
-      TransferProgressIndicator(
-        state = TransferProgressState.Ready(
-          icon = ImageVector.vectorResource(R.drawable.symbol_arrow_down_24),
-          startButtonContentDesc = "",
-          startButtonOnClickLabel = "",
-          onStartClick = {}
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferProgressIndicatorIndeterminatePreview() {
-  Previews.Preview {
-    PreviewBackdrop {
-      TransferProgressIndicator(
-        state = TransferProgressState.InProgress(
-          icon = ImageVector.vectorResource(R.drawable.symbol_arrow_down_24),
-          progress = null,
-          cancelAction = null
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferProgressIndicatorDeterminatePreview() {
-  Previews.Preview {
-    PreviewBackdrop {
-      TransferProgressIndicator(
-        state = TransferProgressState.InProgress(
-          icon = ImageVector.vectorResource(R.drawable.symbol_arrow_down_24),
-          progress = 0.4f,
-          cancelAction = null
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferProgressIndicatorCancelablePreview() {
-  Previews.Preview {
-    PreviewBackdrop {
-      TransferProgressIndicator(
-        state = TransferProgressState.InProgress(
-          progress = 0.4f,
-          cancelAction = TransferProgressState.InProgress.CancelAction(
-            contentDesc = "",
-            onClickLabel = "",
-            onClick = {}
-          )
-        )
-      )
-    }
-  }
-}
-
-@DayNightPreviews
-@Composable
-private fun TransferProgressIndicatorCompletePreview() {
-  Previews.Preview {
-    PreviewBackdrop {
-      TransferProgressIndicator(
-        state = TransferProgressState.Complete(
-          icon = ImageVector.vectorResource(R.drawable.symbol_check_white_24),
-          iconContentDesc = ""
-        )
-      )
-    }
-  }
-}
-
-@Composable
-private fun PreviewBackdrop(content: @Composable () -> Unit) {
-  Box(
-    modifier = Modifier
-      .size(96.dp)
-      .background(colorResource(CoreUiR.color.signal_colorTransparent2))
-  ) {
-    content()
-  }
-}
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2023 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.transfercontrols
+
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.util.AttributeSet
+import android.view.View
+import androidx.annotation.Discouraged
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.withTranslation
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.R
+import kotlin.math.roundToInt
+import org.signal.core.ui.R as CoreUiR
+
+/**
+ * This displays a circular progress around an icon. The icon is either an upload arrow, a download arrow, or a rectangular stop button.
+ */
+@Discouraged("Use TransferProgressIndicator instead.")
+class TransferProgressView @JvmOverloads constructor(
+  context: Context,
+  attrs: AttributeSet? = null,
+  defStyleAttr: Int = 0,
+  defStyleRes: Int = 0
+) : View(context, attrs, defStyleAttr, defStyleRes) {
+  companion object {
+    const val TAG = "TransferProgressView"
+    private const val PROGRESS_ARC_STROKE_WIDTH_DP = 2f
+    private const val ICON_SIZE_DP = 24f
+    private const val STOP_CORNER_RADIUS_DP = 4f
+    private const val PROGRESS_BAR_INSET_DP = 2
+  }
+
+  private val iconColor: Int
+  private val progressColor: Int
+  private val trackColor: Int
+  private val stopIconPaint: Paint
+  private val progressPaint: Paint
+  private val trackPaint: Paint
+  private val progressArcStrokeWidth: Float
+  private val iconSize: Float
+  private val stopIconSize: Float
+  private val stopIconCornerRadius: Float
+
+  private val progressRect = RectF()
+  private val stopIconRect = RectF()
+  private val downloadDrawable = ContextCompat.getDrawable(context, R.drawable.symbol_arrow_down_24)
+  private val uploadDrawable = ContextCompat.getDrawable(context, R.drawable.symbol_arrow_up_24)
+
+  private var progressPercent = 0f
+  private var currentState = State.UNINITIALIZED
+
+  var startClickListener: OnClickListener? = null
+  var cancelClickListener: OnClickListener? = null
+
+  init {
+    val displayDensity = Resources.getSystem().displayMetrics.density
+    val typedArray = context.theme.obtainStyledAttributes(attrs, R.styleable.TransferProgressView, 0, 0)
+    val signalCustomColor = ContextCompat.getColor(context, CoreUiR.color.signal_colorOnCustom)
+    val signalTransparent2 = ContextCompat.getColor(context, CoreUiR.color.signal_colorTransparent2)
+
+    iconColor = typedArray.getColor(R.styleable.TransferProgressView_transferIconColor, signalCustomColor)
+    progressColor = typedArray.getColor(R.styleable.TransferProgressView_progressColor, signalCustomColor)
+    trackColor = typedArray.getColor(R.styleable.TransferProgressView_trackColor, signalTransparent2)
+    progressArcStrokeWidth = typedArray.getDimension(R.styleable.TransferProgressView_progressArcWidth, PROGRESS_ARC_STROKE_WIDTH_DP * displayDensity)
+    iconSize = typedArray.getDimension(R.styleable.TransferProgressView_iconSize, ICON_SIZE_DP * displayDensity)
+    stopIconSize = typedArray.getDimension(R.styleable.TransferProgressView_stopIconSize, ICON_SIZE_DP * displayDensity)
+    stopIconCornerRadius = typedArray.getDimension(R.styleable.TransferProgressView_stopIconCornerRadius, STOP_CORNER_RADIUS_DP * displayDensity)
+
+    typedArray.recycle()
+
+    progressPaint = progressPaint(progressColor)
+    stopIconPaint = stopIconPaint(iconColor)
+    trackPaint = trackPaint(trackColor)
+
+    val filter = PorterDuffColorFilter(iconColor, PorterDuff.Mode.SRC_ATOP)
+    downloadDrawable?.colorFilter = filter
+    uploadDrawable?.colorFilter = filter
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+
+    when (currentState) {
+      State.IN_PROGRESS_CANCELABLE -> drawProgress(canvas, progressPercent, true)
+      State.IN_PROGRESS_NON_CANCELABLE -> drawProgress(canvas, progressPercent, false)
+      State.READY_TO_UPLOAD -> sizeAndDrawDrawable(canvas, uploadDrawable)
+      State.READY_TO_DOWNLOAD -> sizeAndDrawDrawable(canvas, downloadDrawable)
+      State.UNINITIALIZED -> Unit
+    }
+  }
+
+  fun setProgress(progress: Float) {
+    currentState = State.IN_PROGRESS_CANCELABLE
+    if (cancelClickListener == null) {
+      Log.i(TAG, "Illegal click listener attached.")
+    } else {
+      setOnClickListener(cancelClickListener)
+    }
+    progressPercent = progress
+    invalidate()
+  }
+
+  fun setStopped(isUpload: Boolean) {
+    val newState = if (isUpload) State.READY_TO_UPLOAD else State.READY_TO_DOWNLOAD
+    currentState = newState
+    if (startClickListener == null) {
+      Log.i(TAG, "Illegal click listener attached.")
+    } else {
+      setOnClickListener(startClickListener)
+    }
+    progressPercent = 0f
+    invalidate()
+  }
+
+  private fun drawProgress(canvas: Canvas, progressPercent: Float, showStopIcon: Boolean) {
+    if (showStopIcon) {
+      stopIconRect.set(0f, 0f, stopIconSize, stopIconSize)
+
+      canvas.withTranslation(width / 2 - (stopIconSize / 2), height / 2 - (stopIconSize / 2)) {
+        drawRoundRect(stopIconRect, stopIconCornerRadius, stopIconCornerRadius, stopIconPaint)
+      }
+    }
+
+    val trackWidthScaled = progressArcStrokeWidth
+    val inset: Float = PROGRESS_BAR_INSET_DP * Resources.getSystem().displayMetrics.density
+    progressRect.left = trackWidthScaled + inset
+    progressRect.top = trackWidthScaled + inset
+    progressRect.right = (width - trackWidthScaled) - inset
+    progressRect.bottom = (height - trackWidthScaled) - inset
+
+    canvas.drawArc(progressRect, 0f, 360f, false, trackPaint)
+    canvas.drawArc(progressRect, 270f, 360f * progressPercent, false, progressPaint)
+  }
+
+  private fun stopIconPaint(paintColor: Int): Paint {
+    val stopIconPaint = Paint()
+    stopIconPaint.color = paintColor
+    stopIconPaint.isAntiAlias = true
+    stopIconPaint.style = Paint.Style.FILL
+    return stopIconPaint
+  }
+
+  private fun trackPaint(trackColor: Int): Paint {
+    val trackPaint = Paint()
+    trackPaint.color = trackColor
+    trackPaint.isAntiAlias = true
+    trackPaint.style = Paint.Style.STROKE
+    trackPaint.strokeWidth = progressArcStrokeWidth
+    return trackPaint
+  }
+
+  private fun progressPaint(progressColor: Int): Paint {
+    val progressPaint = Paint()
+    progressPaint.color = progressColor
+    progressPaint.isAntiAlias = true
+    progressPaint.style = Paint.Style.STROKE
+    progressPaint.strokeWidth = progressArcStrokeWidth
+    return progressPaint
+  }
+
+  private fun sizeAndDrawDrawable(canvas: Canvas, drawable: Drawable?) {
+    if (drawable == null) {
+      Log.w(TAG, "Could not load icon for $currentState")
+      return
+    }
+
+    val centerX = width / 2f
+    val centerY = height / 2f
+
+    // 0, 0 is the top left corner
+    // width, height is the bottom right
+    val halfIconSize = (iconSize / 2f)
+    val left = (centerX - halfIconSize).roundToInt().coerceAtLeast(0)
+    val top = (centerY - halfIconSize).roundToInt().coerceAtLeast(0)
+    val right = (centerX + halfIconSize).roundToInt().coerceAtMost(width)
+    val bottom = (centerY + halfIconSize).roundToInt().coerceAtMost(height)
+
+    drawable.setBounds(left, top, right, bottom)
+    drawable.draw(canvas)
+  }
+
+  private enum class State {
+    IN_PROGRESS_CANCELABLE,
+    IN_PROGRESS_NON_CANCELABLE,
+    READY_TO_UPLOAD,
+    READY_TO_DOWNLOAD,
+    UNINITIALIZED
+  }
+}
@@ -7,6 +7,7 @@ import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.media.AudioManager;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.Process;

@@ -115,6 +116,10 @@ public class VoiceNotePlaybackService extends MediaSessionService {
  @Nullable
  @Override
  public MediaSession onGetSession(@NonNull MediaSession.ControllerInfo controllerInfo) {
+    if (Build.VERSION.SDK_INT >= 28 && controllerInfo.getUid() != Process.myUid()) {
+      Log.w(TAG, "Denying session to external caller: " + controllerInfo.getPackageName());
+      return null;
+    }
    return mediaSession;
  }

@@ -8,7 +8,9 @@ package org.thoughtcrime.securesms.components.voice
 import android.content.Context
 import android.media.AudioManager
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
+import android.os.Process
 import android.widget.Toast
 import androidx.annotation.MainThread
 import androidx.annotation.OptIn
@@ -94,12 +96,11 @@ class VoiceNotePlayerCallback(val context: Context, val player: VoiceNotePlayer)
  private var latestUri = Uri.EMPTY

  override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult {
-    return if (controller.isTrusted) {
-      MediaSession.ConnectionResult.accept(CUSTOM_COMMANDS, SUPPORTED_ACTIONS)
-    } else {
-      Log.w(TAG, "Rejecting connection from non-trusted caller: ${controller.packageName}")
-      MediaSession.ConnectionResult.reject()
+    if (Build.VERSION.SDK_INT >= 28 && controller.uid != Process.myUid()) {
+      Log.w(TAG, "Rejecting connection from external caller: ${controller.packageName}")
+      return MediaSession.ConnectionResult.reject()
    }
+    return MediaSession.ConnectionResult.accept(CUSTOM_COMMANDS, SUPPORTED_ACTIONS)
  }

  override fun onPostConnect(session: MediaSession, controller: MediaSession.ControllerInfo) {
@@ -96,32 +96,32 @@ private fun ParticipantActionsSheetContent(
 ) {
  ParticipantHeader(recipient = recipient)

-  if (callParticipant.isMicrophoneEnabled) {
+  val hasAdminActions = isSelfAdmin && (callParticipant.isMicrophoneEnabled || isCallLink)
+
+  if (hasAdminActions) {
    Dividers.Default()

-    Rows.TextRow(
-      text = stringResource(id = R.string.CallParticipantSheet__mute_audio),
-      icon = painterResource(id = R.drawable.symbol_mic_slash_24),
-      onClick = {
-        onMuteAudio(callParticipant)
-        onDismiss()
-      }
-    )
-  }
-
-  if (isSelfAdmin && isCallLink) {
-    if (!callParticipant.isMicrophoneEnabled) {
-      Dividers.Default()
+    if (callParticipant.isMicrophoneEnabled) {
+      Rows.TextRow(
+        text = stringResource(id = R.string.CallParticipantSheet__mute_audio),
+        icon = painterResource(id = R.drawable.symbol_mic_slash_24),
+        onClick = {
+          onMuteAudio(callParticipant)
+          onDismiss()
+        }
+      )
    }

-    Rows.TextRow(
-      text = stringResource(id = R.string.CallParticipantSheet__remove_from_call),
-      icon = painterResource(id = R.drawable.symbol_minus_circle_24),
-      onClick = {
-        onRemoveFromCall(callParticipant)
-        onDismiss()
-      }
-    )
+    if (isCallLink) {
+      Rows.TextRow(
+        text = stringResource(id = R.string.CallParticipantSheet__remove_from_call),
+        icon = painterResource(id = R.drawable.symbol_minus_circle_24),
+        onClick = {
+          onRemoveFromCall(callParticipant)
+          onDismiss()
+        }
+      )
+    }
  }

  Dividers.Default()
@@ -221,7 +221,7 @@ private fun Title(
        style = MaterialTheme.typography.headlineMedium
      )
      Icon(
-        painter = painterResource(id = CoreUiR.drawable.symbol_person_circle_24),
+        painter = painterResource(id = R.drawable.symbol_person_circle_24),
        contentDescription = null,
        modifier = Modifier
          .padding(start = 6.dp)
@@ -190,7 +190,7 @@ fun SelfPipContent(
    Box(modifier = modifier) {
      VideoRenderer(
        participant = participant,
-        mirror = !participant.isScreenSharing && participant.cameraDirection == CameraState.Direction.FRONT,
+        mirror = participant.cameraDirection == CameraState.Direction.FRONT,
        modifier = Modifier.fillMaxSize()
      )

@@ -471,7 +471,6 @@ private fun VideoRenderer(
          }

          setMirror(mirror)
-          applyScreenShareAwareScaling(participant.isScreenSharing)
        }

        renderer = textureRenderer
@@ -492,7 +491,6 @@ private fun VideoRenderer(
        }

        textureRenderer.setMirror(mirror)
-        textureRenderer.applyScreenShareAwareScaling(participant.isScreenSharing)
      }
    },
    onRelease = {
@@ -502,18 +500,6 @@ private fun VideoRenderer(
  )
 }

-/**
- * Screen-shared content is fit inside the view ([RendererCommon.ScalingType.SCALE_ASPECT_FIT]) so nothing is cropped,
- * while camera video fills the view, falling back to balanced scaling when the video orientation does not match the view.
- */
-private fun TextureViewRenderer.applyScreenShareAwareScaling(isScreenSharing: Boolean) {
-  if (isScreenSharing) {
-    setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
-  } else {
-    setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL, RendererCommon.ScalingType.SCALE_ASPECT_BALANCED)
-  }
-}
-
@Composable
 internal fun ParticipantAudioIndicator(
  participant: CallParticipant,
@@ -543,7 +543,7 @@ private fun LargeLocalVideoRenderer(
    participant = localParticipant,
    renderInPip = false,
    raiseHandAllowed = false,
-    mirrorVideo = !localParticipant.isScreenSharing && localParticipant.cameraDirection == CameraState.Direction.FRONT,
+    mirrorVideo = localParticipant.cameraDirection == CameraState.Direction.FRONT,
    showAudioIndicator = false,
    onInfoMoreInfoClick = null,
    modifier = modifier
@@ -620,7 +620,7 @@ private fun ParticipantContextMenu(
        .background(color = MaterialTheme.colorScheme.surfaceVariant)
    )

-    if (resolved.isMicrophoneEnabled) {
+    if (isSelfAdmin && resolved.isMicrophoneEnabled) {
      DropdownMenuItem(
        text = { Text(stringResource(R.string.CallParticipantSheet__mute_audio)) },
        leadingIcon = { Icon(painter = painterResource(R.drawable.symbol_mic_slash_24), contentDescription = null) },
@@ -49,7 +49,6 @@ import org.signal.core.ui.compose.Previews
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.webrtc.WebRtcLocalRenderState
 import org.thoughtcrime.securesms.events.CallParticipant
-import org.signal.core.ui.R as CoreUiR

 /**
 * Small moveable local video renderer that displays the user's video in a draggable and expandable view.
@@ -161,7 +160,7 @@ fun MoveableLocalVideoRenderer(
        ) {
          Icon(
            imageVector = ImageVector.vectorResource(
-              if (isFocused) R.drawable.symbol_minimize_24 else CoreUiR.drawable.symbol_maximize_24
+              if (isFocused) R.drawable.symbol_minimize_24 else R.drawable.symbol_maximize_24
            ),
            tint = MaterialTheme.colorScheme.onSecondaryContainer,
            contentDescription = stringResource(
@@ -75,7 +75,7 @@ fun PictureInPictureCallScreen(
      renderInPip = true,
      raiseHandAllowed = false,
      onInfoMoreInfoClick = null,
-      mirrorVideo = isFullScreenLocalParticipant && !fullScreenParticipant.isScreenSharing,
+      mirrorVideo = isFullScreenLocalParticipant,
      modifier = Modifier.fillMaxSize()
    )

@@ -35,7 +35,6 @@ public class ContactRepository {

  public static final String ID_COLUMN           = "id";
  public static final String NAME_COLUMN         = "name";
-  public static final String SORT_NAME_COLUMN    = "sort_name";
         static final String NUMBER_COLUMN       = "number";
         static final String NUMBER_TYPE_COLUMN  = "number_type";
         static final String LABEL_COLUMN        = "label";
@@ -56,11 +55,6 @@ public class ContactRepository {
      return Util.getFirstNonEmpty(system, profile);
    }));

-    // The key the results are actually ordered by (nickname/system/profile/username, lowercased). Letter
-    // headers must derive from this rather than NAME_COLUMN, which omits nickname/username and can begin
-    // with a different letter than the row's sort position.
-    add(new Pair<>(SORT_NAME_COLUMN, cursor -> CursorUtil.requireString(cursor, RecipientTable.SORT_NAME)));
-
    add(new Pair<>(NUMBER_COLUMN, cursor -> {
      String phone = CursorUtil.requireString(cursor, RecipientTable.E164);
      String email = CursorUtil.requireString(cursor, RecipientTable.EMAIL);
@@ -9,6 +9,7 @@ import android.content.ContentResolver;
 import android.content.Context;
 import android.net.Uri;
 import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
 import android.provider.ContactsContract;

 import com.bumptech.glide.load.data.StreamLocalUriFetcher;
@@ -30,7 +31,7 @@ class ContactPhotoLocalUriFetcher extends StreamLocalUriFetcher {
  protected InputStream loadResource(Uri uri, ContentResolver contentResolver)
      throws FileNotFoundException
  {
-    if (VERSION.SDK_INT >= 14) {
+    if (VERSION.SDK_INT >= VERSION_CODES.ICE_CREAM_SANDWICH) {
      return ContactsContract.Contacts.openContactPhotoInputStream(contentResolver, uri, true);
    } else {
      return ContactsContract.Contacts.openContactPhotoInputStream(contentResolver, uri);
@@ -643,7 +643,7 @@ object ContactSearchModels {
      val recipient = getRecipient(model)
      val suffix: CharSequence? = if (recipient.isSystemContact && !recipient.showVerified) {
        SpannableStringBuilder().apply {
-          val drawable = context.requireDrawable(CoreUiR.drawable.symbol_person_circle_24).apply {
+          val drawable = context.requireDrawable(R.drawable.symbol_person_circle_24).apply {
            setTint(ContextCompat.getColor(context, CoreUiR.color.signal_colorOnSurface))
          }
          SpanUtil.appendCenteredImageSpan(this, drawable, 16, 16)
--- a/Show More
+++ b/Show More