Bump version to 8.12.1

Update baseline profile.
Update translations and other static files.
2026-06-09 16:56:21 +01:00 · 2026-05-21 17:06:28 -04:00 · 2026-05-21 16:58:59 -04:00 · 2026-05-21 16:36:58 -04:00 · 2026-05-21 16:57:14 -03:00 · 2026-05-21 15:38:37 -04:00
748 changed files with 32432 additions and 15044 deletions
@@ -27,8 +27,8 @@ plugins {
 val staticIps = Properties().apply { file("static-ips.properties").reader().use { load(it) } }
 staticIps.stringPropertyNames().forEach { rootProject.extra[it] = staticIps.getProperty(it) }

-val canonicalVersionCode = 1687
-val canonicalVersionName = "8.10.2"
+val canonicalVersionCode = 1694
+val canonicalVersionName = "8.12.1"
 val currentHotfixVersion = 0
 val maxHotfixVersions = 100

@@ -100,6 +100,9 @@ tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class.java).conf
  if (!isTestTask && (name.contains("Mocked") || name.contains("Benchmark"))) {
    source("$projectDir/src/benchmarkShared/java")
  }
+  if (isTestTask && name.contains("AndroidTest")) {
+    source("$projectDir/src/benchmarkShared/java")
+  }
 }

 wire {
@@ -168,6 +171,7 @@ android {

    getByName("androidTest") {
      java.srcDir("$projectDir/src/testShared")
+      java.srcDir("$projectDir/src/benchmarkShared/java")
    }
  }

@@ -272,7 +276,6 @@ android {
    buildConfigField("String", "STRIPE_PUBLISHABLE_KEY", "\"pk_live_6cmGZopuTsV8novGgJJW9JpC00vLIgtQ1D\"")
    buildConfigField("boolean", "TRACING_ENABLED", "false")
    buildConfigField("boolean", "LINK_DEVICE_UX_ENABLED", "false")
-    buildConfigField("boolean", "USE_STRING_ID", "false")

    ndk {
      abiFilters += listOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
@@ -288,7 +291,11 @@ android {
      }
    }

-    testInstrumentationRunner = "org.thoughtcrime.securesms.testing.SignalTestRunner"
+    testInstrumentationRunner = if (project.hasProperty("imoTests")) {
+      "org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverTestRunner"
+    } else {
+      "org.thoughtcrime.securesms.testing.SignalTestRunner"
+    }
    testInstrumentationRunnerArguments["clearPackageData"] = "true"
  }

@@ -346,6 +353,7 @@ android {

      buildConfigField("String", "BUILD_VARIANT_TYPE", "\"Instrumentation\"")
      buildConfigField("String", "STRIPE_BASE_URL", "\"http://127.0.0.1:8080/stripe\"")
+      buildConfigField("String[]", "UNIDENTIFIED_SENDER_TRUST_ROOTS", "new String[]{ \"BVT/2gHqbrG1xzuIypLIOjFgMtihrMld1/5TGADL6Dhv\"}")
    }

    create("spinner") {
@@ -463,8 +471,8 @@ android {
      buildConfigField("String", "SIGNAL_CDN3_URL", "\"https://cdn3-staging.signal.org\"")
      buildConfigField("String", "SIGNAL_CDSI_URL", "\"https://cdsi.staging.signal.org\"")
      buildConfigField("String", "SIGNAL_SVR2_URL", "\"https://svr2.staging.signal.org\"")
-      buildConfigField("String", "SVR2_MRENCLAVE_LEGACY", "\"a75542d82da9f6914a1e31f8a7407053b99cc99a0e7291d8fbd394253e19b036\"")
-      buildConfigField("String", "SVR2_MRENCLAVE", "\"97f151f6ed078edbbfd72fa9cae694dcc08353f1f5e8d9ccd79a971b10ffc535\"")
+      buildConfigField("String", "SVR2_MRENCLAVE_LEGACY", "\"97f151f6ed078edbbfd72fa9cae694dcc08353f1f5e8d9ccd79a971b10ffc535\"")
+      buildConfigField("String", "SVR2_MRENCLAVE", "\"3c699f4975aaa3d172c0aad042f94f031b2b03e10b9c19a45116a01693d83302\"")
      buildConfigField("String[]", "UNIDENTIFIED_SENDER_TRUST_ROOTS", "new String[]{\"BbqY1DzohE4NUZoVF+L18oUPrK3kILllLEJh2UnPSsEx\", \"BYhU6tPjqP46KGZEzRs1OL4U39V5dlPJ/X09ha4rErkm\"}")
      buildConfigField("String", "ZKGROUP_SERVER_PUBLIC_PARAMS", "\"ABSY21VckQcbSXVNCGRYJcfWHiAMZmpTtTELcDmxgdFbtp/bWsSxZdMKzfCp8rvIs8ocCU3B37fT3r4Mi5qAemeGeR2X+/YmOGR5ofui7tD5mDQfstAI9i+4WpMtIe8KC3wU5w3Inq3uNWVmoGtpKndsNfwJrCg0Hd9zmObhypUnSkfYn2ooMOOnBpfdanRtrvetZUayDMSC5iSRcXKpdlukrpzzsCIvEwjwQlJYVPOQPj4V0F4UXXBdHSLK05uoPBCQG8G9rYIGedYsClJXnbrgGYG3eMTG5hnx4X4ntARBgELuMWWUEEfSK0mjXg+/2lPmWcTZWR9nkqgQQP0tbzuiPm74H2wMO4u1Wafe+UwyIlIT9L7KLS19Aw8r4sPrXZSSsOZ6s7M1+rTJN0bI5CKY2PX29y5Ok3jSWufIKcgKOnWoP67d5b2du2ZVJjpjfibNIHbT/cegy/sBLoFwtHogVYUewANUAXIaMPyCLRArsKhfJ5wBtTminG/PAvuBdJ70Z/bXVPf8TVsR292zQ65xwvWTejROW6AZX6aqucUjlENAErBme1YHmOSpU6tr6doJ66dPzVAWIanmO/5mgjNEDeK7DDqQdB1xd03HT2Qs2TxY3kCK8aAb/0iM0HQiXjxZ9HIgYhbtvGEnDKW5ILSUydqH/KBhW4Pb0jZWnqN/YgbWDKeJxnDbYcUob5ZY5Lt5ZCMKuaGUvCJRrCtuugSMaqjowCGRempsDdJEt+cMaalhZ6gczklJB/IbdwENW9KeVFPoFNFzhxWUIS5ML9riVYhAtE6JE5jX0xiHNVIIPthb458cfA8daR0nYfYAUKogQArm0iBezOO+mPk5vCNWI+wwkyFCqNDXz/qxl1gAntuCJtSfq9OC3NkdhQlgYQ==\"")
      buildConfigField("String", "GENERIC_SERVER_PUBLIC_PARAMS", "\"AHILOIrFPXX9laLbalbA9+L1CXpSbM/bTJXZGZiuyK1JaI6dK5FHHWL6tWxmHKYAZTSYmElmJ5z2A5YcirjO/yfoemE03FItyaf8W1fE4p14hzb5qnrmfXUSiAIVrhaXVwIwSzH6RL/+EO8jFIjJ/YfExfJ8aBl48CKHgu1+A6kWynhttonvWWx6h7924mIzW0Czj2ROuh4LwQyZypex4GuOPW8sgIT21KNZaafgg+KbV7XM1x1tF3XA17B4uGUaDbDw2O+nR1+U5p6qHPzmJ7ggFjSN6Utu+35dS1sS0P9N\"")
@@ -516,6 +524,9 @@ android {
 androidComponents {
  beforeVariants { variant ->
    variant.enable = variant.name in selectableVariants
+    if (variant.enable) {
+      (variant as? com.android.build.api.variant.HasUnitTestBuilder)?.enableUnitTest = true
+    }
  }
  onVariants(selector().all()) { variant: com.android.build.api.variant.ApplicationVariant ->
    // Rename APK to include version name
@@ -686,6 +697,7 @@ dependencies {
  implementation(libs.google.play.services.maps)
  implementation(libs.google.play.services.auth)
  implementation(libs.google.signin)
+  implementation(libs.androidx.media)
  implementation(libs.bundles.media3)
  implementation(libs.conscrypt.android)
  implementation(libs.signal.aesgcmprovider)
@@ -513,6 +513,17 @@
            column="31"/>
    </issue>

+    <issue
+        id="SoonBlockedPrivateApi"
+        message="Reflective access to mAttachInfo will throw an exception when targeting API 35 and above"
+        errorLine1="      Field attachInfoField = View.class.getDeclaredField(&quot;mAttachInfo&quot;);"
+        errorLine2="                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/org/thoughtcrime/securesms/components/KeyboardAwareLinearLayout.java"
+            line="157"
+            column="31"/>
+    </issue>
+
    <issue
        id="SimpleDateFormat"
        message="To get local formatting use `getDateInstance()`, `getDateTimeInstance()`, or `getTimeInstance()`, or use `new SimpleDateFormat(String template, Locale locale)` with for example `Locale.US` for ASCII dates."
@@ -7,6 +7,7 @@
 -keep class org.signal.libsignal.usernames.** { *; }
 -keep class org.thoughtcrime.securesms.** { *; }
 -keep class org.signal.donations.json.** { *; }
+-keep class org.signal.network.** { *; }
 -keepclassmembers class ** {
    public void onEvent*(**);
 }
@@ -16,6 +17,14 @@

 -keep class androidx.window.** { *; }

+# Workaround for R8 non-determinism in AGP 9.x. R8 inconsistently keeps or strips
+# the Signature attribute on this Kotlin lambda subclass of the generic
+# LottieValueCallback, causing intermittent dex byte differences. Explicitly
+# keeping the class stabilizes R8's attribute decisions.
+-keep class com.airbnb.lottie.compose.LottieDynamicPropertiesKt$toValueCallback$1 {
+  *;
+}
+
 -keepclassmembers class * extends androidx.constraintlayout.motion.widget.Key {
  public <init>();
 }
@@ -0,0 +1,36 @@
+package org.thoughtcrime.securesms
+
+import org.signal.core.util.logging.AndroidLogger
+import org.signal.core.util.logging.Log
+import org.signal.libsignal.protocol.logging.SignalProtocolLoggerProvider
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencyProvider
+import org.thoughtcrime.securesms.logging.CustomSignalProtocolLogger
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverDependencyProvider
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverTestRunner
+
+/**
+ * Application used when running `IncomingMessageObserver` instrumentation tests. Installs
+ * [IncomingMessageObserverDependencyProvider] so the websocket and job manager are replaced
+ * with test-friendly implementations. Selected by [IncomingMessageObserverTestRunner] when
+ * gradle is invoked with `-PimoTests`.
+ */
+class IncomingMessageObserverInstrumentationApplicationContext : ApplicationContext() {
+
+  override fun initializeAppDependencies() {
+    val default = ApplicationDependencyProvider(this)
+    AppDependencies.init(this, IncomingMessageObserverDependencyProvider(this, default))
+    AppDependencies.deadlockDetector.start()
+  }
+
+  override fun initializeLogging() {
+    Log.initialize({ true }, AndroidLogger)
+    SignalProtocolLoggerProvider.setProvider(CustomSignalProtocolLogger())
+  }
+
+  override fun beginJobLoop() = Unit
+
+  fun beginJobLoopForTests() {
+    super.beginJobLoop()
+  }
+}
@@ -16,6 +16,7 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.signal.donations.InAppPaymentType
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
@@ -26,7 +27,6 @@ import org.thoughtcrime.securesms.testing.InAppPaymentsRule
 import org.thoughtcrime.securesms.testing.RxTestSchedulerRule
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.testing.actions.RecyclerViewScrollToBottomAction
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.SubscriberId
 import java.math.BigDecimal
@@ -7,9 +7,9 @@ package org.thoughtcrime.securesms.database

 import org.signal.core.util.Base64
 import org.signal.core.util.Util
+import org.signal.network.api.AttachmentUploadResult
 import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.Cdn
-import org.whispersystems.signalservice.api.attachment.AttachmentUploadResult
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId
 import kotlin.random.Random

@@ -10,11 +10,11 @@ import org.thoughtcrime.securesms.recipients.LiveRecipientCache
 import org.whispersystems.signalservice.api.SignalServiceDataStore
 import org.whispersystems.signalservice.api.SignalServiceMessageSender
 import org.whispersystems.signalservice.api.account.AccountApi
-import org.whispersystems.signalservice.api.attachment.AttachmentApi
 import org.whispersystems.signalservice.api.donations.DonationsApi
 import org.whispersystems.signalservice.api.keys.KeysApi
 import org.whispersystems.signalservice.api.message.MessageApi
 import org.whispersystems.signalservice.api.websocket.SignalWebSocket
+import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration
 import org.whispersystems.signalservice.internal.push.PushServiceSocket

 /**
@@ -41,7 +41,7 @@ class InstrumentationApplicationDependencyProvider(val application: Application,
    return recipientCache
  }

-  override fun provideArchiveApi(authWebSocket: SignalWebSocket.AuthenticatedWebSocket, unauthWebSocket: SignalWebSocket.UnauthenticatedWebSocket, pushServiceSocket: PushServiceSocket): ArchiveApi {
+  override fun provideArchiveApi(authWebSocket: SignalWebSocket.AuthenticatedWebSocket, unauthWebSocket: SignalWebSocket.UnauthenticatedWebSocket, pushServiceSocket: PushServiceSocket, signalServiceConfiguration: SignalServiceConfiguration): ArchiveApi {
    return mockk()
  }

@@ -52,12 +52,11 @@ class InstrumentationApplicationDependencyProvider(val application: Application,
  override fun provideSignalServiceMessageSender(
    protocolStore: SignalServiceDataStore,
    pushServiceSocket: PushServiceSocket,
-    attachmentApi: AttachmentApi,
    messageApi: MessageApi,
    keysApi: KeysApi
  ): SignalServiceMessageSender {
    if (signalServiceMessageSender == null) {
-      signalServiceMessageSender = spyk(objToCopy = default.provideSignalServiceMessageSender(protocolStore, pushServiceSocket, attachmentApi, messageApi, keysApi))
+      signalServiceMessageSender = spyk(objToCopy = default.provideSignalServiceMessageSender(protocolStore, pushServiceSocket, messageApi, keysApi))
    }
    return signalServiceMessageSender!!
  }
@@ -19,6 +19,8 @@ import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
+import org.signal.network.NetworkResult
+import org.signal.network.exceptions.NonSuccessfulResponseCodeException
 import org.thoughtcrime.securesms.backup.DeletionState
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
@@ -27,8 +29,6 @@ import org.thoughtcrime.securesms.jobs.protos.BackupDeleteJobData
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.RemoteConfig
-import org.whispersystems.signalservice.api.NetworkResult
-import org.whispersystems.signalservice.api.push.exceptions.NonSuccessfulResponseCodeException

 class BackupDeleteJobTest {

@@ -27,6 +27,8 @@ import org.signal.core.util.billing.BillingPurchaseState
 import org.signal.core.util.billing.BillingResponseCode
 import org.signal.core.util.money.FiatMoney
 import org.signal.donations.InAppPaymentType
+import org.signal.network.NetworkResult
+import org.signal.network.exceptions.NonSuccessfulResponseCodeException
 import org.thoughtcrime.securesms.backup.DeletionState
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
@@ -42,8 +44,6 @@ import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.net.SignalNetwork
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.RemoteConfig
-import org.whispersystems.signalservice.api.NetworkResult
-import org.whispersystems.signalservice.api.push.exceptions.NonSuccessfulResponseCodeException
 import org.whispersystems.signalservice.api.storage.IAPSubscriptionId
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription.ChargeFailure
@@ -0,0 +1,843 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.main
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Bundle
+import android.view.View
+import android.widget.TextView
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.lifecycle.ViewModelProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.models.media.Media
+import org.thoughtcrime.securesms.MainActivity
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.calls.log.CallLogFragment
+import org.thoughtcrime.securesms.conversation.ConversationArgs
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.conversation.v2.ConversationFragment
+import org.thoughtcrime.securesms.conversationlist.ConversationListArchiveFragment
+import org.thoughtcrime.securesms.conversationlist.ConversationListFragment
+import org.thoughtcrime.securesms.mediasend.v2.MediaSelectionActivity
+import org.thoughtcrime.securesms.providers.BlobProvider
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.stories.landing.StoriesLandingFragment
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import java.io.ByteArrayOutputStream
+import java.util.Collections
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * End-to-end launch tests for [MainActivity], covering cold-launch and onNewIntent paths
+ * through [MainNavigationViewModel].
+ */
+@RunWith(AndroidJUnit4::class)
+class MainNavigationLaunchTest {
+
+  @get:Rule
+  val harness = SignalActivityRule(othersCount = 2)
+
+  private val context: Context get() = harness.context
+  private val recipient: RecipientId get() = harness.others.first()
+
+  /**
+   * Share-target cold-launch regression test. Pre-fix, wrapNavigator() re-routed the
+   * early-staged Conversation through goTo(), whose async wallpaper-prefetch path emitted
+   * a SECOND internalDetailLocation with a fresh ConversationArgs — recreating the
+   * fragment and dropping share data.
+   */
+  @Test
+  fun coldLaunch_shareIntent_createsFragmentExactlyOnceWithShareData() {
+    val timestamp = System.currentTimeMillis()
+    val mimeType = "image/jpeg"
+    val blob = realBlob(byteArrayOf(0x01, 0x02, 0x03), mimeType)
+    val intent = shareToConversationIntent(
+      recipient = recipient,
+      blob = blob,
+      mimeType = mimeType,
+      shareDataTimestamp = timestamp
+    )
+
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+
+      try {
+        await(timeoutMs = 10_000, description = "ConversationFragment to be added") {
+          recorder.createdArgs.isNotEmpty()
+        }
+      } catch (e: IllegalStateException) {
+        val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+        val state = runOnMainSync {
+          buildString {
+            appendLine("--- diagnostic dump ---")
+            appendLine("fragments observed: ${recorder.allCreated}")
+            appendLine("activity fragments: ${launched.activity.supportFragmentManager.fragments.map { it::class.simpleName }}")
+            appendLine("vm.currentListLocation: ${vm.mainNavigationState.value.currentListLocation}")
+            appendLine("vm.earlyNavigationDetailLocationRequested: ${vm.earlyNavigationDetailLocationRequested}")
+          }
+        }
+        throw IllegalStateException("${e.message}\n$state", e)
+      }
+
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+      awaitConversationTitle(launched, expectedName)
+
+      // Give the post-navigator wallpaper-prefetch path a chance to emit a (pre-fix)
+      // duplicate second nav before we count fragments.
+      Thread.sleep(750)
+
+      check(recorder.createdArgs.size == 1) {
+        "Expected exactly one ConversationFragment, got ${recorder.createdArgs.size}"
+      }
+      val args = recorder.createdArgs.single()
+      check(args.shareDataTimestamp == timestamp) {
+        "Expected shareDataTimestamp=$timestamp, got ${args.shareDataTimestamp}"
+      }
+      check(args.recipientId == recipient) {
+        "Expected recipient=$recipient, got ${args.recipientId}"
+      }
+      check(args.draftMedia == blob) {
+        "Expected draftMedia=$blob, got ${args.draftMedia}"
+      }
+    }
+  }
+
+  /**
+   * Image-share cold-launch: the dispatch path through `ShareOrDraftData.StartSendMedia`
+   * that hops the user from the conversation into the media-send screen
+   * ([MediaSelectionActivity]). Asserts that the secondary activity actually launches and
+   * that its [MediaReviewFragment] surfaces the recipient's display name in the top
+   * corner — i.e. it knows who the share is targeted at.
+   */
+  @Test
+  fun coldLaunch_shareImageIntent_opensMediaSendForRecipient() {
+    val media = realJpegMedia()
+    val intent = shareImageIntent(recipient = recipient, media = media)
+
+    launchSync(intent).use { launched ->
+      val mediaSend = launched.awaitActivity(MediaSelectionActivity::class.java, timeoutMs = 20_000)
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+
+      await(timeoutMs = 15_000, description = "recipient label populated in MediaReviewFragment") {
+        // await() already runs the predicate on the main thread; nesting another
+        // runOnMainSync here would throw "can not be called from the main application thread".
+        mediaSend.findViewById<TextView>(R.id.recipient)?.text?.toString() == expectedName
+      }
+
+      // Exactly one ConversationFragment should have been created — the share dispatch
+      // happens from inside it, then it stays put while the media editor sits on top.
+      check(launched.recorder.createdArgs.size == 1) {
+        "Expected exactly one ConversationFragment for image share, got ${launched.recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  /**
+   * Text-share cold-launch: the dispatch path through `ShareOrDraftData.SetText`. Asserts
+   * the navigation boundary — one ConversationFragment, no secondary activity pushed on
+   * top — *and* that the draft text actually shows up in the composer the user sees.
+   */
+  @Test
+  fun coldLaunch_shareTextIntent_opensConversationWithDraftText() {
+    val draftText = "hello from share"
+    val intent = shareTextIntent(recipient = recipient, text = draftText)
+
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      await(timeoutMs = 10_000, description = "ConversationFragment to be added") {
+        recorder.createdArgs.isNotEmpty()
+      }
+
+      awaitComposerText(launched, draftText)
+
+      // Give a beat for any spurious second navigation to surface.
+      Thread.sleep(750)
+
+      check(recorder.createdArgs.size == 1) {
+        "Expected exactly one ConversationFragment, got ${recorder.createdArgs.size}"
+      }
+      val args = recorder.createdArgs.single()
+      check(args.recipientId == recipient) {
+        "Expected recipient=$recipient, got ${args.recipientId}"
+      }
+      check(args.draftMedia == null) {
+        "Expected no draftMedia, got ${args.draftMedia}"
+      }
+      check(launched.nonMainActivities().isEmpty()) {
+        "Text share should not launch a secondary activity, got ${launched.nonMainActivities().map { it::class.simpleName }}"
+      }
+    }
+  }
+
+  @Test
+  fun coldLaunch_notificationIntent_opensConversation() {
+    val intent = notificationToConversationIntent(recipient)
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      await(timeoutMs = 10_000, description = "ConversationFragment to be added") {
+        recorder.createdArgs.isNotEmpty()
+      }
+
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+      awaitConversationTitle(launched, expectedName)
+
+      check(recorder.createdArgs.size == 1) {
+        "Expected exactly one ConversationFragment, got ${recorder.createdArgs.size}"
+      }
+      val args = recorder.createdArgs.single()
+      check(args.recipientId == recipient) {
+        "Expected recipient=$recipient, got ${args.recipientId}"
+      }
+      check(args.threadId > 0) {
+        "Expected threadId > 0, got ${args.threadId}"
+      }
+      check(args.draftMedia == null) {
+        "Expected no draftMedia, got ${args.draftMedia}"
+      }
+      check(args.shareDataTimestamp == -1L) {
+        "Expected shareDataTimestamp=-1 for notification path, got ${args.shareDataTimestamp}"
+      }
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
+        "Expected currentListLocation=CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+    }
+  }
+
+  @Test
+  fun coldLaunch_tabIntent_setsListLocation() {
+    val intent = tabIntent(MainNavigationListLocation.CALLS)
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      awaitListFragment(launched, MainNavigationListLocation.CALLS)
+
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CALLS) {
+        "Expected VM CALLS, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+      Thread.sleep(750)
+      check(recorder.createdArgs.isEmpty()) {
+        "Expected no ConversationFragment for tab launch, got ${recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  /**
+   * Locks down present cold-launch behaviour for KEY_DETAIL_LOCATION: today it is only
+   * consumed by onNewIntent. If a future change starts handling it on cold launch, this
+   * test should fail and force a deliberate decision.
+   */
+  @Test
+  fun coldLaunch_detailLocationIntent_isNoOpToday() {
+    val intent = detailLocationIntent(MainNavigationDetailLocation.Chats.ConversationSettings(recipient))
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      Thread.sleep(1500)
+      check(recorder.createdArgs.isEmpty()) {
+        "KEY_DETAIL_LOCATION is currently only handled by onNewIntent. If a future change " +
+          "starts handling it on cold launch, update or delete this test. Got: ${recorder.allCreated}"
+      }
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.earlyNavigationDetailLocationRequested == null) {
+        "Expected no early detail to be staged, got ${vm.earlyNavigationDetailLocationRequested}"
+      }
+    }
+  }
+
+  @Test
+  fun coldLaunch_deepLinkIntent_reachesChatsList() {
+    val intent = deepLinkIntent(Uri.parse("https://signal.org/test-not-a-real-deeplink"))
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      awaitListFragment(launched, MainNavigationListLocation.CHATS)
+
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
+        "Expected CHATS for deep-link launch, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+      check(recorder.createdArgs.isEmpty()) {
+        "Expected no ConversationFragment for deep-link launch, got ${recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  @Test
+  fun coldLaunch_noExtras_defaultsToChats() {
+    val intent = Intent(context, MainActivity::class.java)
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      awaitListFragment(launched, MainNavigationListLocation.CHATS)
+
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
+        "Expected default CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+      Thread.sleep(750)
+      check(vm.earlyNavigationDetailLocationRequested == null) {
+        "Expected no early detail, got ${vm.earlyNavigationDetailLocationRequested}"
+      }
+      check(recorder.createdArgs.isEmpty()) {
+        "Expected no ConversationFragment for bare launch, got ${recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  @Test
+  fun warmStart_onNewIntent_conversationIntent_opensConversation() {
+    launchSync(Intent(context, MainActivity::class.java)).use { launched ->
+      val recorder = launched.recorder
+      // Let the bare list settle so we know any further fragment adds came from onNewIntent.
+      Thread.sleep(1000)
+      val baseline = recorder.createdArgs.size
+
+      val warmIntent = notificationToConversationIntent(recipient)
+      runOnMainSync {
+        InstrumentationRegistry.getInstrumentation().callActivityOnNewIntent(launched.activity, warmIntent)
+      }
+
+      await(timeoutMs = 10_000, description = "ConversationFragment after onNewIntent") {
+        recorder.createdArgs.size > baseline
+      }
+
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+      awaitConversationTitle(launched, expectedName)
+
+      val newArgs = recorder.createdArgs.drop(baseline)
+      check(newArgs.size == 1) { "Expected one new ConversationFragment, got ${newArgs.size}" }
+      check(newArgs.single().recipientId == recipient) {
+        "Expected recipient=$recipient, got ${newArgs.single().recipientId}"
+      }
+    }
+  }
+
+  /**
+   * Mid-conversation onNewIntent with `KEY_DETAIL_LOCATION = Empty` — the contract used
+   * by [ConversationSettingsFragment.goToConversationList] to drop back to the chat list
+   * on phones. No new ConversationFragment should be added.
+   */
+  @Test
+  fun warmStart_onNewIntent_emptyDetailIntent_returnsToList() {
+    launchSync(notificationToConversationIntent(recipient)).use { launched ->
+      val recorder = launched.recorder
+      await(timeoutMs = 10_000, description = "initial ConversationFragment") {
+        recorder.createdArgs.isNotEmpty()
+      }
+      val baseline = recorder.createdArgs.size
+
+      val warmIntent = detailLocationIntent(MainNavigationDetailLocation.Empty)
+      runOnMainSync {
+        InstrumentationRegistry.getInstrumentation().callActivityOnNewIntent(launched.activity, warmIntent)
+      }
+
+      await(description = "no new ConversationFragment after Empty detail intent") {
+        recorder.createdArgs.size == baseline
+      }
+      // The user-visible signal that we're "back on the list" is the chat list fragment
+      // being attached, not just the VM saying CHATS.
+      awaitListFragment(launched, MainNavigationListLocation.CHATS)
+
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CHATS) {
+        "Expected CHATS, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+    }
+  }
+
+  @Test
+  fun warmStart_onNewIntent_tabIntent_switchesList() {
+    launchSync(Intent(context, MainActivity::class.java)).use { launched ->
+      awaitListFragment(launched, MainNavigationListLocation.CHATS)
+
+      val warmIntent = tabIntent(MainNavigationListLocation.CALLS)
+      runOnMainSync {
+        InstrumentationRegistry.getInstrumentation().callActivityOnNewIntent(launched.activity, warmIntent)
+      }
+
+      awaitListFragment(launched, MainNavigationListLocation.CALLS)
+
+      val vm = runOnMainSync { launched.activity.mainNavigationViewModel() }
+      check(vm.mainNavigationState.value.currentListLocation == MainNavigationListLocation.CALLS) {
+        "Expected VM CALLS, got ${vm.mainNavigationState.value.currentListLocation}"
+      }
+      check(launched.recorder.createdArgs.isEmpty()) {
+        "Expected no ConversationFragment for tab switch, got ${launched.recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  @Test
+  fun recreate_midConversation_restoresState() {
+    launchSync(notificationToConversationIntent(recipient)).use { launched ->
+      val recorder = launched.recorder
+      await(timeoutMs = 10_000, description = "initial ConversationFragment") {
+        recorder.createdArgs.isNotEmpty()
+      }
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+      awaitConversationTitle(launched, expectedName)
+      val initial = recorder.createdArgs.first()
+
+      runOnMainSync { launched.activity.recreate() }
+
+      await(timeoutMs = 15_000, description = "ConversationFragment after recreate") {
+        recorder.createdArgs.size >= 2
+      }
+      // Verify the user-visible title rebinds after recreate, not just the args.
+      awaitConversationTitle(launched, expectedName)
+
+      val recreated = recorder.createdArgs[1]
+      check(recreated.recipientId == initial.recipientId) {
+        "Recipient changed across recreate: ${initial.recipientId} -> ${recreated.recipientId}"
+      }
+      check(recreated.threadId == initial.threadId) {
+        "Thread changed across recreate: ${initial.threadId} -> ${recreated.threadId}"
+      }
+    }
+  }
+
+  @Test
+  fun recreate_midTab_restoresTab() {
+    launchSync(tabIntent(MainNavigationListLocation.CALLS)).use { launched ->
+      awaitListFragment(launched, MainNavigationListLocation.CALLS)
+
+      runOnMainSync { launched.activity.recreate() }
+
+      // Verify the user-visible tab content rebinds after recreate, not just the VM. The
+      // recorder removes destroyed fragments, so this only passes once the post-recreate
+      // CallLogFragment instance is attached.
+      awaitListFragment(launched, MainNavigationListLocation.CALLS)
+
+      // launched.activity returns the *latest* MainActivity (the holder updates in
+      // onActivityCreated), so this reads the post-recreate VM instance.
+      val location = runOnMainSync {
+        launched.activity.mainNavigationViewModel().mainNavigationState.value.currentListLocation
+      }
+      check(location == MainNavigationListLocation.CALLS) {
+        "Expected VM CALLS post-recreate, got $location"
+      }
+      check(launched.recorder.createdArgs.isEmpty()) {
+        "Expected no ConversationFragment across tab recreate, got ${launched.recorder.createdArgs.size}"
+      }
+    }
+  }
+
+  @Test
+  fun recreate_midShareConversation_preservesShareData() {
+    val timestamp = System.currentTimeMillis()
+    val mimeType = "image/jpeg"
+    val blob = realBlob(byteArrayOf(0x01, 0x02, 0x03), mimeType)
+    val intent = shareToConversationIntent(
+      recipient = recipient,
+      blob = blob,
+      mimeType = mimeType,
+      shareDataTimestamp = timestamp
+    )
+
+    launchSync(intent).use { launched ->
+      val recorder = launched.recorder
+      await(timeoutMs = 10_000, description = "initial ConversationFragment") {
+        recorder.createdArgs.isNotEmpty()
+      }
+      val expectedName = runOnMainSync { Recipient.resolved(recipient).getDisplayName(context) }
+      awaitConversationTitle(launched, expectedName)
+      val initialCount = recorder.createdArgs.size
+
+      runOnMainSync { launched.activity.recreate() }
+
+      await(timeoutMs = 15_000, description = "ConversationFragment after recreate") {
+        recorder.createdArgs.size > initialCount
+      }
+      awaitConversationTitle(launched, expectedName)
+
+      val recreated = recorder.createdArgs.last()
+      check(recreated.shareDataTimestamp == timestamp) {
+        "shareDataTimestamp not preserved across recreate: $timestamp -> ${recreated.shareDataTimestamp}"
+      }
+      check(recreated.draftMedia == blob) {
+        "draftMedia not preserved across recreate: $blob -> ${recreated.draftMedia}"
+      }
+    }
+  }
+
+  // region Helpers
+
+  /**
+   * Mirrors [org.thoughtcrime.securesms.sharing.v2.ShareActivity.openConversation]. We
+   * deliberately drop the producer's `clearTop` flags (NEW_TASK | CLEAR_TOP | SINGLE_TOP)
+   * — they are launch-routing concerns that are incompatible with our lifecycle monitor.
+   */
+  private fun shareToConversationIntent(
+    recipient: RecipientId,
+    blob: Uri,
+    mimeType: String,
+    draftText: String? = null,
+    shareDataTimestamp: Long = System.currentTimeMillis()
+  ): Intent {
+    val builder = ConversationIntents.createBuilder(context, recipient, -1L).blockingGet()
+    val conversationIntent = builder
+      .withDataUri(blob)
+      .withDataType(mimeType)
+      .withMedia(emptyList())
+      .withDraftText(draftText)
+      .withStickerLocator(null)
+      .asBorderless(false)
+      .withShareDataTimestamp(shareDataTimestamp)
+      .build()
+
+    return Intent(context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+    }
+  }
+
+  /**
+   * Mirrors the image-share path through [org.thoughtcrime.securesms.sharing.v2.ShareActivity.openConversation]:
+   * a non-empty `media` list is what flips dispatch to `ShareOrDraftData.StartSendMedia`,
+   * which is what triggers the hop to the media-send screen.
+   */
+  private fun shareImageIntent(recipient: RecipientId, media: Media): Intent {
+    val builder = ConversationIntents.createBuilder(context, recipient, -1L).blockingGet()
+    val conversationIntent = builder
+      .withDataUri(media.uri)
+      .withDataType(media.contentType)
+      .withMedia(listOf(media))
+      .withStickerLocator(null)
+      .asBorderless(false)
+      .withShareDataTimestamp(System.currentTimeMillis())
+      .build()
+
+    return Intent(context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+    }
+  }
+
+  /**
+   * Mirrors a text-only share. Empty media list + non-null draft text routes dispatch to
+   * `ShareOrDraftData.SetText`.
+   */
+  private fun shareTextIntent(recipient: RecipientId, text: String): Intent {
+    val builder = ConversationIntents.createBuilder(context, recipient, -1L).blockingGet()
+    val conversationIntent = builder
+      .withMedia(emptyList())
+      .withDraftText(text)
+      .withStickerLocator(null)
+      .asBorderless(false)
+      .withShareDataTimestamp(System.currentTimeMillis())
+      .build()
+
+    return Intent(context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+    }
+  }
+
+  private fun notificationToConversationIntent(recipient: RecipientId): Intent {
+    val conversationIntent = ConversationIntents.createBuilder(context, recipient, -1L)
+      .blockingGet()
+      .build()
+
+    return Intent(context, MainActivity::class.java).apply {
+      action = ConversationIntents.ACTION
+      putExtras(conversationIntent)
+    }
+  }
+
+  private fun tabIntent(tab: MainNavigationListLocation): Intent {
+    return Intent(context, MainActivity::class.java)
+      .putExtra("STARTING_TAB", tab)
+  }
+
+  private fun detailLocationIntent(location: MainNavigationDetailLocation): Intent {
+    return Intent(context, MainActivity::class.java)
+      .putExtra("DETAIL_LOCATION", location)
+  }
+
+  private fun realBlob(bytes: ByteArray, mimeType: String): Uri {
+    return BlobProvider.getInstance()
+      .forData(bytes)
+      .withMimeType(mimeType)
+      .createForSingleSessionInMemory()
+  }
+
+  /**
+   * Build a [Media] backed by a real 1×1 JPEG. The media-send screen attempts to decode
+   * the image during MediaReviewFragment setup, so a fake byte array won't survive — we
+   * need genuine JPEG bytes for the fragment to reach the state where `R.id.recipient`
+   * is populated.
+   */
+  private fun realJpegMedia(): Media {
+    val bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888)
+    val bytes = ByteArrayOutputStream().use { stream ->
+      bitmap.compress(Bitmap.CompressFormat.JPEG, 90, stream)
+      stream.toByteArray()
+    }
+    bitmap.recycle()
+    val uri = realBlob(bytes, "image/jpeg")
+    return Media(
+      uri = uri,
+      contentType = "image/jpeg",
+      date = 0L,
+      width = 1,
+      height = 1,
+      size = bytes.size.toLong(),
+      duration = 0L,
+      isBorderless = false,
+      isVideoGif = false,
+      bucketId = null,
+      caption = null,
+      transformProperties = null,
+      fileName = null
+    )
+  }
+
+  /**
+   * Mirrors [org.thoughtcrime.securesms.deeplinks.DeepLinkEntryActivity]: bare clearTop
+   * plus a [Uri] in the data field.
+   */
+  private fun deepLinkIntent(data: Uri): Intent {
+    return Intent(context, MainActivity::class.java).setData(data)
+  }
+
+  /**
+   * Synchronously launch [MainActivity] and return the running instance plus a fragment
+   * recorder wired up *before* the activity is created.
+   *
+   * We bypass [androidx.test.core.app.ActivityScenario] and
+   * [android.app.Instrumentation.startActivitySync] because both fail for our case:
+   * ActivityScenario's lifecycle tracker misses CREATED/STARTED/RESUMED for activities
+   * launched with a custom-action intent, and `startActivitySync` waits for main-thread
+   * idle which never arrives while MainActivity's composition + ConversationFragment
+   * setup keeps the looper busy.
+   */
+  private fun launchSync(intent: Intent): LaunchedActivity {
+    val recorder = ConversationFragmentRecorder()
+    val app = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
+    val resumed = CountDownLatch(1)
+    val activityHolder = arrayOfNulls<MainActivity>(1)
+    val allActivities: MutableList<Activity> = Collections.synchronizedList(mutableListOf())
+    val callbacks = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        allActivities += activity
+        if (activity is MainActivity) {
+          activityHolder[0] = activity
+          activity.supportFragmentManager.registerFragmentLifecycleCallbacks(recorder, true)
+        }
+      }
+
+      override fun onActivityStarted(activity: Activity) = Unit
+      override fun onActivityResumed(activity: Activity) {
+        if (activity is MainActivity) resumed.countDown()
+      }
+
+      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(callbacks)
+
+    // Application.startActivity from a non-Activity context requires FLAG_ACTIVITY_NEW_TASK.
+    val launchIntent = Intent(intent).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
+    try {
+      app.startActivity(launchIntent)
+    } catch (t: Throwable) {
+      app.unregisterActivityLifecycleCallbacks(callbacks)
+      throw t
+    }
+
+    if (!resumed.await(15, TimeUnit.SECONDS)) {
+      app.unregisterActivityLifecycleCallbacks(callbacks)
+      error("MainActivity did not reach RESUMED within 15s")
+    }
+    return LaunchedActivity(activityHolder, recorder, app, callbacks, allActivities)
+  }
+
+  private fun <T> runOnMainSync(block: () -> T): T {
+    var result: Result<T> = Result.failure(IllegalStateException("runOnMainSync did not produce a result"))
+    InstrumentationRegistry.getInstrumentation().runOnMainSync {
+      result = runCatching(block)
+    }
+    return result.getOrThrow()
+  }
+
+  private fun await(
+    timeoutMs: Long = 5_000,
+    pollMs: Long = 50,
+    description: String = "condition",
+    predicate: () -> Boolean
+  ) {
+    val deadline = System.currentTimeMillis() + timeoutMs
+    while (System.currentTimeMillis() < deadline) {
+      if (runOnMainSync(predicate)) return
+      Thread.sleep(pollMs)
+    }
+    error("Timed out after ${timeoutMs}ms waiting for $description")
+  }
+
+  private fun MainActivity.mainNavigationViewModel(): MainNavigationViewModel {
+    return ViewModelProvider(this as FragmentActivity, MainNavigationViewModel.Factory())[MainNavigationViewModel::class.java]
+  }
+
+  /**
+   * Wait until the latest [ConversationFragment]'s composer EditText shows [expected].
+   * setDraftText is invoked off the InputReadyState/ShareOrDraftData reactive chain, so the
+   * text won't be present at fragment-create time — we have to poll the rendered view.
+   */
+  private fun awaitComposerText(launched: LaunchedActivity, expected: String) {
+    await(timeoutMs = 15_000, description = "composer shows \"$expected\"") {
+      val frag = launched.recorder.latestActive() ?: return@await false
+      val view = frag.view ?: return@await false
+      view.findViewById<TextView>(R.id.embedded_text_editor)?.text?.toString() == expected
+    }
+  }
+
+  /**
+   * Wait until the latest [ConversationFragment]'s toolbar shows [expected]. Scoped through
+   * R.id.conversation_title_view to avoid colliding with other R.id.title uses.
+   */
+  private fun awaitConversationTitle(launched: LaunchedActivity, expected: String) {
+    await(timeoutMs = 15_000, description = "conversation title shows \"$expected\"") {
+      val frag = launched.recorder.latestActive() ?: return@await false
+      val view = frag.view ?: return@await false
+      val titleHost = view.findViewById<View>(R.id.conversation_title_view) ?: return@await false
+      titleHost.findViewById<TextView>(R.id.title)?.text?.toString() == expected
+    }
+  }
+
+  /**
+   * MainActivity hosts each tab as a different [Fragment] via Compose's `AndroidFragment`
+   * (see MainActivity.kt:662-698). The user sees the content of whichever one is currently
+   * attached, so a tab assertion that reads the FragmentManager is a real user-visible
+   * signal — strictly stronger than reading the VM's `currentListLocation`.
+   */
+  private fun listFragmentClass(location: MainNavigationListLocation): Class<out Fragment> = when (location) {
+    MainNavigationListLocation.CHATS -> ConversationListFragment::class.java
+    MainNavigationListLocation.ARCHIVE -> ConversationListArchiveFragment::class.java
+    MainNavigationListLocation.CALLS -> CallLogFragment::class.java
+    MainNavigationListLocation.STORIES -> StoriesLandingFragment::class.java
+  }
+
+  private fun awaitListFragment(launched: LaunchedActivity, location: MainNavigationListLocation) {
+    val expected = listFragmentClass(location)
+    try {
+      await(timeoutMs = 10_000, description = "${expected.simpleName} attached for $location") {
+        launched.recorder.isAttached(expected)
+      }
+    } catch (e: IllegalStateException) {
+      throw IllegalStateException("${e.message}; currently attached: ${launched.recorder.attachedNames()}", e)
+    }
+  }
+
+  // endregion
+
+  // region Types
+
+  /**
+   * Records every [ConversationFragment] added under an activity's fragment manager,
+   * capturing each fragment's arguments at create-time.
+   */
+  private class ConversationFragmentRecorder : FragmentManager.FragmentLifecycleCallbacks() {
+    val createdArgs: MutableList<ConversationArgs> = mutableListOf()
+    val allCreated: MutableList<String> = mutableListOf()
+    private val active: MutableList<ConversationFragment> = mutableListOf()
+    private val attached: MutableList<Fragment> = mutableListOf()
+    var destroyedCount: Int = 0
+      private set
+
+    /** Most-recently-added still-attached ConversationFragment, or null. Main-thread read. */
+    fun latestActive(): ConversationFragment? = active.lastOrNull()
+
+    /**
+     * Exact class match (not [Class.isInstance]) — `ConversationListArchiveFragment`
+     * extends `ConversationListFragment`, so an `isInstance` check for CHATS would falsely
+     * pass when the archive list is attached.
+     */
+    fun isAttached(clazz: Class<out Fragment>): Boolean = attached.any { it::class.java == clazz }
+
+    fun attachedNames(): List<String> = attached.map { it::class.simpleName ?: it::class.java.name }
+
+    override fun onFragmentCreated(fm: FragmentManager, f: Fragment, savedInstanceState: android.os.Bundle?) {
+      allCreated += f::class.simpleName ?: f::class.java.name
+      attached += f
+      if (f is ConversationFragment) {
+        createdArgs += ConversationIntents.readArgsFromBundle(f.requireArguments())
+        active += f
+      }
+    }
+
+    override fun onFragmentDestroyed(fm: FragmentManager, f: Fragment) {
+      attached.remove(f)
+      if (f is ConversationFragment) {
+        active.remove(f)
+        destroyedCount++
+      }
+    }
+  }
+
+  private class LaunchedActivity(
+    private val activityHolder: Array<MainActivity?>,
+    val recorder: ConversationFragmentRecorder,
+    private val app: Application,
+    private val callbacks: Application.ActivityLifecycleCallbacks,
+    private val allActivities: MutableList<Activity>
+  ) : AutoCloseable {
+    /**
+     * Always returns the *latest* MainActivity instance so reads follow `recreate()`.
+     */
+    val activity: MainActivity get() = checkNotNull(activityHolder[0]) { "No active MainActivity" }
+
+    /**
+     * Poll until an activity of [clazz] has been created, then return it. Used to assert
+     * the share-image flow's hop into MediaSelectionActivity.
+     */
+    fun <T : Activity> awaitActivity(clazz: Class<T>, timeoutMs: Long = 10_000): T {
+      val deadline = System.currentTimeMillis() + timeoutMs
+      while (System.currentTimeMillis() < deadline) {
+        val match = synchronized(allActivities) {
+          allActivities.firstOrNull { clazz.isInstance(it) }
+        }
+        if (match != null) return clazz.cast(match)!!
+        Thread.sleep(50)
+      }
+      val seen = synchronized(allActivities) { allActivities.map { it::class.simpleName } }
+      error("Timed out after ${timeoutMs}ms waiting for ${clazz.simpleName}; saw $seen")
+    }
+
+    fun nonMainActivities(): List<Activity> = synchronized(allActivities) {
+      allActivities.filter { it !is MainActivity }.toList()
+    }
+
+    override fun close() {
+      // Don't wait for looper idle — secondary activities (e.g. MediaSelectionActivity
+      // opened by share processing) can keep it busy indefinitely. Finish every tracked
+      // activity so subsequent tests start from a clean slate.
+      val toFinish = synchronized(allActivities) { allActivities.toList() }
+      if (toFinish.isNotEmpty()) {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+          toFinish.forEach { it.finish() }
+        }
+      }
+      app.unregisterActivityLifecycleCallbacks(callbacks)
+    }
+  }
+
+  // endregion
+}
@@ -25,6 +25,7 @@ import org.signal.core.util.Util
 import org.signal.core.util.logging.Log
 import org.signal.core.util.update
 import org.signal.core.util.withinTransaction
+import org.signal.network.api.AttachmentUploadResult
 import org.thoughtcrime.securesms.attachments.Attachment
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.database.AttachmentTable
@@ -37,7 +38,6 @@ import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.testing.MessageContentFuzzer.DeleteForMeSync
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.util.IdentityUtil
-import org.whispersystems.signalservice.api.attachment.AttachmentUploadResult
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId
 import java.util.UUID

@@ -0,0 +1,353 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.messages
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isTrue
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.models.ServiceId
+import org.signal.core.util.UuidUtil
+import org.signal.core.util.orNull
+import org.signal.libsignal.protocol.IdentityKeyPair
+import org.signal.libsignal.protocol.SignalProtocolAddress
+import org.signal.libsignal.protocol.state.KyberPreKeyRecord
+import org.signal.libsignal.protocol.state.SignedPreKeyRecord
+import org.thoughtcrime.securesms.crypto.PreKeyUtil
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.testing.MessageContentFuzzer
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.Content
+import org.whispersystems.signalservice.internal.push.SyncMessage
+import java.util.UUID
+
+@Suppress("ClassName")
+@RunWith(AndroidJUnit4::class)
+class SyncMessageProcessorTest_synchronizePniChangeNumber {
+
+  @get:Rule
+  val harness = SignalActivityRule(createGroup = true)
+
+  private lateinit var messageHelper: MessageHelper
+
+  private val newPniUuid: UUID = UUID.randomUUID()
+  private val newPni: ServiceId.PNI = ServiceId.PNI.from(newPniUuid)
+
+  // 16-byte raw UUID — matches the actual wire format the server sends (per proto comment and
+  // iOS/Desktop behavior). Do NOT use `newPni.toByteString()` here — that produces libsignal's
+  // 17-byte ServiceIdBinary form, which is a different format.
+  private val newPniBytes: ByteString = UuidUtil.toByteArray(newPniUuid).toByteString()
+  private val newE164 = "+15555550199"
+  private val newPniIdentity: IdentityKeyPair = IdentityKeyPair.generate()
+  private val newSignedPreKey: SignedPreKeyRecord = PreKeyUtil.generateSignedPreKey(1234, newPniIdentity.privateKey)
+  private val newLastResortKyber: KyberPreKeyRecord = PreKeyUtil.generateLastResortKyberPreKey(5678, newPniIdentity.privateKey)
+  private val newRegistrationId = 4242
+
+  @Before
+  fun setUp() {
+    messageHelper = MessageHelper(harness)
+    SignalStore.account.deviceId = 2
+  }
+
+  @After
+  fun tearDown() {
+    messageHelper.tearDown()
+  }
+
+  @Test
+  fun appliesAllStateOnHappyPath() {
+    sendPniChangeNumber()
+
+    assertThat(SignalStore.account.e164).isEqualTo(newE164)
+    assertThat(SignalStore.account.pni).isEqualTo(newPni)
+    assertThat(SignalStore.account.pniRegistrationId).isEqualTo(newRegistrationId)
+    assertThat(SignalStore.account.pniIdentityKey.publicKey.serialize().toByteString())
+      .isEqualTo(newPniIdentity.publicKey.serialize().toByteString())
+    assertThat(SignalStore.account.pniPreKeys.activeSignedPreKeyId).isEqualTo(newSignedPreKey.id)
+    assertThat(SignalStore.account.pniPreKeys.isSignedPreKeyRegistered).isTrue()
+    assertThat(SignalStore.account.pniPreKeys.lastResortKyberPreKeyId).isEqualTo(newLastResortKyber.id)
+    assertThat(SignalStore.misc.forcePniSignedPreKeyRotation).isTrue()
+
+    val self = Recipient.self().fresh()
+    assertThat(self.requireE164()).isEqualTo(newE164)
+    assertThat(self.pni.orNull()).isEqualTo(newPni)
+
+    val pniProtocolStore = AppDependencies.protocolStore.pni()
+    val storedSigned = pniProtocolStore.loadSignedPreKey(newSignedPreKey.id)
+    assertThat(storedSigned.serialize().toByteString()).isEqualTo(newSignedPreKey.serialize().toByteString())
+    val storedKyber = pniProtocolStore.loadLastResortKyberPreKeys().firstOrNull { it.id == newLastResortKyber.id }
+    assertThat(storedKyber).isNotNull()
+    assertThat(storedKyber!!.serialize().toByteString()).isEqualTo(newLastResortKyber.serialize().toByteString())
+
+    // The IdentityTable cache is keyed by ServiceId string, not RecipientId — for self, that's
+    // separate ACI and PNI rows. We want the PNI row, so look it up by the new PNI directly.
+    val selfPniIdentity = pniProtocolStore.getIdentity(SignalProtocolAddress(newPni.toString(), SignalServiceAddress.DEFAULT_DEVICE_ID))
+    assertThat(selfPniIdentity).isNotNull()
+    assertThat(selfPniIdentity!!.publicKey.serialize().toByteString())
+      .isEqualTo(newPniIdentity.publicKey.serialize().toByteString())
+  }
+
+  @Test
+  fun appliesStateWhenLastResortKyberAbsent() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(lastResortKyberPreKey = null)
+
+    assertThat(SignalStore.account.e164).isEqualTo(newE164)
+    assertThat(SignalStore.account.pni).isEqualTo(newPni)
+    assertThat(SignalStore.account.pniRegistrationId).isEqualTo(newRegistrationId)
+    assertThat(SignalStore.account.pniPreKeys.activeSignedPreKeyId).isEqualTo(newSignedPreKey.id)
+    assertThat(SignalStore.account.pniPreKeys.isSignedPreKeyRegistered).isTrue()
+    // No kyber was supplied, so kyber metadata should be unchanged.
+    assertThat(SignalStore.account.pniPreKeys.lastResortKyberPreKeyId).isEqualTo(original.lastResortKyberPreKeyId)
+    assertThat(SignalStore.misc.forcePniSignedPreKeyRotation).isTrue()
+  }
+
+  @Test
+  fun bailsWhenPrimaryDevice() {
+    SignalStore.account.deviceId = SignalServiceAddress.DEFAULT_DEVICE_ID
+    val original = captureOriginalState()
+
+    sendPniChangeNumber()
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenSourceIsNotPrimaryDevice() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(sourceDeviceId = 3)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenEnvelopePniMissing() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(envelopePniBinary = null)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenIdentityKeyPairMissing() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(identityKeyPair = null)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenSignedPreKeyMissing() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(signedPreKey = null)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenRegistrationIdMissing() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(registrationId = null)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenRegistrationIdZero() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(registrationId = 0)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenNewE164Missing() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(e164 = null)
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenNewE164Empty() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(e164 = "")
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsWhenNewE164NotValid() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(e164 = "not a phone number")
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsOnMalformedIdentityKeyPair() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(identityKeyPair = malformedBytes())
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsOnMalformedSignedPreKey() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(signedPreKey = malformedBytes())
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun bailsOnMalformedLastResortKyber() {
+    val original = captureOriginalState()
+
+    sendPniChangeNumber(lastResortKyberPreKey = malformedBytes())
+
+    assertOriginalStatePreserved(original)
+  }
+
+  @Test
+  fun skipsRedeliveryWhenPniAlreadyMatches() {
+    sendPniChangeNumber()
+    val afterFirstApply = captureOriginalState()
+
+    val otherIdentity = IdentityKeyPair.generate()
+    val otherSignedPreKey = PreKeyUtil.generateSignedPreKey(9999, otherIdentity.privateKey)
+
+    sendPniChangeNumber(
+      identityKeyPair = otherIdentity.serialize().toByteString(),
+      signedPreKey = otherSignedPreKey.serialize().toByteString(),
+      e164 = "+15555550100",
+      timestamp = messageHelper.nextStartTime() + 1000
+    )
+
+    assertOriginalStatePreserved(afterFirstApply)
+  }
+
+  @Test
+  fun bailsWhenServerTimestampStale() {
+    sendPniChangeNumber()
+    val afterFirstApply = captureOriginalState()
+
+    val otherPniUuid = UUID.randomUUID()
+    val otherPniBytes = UuidUtil.toByteArray(otherPniUuid).toByteString()
+
+    sendPniChangeNumber(
+      envelopePniBinary = otherPniBytes,
+      e164 = "+15555550100",
+      timestamp = messageHelper.nextStartTime() - 100_000L
+    )
+
+    assertOriginalStatePreserved(afterFirstApply)
+  }
+
+  private fun captureOriginalState(): OriginalState {
+    val self = Recipient.self().fresh()
+    return OriginalState(
+      e164 = SignalStore.account.e164,
+      pni = SignalStore.account.pni,
+      pniRegistrationId = SignalStore.account.pniRegistrationId,
+      isSignedPreKeyRegistered = SignalStore.account.pniPreKeys.isSignedPreKeyRegistered,
+      activeSignedPreKeyId = SignalStore.account.pniPreKeys.activeSignedPreKeyId,
+      lastResortKyberPreKeyId = SignalStore.account.pniPreKeys.lastResortKyberPreKeyId,
+      pniIdentityPublicKey = SignalStore.account.pniIdentityKey.publicKey.serialize().toByteString(),
+      selfE164 = self.e164.orNull(),
+      selfPni = self.pni.orNull(),
+      forcePniSignedPreKeyRotation = SignalStore.misc.forcePniSignedPreKeyRotation
+    )
+  }
+
+  private fun assertOriginalStatePreserved(original: OriginalState) {
+    assertThat(SignalStore.account.e164).isEqualTo(original.e164)
+    assertThat(SignalStore.account.pni).isEqualTo(original.pni)
+    assertThat(SignalStore.account.pniRegistrationId).isEqualTo(original.pniRegistrationId)
+    assertThat(SignalStore.account.pniPreKeys.isSignedPreKeyRegistered).isEqualTo(original.isSignedPreKeyRegistered)
+    assertThat(SignalStore.account.pniPreKeys.activeSignedPreKeyId).isEqualTo(original.activeSignedPreKeyId)
+    assertThat(SignalStore.account.pniPreKeys.lastResortKyberPreKeyId).isEqualTo(original.lastResortKyberPreKeyId)
+    assertThat(SignalStore.account.pniIdentityKey.publicKey.serialize().toByteString())
+      .isEqualTo(original.pniIdentityPublicKey)
+    assertThat(SignalStore.misc.forcePniSignedPreKeyRotation).isEqualTo(original.forcePniSignedPreKeyRotation)
+    val self = Recipient.self().fresh()
+    assertThat(self.e164.orNull()).isEqualTo(original.selfE164)
+    assertThat(self.pni.orNull()).isEqualTo(original.selfPni)
+  }
+
+  private data class OriginalState(
+    val e164: String?,
+    val pni: ServiceId.PNI?,
+    val pniRegistrationId: Int,
+    val isSignedPreKeyRegistered: Boolean,
+    val activeSignedPreKeyId: Int,
+    val lastResortKyberPreKeyId: Int,
+    val pniIdentityPublicKey: ByteString,
+    val selfE164: String?,
+    val selfPni: ServiceId.PNI?,
+    val forcePniSignedPreKeyRotation: Boolean
+  )
+
+  private fun malformedBytes(): ByteString = byteArrayOf(0x00, 0x01, 0x02).toByteString()
+
+  private fun sendPniChangeNumber(
+    identityKeyPair: ByteString? = newPniIdentity.serialize().toByteString(),
+    signedPreKey: ByteString? = newSignedPreKey.serialize().toByteString(),
+    lastResortKyberPreKey: ByteString? = newLastResortKyber.serialize().toByteString(),
+    registrationId: Int? = newRegistrationId,
+    e164: String? = newE164,
+    envelopePniBinary: ByteString? = newPniBytes,
+    sourceDeviceId: Int = SignalServiceAddress.DEFAULT_DEVICE_ID,
+    timestamp: Long = messageHelper.nextStartTime()
+  ) {
+    val content = Content(
+      syncMessage = SyncMessage(
+        pniChangeNumber = SyncMessage.PniChangeNumber(
+          identityKeyPair = identityKeyPair,
+          signedPreKey = signedPreKey,
+          lastResortKyberPreKey = lastResortKyberPreKey,
+          registrationId = registrationId,
+          newE164 = e164
+        )
+      )
+    )
+
+    val envelope = MessageContentFuzzer.envelope(
+      timestamp = timestamp,
+      updatedPniBinary = envelopePniBinary
+    )
+
+    messageHelper.processor.process(
+      envelope = envelope,
+      content = content,
+      metadata = MessageContentFuzzer.envelopeMetadata(harness.self.id, harness.self.id, sourceDeviceId = sourceDeviceId),
+      serverDeliveredTimestamp = timestamp + 10
+    )
+  }
+}
@@ -0,0 +1,27 @@
+package org.thoughtcrime.securesms.messages.incomingmessageobserver
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverAssertions.assertMessageReceived
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverAssertions.assertNoMessageReceived
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverRule
+
+@RunWith(AndroidJUnit4::class)
+class DecryptionErrorTest {
+
+  @get:Rule
+  val rule = IncomingMessageObserverRule(peerCount = 2)
+
+  @Test
+  fun malformedEnvelope_dropsMessage_butPipelineRecovers() {
+    val peer = rule.peers[0]
+
+    rule.deliver { malformedEnvelope() from peer }
+    assertNoMessageReceived(from = peer, body = "subsequent")
+
+    rule.deliver { text("subsequent") from peer }
+    assertMessageReceived(from = peer, body = "subsequent")
+  }
+}
@@ -0,0 +1,39 @@
+package org.thoughtcrime.securesms.messages.incomingmessageobserver
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverAssertions.assertGroupMessageReceived
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverRule
+
+@RunWith(AndroidJUnit4::class)
+class IncomingGroupMessageTest {
+
+  @get:Rule
+  val rule = IncomingMessageObserverRule(peerCount = 5)
+
+  @Test
+  fun deliveredGroupText_isPersistedInGroupThread() {
+    val group = rule.testGroup
+
+    rule.deliver { groupText("hello group", group = group) from rule.peers[0] }
+
+    assertGroupMessageReceived(from = rule.peers[0], group = group, body = "hello group")
+  }
+
+  @Test
+  fun multipleGroupMembers_messagesPersistedFromEach() {
+    val group = rule.testGroup
+
+    rule.deliver {
+      groupText("from peer 0", group = group) from rule.peers[0]
+      groupText("from peer 1", group = group) from rule.peers[1]
+      groupText("from peer 2", group = group) from rule.peers[2]
+    }
+
+    assertGroupMessageReceived(from = rule.peers[0], group = group, body = "from peer 0")
+    assertGroupMessageReceived(from = rule.peers[1], group = group, body = "from peer 1")
+    assertGroupMessageReceived(from = rule.peers[2], group = group, body = "from peer 2")
+  }
+}
@@ -0,0 +1,22 @@
+package org.thoughtcrime.securesms.messages.incomingmessageobserver
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverAssertions.assertMessageReceived
+import org.thoughtcrime.securesms.testing.incomingmessageobserver.IncomingMessageObserverRule
+
+@RunWith(AndroidJUnit4::class)
+class IncomingTextMessageTest {
+
+  @get:Rule
+  val rule = IncomingMessageObserverRule(peerCount = 2)
+
+  @Test
+  fun deliveredOneToOneText_isPersisted() {
+    rule.deliver { text("hello world") from rule.peers[0] }
+
+    assertMessageReceived(from = rule.peers[0], body = "hello world")
+  }
+}
@@ -8,9 +8,9 @@ package org.thoughtcrime.securesms.testing
 import androidx.test.platform.app.InstrumentationRegistry
 import io.mockk.every
 import org.junit.rules.ExternalResource
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.util.JsonUtils
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.internal.push.SubscriptionsConfiguration

 /**
@@ -41,11 +41,12 @@ object MessageContentFuzzer {
  /**
   * Create an [Envelope].
   */
-  fun envelope(timestamp: Long, serverGuid: UUID = UUID.randomUUID()): Envelope {
+  fun envelope(timestamp: Long, serverGuid: UUID = UUID.randomUUID(), updatedPniBinary: ByteString? = null): Envelope {
    return Envelope.Builder()
      .clientTimestamp(timestamp)
      .serverTimestamp(timestamp + 5)
      .serverGuidBinary(serverGuid.toByteArray().toByteString())
+      .also { if (updatedPniBinary != null) it.updatedPniBinary(updatedPniBinary) }
      .build()
  }

@@ -17,7 +17,6 @@ import org.whispersystems.signalservice.internal.push.PreKeyResponse
 import org.whispersystems.signalservice.internal.push.PreKeyResponseItem
 import org.whispersystems.signalservice.internal.push.PushServiceSocket
 import org.whispersystems.signalservice.internal.push.RegistrationSessionMetadataJson
-import org.whispersystems.signalservice.internal.push.SenderCertificate
 import org.whispersystems.signalservice.internal.push.VerifyAccountResponse
 import org.whispersystems.signalservice.internal.push.WhoAmIResponse
 import java.security.SecureRandom
@@ -27,8 +26,6 @@ import java.security.SecureRandom
 */
 object MockProvider {

-  val senderCertificate = SenderCertificate().apply { certificate = ByteArray(0) }
-
  val lockedFailure = PushServiceSocket.RegistrationLockFailure().apply {
    svr1Credentials = AuthCredentials.create("username", "password")
    svr2Credentials = AuthCredentials.create("username", "password")
@@ -0,0 +1,71 @@
+package org.thoughtcrime.securesms.testing.incomingmessageobserver
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isTrue
+import org.signal.benchmark.setup.OtherClient
+import org.thoughtcrime.securesms.database.MessageTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.MessageRecord
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+
+/**
+ * Reads database state produced by [IncomingMessageObserverRule]-driven tests. Import members
+ * individually (e.g. `import …IncomingMessageObserverAssertions.assertMessageReceived`) so test
+ * bodies stay terse.
+ */
+object IncomingMessageObserverAssertions {
+
+  fun OtherClient.recipientId(): RecipientId = Recipient.externalPush(SignalServiceAddress(serviceId, e164)).id
+
+  fun findIncomingMessage(from: OtherClient, body: String): MessageRecord? {
+    val threadId = SignalDatabase.threads.getThreadIdFor(from.recipientId()) ?: return null
+    return SignalDatabase.messages.getConversation(threadId).use { cursor ->
+      MessageTable.MmsReader(cursor).use { reader -> reader.firstOrNull { it.body == body } }
+    }
+  }
+
+  fun findIncomingGroupMessage(from: OtherClient, group: GroupHandle, body: String): MessageRecord? {
+    val threadId = SignalDatabase.threads.getThreadIdFor(group.recipientId) ?: return null
+    return SignalDatabase.messages.getConversation(threadId).use { cursor ->
+      MessageTable.MmsReader(cursor).use { reader ->
+        reader.firstOrNull { it.body == body && it.fromRecipient.id == from.recipientId() }
+      }
+    }
+  }
+
+  fun assertMessageReceived(from: OtherClient, body: String) {
+    val record = findIncomingMessage(from, body)
+    assertThat(record, "incoming message with body \"$body\" from ${from.serviceId} not found").isNotNull()
+    assertThat(record!!.fromRecipient.id, "incoming message sender mismatch for body \"$body\"").isEqualTo(from.recipientId())
+  }
+
+  fun assertGroupMessageReceived(from: OtherClient, group: GroupHandle, body: String) {
+    val record = findIncomingGroupMessage(from, group, body)
+    assertThat(record, "group message \"$body\" from ${from.serviceId} in ${group.groupId} not found").isNotNull()
+  }
+
+  fun assertNoMessageReceived(from: OtherClient, body: String) {
+    val record = findIncomingMessage(from, body)
+    assertThat(record == null, "expected no message with body \"$body\" from ${from.serviceId}, but found one").isTrue()
+  }
+
+  fun assertNoMessagesInThread(recipientId: RecipientId) {
+    val threadId = SignalDatabase.threads.getThreadIdFor(recipientId) ?: return
+    val count = SignalDatabase.messages.getConversation(threadId).use { cursor -> cursor.count }
+    assertThat(count, "expected thread for $recipientId to be empty, but message count was").isEqualTo(0)
+  }
+
+  fun assertDeliveryReceipt(outgoingMessageId: Long) {
+    val record = SignalDatabase.messages.getMessageRecord(outgoingMessageId)
+    assertThat(record.hasDeliveryReceipt(), "expected delivery receipt on outgoing message $outgoingMessageId, but none recorded").isTrue()
+  }
+
+  fun assertReadReceipt(outgoingMessageId: Long) {
+    val record = SignalDatabase.messages.getMessageRecord(outgoingMessageId)
+    assertThat(record.hasReadReceipt(), "expected read receipt on outgoing message $outgoingMessageId, but none recorded").isTrue()
+  }
+}
@@ -0,0 +1,63 @@
+package org.thoughtcrime.securesms.testing.incomingmessageobserver
+
+import android.app.Application
+import org.signal.benchmark.setup.NoOpJob
+import org.signal.libsignal.net.Network
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencyProvider
+import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
+import org.thoughtcrime.securesms.jobmanager.JobManager
+import org.thoughtcrime.securesms.jobs.JobManagerFactories
+import org.whispersystems.signalservice.api.util.UptimeSleepTimer
+import org.whispersystems.signalservice.api.websocket.SignalWebSocket
+import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration
+import org.whispersystems.signalservice.internal.websocket.BenchmarkWebSocketConnection
+import java.util.function.Supplier
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Dependency provider used by [org.thoughtcrime.securesms.IncomingMessageObserverInstrumentationApplicationContext].
+ * Composes [InstrumentationApplicationDependencyProvider] (so existing mocks for the account /
+ * archive / donations / billing APIs are reused) and overrides:
+ *
+ * - the auth and unauth websocket factories with [BenchmarkWebSocketConnection], so tests can
+ *   inject encrypted envelopes through the real ingest pipeline;
+ * - the job manager, swapping the startup network jobs handled by [NoOpJob.replaceFactories]
+ *   to no-ops so they can't fire against unstubbed mocks during a test.
+ */
+class IncomingMessageObserverDependencyProvider(
+  private val application: Application,
+  default: ApplicationDependencyProvider
+) : AppDependencies.Provider by InstrumentationApplicationDependencyProvider(application, default) {
+
+  override fun provideAuthWebSocket(
+    signalServiceConfigurationSupplier: Supplier<SignalServiceConfiguration>,
+    libSignalNetworkSupplier: Supplier<Network>
+  ): SignalWebSocket.AuthenticatedWebSocket {
+    return SignalWebSocket.AuthenticatedWebSocket(
+      connectionFactory = { BenchmarkWebSocketConnection.createAuthInstance() },
+      canConnect = { true },
+      sleepTimer = UptimeSleepTimer(),
+      disconnectTimeoutMs = 15.seconds.inWholeMilliseconds
+    )
+  }
+
+  override fun provideUnauthWebSocket(
+    signalServiceConfigurationSupplier: Supplier<SignalServiceConfiguration>,
+    libSignalNetworkSupplier: Supplier<Network>
+  ): SignalWebSocket.UnauthenticatedWebSocket {
+    return SignalWebSocket.UnauthenticatedWebSocket(
+      connectionFactory = { BenchmarkWebSocketConnection.createUnauthInstance() },
+      canConnect = { true },
+      sleepTimer = UptimeSleepTimer(),
+      disconnectTimeoutMs = 15.seconds.inWholeMilliseconds
+    )
+  }
+
+  override fun provideJobManager(configurationBuilder: JobManager.Configuration.Builder): JobManager {
+    val config = configurationBuilder
+      .setJobFactories(NoOpJob.replaceFactories(JobManagerFactories.getJobFactories(application)))
+      .build()
+    return JobManager(application, config)
+  }
+}
@@ -0,0 +1,201 @@
+package org.thoughtcrime.securesms.testing.incomingmessageobserver
+
+import okio.ByteString.Companion.toByteString
+import org.junit.Assume
+import org.junit.rules.ExternalResource
+import org.signal.benchmark.setup.Generator
+import org.signal.benchmark.setup.Harness
+import org.signal.benchmark.setup.OtherClient
+import org.signal.benchmark.setup.TestUsers
+import org.signal.core.util.logging.Log
+import org.signal.network.websocket.WebSocketRequestMessage
+import org.thoughtcrime.securesms.IncomingMessageObserverInstrumentationApplicationContext
+import org.thoughtcrime.securesms.dependencies.AppDependencies
+import org.thoughtcrime.securesms.groups.GroupId
+import org.thoughtcrime.securesms.jobmanager.Job
+import org.thoughtcrime.securesms.jobmanager.JobTracker
+import org.thoughtcrime.securesms.jobs.MarkerJob
+import org.thoughtcrime.securesms.jobs.PushProcessMessageJob
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.whispersystems.signalservice.internal.push.Envelope
+import org.whispersystems.signalservice.internal.websocket.BenchmarkWebSocketConnection
+import java.util.concurrent.CopyOnWriteArraySet
+import kotlin.random.Random
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * JUnit rule that drives [org.thoughtcrime.securesms.messages.IncomingMessageObserver] from
+ * instrumentation tests. Sets up self, registers [peerCount] simulated peers from
+ * [Harness.otherClients], establishes a Signal double-ratchet session with each, and exposes a
+ * small DSL for delivering encrypted envelopes through the real ingest pipeline:
+ *
+ * ```
+ * @get:Rule val rule = IncomingMessageObserverRule(peerCount = 2)
+ *
+ * @Test fun example() {
+ *   rule.deliver { text("hi") from rule.peers[0] }
+ *   rule.deliver { groupText("hi all", group = rule.testGroup) from rule.peers[0] }
+ * }
+ * ```
+ *
+ * Run with `-PimoTests`; tests are skipped under the default runner. Throws on drain timeout.
+ * Mutually exclusive with `SignalDatabaseRule` / `SignalActivityRule` — all three claim the
+ * local identity.
+ */
+class IncomingMessageObserverRule(
+  private val peerCount: Int = 2,
+  private val drainTimeout: Duration = 30.seconds
+) : ExternalResource() {
+
+  lateinit var self: Recipient
+    private set
+
+  lateinit var peers: List<OtherClient>
+    private set
+
+  /** Lazily-created group. Touching this from a test triggers setup; tests that don't use groups pay nothing. */
+  val testGroup: GroupHandle by lazy {
+    val gid = TestUsers.setupGroup(withLabels = false)
+    GroupHandle(gid, Recipient.externalGroupExact(gid).id)
+  }
+
+  override fun before() {
+    Assume.assumeTrue(
+      "IncomingMessageObserverRule requires the IMO test runner — run with -PimoTests",
+      AppDependencies.application is IncomingMessageObserverInstrumentationApplicationContext
+    )
+
+    self = TestUsers.setupSelf()
+    TestUsers.setupTestClients(peerCount)
+    peers = Harness.otherClients.take(peerCount)
+
+    val app = AppDependencies.application as IncomingMessageObserverInstrumentationApplicationContext
+    app.beginJobLoopForTests()
+
+    // IncomingMessageObserver caches `canProcessMessages` from restoreDecisionState at thread
+    // construction. If it was built before setupSelf() flipped the state it will silently drop
+    // every message; reset network so a fresh observer is constructed.
+    AppDependencies.incomingMessageObserver.notifyRestoreDecisionMade()
+    AppDependencies.startNetwork()
+    forceObserverConstruction()
+
+    val handshakeEnvelopes = peers.map { client ->
+      client.encrypt(Generator.encryptedTextMessage(System.currentTimeMillis()))
+    }
+    deliverEnvelopes(handshakeEnvelopes)
+    peers.forEach { it.completeSession() }
+  }
+
+  fun deliver(builder: DeliveryBuilder.() -> Unit) {
+    val collected = DeliveryBuilder().apply(builder).specs
+    if (collected.isEmpty()) return
+    deliverEnvelopes(collected.map { it.materialize() })
+  }
+
+  private fun forceObserverConstruction() {
+    AppDependencies.incomingMessageObserver
+  }
+
+  private fun deliverEnvelopes(envelopes: List<Envelope>) {
+    val jobManager = AppDependencies.jobManager
+    val seenQueues = CopyOnWriteArraySet<String>()
+    val queueListener = object : JobTracker.JobListener {
+      override fun onStateChanged(job: Job, jobState: JobTracker.JobState) {
+        job.parameters.queue?.let { queue ->
+          if (queue.startsWith(PushProcessMessageJob.QUEUE_PREFIX)) {
+            seenQueues += queue
+          }
+        }
+      }
+    }
+    jobManager.addListener({ job: Job -> job.parameters.queue?.startsWith(PushProcessMessageJob.QUEUE_PREFIX) == true }, queueListener)
+
+    try {
+      BenchmarkWebSocketConnection.addPendingMessages(envelopes.map { it.toWebSocketPayload() })
+      BenchmarkWebSocketConnection.addQueueEmptyMessage()
+      BenchmarkWebSocketConnection.releaseMessages()
+
+      val consumed = BenchmarkWebSocketConnection.awaitAllMessagesConsumed(drainTimeout.inWholeMilliseconds)
+      check(consumed) { "Timed out waiting for benchmark websocket to consume ${envelopes.size} envelope(s)" }
+
+      // PushProcessMessageJob enqueue happens on a background thread after the websocket marks
+      // messages consumed; this tick lets that settle before we snapshot the queues to wait on.
+      Thread.sleep(100)
+
+      val queuesToDrain = seenQueues.toSet()
+      Log.d(TAG, "Awaiting ${queuesToDrain.size} PushProcessMessageJob queue(s): $queuesToDrain")
+      for (queue in queuesToDrain) {
+        val state = jobManager.runSynchronously(MarkerJob(queue), drainTimeout.inWholeMilliseconds)
+        check(state.isPresent) { "Timed out waiting for queue $queue to drain" }
+      }
+    } finally {
+      jobManager.removeListener(queueListener)
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(IncomingMessageObserverRule::class)
+
+    private fun Envelope.toWebSocketPayload(): WebSocketRequestMessage = WebSocketRequestMessage(
+      verb = "PUT",
+      path = "/api/v1/message",
+      id = Random.nextLong(),
+      headers = listOf("X-Signal-Timestamp: $serverTimestamp"),
+      body = encodeByteString()
+    )
+  }
+}
+
+/** Identifies the test group created by [IncomingMessageObserverRule]. Hold a reference to pass into the [DeliveryBuilder.groupText] DSL. */
+data class GroupHandle(val groupId: GroupId.V2, val recipientId: RecipientId)
+
+/**
+ * Receiver of the DSL passed to [IncomingMessageObserverRule.deliver]. Construct content with
+ * [text] / [groupText] / [deliveryReceipts] / [readReceipts] / [malformedEnvelope] and chain
+ * with the [from] infix to attach a sending peer. Each `from` adds the resulting envelope to
+ * the batch that will be delivered when the lambda returns.
+ */
+class DeliveryBuilder internal constructor() {
+  internal val specs = mutableListOf<EnvelopeSpec>()
+
+  fun text(body: String, timestamp: Long = System.currentTimeMillis()): EnvelopeContentSpec = EnvelopeContentSpec.Text(body, timestamp, group = null)
+
+  fun groupText(body: String, group: GroupHandle, timestamp: Long = System.currentTimeMillis()): EnvelopeContentSpec = EnvelopeContentSpec.Text(body, timestamp, group)
+
+  fun deliveryReceipts(targets: List<Long>, sentAt: Long = System.currentTimeMillis()): EnvelopeContentSpec = EnvelopeContentSpec.DeliveryReceipt(targets, sentAt)
+
+  fun readReceipts(targets: List<Long>, sentAt: Long = System.currentTimeMillis()): EnvelopeContentSpec = EnvelopeContentSpec.ReadReceipt(targets, sentAt)
+
+  fun malformedEnvelope(timestamp: Long = System.currentTimeMillis()): EnvelopeContentSpec = EnvelopeContentSpec.Malformed(timestamp)
+
+  infix fun EnvelopeContentSpec.from(peer: OtherClient) {
+    specs += EnvelopeSpec(this, peer)
+  }
+}
+
+/** Opaque envelope content returned by [DeliveryBuilder]. Tests never construct or inspect variants directly; the type only appears as a return / receiver of the DSL methods. */
+sealed class EnvelopeContentSpec {
+  internal data class Text(val body: String, val timestamp: Long, val group: GroupHandle?) : EnvelopeContentSpec()
+  internal data class DeliveryReceipt(val targets: List<Long>, val sentAt: Long) : EnvelopeContentSpec()
+  internal data class ReadReceipt(val targets: List<Long>, val sentAt: Long) : EnvelopeContentSpec()
+  internal data class Malformed(val timestamp: Long) : EnvelopeContentSpec()
+}
+
+internal data class EnvelopeSpec(val content: EnvelopeContentSpec, val peer: OtherClient) {
+  fun materialize(): Envelope = when (val c = content) {
+    is EnvelopeContentSpec.Text ->
+      peer.encrypt(Generator.encryptedTextMessage(c.timestamp, c.body, c.group?.let { Harness.groupMasterKey }))
+    is EnvelopeContentSpec.DeliveryReceipt ->
+      peer.encrypt(Generator.encryptedDeliveryReceipt(c.sentAt, c.targets), c.sentAt)
+    is EnvelopeContentSpec.ReadReceipt ->
+      peer.encrypt(Generator.encryptedReadReceipt(c.sentAt, c.targets), c.sentAt)
+    is EnvelopeContentSpec.Malformed -> {
+      val valid = peer.encrypt(Generator.encryptedTextMessage(c.timestamp))
+      val original = valid.content ?: error("Encrypted envelope unexpectedly had no content")
+      val corrupted = original.toByteArray().also { it[it.size / 2] = (it[it.size / 2].toInt() xor 0x01).toByte() }
+      valid.copy(content = corrupted.toByteString())
+    }
+  }
+}
@@ -0,0 +1,18 @@
+package org.thoughtcrime.securesms.testing.incomingmessageobserver
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import org.thoughtcrime.securesms.IncomingMessageObserverInstrumentationApplicationContext
+
+/**
+ * Test runner that swaps in [IncomingMessageObserverInstrumentationApplicationContext] so the
+ * `IncomingMessageObserver` test harness can drive a faked websocket. Selected automatically by
+ * the build when `-PimoTests` is set.
+ */
+@Suppress("unused")
+class IncomingMessageObserverTestRunner : AndroidJUnitRunner() {
+  override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application {
+    return super.newApplication(cl, IncomingMessageObserverInstrumentationApplicationContext::class.java.name, context)
+  }
+}
@@ -6,55 +6,13 @@
 package org.thoughtcrime.securesms

 import android.app.Application
+import org.signal.benchmark.setup.NoOpJob
 import org.signal.libsignal.net.Network
-import org.thoughtcrime.securesms.database.JobDatabase
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencyProvider
-import org.thoughtcrime.securesms.jobmanager.Job
 import org.thoughtcrime.securesms.jobmanager.JobManager
-import org.thoughtcrime.securesms.jobmanager.JobMigrator
-import org.thoughtcrime.securesms.jobmanager.impl.FactoryJobPredicate
-import org.thoughtcrime.securesms.jobs.AccountConsistencyWorkerJob
-import org.thoughtcrime.securesms.jobs.ArchiveBackupIdReservationJob
-import org.thoughtcrime.securesms.jobs.AttachmentCompressionJob
-import org.thoughtcrime.securesms.jobs.AttachmentUploadJob
-import org.thoughtcrime.securesms.jobs.AvatarGroupsV2DownloadJob
-import org.thoughtcrime.securesms.jobs.CreateReleaseChannelJob
-import org.thoughtcrime.securesms.jobs.DirectoryRefreshJob
-import org.thoughtcrime.securesms.jobs.DownloadLatestEmojiDataJob
-import org.thoughtcrime.securesms.jobs.EmojiSearchIndexDownloadJob
-import org.thoughtcrime.securesms.jobs.FastJobStorage
-import org.thoughtcrime.securesms.jobs.FontDownloaderJob
-import org.thoughtcrime.securesms.jobs.GroupCallUpdateSendJob
-import org.thoughtcrime.securesms.jobs.GroupRingCleanupJob
-import org.thoughtcrime.securesms.jobs.GroupV2UpdateSelfProfileKeyJob
-import org.thoughtcrime.securesms.jobs.IndividualSendJob
 import org.thoughtcrime.securesms.jobs.JobManagerFactories
-import org.thoughtcrime.securesms.jobs.LinkedDeviceInactiveCheckJob
-import org.thoughtcrime.securesms.jobs.MarkerJob
-import org.thoughtcrime.securesms.jobs.MultiDeviceProfileKeyUpdateJob
-import org.thoughtcrime.securesms.jobs.PostRegistrationBackupRedemptionJob
-import org.thoughtcrime.securesms.jobs.PreKeysSyncJob
-import org.thoughtcrime.securesms.jobs.ProfileUploadJob
-import org.thoughtcrime.securesms.jobs.PushGroupSendJob
-import org.thoughtcrime.securesms.jobs.PushProcessMessageJob
-import org.thoughtcrime.securesms.jobs.ReactionSendJob
-import org.thoughtcrime.securesms.jobs.RefreshAttributesJob
-import org.thoughtcrime.securesms.jobs.RefreshSvrCredentialsJob
-import org.thoughtcrime.securesms.jobs.RequestGroupV2InfoJob
-import org.thoughtcrime.securesms.jobs.ResetSvrGuessCountJob
-import org.thoughtcrime.securesms.jobs.RestoreOptimizedMediaJob
-import org.thoughtcrime.securesms.jobs.RetrieveProfileAvatarJob
-import org.thoughtcrime.securesms.jobs.RetrieveProfileJob
-import org.thoughtcrime.securesms.jobs.RetrieveRemoteAnnouncementsJob
-import org.thoughtcrime.securesms.jobs.RotateCertificateJob
-import org.thoughtcrime.securesms.jobs.SendDeliveryReceiptJob
-import org.thoughtcrime.securesms.jobs.StickerPackDownloadJob
-import org.thoughtcrime.securesms.jobs.StorageSyncJob
-import org.thoughtcrime.securesms.jobs.StoryOnboardingDownloadJob
-import org.thoughtcrime.securesms.jobs.TypingSendJob
 import org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor
-import org.thoughtcrime.securesms.util.TextSecurePreferences
 import org.whispersystems.signalservice.api.util.UptimeSleepTimer
 import org.whispersystems.signalservice.api.websocket.SignalWebSocket
 import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration
@@ -97,85 +55,11 @@ class BenchmarkApplicationContext : ApplicationContext() {
      )
    }

-    override fun provideJobManager(): JobManager {
-      val config = JobManager.Configuration.Builder()
-        .setJobFactories(filterJobFactories(JobManagerFactories.getJobFactories(application)))
-        .setConstraintFactories(JobManagerFactories.getConstraintFactories(application))
-        .setConstraintObservers(JobManagerFactories.getConstraintObservers(application))
-        .setJobStorage(FastJobStorage(JobDatabase.getInstance(application)))
-        .setJobMigrator(JobMigrator(TextSecurePreferences.getJobManagerVersion(application), JobManager.CURRENT_VERSION, JobManagerFactories.getJobMigrations(application)))
-        .addReservedJobRunner(FactoryJobPredicate(PushProcessMessageJob.KEY, MarkerJob.KEY))
-        .addReservedJobRunner(FactoryJobPredicate(AttachmentUploadJob.KEY, AttachmentCompressionJob.KEY))
-        .addReservedJobRunner(
-          FactoryJobPredicate(
-            IndividualSendJob.KEY,
-            PushGroupSendJob.KEY,
-            ReactionSendJob.KEY,
-            TypingSendJob.KEY,
-            GroupCallUpdateSendJob.KEY,
-            SendDeliveryReceiptJob.KEY
-          )
-        )
+    override fun provideJobManager(configurationBuilder: JobManager.Configuration.Builder): JobManager {
+      val config = configurationBuilder
+        .setJobFactories(NoOpJob.replaceFactories(JobManagerFactories.getJobFactories(application)))
        .build()
      return JobManager(application, config)
    }
-
-    private fun filterJobFactories(jobFactories: Map<String, Job.Factory<*>>): Map<String, Job.Factory<*>> {
-      val blockedJobs = setOf(
-        AccountConsistencyWorkerJob.KEY,
-        ArchiveBackupIdReservationJob.KEY,
-        AvatarGroupsV2DownloadJob.KEY,
-        CreateReleaseChannelJob.KEY,
-        DirectoryRefreshJob.KEY,
-        DownloadLatestEmojiDataJob.KEY,
-        EmojiSearchIndexDownloadJob.KEY,
-        FontDownloaderJob.KEY,
-        GroupRingCleanupJob.KEY,
-        GroupV2UpdateSelfProfileKeyJob.KEY,
-        LinkedDeviceInactiveCheckJob.KEY,
-        MultiDeviceProfileKeyUpdateJob.KEY,
-        PostRegistrationBackupRedemptionJob.KEY,
-        PreKeysSyncJob.KEY,
-        ProfileUploadJob.KEY,
-        RefreshAttributesJob.KEY,
-        RefreshSvrCredentialsJob.KEY,
-        RequestGroupV2InfoJob.KEY,
-        ResetSvrGuessCountJob.KEY,
-        RestoreOptimizedMediaJob.KEY,
-        RetrieveProfileAvatarJob.KEY,
-        RetrieveProfileJob.KEY,
-        RetrieveRemoteAnnouncementsJob.KEY,
-        RotateCertificateJob.KEY,
-        StickerPackDownloadJob.KEY,
-        StorageSyncJob.KEY,
-        StoryOnboardingDownloadJob.KEY
-      )
-
-      return jobFactories.mapValues {
-        if (it.key in blockedJobs) {
-          NoOpJob.Factory()
-        } else {
-          it.value
-        }
-      }
-    }
-  }
-
-  private class NoOpJob(parameters: Parameters) : Job(parameters) {
-
-    companion object {
-      const val KEY = "NoOpJob"
-    }
-
-    override fun serialize(): ByteArray? = null
-    override fun getFactoryKey(): String = KEY
-    override fun run(): Result = Result.success()
-    override fun onFailure() = Unit
-
-    class Factory : Job.Factory<NoOpJob> {
-      override fun create(parameters: Parameters, serializedData: ByteArray?): NoOpJob {
-        return NoOpJob(parameters)
-      }
-    }
  }
 }
@@ -23,7 +23,7 @@ import org.thoughtcrime.securesms.groups.GroupId
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.whispersystems.signalservice.internal.push.Envelope
 import org.whispersystems.signalservice.internal.websocket.BenchmarkWebSocketConnection
-import org.whispersystems.signalservice.internal.websocket.WebSocketRequestMessage
+import org.signal.network.websocket.WebSocketRequestMessage
 import kotlin.random.Random

 /**
@@ -0,0 +1,84 @@
+package org.signal.benchmark.setup
+
+import org.thoughtcrime.securesms.jobmanager.Job
+import org.thoughtcrime.securesms.jobs.AccountConsistencyWorkerJob
+import org.thoughtcrime.securesms.jobs.ArchiveBackupIdReservationJob
+import org.thoughtcrime.securesms.jobs.AvatarGroupsV2DownloadJob
+import org.thoughtcrime.securesms.jobs.CreateReleaseChannelJob
+import org.thoughtcrime.securesms.jobs.DirectoryRefreshJob
+import org.thoughtcrime.securesms.jobs.DownloadLatestEmojiDataJob
+import org.thoughtcrime.securesms.jobs.EmojiSearchIndexDownloadJob
+import org.thoughtcrime.securesms.jobs.FontDownloaderJob
+import org.thoughtcrime.securesms.jobs.GroupRingCleanupJob
+import org.thoughtcrime.securesms.jobs.GroupV2UpdateSelfProfileKeyJob
+import org.thoughtcrime.securesms.jobs.LinkedDeviceInactiveCheckJob
+import org.thoughtcrime.securesms.jobs.MultiDeviceProfileKeyUpdateJob
+import org.thoughtcrime.securesms.jobs.PostRegistrationBackupRedemptionJob
+import org.thoughtcrime.securesms.jobs.PreKeysSyncJob
+import org.thoughtcrime.securesms.jobs.ProfileUploadJob
+import org.thoughtcrime.securesms.jobs.RefreshAttributesJob
+import org.thoughtcrime.securesms.jobs.RefreshSvrCredentialsJob
+import org.thoughtcrime.securesms.jobs.RequestGroupV2InfoJob
+import org.thoughtcrime.securesms.jobs.ResetSvrGuessCountJob
+import org.thoughtcrime.securesms.jobs.RestoreOptimizedMediaJob
+import org.thoughtcrime.securesms.jobs.RetrieveProfileAvatarJob
+import org.thoughtcrime.securesms.jobs.RetrieveProfileJob
+import org.thoughtcrime.securesms.jobs.RetrieveRemoteAnnouncementsJob
+import org.thoughtcrime.securesms.jobs.RotateCertificateJob
+import org.thoughtcrime.securesms.jobs.StickerPackDownloadJob
+import org.thoughtcrime.securesms.jobs.StorageSyncJob
+import org.thoughtcrime.securesms.jobs.StoryOnboardingDownloadJob
+
+/**
+ * A [Job] that does nothing and always succeeds. Test setups substitute this for jobs whose
+ * real implementations would hit the network at startup (and so would either generate noise
+ * against the [DeviceTransferBlockingInterceptor][org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor]
+ * or fail against unstubbed mocks). Use [replaceFactories] to apply the swap.
+ */
+class NoOpJob(parameters: Parameters) : Job(parameters) {
+  override fun serialize(): ByteArray? = null
+  override fun getFactoryKey(): String = KEY
+  override fun run(): Result = Result.success()
+  override fun onFailure() = Unit
+
+  class Factory : Job.Factory<NoOpJob> {
+    override fun create(parameters: Parameters, serializedData: ByteArray?): NoOpJob = NoOpJob(parameters)
+  }
+
+  companion object {
+    const val KEY = "NoOpJob"
+
+    private val STARTUP_NETWORK_JOB_KEYS: Set<String> = setOf(
+      AccountConsistencyWorkerJob.KEY,
+      ArchiveBackupIdReservationJob.KEY,
+      AvatarGroupsV2DownloadJob.KEY,
+      CreateReleaseChannelJob.KEY,
+      DirectoryRefreshJob.KEY,
+      DownloadLatestEmojiDataJob.KEY,
+      EmojiSearchIndexDownloadJob.KEY,
+      FontDownloaderJob.KEY,
+      GroupRingCleanupJob.KEY,
+      GroupV2UpdateSelfProfileKeyJob.KEY,
+      LinkedDeviceInactiveCheckJob.KEY,
+      MultiDeviceProfileKeyUpdateJob.KEY,
+      PostRegistrationBackupRedemptionJob.KEY,
+      PreKeysSyncJob.KEY,
+      ProfileUploadJob.KEY,
+      RefreshAttributesJob.KEY,
+      RefreshSvrCredentialsJob.KEY,
+      RequestGroupV2InfoJob.KEY,
+      ResetSvrGuessCountJob.KEY,
+      RestoreOptimizedMediaJob.KEY,
+      RetrieveProfileAvatarJob.KEY,
+      RetrieveProfileJob.KEY,
+      RetrieveRemoteAnnouncementsJob.KEY,
+      RotateCertificateJob.KEY,
+      StickerPackDownloadJob.KEY,
+      StorageSyncJob.KEY,
+      StoryOnboardingDownloadJob.KEY
+    )
+
+    fun replaceFactories(factories: Map<String, Job.Factory<*>>): Map<String, Job.Factory<*>> =
+      factories.mapValues { if (it.key in STARTUP_NETWORK_JOB_KEYS) Factory() else it.value }
+  }
+}
@@ -8,6 +8,9 @@ package org.whispersystems.signalservice.internal.websocket
 import io.reactivex.rxjava3.core.Observable
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.subjects.BehaviorSubject
+import org.signal.network.websocket.WebSocketRequestMessage
+import org.signal.network.websocket.WebSocketResponseMessage
+import org.signal.network.websocket.WebsocketResponse
 import org.thoughtcrime.securesms.util.JsonUtils
 import org.thoughtcrime.securesms.util.SignalTrace
 import org.whispersystems.signalservice.api.websocket.WebSocketConnectionState
@@ -65,6 +68,18 @@ class BenchmarkWebSocketConnection : WebSocketConnection {
    fun addQueueEmptyMessage() {
      authInstances.filterNot(BenchmarkWebSocketConnection::isShutdown).forEach { it.addQueueEmptyMessage() }
    }
+
+    fun awaitAllMessagesConsumed(timeoutMs: Long): Boolean {
+      val deadline = System.currentTimeMillis() + timeoutMs
+      while (System.currentTimeMillis() < deadline) {
+        val activeInstances = synchronized(this) { authInstances.filterNot(BenchmarkWebSocketConnection::isShutdown).toList() }
+        if (activeInstances.isNotEmpty() && activeInstances.all { it.incomingRequests.isEmpty() && it.incomingSemaphore.availablePermits() == 0 }) {
+          return true
+        }
+        Thread.sleep(25)
+      }
+      return false
+    }
  }

  override val name: String = "bench-${System.identityHashCode(this)}"
@@ -2,8 +2,6 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

-    <uses-sdk tools:overrideLibrary="androidx.camera.core,androidx.camera.camera2,androidx.camera.lifecycle,androidx.camera.view" />
-
    <!-- ======================================= -->
    <!-- Features                                -->
    <!-- ======================================= -->
@@ -40,6 +38,7 @@
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_PHONE_CALL" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING" />
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
@@ -1405,7 +1404,7 @@
        <service
            android:name="org.thoughtcrime.securesms.service.webrtc.ActiveCallManager$ActiveCallForegroundService"
            android:exported="false"
-            android:foregroundServiceType="dataSync|microphone|camera|phoneCall" />
+            android:foregroundServiceType="dataSync|microphone|camera|phoneCall|mediaProjection" />

        <service
            android:name="com.google.android.datatransport.runtime.scheduling.jobscheduling.JobInfoSchedulerService"
@@ -77,6 +77,7 @@ import org.thoughtcrime.securesms.jobs.LinkedDeviceInactiveCheckJob;
 import org.thoughtcrime.securesms.jobs.MultiDeviceContactUpdateJob;
 import org.thoughtcrime.securesms.jobs.PreKeysSyncJob;
 import org.thoughtcrime.securesms.jobs.ProfileUploadJob;
+import org.thoughtcrime.securesms.jobs.RefreshAttributesJob;
 import org.thoughtcrime.securesms.jobs.RefreshSvrCredentialsJob;
 import org.thoughtcrime.securesms.jobs.RestoreOptimizedMediaJob;
 import org.thoughtcrime.securesms.jobs.RetrieveProfileJob;
@@ -111,6 +112,7 @@ import org.thoughtcrime.securesms.util.AppStartup;
 import org.thoughtcrime.securesms.util.DeviceProperties;
 import org.thoughtcrime.securesms.util.DynamicTheme;
 import org.thoughtcrime.securesms.util.Environment;
+import org.thoughtcrime.securesms.util.PlayServicesUtil;
 import org.thoughtcrime.securesms.util.RemoteConfig;
 import org.thoughtcrime.securesms.util.SignalLocalMetrics;
 import org.thoughtcrime.securesms.util.SignalUncaughtExceptionHandler;
@@ -439,7 +441,24 @@ public class ApplicationContext extends Application implements AppForegroundObse
  }

  private void initializeFcmCheck() {
-    if (SignalStore.account().isRegistered()) {
+    if (!SignalStore.account().isRegistered()) {
+      return;
+    }
+
+    PlayServicesUtil.PlayServicesStatus playServicesStatus = PlayServicesUtil.getPlayServicesStatus(this);
+
+    if (playServicesStatus == PlayServicesUtil.PlayServicesStatus.SUCCESS && !SignalStore.account().isFcmEnabled()) {
+      Log.i(TAG, "Play Services are newly-available. Enabling FCM and updating server.");
+      SignalStore.account().setFcmEnabled(true);
+      AppDependencies.getJobManager().startChain(new FcmRefreshJob())
+                                      .then(new RefreshAttributesJob())
+                                      .enqueue();
+    } else if (playServicesStatus == PlayServicesUtil.PlayServicesStatus.MISSING && SignalStore.account().isFcmEnabled()) {
+      Log.w(TAG, "Play Services are no longer available. Disabling FCM and updating server.");
+      SignalStore.account().setFcmEnabled(false);
+      SignalStore.account().setFcmToken(null);
+      AppDependencies.getJobManager().add(new RefreshAttributesJob());
+    } else if (SignalStore.account().isFcmEnabled()) {
      long lastSetTime = SignalStore.account().getFcmTokenLastSetTime();
      long nextSetTime = lastSetTime + TimeUnit.HOURS.toMillis(6);
      long now         = System.currentTimeMillis();
@@ -447,6 +466,8 @@ public class ApplicationContext extends Application implements AppForegroundObse
      if (SignalStore.account().getFcmToken() == null || nextSetTime <= now || lastSetTime > now) {
        AppDependencies.getJobManager().add(new FcmRefreshJob());
      }
+    } else {
+      Log.d(TAG, "Play Services status: " + playServicesStatus + ", fcmEnabled: false. Skipping FCM check.");
    }
  }

@@ -34,7 +34,6 @@ import org.thoughtcrime.securesms.contacts.sync.ContactDiscovery;
 import org.thoughtcrime.securesms.recipients.RecipientId;
 import org.thoughtcrime.securesms.util.DynamicNoActionBarTheme;
 import org.thoughtcrime.securesms.util.DynamicTheme;
-import org.thoughtcrime.securesms.util.ServiceUtil;

 import java.io.IOException;
 import java.lang.ref.WeakReference;
@@ -49,8 +48,7 @@ import java.util.function.Consumer;
 */
 public abstract class ContactSelectionActivity extends PassphraseRequiredActivity
                                               implements SwipeRefreshLayout.OnRefreshListener,
-                                                          ContactSelectionListFragment.OnContactSelectedListener,
-                                                          ContactSelectionListFragment.ScrollCallback
+                                                          ContactSelectionListFragment.OnContactSelectedListener
 {
  private static final String TAG = Log.tag(ContactSelectionActivity.class);

@@ -136,17 +134,6 @@ public abstract class ContactSelectionActivity extends PassphraseRequiredActivit
  @Override
  public void onContactDeselected(@NonNull Optional<RecipientId> recipientId, String number, @NonNull Optional<ChatType> chatType) {}

-  @Override
-  public void onBeginScroll() {
-    hideKeyboard();
-  }
-
-  private void hideKeyboard() {
-    ServiceUtil.getInputMethodManager(this)
-               .hideSoftInputFromWindow(toolbar.getWindowToken(), 0);
-    toolbar.clearFocus();
-  }
-
  private static class RefreshDirectoryTask extends AsyncTask<Context, Void, Void> {

    private final WeakReference<ContactSelectionActivity> activity;
@@ -1,16 +1,19 @@
 package org.thoughtcrime.securesms

 import android.content.Context
-import android.view.View
-import android.widget.TextView
-import com.google.android.material.button.MaterialButton
+import org.thoughtcrime.securesms.ContactSelectionListModels.FindByPhoneNumberModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.FindByUsernameModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.FindContactsBannerModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.FindContactsModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.InviteToSignalModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.MoreHeaderModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.NewGroupModel
+import org.thoughtcrime.securesms.ContactSelectionListModels.RefreshContactsModel
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchAdapter
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchConfiguration
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchData
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchKey
-import org.thoughtcrime.securesms.util.adapter.mapping.LayoutFactory
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingViewHolder

 class ContactSelectionListAdapter(
  context: Context,
@@ -23,152 +26,19 @@ class ContactSelectionListAdapter(
 ) : ContactSearchAdapter(context, fixedContacts, displayOptions, onClickCallbacks, longClickCallbacks, storyContextMenuCallbacks, callButtonClickCallbacks) {

  init {
-    registerFactory(NewGroupModel::class.java, LayoutFactory({ NewGroupViewHolder(it, onClickCallbacks::onNewGroupClicked) }, R.layout.contact_selection_new_group_item))
-    registerFactory(InviteToSignalModel::class.java, LayoutFactory({ InviteToSignalViewHolder(it, onClickCallbacks::onInviteToSignalClicked) }, R.layout.contact_selection_invite_action_item))
-    registerFactory(FindContactsModel::class.java, LayoutFactory({ FindContactsViewHolder(it, onClickCallbacks::onFindContactsClicked) }, R.layout.contact_selection_find_contacts_item))
-    registerFactory(FindContactsBannerModel::class.java, LayoutFactory({ FindContactsBannerViewHolder(it, onClickCallbacks::onDismissFindContactsBannerClicked, onClickCallbacks::onFindContactsClicked) }, R.layout.contact_selection_find_contacts_banner_item))
-    registerFactory(RefreshContactsModel::class.java, LayoutFactory({ RefreshContactsViewHolder(it, onClickCallbacks::onRefreshContactsClicked) }, R.layout.contact_selection_refresh_action_item))
-    registerFactory(MoreHeaderModel::class.java, LayoutFactory({ MoreHeaderViewHolder(it) }, R.layout.contact_search_section_header))
-    registerFactory(EmptyModel::class.java, LayoutFactory({ EmptyViewHolder(it) }, R.layout.contact_selection_empty_state))
-    registerFactory(FindByUsernameModel::class.java, LayoutFactory({ FindByUsernameViewHolder(it, onClickCallbacks::onFindByUsernameClicked) }, R.layout.contact_selection_find_by_username_item))
-    registerFactory(FindByPhoneNumberModel::class.java, LayoutFactory({ FindByPhoneNumberViewHolder(it, onClickCallbacks::onFindByPhoneNumberClicked) }, R.layout.contact_selection_find_by_phone_number_item))
-  }
-
-  class NewGroupModel : MappingModel<NewGroupModel> {
-    override fun areItemsTheSame(newItem: NewGroupModel): Boolean = true
-    override fun areContentsTheSame(newItem: NewGroupModel): Boolean = true
-  }
-
-  class InviteToSignalModel : MappingModel<InviteToSignalModel> {
-    override fun areItemsTheSame(newItem: InviteToSignalModel): Boolean = true
-    override fun areContentsTheSame(newItem: InviteToSignalModel): Boolean = true
-  }
-
-  class RefreshContactsModel : MappingModel<RefreshContactsModel> {
-    override fun areItemsTheSame(newItem: RefreshContactsModel): Boolean = true
-    override fun areContentsTheSame(newItem: RefreshContactsModel): Boolean = true
-  }
-
-  class FindContactsModel : MappingModel<FindContactsModel> {
-    override fun areItemsTheSame(newItem: FindContactsModel): Boolean = true
-    override fun areContentsTheSame(newItem: FindContactsModel): Boolean = true
-  }
-
-  class FindContactsBannerModel : MappingModel<FindContactsBannerModel> {
-    override fun areItemsTheSame(newItem: FindContactsBannerModel): Boolean = true
-    override fun areContentsTheSame(newItem: FindContactsBannerModel): Boolean = true
-  }
-
-  class FindByUsernameModel : MappingModel<FindByUsernameModel> {
-    override fun areItemsTheSame(newItem: FindByUsernameModel): Boolean = true
-    override fun areContentsTheSame(newItem: FindByUsernameModel): Boolean = true
-  }
-
-  class FindByPhoneNumberModel : MappingModel<FindByPhoneNumberModel> {
-    override fun areItemsTheSame(newItem: FindByPhoneNumberModel): Boolean = true
-    override fun areContentsTheSame(newItem: FindByPhoneNumberModel): Boolean = true
-  }
-
-  class MoreHeaderModel : MappingModel<MoreHeaderModel> {
-    override fun areItemsTheSame(newItem: MoreHeaderModel): Boolean = true
-
-    override fun areContentsTheSame(newItem: MoreHeaderModel): Boolean = true
-  }
-
-  private class InviteToSignalViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<InviteToSignalModel>(itemView) {
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: InviteToSignalModel) = Unit
-  }
-
-  private class NewGroupViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<NewGroupModel>(itemView) {
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: NewGroupModel) = Unit
-  }
-
-  private class RefreshContactsViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<RefreshContactsModel>(itemView) {
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: RefreshContactsModel) = Unit
-  }
-
-  private class FindContactsViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindContactsModel>(itemView) {
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: FindContactsModel) = Unit
-  }
-
-  private class FindContactsBannerViewHolder(itemView: View, onDismissListener: () -> Unit, onClickListener: () -> Unit) : MappingViewHolder<FindContactsBannerModel>(itemView) {
-    init {
-      itemView.findViewById<MaterialButton>(R.id.no_thanks_button).setOnClickListener { onDismissListener() }
-      itemView.findViewById<MaterialButton>(R.id.allow_contacts_button).setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: FindContactsBannerModel) = Unit
-  }
-
-  private class MoreHeaderViewHolder(itemView: View) : MappingViewHolder<MoreHeaderModel>(itemView) {
-
-    private val headerTextView: TextView = itemView.findViewById(R.id.section_header)
-
-    override fun bind(model: MoreHeaderModel) {
-      headerTextView.setText(R.string.contact_selection_activity__more)
-    }
-  }
-
-  private class EmptyViewHolder(itemView: View) : MappingViewHolder<EmptyModel>(itemView) {
-
-    private val emptyText: TextView = itemView.findViewById(R.id.search_no_results)
-
-    override fun bind(model: EmptyModel) {
-      emptyText.text = context.getString(R.string.SearchFragment_no_results, model.empty.query ?: "")
-    }
-  }
-
-  private class FindByPhoneNumberViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindByPhoneNumberModel>(itemView) {
-
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: FindByPhoneNumberModel) = Unit
-  }
-
-  private class FindByUsernameViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindByUsernameModel>(itemView) {
-
-    init {
-      itemView.setOnClickListener { onClickListener() }
-    }
-
-    override fun bind(model: FindByUsernameModel) = Unit
+    ContactSelectionListModels.registerNewGroup(this, onClickCallbacks::onNewGroupClicked)
+    ContactSelectionListModels.registerInviteToSignal(this, onClickCallbacks::onInviteToSignalClicked)
+    ContactSelectionListModels.registerFindContacts(this, onClickCallbacks::onFindContactsClicked)
+    ContactSelectionListModels.registerFindContactsBanner(this, onClickCallbacks::onDismissFindContactsBannerClicked, onClickCallbacks::onFindContactsClicked)
+    ContactSelectionListModels.registerRefreshContacts(this, onClickCallbacks::onRefreshContactsClicked)
+    ContactSelectionListModels.registerMoreHeader(this)
+    ContactSelectionListModels.registerEmpty(this)
+    ContactSelectionListModels.registerFindByUsername(this, onClickCallbacks::onFindByUsernameClicked)
+    ContactSelectionListModels.registerFindByPhoneNumber(this, onClickCallbacks::onFindByPhoneNumberClicked)
  }

  class ArbitraryRepository : org.thoughtcrime.securesms.contacts.paged.ArbitraryRepository {

-    enum class ArbitraryRow(val code: String) {
-      NEW_GROUP("new-group"),
-      INVITE_TO_SIGNAL("invite-to-signal"),
-      MORE_HEADING("more-heading"),
-      REFRESH_CONTACTS("refresh-contacts"),
-      FIND_CONTACTS("find-contacts"),
-      FIND_CONTACTS_BANNER("find-contacts-banner"),
-      FIND_BY_USERNAME("find-by-username"),
-      FIND_BY_PHONE_NUMBER("find-by-phone-number");
-
-      companion object {
-        fun fromCode(code: String) = entries.first { it.code == code }
-      }
-    }
-
    override fun getSize(section: ContactSearchConfiguration.Section.Arbitrary, query: String?): Int {
      return section.types.size
    }
@@ -179,15 +49,15 @@ class ContactSelectionListAdapter(
    }

    override fun getMappingModel(arbitrary: ContactSearchData.Arbitrary): MappingModel<*> {
-      return when (ArbitraryRow.fromCode(arbitrary.type)) {
-        ArbitraryRow.NEW_GROUP -> NewGroupModel()
-        ArbitraryRow.INVITE_TO_SIGNAL -> InviteToSignalModel()
-        ArbitraryRow.MORE_HEADING -> MoreHeaderModel()
-        ArbitraryRow.REFRESH_CONTACTS -> RefreshContactsModel()
-        ArbitraryRow.FIND_CONTACTS -> FindContactsModel()
-        ArbitraryRow.FIND_CONTACTS_BANNER -> FindContactsBannerModel()
-        ArbitraryRow.FIND_BY_PHONE_NUMBER -> FindByPhoneNumberModel()
-        ArbitraryRow.FIND_BY_USERNAME -> FindByUsernameModel()
+      return when (ContactSelectionListModels.ArbitraryRow.fromCode(arbitrary.type)) {
+        ContactSelectionListModels.ArbitraryRow.NEW_GROUP -> NewGroupModel()
+        ContactSelectionListModels.ArbitraryRow.INVITE_TO_SIGNAL -> InviteToSignalModel()
+        ContactSelectionListModels.ArbitraryRow.MORE_HEADING -> MoreHeaderModel()
+        ContactSelectionListModels.ArbitraryRow.REFRESH_CONTACTS -> RefreshContactsModel()
+        ContactSelectionListModels.ArbitraryRow.FIND_CONTACTS -> FindContactsModel()
+        ContactSelectionListModels.ArbitraryRow.FIND_CONTACTS_BANNER -> FindContactsBannerModel()
+        ContactSelectionListModels.ArbitraryRow.FIND_BY_PHONE_NUMBER -> FindByPhoneNumberModel()
+        ContactSelectionListModels.ArbitraryRow.FIND_BY_USERNAME -> FindByUsernameModel()
      }
    }
  }
@@ -18,10 +18,8 @@ package org.thoughtcrime.securesms;


 import android.Manifest;
-import org.signal.core.ui.logging.LoggingFragment;
 import android.annotation.SuppressLint;
 import android.content.Context;
-import android.graphics.Rect;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.text.TextUtils;
@@ -38,27 +36,24 @@ import androidx.appcompat.app.AlertDialog;
 import androidx.constraintlayout.widget.ConstraintLayout;
 import androidx.constraintlayout.widget.ConstraintSet;
 import androidx.lifecycle.ViewModelProvider;
-import androidx.recyclerview.widget.DefaultItemAnimator;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 import androidx.transition.AutoTransition;
 import androidx.transition.TransitionManager;

-import org.thoughtcrime.securesms.contacts.paged.ContactSearchView;
-import org.thoughtcrime.securesms.contacts.paged.ContactSearchViewModel;
-
 import com.google.android.material.dialog.MaterialAlertDialogBuilder;

+import org.jetbrains.annotations.NotNull;
+import org.signal.core.ui.logging.LoggingFragment;
+import org.signal.core.ui.permissions.Permissions;
 import org.signal.core.util.concurrent.LifecycleDisposable;
 import org.signal.core.util.concurrent.SimpleTask;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.calls.YouAreAlreadyInACallSnackbar;
-import org.thoughtcrime.securesms.components.RecyclerViewFastScroller;
 import org.thoughtcrime.securesms.contacts.ContactChipViewModel;
 import org.thoughtcrime.securesms.contacts.ContactSelectionDisplayMode;
 import org.thoughtcrime.securesms.contacts.HeaderAction;
-import org.thoughtcrime.securesms.contacts.LetterHeaderDecoration;
 import org.thoughtcrime.securesms.contacts.SelectedContact;
 import org.thoughtcrime.securesms.contacts.SelectedContacts;
 import org.thoughtcrime.securesms.contacts.paged.ChatType;
@@ -71,18 +66,19 @@ import org.thoughtcrime.securesms.contacts.paged.ContactSearchPagedDataSourceRep
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchRepository;
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchSortOrder;
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchState;
+import org.thoughtcrime.securesms.contacts.paged.ContactSearchView;
+import org.thoughtcrime.securesms.contacts.paged.ContactSearchViewModel;
 import org.thoughtcrime.securesms.contacts.selection.ContactSelectionArguments;
 import org.thoughtcrime.securesms.contacts.sync.ContactDiscovery;
 import org.thoughtcrime.securesms.database.RecipientTable;
 import org.thoughtcrime.securesms.groups.SelectionLimits;
 import org.thoughtcrime.securesms.groups.ui.GroupLimitDialog;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
-import org.signal.core.ui.permissions.Permissions;
 import org.thoughtcrime.securesms.profiles.manage.UsernameRepository;
-import org.thoughtcrime.securesms.search.SearchRepository;
 import org.thoughtcrime.securesms.profiles.manage.UsernameRepository.UsernameAciFetchResult;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
+import org.thoughtcrime.securesms.search.SearchRepository;
 import org.thoughtcrime.securesms.util.CommunicationActions;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.thoughtcrime.securesms.util.UsernameUtil;
@@ -92,14 +88,13 @@ import org.thoughtcrime.securesms.util.adapter.mapping.MappingModelList;
 import org.thoughtcrime.securesms.util.views.SimpleProgressDialog;

 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Collections;
-import java.util.stream.Collectors;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;

 import io.reactivex.rxjava3.disposables.Disposable;
 import kotlin.Unit;
@@ -126,22 +121,17 @@ public final class ContactSelectionListFragment extends LoggingFragment {
  private SwipeRefreshLayout              swipeRefresh;
  private String                          cursorFilter;
  private ContactSearchView               contactSearchView;
-  private RecyclerViewFastScroller        fastScroller;
  private RecyclerView                    chipRecycler;
  private OnSelectionLimitReachedListener onSelectionLimitReachedListener;
  private MappingAdapter                  contactChipAdapter;
  private ContactChipViewModel            contactChipViewModel;
  private LifecycleDisposable             lifecycleDisposable;
  private HeaderActionProvider            headerActionProvider;
-  private TextView                        headerActionView;
  private ContactSearchViewModel          contactSearchViewModel;

-  @Nullable private RecyclerView            innerRecyclerView;
-  @Nullable private LinearLayoutManager     innerLayoutManager;
  @Nullable private NewConversationCallback newConversationCallback;
  @Nullable private FindByCallback          findByCallback;
  @Nullable private NewCallCallback         newCallCallback;
-  @Nullable private ScrollCallback          scrollCallback;
  @Nullable private OnItemLongClickListener onItemLongClickListener;
  private           SelectionLimits         selectionLimit        = SelectionLimits.NO_LIMITS;
  private           Set<RecipientId>        currentSelection;
@@ -168,14 +158,6 @@ public final class ContactSelectionListFragment extends LoggingFragment {
      setNewCallCallback((NewCallCallback) context);
    }

-    if (getParentFragment() instanceof ScrollCallback) {
-      setScrollCallback((ScrollCallback) getParentFragment());
-    }
-
-    if (context instanceof ScrollCallback) {
-      setScrollCallback((ScrollCallback) context);
-    }
-
    if (getParentFragment() instanceof OnContactSelectedListener) {
      setOnContactSelectedListener((OnContactSelectedListener) getParentFragment());
    }
@@ -221,10 +203,6 @@ public final class ContactSelectionListFragment extends LoggingFragment {
    this.newCallCallback = callback;
  }

-  public void setScrollCallback(@Nullable ScrollCallback callback) {
-    this.scrollCallback = callback;
-  }
-
  public void setOnContactSelectedListener(@Nullable OnContactSelectedListener listener) {
    this.onContactSelectedListener = listener;
  }
@@ -259,10 +237,8 @@ public final class ContactSelectionListFragment extends LoggingFragment {
    emptyText         = view.findViewById(android.R.id.empty);
    contactSearchView = view.findViewById(R.id.recycler_view);
    swipeRefresh      = view.findViewById(R.id.swipe_refresh);
-    fastScroller     = view.findViewById(R.id.fast_scroller);
    chipRecycler     = view.findViewById(R.id.chipRecycler);
    constraintLayout = view.findViewById(R.id.container);
-    headerActionView = view.findViewById(R.id.header_action);

    contactChipViewModel = new ViewModelProvider(this).get(ContactChipViewModel.class);
    contactChipAdapter   = new MappingAdapter();
@@ -309,133 +285,6 @@ public final class ContactSelectionListFragment extends LoggingFragment {
        )
    ).get(ContactSearchViewModel.class);

-    List<RecyclerView.OnScrollListener> scrollListeners = new ArrayList<>();
-
-    final HeaderAction headerAction;
-    if (headerActionProvider != null) {
-      headerAction = headerActionProvider.getHeaderAction();
-
-      headerActionView.setEnabled(true);
-      headerActionView.setText(headerAction.getLabel());
-      headerActionView.setCompoundDrawablesRelativeWithIntrinsicBounds(headerAction.getIcon(), 0, 0, 0);
-      headerActionView.setOnClickListener(v -> headerAction.getAction().run());
-      scrollListeners.add(new RecyclerView.OnScrollListener() {
-
-        private final Rect bounds = new Rect();
-
-        @Override
-        public void onScrolled(@NonNull RecyclerView rv, int dx, int dy) {
-          if (hideLetterHeaders() || innerLayoutManager == null) {
-            return;
-          }
-
-          int firstPosition = innerLayoutManager.findFirstVisibleItemPosition();
-          if (firstPosition == 0) {
-            View firstChild = rv.getChildAt(0);
-            rv.getDecoratedBoundsWithMargins(firstChild, bounds);
-            headerActionView.setTranslationY(bounds.top);
-          }
-        }
-      });
-    } else {
-      headerActionView.setEnabled(false);
-    }
-
-    scrollListeners.add(new RecyclerView.OnScrollListener() {
-      @Override
-      public void onScrollStateChanged(@NonNull RecyclerView rv, int newState) {
-        if (newState == RecyclerView.SCROLL_STATE_DRAGGING && scrollCallback != null) {
-          scrollCallback.onBeginScroll();
-        }
-      }
-    });
-
-    float contentBottomPaddingDp = fragmentArgs.getRecyclerPadBottom() != -1
-        ? fragmentArgs.getRecyclerPadBottom() / getResources().getDisplayMetrics().density
-        : 0f;
-
-    ContactSearchAdapter.AdapterFactory adapterFactory =
-        (context, fc, displayOptions, callbacks, longClickCallbacks, storyContextMenuCallbacks, callButtonClickCallbacks) ->
-            new ContactSelectionListAdapter(
-                context,
-                fc,
-                displayOptions,
-                new ContactSelectionListAdapter.OnContactSelectionClick() {
-                  @Override
-                  public void onDismissFindContactsBannerClicked() {
-                    SignalStore.uiHints().markDismissedContactsPermissionBanner();
-                    contactSearchViewModel.refresh();
-                  }
-
-                  @Override
-                  public void onFindContactsClicked() {
-                    requestContactPermissions();
-                  }
-
-                  @Override
-                  public void onRefreshContactsClicked() {
-                    if (onRefreshListener != null && !isRefreshing()) {
-                      setRefreshing(true);
-                      onRefreshListener.onRefresh();
-                    }
-                  }
-
-                  @Override
-                  public void onNewGroupClicked() {
-                    newConversationCallback.onNewGroup(false);
-                  }
-
-                  @Override
-                  public void onFindByPhoneNumberClicked() {
-                    findByCallback.onFindByPhoneNumber();
-                  }
-
-                  @Override
-                  public void onFindByUsernameClicked() {
-                    findByCallback.onFindByUsername();
-                  }
-
-                  @Override
-                  public void onInviteToSignalClicked() {
-                    if (newConversationCallback != null) {
-                      newConversationCallback.onInvite();
-                    }
-
-                    if (newCallCallback != null) {
-                      newCallCallback.onInvite();
-                    }
-                  }
-
-                  @Override
-                  public void onStoryClicked(@NonNull View view1, @NonNull ContactSearchData.Story story, boolean isSelected) {
-                    throw new UnsupportedOperationException();
-                  }
-
-                  @Override
-                  public void onKnownRecipientClicked(@NonNull View view1, @NonNull ContactSearchData.KnownRecipient knownRecipient, boolean isSelected) {
-                    listClickListener.onItemClick(knownRecipient.getContactSearchKey());
-                  }
-
-                  @Override
-                  public void onExpandClicked(@NonNull ContactSearchData.Expand expand) {
-                    callbacks.onExpandClicked(expand);
-                  }
-
-                  @Override
-                  public void onUnknownRecipientClicked(@NonNull View view, @NonNull ContactSearchData.UnknownRecipient unknownRecipient, boolean isSelected) {
-                    listClickListener.onItemClick(unknownRecipient.getContactSearchKey());
-                  }
-
-                  @Override
-                  public void onChatTypeClicked(@NonNull View view, @NonNull ContactSearchData.ChatTypeRow chatTypeRow, boolean isSelected) {
-                    listClickListener.onItemClick(chatTypeRow.getContactSearchKey());
-                  }
-                },
-                (anchorView, data) -> listClickListener.onItemLongClick(anchorView, data.getContactSearchKey()),
-                storyContextMenuCallbacks,
-                new CallButtonClickCallbacks()
-            );
-
    contactSearchView.bind(
        contactSearchViewModel,
        getChildFragmentManager(),
@@ -452,25 +301,83 @@ public final class ContactSelectionListFragment extends LoggingFragment {
            onLoadFinished(size);
          }
        },
-        Collections.singletonList(new LetterHeaderDecoration(requireContext(), this::hideLetterHeaders)),
-        contentBottomPaddingDp,
-        adapterFactory,
-        scrollListeners,
-        rv -> {
-          innerRecyclerView   = rv;
-          innerLayoutManager  = (LinearLayoutManager) rv.getLayoutManager();
-          rv.setItemAnimator(new DefaultItemAnimator() {
-            @Override
-            public boolean canReuseUpdatedViewHolder(@NonNull RecyclerView.ViewHolder viewHolder) {
-              return true;
-            }
+        ContactSelectionListModels.composeEntries(
+            new ContactSelectionListModels.Callback() {
+              @Override
+              public void onNewGroupClicked() {
+                newConversationCallback.onNewGroup(false);
+              }

-            @Override
-            public void onAnimationFinished(@NonNull RecyclerView.ViewHolder viewHolder) {
-              contactSearchView.setAlpha(1f);
+              @Override
+              public void onInviteToSignalClicked() {
+                if (newConversationCallback != null) {
+                  newConversationCallback.onInvite();
+                }
+
+                if (newCallCallback != null) {
+                  newCallCallback.onInvite();
+                }
+              }
+
+              @Override
+              public void onFindContactsClicked() {
+                requestContactPermissions();
+              }
+
+              @Override
+              public void onDismissFindContactsBannerClicked() {
+                SignalStore.uiHints().markDismissedContactsPermissionBanner();
+                contactSearchViewModel.refresh();
+              }
+
+              @Override
+              public void onRefreshContactsClicked() {
+                if (onRefreshListener != null && !isRefreshing()) {
+                  setRefreshing(true);
+                  onRefreshListener.onRefresh();
+                }
+              }
+
+              @Override
+              public void onFindByUsernameClicked() {
+                findByCallback.onFindByUsername();
+              }
+
+              @Override
+              public void onFindByPhoneNumberClicked() {
+                findByCallback.onFindByPhoneNumber();
+              }
            }
-          });
-        }
+        ),
+        new ContactSearchAdapter.ClickCallbacks() {
+          @Override
+          public void onStoryClicked(@NotNull View view, ContactSearchData.@NotNull Story story, boolean isSelected) {
+            throw new UnsupportedOperationException();
+          }
+
+          @Override
+          public void onKnownRecipientClicked(@NotNull View view, ContactSearchData.@NotNull KnownRecipient knownRecipient, boolean isSelected) {
+            listClickListener.onItemClick(knownRecipient.getContactSearchKey());
+          }
+
+          @Override
+          public void onExpandClicked(ContactSearchData.@NotNull Expand expand) {
+            contactSearchViewModel.expandSection(expand.getSectionKey());
+          }
+
+          @Override
+          public void onChatTypeClicked(@NotNull View view, ContactSearchData.@NotNull ChatTypeRow chatTypeRow, boolean isSelected) {
+            listClickListener.onItemClick(chatTypeRow.getContactSearchKey());
+          }
+
+          @Override
+          public void onUnknownRecipientClicked(@NotNull View view, ContactSearchData.@NotNull UnknownRecipient unknownRecipient, boolean isSelected) {
+            listClickListener.onItemClick(unknownRecipient.getContactSearchKey());
+          }
+        },
+        (anchorView, data) -> listClickListener.onItemLongClick(anchorView, data.getContactSearchKey()),
+        null,
+        new CallButtonClickCallbacks()
    );

    return view;
@@ -595,32 +502,23 @@ public final class ContactSelectionListFragment extends LoggingFragment {
  public void reset() {
    contactSearchViewModel.clearSelection();
    contactSearchViewModel.refresh();
-    fastScroller.setVisibility(View.GONE);
-    headerActionView.setVisibility(View.GONE);
+    contactSearchViewModel.setFastScrollEnabled(false);
  }

  private void onLoadFinished(int count) {
-    if (resetPositionOnCommit && innerRecyclerView != null) {
+    if (resetPositionOnCommit) {
      resetPositionOnCommit = false;
-      innerRecyclerView.scrollToPosition(0);
+      contactSearchViewModel.requestScrollPosition(0);
    }

    swipeRefresh.setVisibility(View.VISIBLE);

    emptyText.setText(R.string.contact_selection_group_activity__no_contacts);
    boolean useFastScroller = count > 20;
-    if (useFastScroller && innerRecyclerView != null) {
-      fastScroller.setVisibility(View.VISIBLE);
-      fastScroller.setRecyclerView(innerRecyclerView);
+    if (useFastScroller) {
+      contactSearchViewModel.setFastScrollEnabled(true);
    } else {
-      fastScroller.setRecyclerView(null);
-      fastScroller.setVisibility(View.GONE);
-    }
-
-    if (headerActionView.isEnabled() && !hasQueryFilter()) {
-      headerActionView.setVisibility(View.VISIBLE);
-    } else {
-      headerActionView.setVisibility(View.GONE);
+      contactSearchViewModel.setFastScrollEnabled(false);
    }
  }

@@ -790,8 +688,8 @@ public final class ContactSelectionListFragment extends LoggingFragment {
    }

    public boolean onItemLongClick(View anchorView, ContactSearchKey item) {
-      if (onItemLongClickListener != null && innerRecyclerView != null) {
-        return onItemLongClickListener.onLongClick(anchorView, item, innerRecyclerView);
+      if (onItemLongClickListener != null) {
+        return onItemLongClickListener.onLongClick(anchorView, item, isDisplayingContextMenu -> contactSearchViewModel.setDisplayingContextMenu(isDisplayingContextMenu));
      } else {
        return false;
      }
@@ -933,19 +831,19 @@ public final class ContactSelectionListFragment extends LoggingFragment {
          !SignalStore.uiHints().getDismissedContactsPermissionBanner() &&
          !hasQuery)
      {
-        builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.FIND_CONTACTS_BANNER.getCode());
+        builder.arbitrary(ContactSelectionListModels.ArbitraryRow.FIND_CONTACTS_BANNER.getCode());
      }

      if (fragmentArgs.getEnableCreateNewGroup() && !hasQuery) {
-        builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.NEW_GROUP.getCode());
+        builder.arbitrary(ContactSelectionListModels.ArbitraryRow.NEW_GROUP.getCode());
      }

      if (fragmentArgs.getEnableFindByUsername() && !hasQuery) {
-        builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.FIND_BY_USERNAME.getCode());
+        builder.arbitrary(ContactSelectionListModels.ArbitraryRow.FIND_BY_USERNAME.getCode());
      }

      if (fragmentArgs.getEnableFindByPhoneNumber() && !hasQuery) {
-        builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.FIND_BY_PHONE_NUMBER.getCode());
+        builder.arbitrary(ContactSelectionListModels.ArbitraryRow.FIND_BY_PHONE_NUMBER.getCode());
      }

      if (includeChatTypes && !hasQuery) {
@@ -967,10 +865,12 @@ public final class ContactSelectionListFragment extends LoggingFragment {
        }

        boolean hideHeader = newCallCallback != null || (newConversationCallback != null && !hasQuery);
+        HeaderAction sectionHeaderAction = (headerActionProvider != null && !hasQuery) ? headerActionProvider.getHeaderAction() : null;
        builder.addSection(new ContactSearchConfiguration.Section.Individuals(
            includeSelf ? new RecipientTable.IncludeSelfMode.IncludeWithRemap(getString(R.string.note_to_self)) : RecipientTable.IncludeSelfMode.Exclude.INSTANCE,
            transportType,
            !hideHeader,
+            sectionHeaderAction,
            null,
            !hideLetterHeaders(),
            newConversationCallback != null ? ContactSearchSortOrder.RECENCY : ContactSearchSortOrder.NATURAL
@@ -1017,13 +917,13 @@ public final class ContactSelectionListFragment extends LoggingFragment {
  }

  private void addMoreSection(@NonNull ContactSearchConfiguration.Builder builder) {
-    builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.MORE_HEADING.getCode());
+    builder.arbitrary(ContactSelectionListModels.ArbitraryRow.MORE_HEADING.getCode());
    if (hasContactsPermissions(requireContext())) {
-      builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.REFRESH_CONTACTS.getCode());
+      builder.arbitrary(ContactSelectionListModels.ArbitraryRow.REFRESH_CONTACTS.getCode());
    } else if (SignalStore.uiHints().getDismissedContactsPermissionBanner()) {
-      builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.FIND_CONTACTS.getCode());
+      builder.arbitrary(ContactSelectionListModels.ArbitraryRow.FIND_CONTACTS.getCode());
    }
-    builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.INVITE_TO_SIGNAL.getCode());
+    builder.arbitrary(ContactSelectionListModels.ArbitraryRow.INVITE_TO_SIGNAL.getCode());
  }

  private static @Nullable ContactSearchConfiguration.TransportType resolveTransportType(boolean includePushContacts, boolean includeSmsContacts) {
@@ -1113,15 +1013,11 @@ public final class ContactSelectionListFragment extends LoggingFragment {
    void onInvite();
  }

-  public interface ScrollCallback {
-    void onBeginScroll();
-  }
-
  public interface HeaderActionProvider {
    @NonNull HeaderAction getHeaderAction();
  }

  public interface OnItemLongClickListener {
-    boolean onLongClick(View anchorView, ContactSearchKey contactSearchKey, RecyclerView recyclerView);
+    boolean onLongClick(View anchorView, ContactSearchKey contactSearchKey, Consumer<Boolean> setIsDisplayingContextMenu);
  }
 }
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms
+
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.TextView
+import com.google.android.material.button.MaterialButton
+import org.thoughtcrime.securesms.contacts.paged.ContactSearchModels.EmptyModel
+import org.thoughtcrime.securesms.util.adapter.mapping.LayoutFactory
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingViewHolder
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingEntryProvider
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingEntryProviderBuilder
+
+/**
+ * Holds the [MappingModel]s and [MappingViewHolder]s used by [ContactSelectionListAdapter] on top of
+ * the base set in [org.thoughtcrime.securesms.contacts.paged.ContactSearchModels], along with helpers
+ * for registering them on a [MappingAdapter] (RecyclerView) or building a [MappingEntryProvider]
+ * (Compose).
+ */
+object ContactSelectionListModels {
+
+  fun registerNewGroup(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      NewGroupModel::class.java,
+      LayoutFactory({ NewGroupViewHolder(it, onClick) }, R.layout.contact_selection_new_group_item)
+    )
+  }
+
+  fun registerInviteToSignal(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      InviteToSignalModel::class.java,
+      LayoutFactory({ InviteToSignalViewHolder(it, onClick) }, R.layout.contact_selection_invite_action_item)
+    )
+  }
+
+  fun registerFindContacts(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      FindContactsModel::class.java,
+      LayoutFactory({ FindContactsViewHolder(it, onClick) }, R.layout.contact_selection_find_contacts_item)
+    )
+  }
+
+  fun registerFindContactsBanner(mappingAdapter: MappingAdapter, onDismiss: () -> Unit, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      FindContactsBannerModel::class.java,
+      LayoutFactory({ FindContactsBannerViewHolder(it, onDismiss, onClick) }, R.layout.contact_selection_find_contacts_banner_item)
+    )
+  }
+
+  fun registerRefreshContacts(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      RefreshContactsModel::class.java,
+      LayoutFactory({ RefreshContactsViewHolder(it, onClick) }, R.layout.contact_selection_refresh_action_item)
+    )
+  }
+
+  fun registerMoreHeader(mappingAdapter: MappingAdapter) {
+    mappingAdapter.registerFactory(
+      MoreHeaderModel::class.java,
+      LayoutFactory({ MoreHeaderViewHolder(it) }, R.layout.contact_search_section_header)
+    )
+  }
+
+  fun registerEmpty(mappingAdapter: MappingAdapter) {
+    mappingAdapter.registerFactory(
+      EmptyModel::class.java,
+      LayoutFactory({ EmptyViewHolder(it) }, R.layout.contact_selection_empty_state)
+    )
+  }
+
+  fun registerFindByUsername(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      FindByUsernameModel::class.java,
+      LayoutFactory({ FindByUsernameViewHolder(it, onClick) }, R.layout.contact_selection_find_by_username_item)
+    )
+  }
+
+  fun registerFindByPhoneNumber(mappingAdapter: MappingAdapter, onClick: () -> Unit) {
+    mappingAdapter.registerFactory(
+      FindByPhoneNumberModel::class.java,
+      LayoutFactory({ FindByPhoneNumberViewHolder(it, onClick) }, R.layout.contact_selection_find_by_phone_number_item)
+    )
+  }
+
+  /**
+   * Returns a [MappingEntryProvider] containing the same set of view holders registered by the
+   * adapter-side `register*` methods, suitable for use with a Compose `MappingLazyColumn`.
+   */
+  @JvmStatic
+  fun composeEntries(
+    callback: Callback
+  ): MappingEntryProvider<Any> {
+    return MappingEntryProviderBuilder<Any>().apply {
+      viewHolder<NewGroupModel> { context ->
+        LayoutFactory(
+          { view -> NewGroupViewHolder(view, callback::onNewGroupClicked) },
+          R.layout.contact_selection_new_group_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<InviteToSignalModel> { context ->
+        LayoutFactory(
+          { view -> InviteToSignalViewHolder(view, callback::onInviteToSignalClicked) },
+          R.layout.contact_selection_invite_action_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<FindContactsModel> { context ->
+        LayoutFactory(
+          { view -> FindContactsViewHolder(view, callback::onFindContactsClicked) },
+          R.layout.contact_selection_find_contacts_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<FindContactsBannerModel> { context ->
+        LayoutFactory(
+          { view -> FindContactsBannerViewHolder(view, callback::onDismissFindContactsBannerClicked, callback::onFindContactsClicked) },
+          R.layout.contact_selection_find_contacts_banner_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<RefreshContactsModel> { context ->
+        LayoutFactory(
+          { view -> RefreshContactsViewHolder(view, callback::onRefreshContactsClicked) },
+          R.layout.contact_selection_refresh_action_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<MoreHeaderModel> { context ->
+        LayoutFactory(
+          { view -> MoreHeaderViewHolder(view) },
+          R.layout.contact_search_section_header
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<EmptyModel> { context ->
+        LayoutFactory(
+          { view -> EmptyViewHolder(view) },
+          R.layout.contact_selection_empty_state
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<FindByUsernameModel> { context ->
+        LayoutFactory(
+          { view -> FindByUsernameViewHolder(view, callback::onFindByUsernameClicked) },
+          R.layout.contact_selection_find_by_username_item
+        ).createViewHolder(FrameLayout(context))
+      }
+      viewHolder<FindByPhoneNumberModel> { context ->
+        LayoutFactory(
+          { view -> FindByPhoneNumberViewHolder(view, callback::onFindByPhoneNumberClicked) },
+          R.layout.contact_selection_find_by_phone_number_item
+        ).createViewHolder(FrameLayout(context))
+      }
+    }.build()
+  }
+
+  interface Callback {
+    fun onNewGroupClicked()
+    fun onInviteToSignalClicked()
+    fun onFindContactsClicked()
+    fun onDismissFindContactsBannerClicked()
+    fun onRefreshContactsClicked()
+    fun onFindByUsernameClicked()
+    fun onFindByPhoneNumberClicked()
+  }
+
+  enum class ArbitraryRow(val code: String) {
+    NEW_GROUP("new-group"),
+    INVITE_TO_SIGNAL("invite-to-signal"),
+    MORE_HEADING("more-heading"),
+    REFRESH_CONTACTS("refresh-contacts"),
+    FIND_CONTACTS("find-contacts"),
+    FIND_CONTACTS_BANNER("find-contacts-banner"),
+    FIND_BY_USERNAME("find-by-username"),
+    FIND_BY_PHONE_NUMBER("find-by-phone-number");
+
+    companion object {
+      fun fromCode(code: String) = entries.first { it.code == code }
+    }
+  }
+
+  class NewGroupModel : MappingModel<NewGroupModel> {
+    override fun areItemsTheSame(newItem: NewGroupModel): Boolean = true
+    override fun areContentsTheSame(newItem: NewGroupModel): Boolean = true
+  }
+
+  class InviteToSignalModel : MappingModel<InviteToSignalModel> {
+    override fun areItemsTheSame(newItem: InviteToSignalModel): Boolean = true
+    override fun areContentsTheSame(newItem: InviteToSignalModel): Boolean = true
+  }
+
+  class RefreshContactsModel : MappingModel<RefreshContactsModel> {
+    override fun areItemsTheSame(newItem: RefreshContactsModel): Boolean = true
+    override fun areContentsTheSame(newItem: RefreshContactsModel): Boolean = true
+  }
+
+  class FindContactsModel : MappingModel<FindContactsModel> {
+    override fun areItemsTheSame(newItem: FindContactsModel): Boolean = true
+    override fun areContentsTheSame(newItem: FindContactsModel): Boolean = true
+  }
+
+  class FindContactsBannerModel : MappingModel<FindContactsBannerModel> {
+    override fun areItemsTheSame(newItem: FindContactsBannerModel): Boolean = true
+    override fun areContentsTheSame(newItem: FindContactsBannerModel): Boolean = true
+  }
+
+  class FindByUsernameModel : MappingModel<FindByUsernameModel> {
+    override fun areItemsTheSame(newItem: FindByUsernameModel): Boolean = true
+    override fun areContentsTheSame(newItem: FindByUsernameModel): Boolean = true
+  }
+
+  class FindByPhoneNumberModel : MappingModel<FindByPhoneNumberModel> {
+    override fun areItemsTheSame(newItem: FindByPhoneNumberModel): Boolean = true
+    override fun areContentsTheSame(newItem: FindByPhoneNumberModel): Boolean = true
+  }
+
+  class MoreHeaderModel : MappingModel<MoreHeaderModel> {
+    override fun areItemsTheSame(newItem: MoreHeaderModel): Boolean = true
+
+    override fun areContentsTheSame(newItem: MoreHeaderModel): Boolean = true
+  }
+
+  private class InviteToSignalViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<InviteToSignalModel>(itemView) {
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: InviteToSignalModel) = Unit
+  }
+
+  private class NewGroupViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<NewGroupModel>(itemView) {
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: NewGroupModel) = Unit
+  }
+
+  private class RefreshContactsViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<RefreshContactsModel>(itemView) {
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: RefreshContactsModel) = Unit
+  }
+
+  private class FindContactsViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindContactsModel>(itemView) {
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: FindContactsModel) = Unit
+  }
+
+  private class FindContactsBannerViewHolder(itemView: View, onDismissListener: () -> Unit, onClickListener: () -> Unit) : MappingViewHolder<FindContactsBannerModel>(itemView) {
+    init {
+      itemView.findViewById<MaterialButton>(R.id.no_thanks_button).setOnClickListener { onDismissListener() }
+      itemView.findViewById<MaterialButton>(R.id.allow_contacts_button).setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: FindContactsBannerModel) = Unit
+  }
+
+  private class MoreHeaderViewHolder(itemView: View) : MappingViewHolder<MoreHeaderModel>(itemView) {
+
+    private val headerTextView: TextView = itemView.findViewById(R.id.section_header)
+
+    override fun bind(model: MoreHeaderModel) {
+      headerTextView.setText(R.string.contact_selection_activity__more)
+    }
+  }
+
+  private class EmptyViewHolder(itemView: View) : MappingViewHolder<EmptyModel>(itemView) {
+
+    private val emptyText: TextView = itemView.findViewById(R.id.search_no_results)
+
+    override fun bind(model: EmptyModel) {
+      emptyText.text = context.getString(R.string.SearchFragment_no_results, model.empty.query ?: "")
+    }
+  }
+
+  private class FindByPhoneNumberViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindByPhoneNumberModel>(itemView) {
+
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: FindByPhoneNumberModel) = Unit
+  }
+
+  private class FindByUsernameViewHolder(itemView: View, onClickListener: () -> Unit) : MappingViewHolder<FindByUsernameModel>(itemView) {
+
+    init {
+      itemView.setOnClickListener { onClickListener() }
+    }
+
+    override fun bind(model: FindByUsernameModel) = Unit
+  }
+}
@@ -116,6 +116,7 @@ import org.thoughtcrime.securesms.components.settings.app.subscription.GooglePay
 import org.thoughtcrime.securesms.components.snackbars.LocalSnackbarStateConsumerRegistry
 import org.thoughtcrime.securesms.components.snackbars.SnackbarHostKey
 import org.thoughtcrime.securesms.components.snackbars.SnackbarState
+import org.thoughtcrime.securesms.components.verificationrequested.VerificationCodeRequestedBottomSheet
 import org.thoughtcrime.securesms.components.voice.VoiceNoteMediaController
 import org.thoughtcrime.securesms.components.voice.VoiceNoteMediaControllerOwner
 import org.thoughtcrime.securesms.conversation.ConversationIntents
@@ -195,6 +196,7 @@ import org.thoughtcrime.securesms.window.AppScaffoldNavigator
 import org.thoughtcrime.securesms.window.NavigationType
 import org.thoughtcrime.securesms.window.rememberThreePaneScaffoldNavigatorDelegate
 import org.whispersystems.signalservice.api.websocket.WebSocketConnectionState
+import kotlin.time.Duration.Companion.minutes
 import org.signal.core.ui.R as CoreUiR

 class MainActivity :
@@ -357,6 +359,25 @@ class MainActivity :
            }
        }
      }
+
+      launch {
+        repeatOnLifecycle(Lifecycle.State.RESUMED) {
+          SignalStore
+            .account
+            .verificationCodeRequestedAtMsFlow
+            .filter { it > 0L }
+            .collect { requestedAt ->
+              val notificationThreshold = requestedAt + 10.minutes.inWholeMilliseconds
+              if (System.currentTimeMillis() < notificationThreshold) {
+                VerificationCodeRequestedBottomSheet.show(supportFragmentManager, requestedAt)
+              } else {
+                Log.i(TAG, "Verification code requested but is older than 10 minutes, not showing sheet")
+              }
+
+              SignalStore.account.verificationCodeRequestedAtMs = 0L
+            }
+        }
+      }
    }

    supportFragmentManager.setFragmentResultListener(
@@ -10,12 +10,15 @@ import androidx.annotation.Nullable;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.app.TaskStackBuilder;

+import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
 import org.thoughtcrime.securesms.util.CommunicationActions;

 public class ShortcutLauncherActivity extends AppCompatActivity {

+  private static final String TAG = Log.tag(ShortcutLauncherActivity.class);
+
  private static final String KEY_RECIPIENT = "recipient_id";

  public static Intent createIntent(@NonNull Context context, @NonNull RecipientId recipientId) {
@@ -30,9 +33,18 @@ public class ShortcutLauncherActivity extends AppCompatActivity {
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

-    String rawId = getIntent().getStringExtra(KEY_RECIPIENT);
+    String      rawId       = getIntent().getStringExtra(KEY_RECIPIENT);
+    RecipientId recipientId = null;

-    if (rawId == null) {
+    if (rawId != null) {
+      try {
+        recipientId = RecipientId.from(rawId);
+      } catch (Throwable t) {
+        Log.w(TAG, "Failed to parse recipientId from intent.", t);
+      }
+    }
+
+    if (recipientId == null) {
      Toast.makeText(this, R.string.ShortcutLauncherActivity_invalid_shortcut, Toast.LENGTH_SHORT).show();
      // TODO [greyson] Navigation
      startActivity(MainActivity.clearTop(this));
@@ -40,7 +52,7 @@ public class ShortcutLauncherActivity extends AppCompatActivity {
      return;
    }

-    Recipient        recipient = Recipient.live(RecipientId.from(rawId)).get();
+    Recipient        recipient = Recipient.live(recipientId).get();
    // TODO [greyson] Navigation
    TaskStackBuilder backStack = TaskStackBuilder.create(this)
                                                 .addNextIntent(MainActivity.clearTop(this));
@@ -66,7 +66,12 @@ import org.signal.libsignal.messagebackup.BackupForwardSecrecyToken
 import org.signal.libsignal.zkgroup.VerificationFailedException
 import org.signal.libsignal.zkgroup.backups.BackupLevel
 import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.signal.network.ApplicationErrorAction
+import org.signal.network.NetworkResult
+import org.signal.network.StatusCodeErrorAction
 import org.signal.network.api.SvrBApi
+import org.signal.network.exceptions.NonSuccessfulResponseCodeException
+import org.signal.network.rest.toNetworkResult
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.Cdn
@@ -145,9 +150,6 @@ import org.thoughtcrime.securesms.util.RemoteConfig
 import org.thoughtcrime.securesms.util.ServiceUtil
 import org.thoughtcrime.securesms.util.TextSecurePreferences
 import org.thoughtcrime.securesms.util.toMillis
-import org.whispersystems.signalservice.api.ApplicationErrorAction
-import org.whispersystems.signalservice.api.NetworkResult
-import org.whispersystems.signalservice.api.StatusCodeErrorAction
 import org.whispersystems.signalservice.api.archive.ArchiveGetMediaItemsResponse
 import org.whispersystems.signalservice.api.archive.ArchiveKeyRotationLimitResponse
 import org.whispersystems.signalservice.api.archive.ArchiveMediaRequest
@@ -161,7 +163,6 @@ import org.whispersystems.signalservice.api.crypto.AttachmentCipherStreamUtil
 import org.whispersystems.signalservice.api.link.TransferArchiveResponse
 import org.whispersystems.signalservice.api.messages.AttachmentTransferProgress
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment.ProgressListener
-import org.whispersystems.signalservice.api.push.exceptions.NonSuccessfulResponseCodeException
 import org.whispersystems.signalservice.internal.crypto.PaddingInputStream
 import org.whispersystems.signalservice.internal.push.AttachmentUploadForm
 import org.whispersystems.signalservice.internal.push.AuthCredentials
@@ -1628,19 +1629,6 @@ object BackupRepository {
      }
  }

-  fun getResumableMessagesBackupUploadSpec(backupFileSize: Long): NetworkResult<ResumableMessagesBackupUploadSpec> {
-    return initBackupAndFetchAuth()
-      .then { credential ->
-        SignalNetwork.archive.getMessageBackupUploadForm(SignalStore.account.requireAci(), credential.messageBackupAccess, backupFileSize)
-          .also { Log.i(TAG, "UploadFormResult: ${it::class.simpleName}") }
-      }
-      .then { form ->
-        SignalNetwork.archive.getBackupResumableUploadUrl(form)
-          .also { Log.i(TAG, "ResumableUploadUrlResult: ${it::class.simpleName}") }
-          .map { ResumableMessagesBackupUploadSpec(attachmentUploadForm = form, resumableUri = it) }
-      }
-  }
-
  fun getMessageBackupUploadForm(backupFileSize: Long): NetworkResult<AttachmentUploadForm> {
    return initBackupAndFetchAuth()
      .then { credential ->
@@ -156,8 +156,7 @@ object AccountDataArchiveProcessor {
            navigationBarSize = signalStore.settingsValues.useCompactNavigationBar.toRemoteNavigationBarSize()
          ).takeUnless { Environment.IS_INSTRUMENTATION && SignalStore.backup.importedEmptyAndroidSettings },
          bioText = selfRecord.about ?: "",
-          bioEmoji = selfRecord.aboutEmoji ?: "",
-          keyTransparencyData = selfRecord.keyTransparencyData?.toByteString()
+          bioEmoji = selfRecord.aboutEmoji ?: ""
        )
      )
    )
@@ -251,7 +250,7 @@ object AccountDataArchiveProcessor {
      SignalStore.account.usernameLink = null
    }

-    SignalDatabase.recipients.setKeyTransparencyData(Recipient.self().aci.get(), accountData.keyTransparencyData?.toByteArray())
+    SignalDatabase.recipients.clearSelfKeyTransparencyData()

    SignalDatabase.runPostSuccessfulTransaction { ProfileUtil.handleSelfProfileKeyChange() }

@@ -93,7 +93,8 @@ fun EnterKeyScreen(

      val updateEnteredBackupKey = { input: String ->
        enteredBackupKey = AccountEntropyPool.removeIllegalCharacters(input).uppercase()
-        isBackupKeyValid = enteredBackupKey == backupKey
+        val normalized = AccountEntropyPool.formatForStorage(enteredBackupKey)
+        isBackupKeyValid = normalized.equals(AccountEntropyPool.formatForStorage(backupKey), ignoreCase = true)
        showError = !isBackupKeyValid && enteredBackupKey.length >= backupKey.length
      }

@@ -15,6 +15,7 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.signal.core.util.logging.Log
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.calls.new.NewCallUiState.CallType
 import org.thoughtcrime.securesms.calls.new.NewCallUiState.UserMessage
 import org.thoughtcrime.securesms.contacts.sync.ContactDiscovery
@@ -25,7 +26,6 @@ import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.recipients.RecipientRepository
 import org.thoughtcrime.securesms.recipients.ui.RecipientSelection
-import org.whispersystems.signalservice.api.NetworkResult

 class NewCallViewModel : ViewModel() {
  companion object {
@@ -36,6 +36,7 @@ import com.bumptech.glide.request.Request;
 import com.bumptech.glide.request.RequestListener;
 import com.bumptech.glide.request.RequestOptions;

+import org.signal.core.models.media.TransformProperties;
 import org.signal.core.util.concurrent.ListenableFuture;
 import org.signal.core.util.concurrent.SettableFuture;
 import org.signal.core.util.logging.Log;
@@ -608,7 +609,14 @@ public class ThumbnailView extends FrameLayout {
  }

  private RequestBuilder<Drawable> buildThumbnailRequestBuilder(@NonNull RequestManager requestManager, @NonNull Slide slide) {
-    RequestBuilder<Drawable> requestBuilder = applySizing(requestManager.load(new DecryptableUri(Objects.requireNonNull(slide.getDisplayUri())))
+    long                videoTrimStartTimeUs = 0;
+    TransformProperties transformProperties  = slide.asAttachment().transformProperties;
+
+    if (transformProperties != null && !transformProperties.shouldSkipTransform()) {
+      videoTrimStartTimeUs = transformProperties.videoTrimStartTimeUs;
+    }
+
+    RequestBuilder<Drawable> requestBuilder = applySizing(requestManager.load(new DecryptableUri(Objects.requireNonNull(slide.getDisplayUri()), videoTrimStartTimeUs))
                                                              .diskCacheStrategy(DiskCacheStrategy.RESOURCE)
                                                              .downsample(SignalDownsampleStrategy.CENTER_OUTSIDE_NO_UPSCALE)
                                                              .transition(withCrossFade()));
@@ -86,6 +86,7 @@ class AppSettingsActivity : DSLSettingsActivity(), GooglePayComponent {
        is AppSettingsRoute.BackupsRoute.Backups -> AppSettingsFragmentDirections.actionDirectToBackupsSettingsFragment().setLaunchCheckoutFlow(appSettingsRoute.launchCheckoutFlow)
        AppSettingsRoute.Invite -> AppSettingsFragmentDirections.actionDirectToInviteFragment()
        AppSettingsRoute.DataAndStorageRoute.DataAndStorage -> AppSettingsFragmentDirections.actionDirectToStoragePreferenceFragment()
+        AppSettingsRoute.AccountRoute.Account -> AppSettingsFragmentDirections.actionDirectToAccountSettingsFragment()
        else -> error("Unsupported start location: ${appSettingsRoute?.javaClass?.name}")
      }
    }
@@ -177,6 +178,9 @@ class AppSettingsActivity : DSLSettingsActivity(), GooglePayComponent {
    @JvmStatic
    fun changeNumber(context: Context): Intent = getIntentForStartLocation(context, AppSettingsRoute.ChangeNumberRoute.Start)

+    @JvmStatic
+    fun account(context: Context): Intent = getIntentForStartLocation(context, AppSettingsRoute.AccountRoute.Account)
+
    @JvmStatic
    fun subscriptions(context: Context): Intent = getIntentForStartLocation(context, AppSettingsRoute.DonationsRoute.Donations(directToCheckoutType = InAppPaymentType.RECURRING_DONATION))

@@ -312,49 +312,49 @@ private fun AppSettingsContent(
              enabled = isRegisteredAndUpToDate
            )
          }
+        }

-          item {
-            val context = LocalContext.current
-            val donateUrl = stringResource(R.string.donate_url)
+        item {
+          val context = LocalContext.current
+          val donateUrl = stringResource(R.string.donate_url)

-            Rows.TextRow(
-              text = {
-                Text(
-                  text = stringResource(R.string.preferences__donate_to_signal),
-                  modifier = Modifier.weight(1f)
-                )
+          Rows.TextRow(
+            text = {
+              Text(
+                text = stringResource(R.string.preferences__donate_to_signal),
+                modifier = Modifier.weight(1f)
+              )

-                if (state.hasExpiredGiftBadge) {
-                  Icon(
-                    painter = painterResource(R.drawable.symbol_info_fill_24),
-                    tint = colorResource(R.color.signal_accent_primary),
-                    contentDescription = null
-                  )
-                }
-              },
-              icon = {
+              if (state.hasExpiredGiftBadge) {
                Icon(
-                  painter = painterResource(R.drawable.symbol_heart_24),
-                  contentDescription = null,
-                  tint = MaterialTheme.colorScheme.onSurface
+                  painter = painterResource(R.drawable.symbol_info_fill_24),
+                  tint = colorResource(R.color.signal_accent_primary),
+                  contentDescription = null
                )
-              },
-              onClick = {
-                if (state.allowUserToGoToDonationManagementScreen) {
-                  callbacks.navigate(AppSettingsRoute.DonationsRoute.Donations())
-                } else {
-                  CommunicationActions.openBrowserLink(context, donateUrl)
-                }
-              },
-              onLongClick = {
-                callbacks.copyDonorBadgeSubscriberIdToClipboard()
              }
-            )
-          }
+            },
+            icon = {
+              Icon(
+                painter = painterResource(R.drawable.symbol_heart_24),
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurface
+              )
+            },
+            onClick = {
+              if (state.allowUserToGoToDonationManagementScreen) {
+                callbacks.navigate(AppSettingsRoute.DonationsRoute.Donations())
+              } else {
+                CommunicationActions.openBrowserLink(context, donateUrl)
+              }
+            },
+            onLongClick = {
+              callbacks.copyDonorBadgeSubscriberIdToClipboard()
+            }
+          )
+        }

-          item {
-            Dividers.Default()
-          }
+        item {
+          Dividers.Default()
        }

        item {
@@ -5,10 +5,10 @@ import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.node.ObjectNode
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.net.SignalNetwork
 import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.util.JsonUtils
-import org.whispersystems.signalservice.api.NetworkResult

 class ExportAccountDataRepository {

@@ -21,6 +21,7 @@ import org.signal.core.util.logging.Log
 import org.signal.core.util.money.FiatMoney
 import org.signal.core.util.throttleLatest
 import org.signal.donations.InAppPaymentType
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
 import org.thoughtcrime.securesms.backup.v2.ui.subscription.MessageBackupsType
@@ -33,7 +34,6 @@ import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.util.InternetConnectionObserver
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import java.math.BigDecimal
 import java.util.Currency
@@ -16,12 +16,12 @@ import kotlinx.coroutines.withContext
 import org.signal.core.models.AccountEntropyPool
 import org.signal.core.util.concurrent.SignalDispatchers
 import org.signal.core.util.logging.Log
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
 import org.thoughtcrime.securesms.backup.v2.StagedBackupKeyRotations
 import org.thoughtcrime.securesms.dependencies.AppDependencies
 import org.thoughtcrime.securesms.jobs.RestoreOptimizedMediaJob
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.whispersystems.signalservice.api.NetworkResult

 class BackupKeyDisplayViewModel : ViewModel(), BackupKeyCredentialManagerHandler {

@@ -29,6 +29,7 @@ import org.signal.core.util.logging.Log
 import org.signal.core.util.mebiBytes
 import org.signal.core.util.throttleLatest
 import org.signal.donations.InAppPaymentType
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.backup.ArchiveUploadProgress
 import org.thoughtcrime.securesms.backup.DeletionState
 import org.thoughtcrime.securesms.backup.v2.ArchiveRestoreProgress
@@ -51,7 +52,6 @@ import org.thoughtcrime.securesms.keyvalue.protos.ArchiveUploadProgressState
 import org.thoughtcrime.securesms.util.Environment
 import org.thoughtcrime.securesms.util.RemoteConfig
 import org.thoughtcrime.securesms.util.TextSecurePreferences
-import org.whispersystems.signalservice.api.NetworkResult
 import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
@@ -33,6 +33,7 @@ import org.thoughtcrime.securesms.registration.sms.ReceivedSmsEvent
 import org.thoughtcrime.securesms.util.concurrent.AssertedSuccessListener
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
 import org.thoughtcrime.securesms.util.visible
+import kotlin.math.ceil
 import kotlin.time.Duration.Companion.milliseconds

 /**
@@ -168,7 +169,7 @@ class ChangeNumberEnterCodeFragment : LoggingFragment(R.layout.fragment_change_n
      is ChangeNumberResult.RegistrationLocked -> presentRegistrationLocked(result.timeRemaining)
      is ChangeNumberResult.AuthorizationFailed -> presentIncorrectCodeDialog()
      is ChangeNumberResult.AttemptsExhausted -> presentAccountLocked()
-      is ChangeNumberResult.RateLimited -> presentRateLimitedDialog()
+      is ChangeNumberResult.RateLimited -> presentRateLimitedDialog(result.timeRemaining)

      else -> presentGenericError(result)
    }
@@ -195,13 +196,25 @@ class ChangeNumberEnterCodeFragment : LoggingFragment(R.layout.fragment_change_n
    )
  }

-  private fun presentRateLimitedDialog() {
+  private fun presentRateLimitedDialog(retryAfterSeconds: Long = 0) {
    binding.codeEntryLayout.keyboard.displayFailure().addListener(
      object : AssertedSuccessListener<Boolean?>() {
        override fun onSuccess(result: Boolean?) {
          MaterialAlertDialogBuilder(requireContext()).apply {
            setTitle(R.string.RegistrationActivity_too_many_attempts)
-            setMessage(R.string.RegistrationActivity_you_have_made_too_many_attempts_please_try_again_later)
+            if (retryAfterSeconds > 0) {
+              val minutes = ceil(retryAfterSeconds / 60.0).toInt().coerceAtLeast(1)
+              setMessage(
+                if (minutes >= 60) {
+                  val hours = ceil(minutes / 60.0).toInt()
+                  resources.getQuantityString(R.plurals.ChangeNumberEnterCodeFragment__too_many_attempts_try_again_in_hours, hours, hours)
+                } else {
+                  resources.getQuantityString(R.plurals.ChangeNumberEnterCodeFragment__too_many_attempts_try_again_in_minutes, minutes, minutes)
+                }
+              )
+            } else {
+              setMessage(R.string.RegistrationActivity_you_have_made_too_many_attempts_please_try_again_later)
+            }
            setPositiveButton(android.R.string.ok) { _: DialogInterface?, _: Int ->
              binding.codeEntryLayout.callMeCountDown.visibility = View.VISIBLE
              binding.codeEntryLayout.resendSmsCountDown.visibility = View.VISIBLE
@@ -23,7 +23,6 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
@@ -34,7 +33,10 @@ import org.signal.core.ui.compose.DayNightPreviews
 import org.signal.core.ui.compose.Previews
 import org.signal.core.ui.compose.Scaffolds
 import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.util.RemoteConfig
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
+import kotlin.time.Duration.Companion.milliseconds

 class ChangeNumberFragment : ComposeFragment() {

@@ -46,10 +48,25 @@ class ChangeNumberFragment : ComposeFragment() {
        navController.popBackStack()
      },
      onContinueClick = {
-        navController.safeNavigate(ChangeNumberFragmentDirections.actionChangePhoneNumberFragmentToEnterPhoneNumberChangeFragment())
+        val remainingWaitSeconds = remainingPostRegistrationWaitSeconds()
+        if (remainingWaitSeconds > 0) {
+          ChangeNumberPostRegistrationWaitSheet.show(parentFragmentManager, remainingWaitSeconds)
+        } else {
+          navController.safeNavigate(ChangeNumberFragmentDirections.actionChangePhoneNumberFragmentToEnterPhoneNumberChangeFragment())
+        }
      }
    )
  }
+
+  private fun remainingPostRegistrationWaitSeconds(): Long {
+    val registeredAt = SignalStore.account.registeredAtTimestamp
+    if (registeredAt <= 0) {
+      return 0
+    }
+    val waitingPeriodSeconds = RemoteConfig.changeNumberPostRegistrationWaitingPeriodSeconds
+    val elapsedSeconds = (System.currentTimeMillis() - registeredAt).milliseconds.inWholeSeconds
+    return (waitingPeriodSeconds - elapsedSeconds).coerceAtLeast(0)
+  }
 }

@Composable
@@ -73,7 +90,7 @@ fun ChangeNumberScreen(
        .padding(horizontal = 32.dp)
    ) {
      Image(
-        painter = painterResource(id = R.drawable.change_number_hero_image),
+        painter = painterResource(id = R.drawable.change_number),
        contentDescription = null,
        modifier = Modifier
          .padding(top = 20.dp)
@@ -83,7 +100,6 @@ fun ChangeNumberScreen(
        text = stringResource(id = R.string.AccountSettingsFragment__change_phone_number),
        style = MaterialTheme.typography.headlineMedium,
        textAlign = TextAlign.Center,
-        fontWeight = FontWeight.Bold,
        modifier = Modifier.padding(top = 24.dp)
      )

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.settings.app.changenumber
+
+import android.os.Bundle
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.FragmentManager
+import org.signal.core.ui.BottomSheetUtil
+import org.signal.core.ui.compose.BottomSheets
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.signal.core.ui.compose.horizontalGutters
+import org.thoughtcrime.securesms.R
+import kotlin.math.ceil
+
+/**
+ * Sheet shown when the user attempts to change their phone number before the
+ * post-registration waiting period has elapsed.
+ */
+class ChangeNumberPostRegistrationWaitSheet : ComposeBottomSheetDialogFragment() {
+
+  companion object {
+    private const val ARG_REMAINING_SECONDS = "arg.remaining_seconds"
+
+    @JvmStatic
+    fun show(fragmentManager: FragmentManager, remainingSeconds: Long) {
+      ChangeNumberPostRegistrationWaitSheet().apply {
+        arguments = Bundle().apply {
+          putLong(ARG_REMAINING_SECONDS, remainingSeconds)
+        }
+      }.show(fragmentManager, BottomSheetUtil.STANDARD_BOTTOM_SHEET_FRAGMENT_TAG)
+    }
+  }
+
+  private val remainingSeconds: Long
+    get() = requireArguments().getLong(ARG_REMAINING_SECONDS)
+
+  @Composable
+  override fun SheetContent() {
+    SheetContent(
+      remainingSeconds = remainingSeconds,
+      onDismiss = { dismissAllowingStateLoss() }
+    )
+  }
+}
+
+@Composable
+private fun SheetContent(
+  remainingSeconds: Long,
+  onDismiss: () -> Unit
+) {
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally,
+    modifier = Modifier
+      .fillMaxWidth()
+      .horizontalGutters(gutterSize = 36.dp)
+  ) {
+    BottomSheets.Handle()
+
+    Image(
+      painter = painterResource(R.drawable.change_number_error),
+      contentDescription = null,
+      modifier = Modifier
+        .padding(top = 26.dp)
+    )
+
+    Text(
+      text = stringResource(R.string.ChangeNumberPostRegistrationWaitSheet__title),
+      style = MaterialTheme.typography.titleLarge,
+      textAlign = TextAlign.Center,
+      color = MaterialTheme.colorScheme.onPrimaryContainer,
+      modifier = Modifier.padding(top = 16.dp)
+    )
+
+    Text(
+      text = stringResource(R.string.ChangeNumberPostRegistrationWaitSheet__body),
+      style = MaterialTheme.typography.bodyLarge,
+      textAlign = TextAlign.Center,
+      color = MaterialTheme.colorScheme.onSurfaceVariant,
+      modifier = Modifier.padding(top = 12.dp)
+    )
+
+    Text(
+      text = formatTryAgainIn(remainingSeconds),
+      style = MaterialTheme.typography.bodyLarge,
+      textAlign = TextAlign.Center,
+      color = MaterialTheme.colorScheme.onSurfaceVariant,
+      modifier = Modifier.padding(top = 16.dp)
+    )
+
+    Buttons.LargeTonal(
+      onClick = onDismiss,
+      modifier = Modifier
+        .fillMaxWidth()
+        .padding(top = 32.dp, bottom = 24.dp, start = 12.dp, end = 12.dp)
+    ) {
+      Text(stringResource(R.string.ChangeNumberPostRegistrationWaitSheet__ok))
+    }
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun SheetContentMinutesPreview() {
+  Previews.BottomSheetContentPreview {
+    SheetContent(
+      remainingSeconds = 25 * 60,
+      onDismiss = {}
+    )
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun SheetContentHoursPreview() {
+  Previews.BottomSheetContentPreview {
+    SheetContent(
+      remainingSeconds = 2 * 60 * 60,
+      onDismiss = {}
+    )
+  }
+}
+
+@Composable
+private fun formatTryAgainIn(remainingSeconds: Long): String {
+  val minutes = ceil(remainingSeconds / 60.0).toInt().coerceAtLeast(1)
+  return if (minutes >= 60) {
+    val hours = ceil(minutes / 60.0).toInt()
+    pluralStringResource(R.plurals.ChangeNumberPostRegistrationWaitSheet__try_again_in_hours, hours, hours)
+  } else {
+    pluralStringResource(R.plurals.ChangeNumberPostRegistrationWaitSheet__try_again_in_minutes, minutes, minutes)
+  }
+}
@@ -21,6 +21,7 @@ import org.signal.libsignal.protocol.state.SignalProtocolStore
 import org.signal.libsignal.protocol.state.SignedPreKeyRecord
 import org.signal.libsignal.protocol.util.KeyHelper
 import org.signal.libsignal.protocol.util.Medium
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.crypto.PreKeyUtil
 import org.thoughtcrime.securesms.database.IdentityTable
 import org.thoughtcrime.securesms.database.SignalDatabase
@@ -36,7 +37,6 @@ import org.thoughtcrime.securesms.pin.SvrWrongPinException
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.registration.viewmodel.SvrAuthCredentialSet
 import org.thoughtcrime.securesms.storage.StorageSyncHelper
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.api.SignalServiceAccountManager
 import org.whispersystems.signalservice.api.SignalServiceMessageSender
 import org.whispersystems.signalservice.api.SvrNoDataException
@@ -103,6 +103,83 @@ class ChangeNumberRepository(

  @WorkerThread
  fun changeLocalNumber(e164: String, pni: ServiceId.PNI) {
+    val metadata: PendingChangeNumberMetadata? = SignalStore.misc.pendingChangeNumberMetadata
+    if (metadata == null) {
+      Log.w(TAG, "No change number metadata, this shouldn't happen")
+      throw AssertionError("No change number metadata")
+    }
+
+    val pniIdentityKeyPair = IdentityKeyPair(metadata.pniIdentityKeyPair.toByteArray())
+    val pniRegistrationId = metadata.pniRegistrationId
+    val pniSignedPreKeyId = metadata.pniSignedPreKeyId
+    val pniLastResortKyberPreKeyId = metadata.pniLastResortKyberPreKeyId
+
+    // Prekeys were generated and stored during createChangeNumberRequest; reload them so we can pass them through and reuse for the upload below.
+    val preResetPniStore = AppDependencies.protocolStore.pni()
+    val signedPreKey = preResetPniStore.loadSignedPreKey(pniSignedPreKeyId)
+    val lastResortKyberPreKey = preResetPniStore.loadLastResortKyberPreKeys().firstOrNull { it.id == pniLastResortKyberPreKeyId }
+
+    applyLocalNumberChange(
+      e164 = e164,
+      pni = pni,
+      pniIdentityKeyPair = pniIdentityKeyPair,
+      pniSignedPreKey = signedPreKey,
+      pniLastResortKyberPreKey = lastResortKyberPreKey,
+      pniRegistrationId = pniRegistrationId
+    )
+
+    AppDependencies.resetNetwork()
+    AppDependencies.startNetwork()
+
+    val pniProtocolStore = AppDependencies.protocolStore.pni()
+    val pniMetadataStore = SignalStore.account.pniPreKeys
+
+    val oneTimeEcPreKeys = PreKeyUtil.generateAndStoreOneTimeEcPreKeys(pniProtocolStore, pniMetadataStore)
+    val oneTimeKyberPreKeys = PreKeyUtil.generateAndStoreOneTimeKyberPreKeys(pniProtocolStore, pniMetadataStore)
+
+    Log.i(TAG, "Submitting prekeys with PNI identity key: ${pniIdentityKeyPair.publicKey.fingerprint}")
+
+    retryChangeLocalNumberNetworkOperation {
+      SignalNetwork.keys.setPreKeysSync(
+        PreKeyUpload(
+          serviceIdType = ServiceIdType.PNI,
+          signedPreKey = signedPreKey,
+          oneTimeEcPreKeys = oneTimeEcPreKeys,
+          lastResortKyberPreKey = lastResortKyberPreKey,
+          oneTimeKyberPreKeys = oneTimeKyberPreKeys
+        )
+      )
+    }.successOrThrow()
+
+    pniMetadataStore.isSignedPreKeyRegistered = true
+    pniMetadataStore.lastResortKyberPreKeyId = pniLastResortKyberPreKeyId
+
+    SignalStore.misc.hasPniInitializedDevices = true
+
+    AppDependencies.jobManager.add(RefreshAttributesJob())
+
+    rotateCertificates()
+
+    SignalStore.misc.unlockChangeNumber()
+  }
+
+  /**
+   * Applies the local state for a successful number change: self recipient row, account values,
+   * PNI protocol store, and identity entry.
+   *
+   * Does NOT reset the network — callers must do so before any subsequent traffic that needs to
+   * use the new PNI. Does NOT make any server requests and does NOT flag prekeys as registered
+   * server-side — the caller is responsible for that once it can attest to server state.
+   */
+  @WorkerThread
+  fun applyLocalNumberChange(
+    e164: String,
+    pni: ServiceId.PNI,
+    pniIdentityKeyPair: IdentityKeyPair,
+    pniSignedPreKey: SignedPreKeyRecord,
+    pniLastResortKyberPreKey: KyberPreKeyRecord?,
+    pniRegistrationId: Int
+  ) {
    SignalDatabase.recipients.updateSelfE164(e164, pni)
    AppDependencies.recipientCache.clear()

@@ -117,50 +194,21 @@ class ChangeNumberRepository(

    AppDependencies.groupsV2Authorization.clear()

-    val metadata: PendingChangeNumberMetadata? = SignalStore.misc.pendingChangeNumberMetadata
-    if (metadata == null) {
-      Log.w(TAG, "No change number metadata, this shouldn't happen")
-      throw AssertionError("No change number metadata")
-    }
-
-    val pniIdentityKeyPair = IdentityKeyPair(metadata.pniIdentityKeyPair.toByteArray())
-    val pniRegistrationId = metadata.pniRegistrationId
-    val pniSignedPreyKeyId = metadata.pniSignedPreKeyId
-    val pniLastResortKyberPreKeyId = metadata.pniLastResortKyberPreKeyId
-
    val pniProtocolStore = AppDependencies.protocolStore.pni()
    val pniMetadataStore = SignalStore.account.pniPreKeys

    SignalStore.account.pniRegistrationId = pniRegistrationId
    SignalStore.account.setPniIdentityKeyAfterChangeNumber(pniIdentityKeyPair)

-    val signedPreKey = pniProtocolStore.loadSignedPreKey(pniSignedPreyKeyId)
-    val oneTimeEcPreKeys = PreKeyUtil.generateAndStoreOneTimeEcPreKeys(pniProtocolStore, pniMetadataStore)
-    val lastResortKyberPreKey = pniProtocolStore.loadLastResortKyberPreKeys().firstOrNull { it.id == pniLastResortKyberPreKeyId }
-    val oneTimeKyberPreKeys = PreKeyUtil.generateAndStoreOneTimeKyberPreKeys(pniProtocolStore, pniMetadataStore)
+    PreKeyUtil.storeSignedPreKey(pniProtocolStore, pniMetadataStore, pniSignedPreKey)
+    pniMetadataStore.activeSignedPreKeyId = pniSignedPreKey.id

-    if (lastResortKyberPreKey == null) {
+    if (pniLastResortKyberPreKey != null) {
+      PreKeyUtil.storeLastResortKyberPreKey(pniProtocolStore, pniMetadataStore, pniLastResortKyberPreKey)
+    } else {
      Log.w(TAG, "Last-resort kyber prekey is missing!")
    }

-    pniMetadataStore.activeSignedPreKeyId = signedPreKey.id
-    Log.i(TAG, "Submitting prekeys with PNI identity key: ${pniIdentityKeyPair.publicKey.fingerprint}")
-
-    retryChangeLocalNumberNetworkOperation {
-      SignalNetwork.keys.setPreKeys(
-        PreKeyUpload(
-          serviceIdType = ServiceIdType.PNI,
-          signedPreKey = signedPreKey,
-          oneTimeEcPreKeys = oneTimeEcPreKeys,
-          lastResortKyberPreKey = lastResortKyberPreKey,
-          oneTimeKyberPreKeys = oneTimeKyberPreKeys
-        )
-      )
-    }.successOrThrow()
-
-    pniMetadataStore.isSignedPreKeyRegistered = true
-    pniMetadataStore.lastResortKyberPreKeyId = pniLastResortKyberPreKeyId
-
    pniProtocolStore.identities().saveIdentityWithoutSideEffects(
      Recipient.self().id,
      pni,
@@ -171,20 +219,8 @@ class ChangeNumberRepository(
      true
    )

-    SignalStore.misc.hasPniInitializedDevices = true
-    AppDependencies.groupsV2Authorization.clear()
-
    Recipient.self().fresh()
    StorageSyncHelper.scheduleSyncForDataChange()
-
-    AppDependencies.resetNetwork()
-    AppDependencies.startNetwork()
-
-    AppDependencies.jobManager.add(RefreshAttributesJob())
-
-    rotateCertificates()
-
-    SignalStore.misc.unlockChangeNumber()
  }

  @WorkerThread
@@ -5,11 +5,11 @@

 package org.thoughtcrime.securesms.components.settings.app.changenumber

+import org.signal.network.NetworkResult
+import org.signal.network.exceptions.NonSuccessfulResponseCodeException
 import org.thoughtcrime.securesms.pin.SvrWrongPinException
 import org.thoughtcrime.securesms.registration.data.network.RegistrationResult
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.api.SvrNoDataException
-import org.whispersystems.signalservice.api.push.exceptions.NonSuccessfulResponseCodeException
 import org.whispersystems.signalservice.api.svr.Svr3Credentials
 import org.whispersystems.signalservice.internal.push.AuthCredentials
 import org.whispersystems.signalservice.internal.push.PushServiceSocket.RegistrationLockFailure
@@ -4,15 +4,20 @@ import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
 import android.content.DialogInterface
+import android.os.Build
 import android.os.Bundle
 import android.view.View
 import android.widget.EditText
 import android.widget.Toast
 import androidx.fragment.app.setFragmentResultListener
 import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.fragment.findNavController
 import androidx.recyclerview.widget.LinearLayoutManager
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.signal.core.ui.BottomSheetUtil
 import org.signal.core.ui.permissions.PermissionDeniedBottomSheet
 import org.signal.core.ui.permissions.RationaleDialog
@@ -1092,15 +1097,26 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
  }

  private fun refreshRemoteValues() {
-    Toast.makeText(context, "Running remote config refresh, app will restart after completion.", Toast.LENGTH_LONG).show()
-    SignalExecutors.BOUNDED.execute {
+    val starterToast = Toast.makeText(context, "Running remote config refresh, app will restart after completion.", Toast.LENGTH_LONG).apply { show() }
+    lifecycleScope.launch(Dispatchers.IO) {
      SignalStore.remoteConfig.eTag = ""
      val result: Optional<JobTracker.JobState> = AppDependencies.jobManager.runSynchronously(RemoteConfigRefreshJob(), TimeUnit.SECONDS.toMillis(10))

-      if (result.isPresent && result.get() == JobTracker.JobState.SUCCESS) {
-        AppUtil.restart(requireContext())
-      } else {
-        Toast.makeText(context, "Failed to refresh config remote config.", Toast.LENGTH_SHORT).show()
+      withContext(Dispatchers.Main) {
+        starterToast.cancel()
+        if (result.isPresent && result.get() == JobTracker.JobState.SUCCESS) {
+          val toast = Toast.makeText(context, "Refresh successful. Restarting...", Toast.LENGTH_SHORT)
+          if (Build.VERSION.SDK_INT >= 30) {
+            toast.addCallback(object : Toast.Callback() {
+              override fun onToastHidden() {
+                AppUtil.restart(requireContext())
+              }
+            })
+          }
+          toast.show()
+        } else {
+          Toast.makeText(context, "Failed to refresh config remote config.", Toast.LENGTH_SHORT).show()
+        }
      }
    }
  }
@@ -503,7 +503,7 @@ fun Screen(
        text = "Copy Account Entropy Pool (AEP)",
        label = "Copies the Account Entropy Pool (AEP) to the clipboard, which is labeled as the \"Backup Key\" in the designs.",
        onClick = {
-          Util.copyToClipboard(context, SignalStore.account.accountEntropyPool.value)
+          Util.copyToClipboard(context, SignalStore.account.accountEntropyPool.displayValue)
          Toast.makeText(context, "Copied!", Toast.LENGTH_SHORT).show()
        }
      )
@@ -37,6 +37,7 @@ import org.signal.core.util.readNBytesOrThrow
 import org.signal.core.util.roundedString
 import org.signal.core.util.stream.LimitedInputStream
 import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.signal.network.NetworkResult
 import org.signal.network.api.SvrBApi
 import org.thoughtcrime.securesms.attachments.AttachmentId
 import org.thoughtcrime.securesms.attachments.DatabaseAttachment
@@ -58,7 +59,6 @@ import org.thoughtcrime.securesms.keyvalue.protos.LocalBackupCreationProgress
 import org.thoughtcrime.securesms.net.SignalNetwork
 import org.thoughtcrime.securesms.providers.BlobProvider
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.whispersystems.signalservice.api.NetworkResult
 import java.io.FileOutputStream
 import java.io.IOException
 import java.io.InputStream
@@ -12,6 +12,5 @@ sealed interface LabsSettingsEvents {
  data class ToggleGroupSuggestionsForMembers(val enabled: Boolean) : LabsSettingsEvents
  data class ToggleBetterSearch(val enabled: Boolean) : LabsSettingsEvents
  data class ToggleAutoLowerHand(val enabled: Boolean) : LabsSettingsEvents
-
  data class ToggleStarredMessages(val enabled: Boolean) : LabsSettingsEvents
 }
@@ -15,6 +15,5 @@ data class LabsSettingsState(
  val groupSuggestionsForMembers: Boolean = false,
  val betterSearch: Boolean = false,
  val autoLowerHand: Boolean = false,
-
  val starredMessages: Boolean = false
 )
@@ -57,7 +57,6 @@ class LabsSettingsViewModel : ViewModel() {
      groupSuggestionsForMembers = SignalStore.labs.groupSuggestionsForMembers,
      betterSearch = SignalStore.labs.betterSearch,
      autoLowerHand = SignalStore.labs.autoLowerHand,
-
      starredMessages = SignalStore.labs.starredMessages
    )
  }
@@ -45,7 +45,6 @@ import org.signal.core.ui.compose.Texts
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.compose.rememberStatusBarColorNestedScrollModifier
 import org.thoughtcrime.securesms.util.CommunicationActions
-import org.thoughtcrime.securesms.util.RemoteConfig
 import org.thoughtcrime.securesms.util.viewModel

 /**
@@ -299,31 +298,29 @@ private fun AdvancedPrivacySettingsScreen(
        )
      }

-      if (RemoteConfig.internalUser) {
-        item {
-          Dividers.Default()
-        }
+      item {
+        Dividers.Default()
+      }

-        item {
-          val label = buildAnnotatedString {
-            append(stringResource(R.string.preferences_automatic_key_verification_body))
-            append(" ")
-            withLink(
-              LinkAnnotation.Clickable("learn-more", linkInteractionListener = {
-                callbacks.onAutomaticVerificationLearnMoreClick()
-              })
-            ) {
-              append(stringResource(R.string.LearnMoreTextView_learn_more))
-            }
+      item {
+        val label = buildAnnotatedString {
+          append(stringResource(R.string.preferences_automatic_key_verification_body))
+          append(" ")
+          withLink(
+            LinkAnnotation.Clickable("learn-more", linkInteractionListener = {
+              callbacks.onAutomaticVerificationLearnMoreClick()
+            })
+          ) {
+            append(stringResource(R.string.LearnMoreTextView_learn_more))
          }
-
-          Rows.ToggleRow(
-            checked = state.allowAutomaticKeyVerification,
-            text = AnnotatedString(stringResource(R.string.preferences_automatic_key_verification)),
-            label = label,
-            onCheckChanged = callbacks::onAllowAutomaticVerificationChanged
-          )
        }
+
+        Rows.ToggleRow(
+          checked = state.allowAutomaticKeyVerification,
+          text = AnnotatedString(stringResource(R.string.preferences_automatic_key_verification)),
+          label = label,
+          onCheckChanged = callbacks::onAllowAutomaticVerificationChanged
+        )
      }
    }
  }
@@ -7,6 +7,7 @@ import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
 import org.signal.core.util.logging.Log
 import org.signal.donations.PaymentSourceType
+import org.signal.network.NetworkResult
 import org.thoughtcrime.securesms.backup.v2.MessageBackupTier
 import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository.requireSubscriberType
@@ -29,7 +30,6 @@ import org.thoughtcrime.securesms.storage.StorageSyncHelper
 import org.thoughtcrime.securesms.subscription.LevelUpdate
 import org.thoughtcrime.securesms.subscription.LevelUpdateOperation
 import org.thoughtcrime.securesms.subscription.Subscription
-import org.whispersystems.signalservice.api.NetworkResult
 import org.whispersystems.signalservice.api.storage.IAPSubscriptionId
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.IdempotencyKey
@@ -297,6 +297,7 @@ object RecurringInAppPaymentRepository {
      if (response.status == 200 || response.status == 204) {
        Log.d(TAG, "Successfully set user subscription to level $subscriptionLevel with response code ${response.status}", true)
        SignalStore.inAppPayments.updateLocalStateForLocalSubscribe(subscriberType)
+        MultiDeviceSubscriptionSyncRequestJob.enqueue()
        syncAccountRecord().subscribe()
      } else {
        if (response.applicationError.isPresent) {
@@ -2,8 +2,8 @@ package org.thoughtcrime.securesms.components.settings.app.subscription.donate

 import androidx.lifecycle.ViewModel
 import org.signal.core.util.logging.Log
+import org.signal.network.util.Preconditions
 import org.thoughtcrime.securesms.database.InAppPaymentTable
-import org.whispersystems.signalservice.api.util.Preconditions

 /**
 * State holder for the checkout flow when utilizing Google Pay.
@@ -236,8 +236,8 @@ private fun TitleAndSubtitle(inAppPayment: InAppPaymentTable.InAppPayment) {
  when (inAppPayment.type) {
    InAppPaymentType.UNKNOWN -> error("Unsupported type UNKNOWN")
    InAppPaymentType.ONE_TIME_GIFT -> OneTimeGiftTitleAndSubtitle(inAppPayment)
-    InAppPaymentType.ONE_TIME_DONATION -> RecurringDonationTitleAndSubtitle(inAppPayment)
-    InAppPaymentType.RECURRING_DONATION -> OneTimeDonationTitleAndSubtitle(inAppPayment)
+    InAppPaymentType.ONE_TIME_DONATION -> OneTimeDonationTitleAndSubtitle(inAppPayment)
+    InAppPaymentType.RECURRING_DONATION -> RecurringDonationTitleAndSubtitle(inAppPayment)
    InAppPaymentType.RECURRING_BACKUP -> error("This type is not supported")
  }
 }
@@ -14,6 +14,7 @@ import org.signal.core.util.logging.Log
 import org.signal.donations.InAppPaymentType
 import org.signal.donations.PayPalPaymentSource
 import org.signal.donations.PaymentSourceType
+import org.signal.network.util.Preconditions
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository.requireSubscriberType
 import org.thoughtcrime.securesms.components.settings.app.subscription.RecurringInAppPaymentRepository
@@ -26,7 +27,6 @@ import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
 import org.thoughtcrime.securesms.jobs.MultiDeviceSubscriptionSyncRequestJob
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.util.rx.RxStore
-import org.whispersystems.signalservice.api.util.Preconditions

 class PayPalPaymentInProgressViewModel : ViewModel() {

@@ -16,6 +16,7 @@ import org.signal.donations.InAppPaymentType
 import org.signal.donations.PaymentSource
 import org.signal.donations.PaymentSourceType
 import org.signal.donations.StripeApi
+import org.signal.network.util.Preconditions
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository.requireSubscriberType
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppPaymentsRepository.toErrorSource
@@ -29,7 +30,6 @@ import org.thoughtcrime.securesms.database.InAppPaymentTable
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.model.InAppPaymentSubscriberRecord
 import org.thoughtcrime.securesms.util.rx.RxStore
-import org.whispersystems.signalservice.api.util.Preconditions

 class StripePaymentInProgressViewModel : ViewModel() {

@@ -28,6 +28,7 @@ import org.signal.libsignal.zkgroup.profiles.ProfileKey
 import org.thoughtcrime.securesms.MainActivity
 import org.thoughtcrime.securesms.attachments.Attachment
 import org.thoughtcrime.securesms.attachments.UriAttachment
+import org.thoughtcrime.securesms.components.SignalProgressDialog
 import org.thoughtcrime.securesms.database.AttachmentTable
 import org.thoughtcrime.securesms.database.MessageType
 import org.thoughtcrime.securesms.database.SignalDatabase
@@ -297,15 +298,38 @@ class InternalConversationSettingsFragment : ComposeFragment(), InternalConversa
  }

  override fun clearSenderKeyAndArchiveSessions(recipientId: RecipientId) {
-    clearSenderKey(recipientId)
+    lifecycleScope.launch {
+      val dialog = withContext(Dispatchers.Main) {
+        SignalProgressDialog.show(requireContext(), "Clearing...", cancelable = false, indeterminate = true)
+      }

-    val group = SignalDatabase.groups.getGroup(recipientId).orNull()
-    if (group == null) {
-      Log.w(TAG, "Couldn't find group for recipientId: $recipientId")
-      return
+      withContext(Dispatchers.Default) {
+        clearSenderKey(recipientId)
+
+        val group = SignalDatabase.groups.getGroup(recipientId).orNull()
+        if (group == null) {
+          Log.w(TAG, "Couldn't find group for recipientId: $recipientId")
+          return@withContext
+        }
+
+        group.members.forEach { memberId ->
+          archiveSessions(memberId)
+
+          val member = Recipient.resolved(memberId)
+          if (member.hasAci) {
+            AppDependencies.protocolStore.aci().identities().delete(member.requireAci().toString())
+          }
+
+          if (member.hasPni) {
+            AppDependencies.protocolStore.aci().identities().delete(member.requirePni().toString())
+          }
+        }
+      }
+
+      withContext(Dispatchers.Main) {
+        dialog.dismiss()
+      }
    }
-
-    group.members.forEach { archiveSessions(it) }
  }

  class InternalViewModel(
@@ -212,7 +212,7 @@ fun InternalConversationSettingsScreen(
        item {
          Rows.TextRow(
            text = "Clear sender key and archive sessions",
-            label = "Resets any sender key state and archives all sessions for group members, will force creating new sessions and re-distributing sender key material.",
+            label = "Resets any sender key state, archives all sessions, and removes identity keys for group members, will force creating new sessions and re-distributing sender key material.",
            onClick = {
              dialog = Dialog.CLEAR_SENDER_KEY_AND_ARCHIVE_SESSIONS
            }
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.verificationrequested
+
+import android.os.Bundle
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+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.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalResources
+import androidx.compose.ui.platform.rememberNestedScrollInteropConnection
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.FragmentManager
+import org.signal.core.ui.BottomSheetUtil
+import org.signal.core.ui.compose.BottomSheets
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.util.DateUtils
+import java.util.Locale
+
+/**
+ * Sheet shown when the server has pushed a notification telling us a verification code was
+ * requested for the user's account.
+ */
+class VerificationCodeRequestedBottomSheet : ComposeBottomSheetDialogFragment() {
+
+  override val peekHeightPercentage: Float = 1f
+
+  companion object {
+    private const val ARG_REQUESTED_AT = "requested_at"
+
+    @JvmStatic
+    fun show(fragmentManager: FragmentManager, requestedAtMs: Long) {
+      VerificationCodeRequestedBottomSheet().apply {
+        arguments = Bundle().apply { putLong(ARG_REQUESTED_AT, requestedAtMs) }
+      }.show(fragmentManager, BottomSheetUtil.STANDARD_BOTTOM_SHEET_FRAGMENT_TAG)
+    }
+  }
+
+  @Composable
+  override fun SheetContent() {
+    val context = LocalContext.current
+    val resources = LocalResources.current
+    val requestedAt = requireArguments().getLong(ARG_REQUESTED_AT)
+    val formattedTime = remember(requestedAt) {
+      val time = DateUtils.getOnlyTimeString(context, requestedAt)
+      val day = DateUtils.getDayPrecisionTimeString(context, Locale.getDefault(), requestedAt)
+      resources.getString(R.string.VerificationCodeRequestedBottomSheet__time_with_day, time, day)
+    }
+    val nestedScrollInterop = rememberNestedScrollInteropConnection()
+    val scrollModifier = Modifier.nestedScroll(nestedScrollInterop)
+
+    VerificationCodeRequestedContent(
+      formattedTime = formattedTime,
+      onSafetyTipsClicked = {
+        val fragmentManager = parentFragmentManager
+        dismissAllowingStateLoss()
+        VerificationCodeRequestedSafetyTipsBottomSheet.show(fragmentManager)
+      },
+      onOkClicked = { dismissAllowingStateLoss() },
+      modifier = scrollModifier
+    )
+  }
+}
+
+@Composable
+private fun VerificationCodeRequestedContent(
+  formattedTime: String,
+  onSafetyTipsClicked: () -> Unit,
+  onOkClicked: () -> Unit,
+  modifier: Modifier = Modifier
+) {
+  val scrollState = rememberScrollState()
+
+  Column(
+    modifier = Modifier.fillMaxWidth()
+  ) {
+    Box(
+      contentAlignment = Alignment.Center,
+      modifier = Modifier.fillMaxWidth()
+    ) {
+      BottomSheets.Handle()
+    }
+
+    Column(
+      horizontalAlignment = Alignment.CenterHorizontally,
+      modifier = modifier
+        .weight(weight = 1f, fill = false)
+        .verticalScroll(state = scrollState)
+        .padding(horizontal = 36.dp)
+        .padding(bottom = 36.dp)
+    ) {
+      Spacer(modifier = Modifier.height(26.dp))
+
+      Image(
+        painter = painterResource(id = R.drawable.verificationcode_alert_96),
+        contentDescription = null,
+        modifier = Modifier.size(96.dp)
+      )
+
+      Spacer(modifier = Modifier.height(12.dp))
+
+      Text(
+        text = stringResource(id = R.string.VerificationCodeRequestedBottomSheet__title),
+        style = MaterialTheme.typography.titleLarge,
+        color = MaterialTheme.colorScheme.onSurface,
+        textAlign = TextAlign.Center
+      )
+
+      Spacer(modifier = Modifier.height(4.dp))
+
+      Text(
+        text = formattedTime,
+        style = MaterialTheme.typography.bodyLarge,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        textAlign = TextAlign.Center
+      )
+
+      Spacer(modifier = Modifier.height(20.dp))
+
+      Text(
+        text = stringResource(id = R.string.VerificationCodeRequestedBottomSheet__body_1),
+        style = MaterialTheme.typography.bodyLarge,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        textAlign = TextAlign.Center
+      )
+
+      Spacer(modifier = Modifier.height(12.dp))
+
+      Text(
+        text = stringResource(id = R.string.VerificationCodeRequestedBottomSheet__body_2),
+        style = MaterialTheme.typography.bodyLarge,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        textAlign = TextAlign.Center
+      )
+
+      Spacer(modifier = Modifier.height(32.dp))
+
+      Buttons.LargeTonal(
+        onClick = onSafetyTipsClicked,
+        modifier = Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 8.dp)
+      ) {
+        Text(text = stringResource(id = R.string.VerificationCodeRequestedBottomSheet__safety_tips))
+      }
+
+      Spacer(modifier = Modifier.height(8.dp))
+
+      Buttons.LargeTonal(
+        onClick = onOkClicked,
+        modifier = Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 8.dp)
+      ) {
+        Text(text = stringResource(id = R.string.VerificationCodeRequestedBottomSheet__ok))
+      }
+    }
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun VerificationCodeRequestedContentPreview() {
+  Previews.BottomSheetContentPreview {
+    VerificationCodeRequestedContent(
+      formattedTime = "3:25 PM Today",
+      onSafetyTipsClicked = {},
+      onOkClicked = {}
+    )
+  }
+}
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.components.verificationrequested
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.rememberNestedScrollInteropConnection
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.FragmentManager
+import org.signal.core.ui.BottomSheetUtil
+import org.signal.core.ui.compose.BottomSheets
+import org.signal.core.ui.compose.Buttons
+import org.signal.core.ui.compose.ComposeBottomSheetDialogFragment
+import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.Previews
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+
+/**
+ * Sheet showing safety tips related to a verification code alert.
+ */
+class VerificationCodeRequestedSafetyTipsBottomSheet : ComposeBottomSheetDialogFragment() {
+
+  override val peekHeightPercentage: Float = 1f
+
+  companion object {
+    @JvmStatic
+    fun show(fragmentManager: FragmentManager) {
+      VerificationCodeRequestedSafetyTipsBottomSheet().show(fragmentManager, BottomSheetUtil.STANDARD_BOTTOM_SHEET_FRAGMENT_TAG)
+    }
+  }
+
+  @Composable
+  override fun SheetContent() {
+    val nestedScrollInterop = rememberNestedScrollInteropConnection()
+    val scrollModifier = Modifier.nestedScroll(nestedScrollInterop)
+
+    SafetyTipsContent(
+      onOpenAccountSettings = {
+        startActivity(AppSettingsActivity.account(requireContext()))
+        dismissAllowingStateLoss()
+      },
+      modifier = scrollModifier
+    )
+  }
+}
+
+@Composable
+private fun SafetyTipsContent(
+  onOpenAccountSettings: () -> Unit,
+  modifier: Modifier = Modifier
+) {
+  val scrollState = rememberScrollState()
+
+  Column(
+    modifier = Modifier.fillMaxWidth()
+  ) {
+    Box(
+      contentAlignment = Alignment.Center,
+      modifier = Modifier.fillMaxWidth()
+    ) {
+      BottomSheets.Handle()
+    }
+
+    Column(
+      horizontalAlignment = Alignment.CenterHorizontally,
+      modifier = modifier
+        .weight(weight = 1f, fill = false)
+        .verticalScroll(state = scrollState)
+        .padding(horizontal = 36.dp)
+        .padding(bottom = 36.dp)
+    ) {
+      Spacer(modifier = Modifier.height(26.dp))
+
+      Text(
+        text = stringResource(id = R.string.SafetyTipsBottomSheet__title),
+        style = MaterialTheme.typography.headlineSmall,
+        color = MaterialTheme.colorScheme.onSurface,
+        textAlign = TextAlign.Center
+      )
+
+      Spacer(modifier = Modifier.height(36.dp))
+
+      SafetyTipRow(
+        iconRes = R.drawable.safetytip_48_message,
+        titleRes = R.string.SafetyTipsBottomSheet__tip_1_title,
+        bodyRes = R.string.SafetyTipsBottomSheet__tip_1_body
+      )
+
+      Spacer(modifier = Modifier.height(40.dp))
+
+      SafetyTipRow(
+        iconRes = R.drawable.safetytip_48_pin,
+        titleRes = R.string.SafetyTipsBottomSheet__tip_2_title,
+        bodyRes = R.string.SafetyTipsBottomSheet__tip_2_body
+      )
+
+      Spacer(modifier = Modifier.height(40.dp))
+
+      SafetyTipRow(
+        iconRes = R.drawable.safetytip_48_lock,
+        titleRes = R.string.SafetyTipsBottomSheet__tip_3_title,
+        bodyRes = R.string.SafetyTipsBottomSheet__tip_3_body
+      )
+
+      Spacer(modifier = Modifier.height(40.dp))
+
+      Buttons.LargeTonal(
+        onClick = onOpenAccountSettings,
+        modifier = Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 8.dp)
+      ) {
+        Text(text = stringResource(id = R.string.SafetyTipsBottomSheet__open_account_settings))
+      }
+    }
+  }
+}
+
+@Composable
+private fun SafetyTipRow(
+  iconRes: Int,
+  titleRes: Int,
+  bodyRes: Int
+) {
+  Row(
+    modifier = Modifier.fillMaxWidth(),
+    horizontalArrangement = Arrangement.spacedBy(24.dp)
+  ) {
+    Image(
+      painter = painterResource(id = iconRes),
+      contentDescription = null,
+      modifier = Modifier.size(48.dp)
+    )
+
+    Column(modifier = Modifier.fillMaxWidth()) {
+      Text(
+        text = stringResource(id = titleRes),
+        style = MaterialTheme.typography.titleMedium,
+        color = MaterialTheme.colorScheme.onSurface
+      )
+
+      Spacer(modifier = Modifier.height(4.dp))
+
+      Text(
+        text = stringResource(id = bodyRes),
+        style = MaterialTheme.typography.bodyLarge,
+        color = MaterialTheme.colorScheme.onSurfaceVariant
+      )
+    }
+  }
+}
+
+@DayNightPreviews
+@Composable
+private fun SafetyTipsContentPreview() {
+  Previews.BottomSheetContentPreview {
+    SafetyTipsContent(onOpenAccountSettings = {})
+  }
+}
@@ -8,6 +8,8 @@ import androidx.annotation.Px;
 import androidx.annotation.StringRes;

 import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.keyvalue.SignalStore;
+import org.thoughtcrime.securesms.util.RemoteConfig;
 import org.thoughtcrime.securesms.webrtc.audio.SignalAudioManager;

 import java.util.Set;
@@ -164,7 +166,9 @@ public final class WebRtcControls {
  }

  public boolean displayOverflow() {
-    return isAtLeastOutgoing() && hasAtLeastOneRemote && isGroupCall() && groupCallState == GroupCallState.CONNECTED;
+    boolean connectedGroupCall = isGroupCall() && groupCallState == GroupCallState.CONNECTED && hasAtLeastOneRemote;
+    boolean connected1to1Call  = !isGroupCall() && callState == CallState.ONGOING && RemoteConfig.screenSharing();
+    return isAtLeastOutgoing() && (connectedGroupCall || connected1to1Call);
  }

  public boolean displayMuteAudio() {
@@ -280,7 +284,7 @@ public final class WebRtcControls {
    return callState.isAtLeast(CallState.OUTGOING);
  }

-  private boolean isGroupCall() {
+  public boolean isGroupCall() {
    return groupCallState != GroupCallState.NONE;
  }

@@ -46,6 +46,9 @@ data class AdditionalActionsState(
  val isShown: Boolean = false,
  val reactions: PersistentList<String> = persistentListOf(),
  val isSelfHandRaised: Boolean = false,
+  val isScreenSharing: Boolean = false,
+  val displayScreenShareToggle: Boolean = false,
+  val isGroupCall: Boolean = true,
  @Stable val listener: AdditionalActionsListener = AdditionalActionsListener.Empty
 )

@@ -53,11 +56,13 @@ interface AdditionalActionsListener {
  fun onReactClick(reaction: String)
  fun onReactWithAnyClick()
  fun onRaiseHandClick(raised: Boolean)
+  fun onScreenShareClick(sharing: Boolean)

  object Empty : AdditionalActionsListener {
    override fun onReactClick(reaction: String) = Unit
    override fun onReactWithAnyClick() = Unit
    override fun onRaiseHandClick(raised: Boolean) = Unit
+    override fun onScreenShareClick(sharing: Boolean) = Unit
  }
 }

@@ -81,17 +86,23 @@ private fun AdditionalActionsPopupContent(
  Column(
    verticalArrangement = spacedBy(12.dp),
    modifier = Modifier
-      .width(IntrinsicSize.Min)
+      .width(IntrinsicSize.Max)
      .padding(12.dp)
  ) {
-    CallReactionScrubber(
-      reactions = state.reactions,
-      listener = state.listener
-    )
+    if (state.isGroupCall) {
+      CallReactionScrubber(
+        reactions = state.reactions,
+        listener = state.listener
+      )
+    }

    CallScreenMenu(
+      isGroupCall = state.isGroupCall,
      onRaiseHandClick = state.listener::onRaiseHandClick,
-      isSelfHandRaised = state.isSelfHandRaised
+      isSelfHandRaised = state.isSelfHandRaised,
+      isScreenSharing = state.isScreenSharing,
+      displayScreenShareToggle = state.displayScreenShareToggle,
+      onScreenShareClick = state.listener::onScreenShareClick
    )
  }
 }
@@ -134,19 +145,33 @@ private fun CallReactionScrubber(

@Composable
 private fun CallScreenMenu(
+  isGroupCall: Boolean,
  isSelfHandRaised: Boolean,
-  onRaiseHandClick: (Boolean) -> Unit
+  onRaiseHandClick: (Boolean) -> Unit,
+  isScreenSharing: Boolean = false,
+  displayScreenShareToggle: Boolean = false,
+  onScreenShareClick: (Boolean) -> Unit = {}
 ) {
  Column(
    modifier = Modifier
      .fillMaxWidth()
      .background(SignalTheme.colors.colorSurface2, RoundedCornerShape(18.dp))
  ) {
-    CallScreenMenuOption(
-      imageVector = ImageVector.vectorResource(R.drawable.symbol_raise_hand_24),
-      title = if (isSelfHandRaised) stringResource(R.string.CallOverflowPopupWindow__lower_hand) else stringResource(R.string.CallOverflowPopupWindow__raise_hand),
-      onClick = { onRaiseHandClick(!isSelfHandRaised) }
-    )
+    if (isGroupCall) {
+      CallScreenMenuOption(
+        imageVector = ImageVector.vectorResource(R.drawable.symbol_raise_hand_24),
+        title = if (isSelfHandRaised) stringResource(R.string.CallOverflowPopupWindow__lower_hand) else stringResource(R.string.CallOverflowPopupWindow__raise_hand),
+        onClick = { onRaiseHandClick(!isSelfHandRaised) }
+      )
+    }
+
+    if (displayScreenShareToggle) {
+      CallScreenMenuOption(
+        imageVector = ImageVector.vectorResource(R.drawable.symbol_screen_share_24),
+        title = if (isScreenSharing) stringResource(R.string.CallOverflowPopupWindow__stop_screen_share) else stringResource(R.string.CallOverflowPopupWindow__share_screen),
+        onClick = { onScreenShareClick(!isScreenSharing) }
+      )
+    }
  }
 }

@@ -224,3 +249,28 @@ private fun CallScreenAdditionalActionsPopupPreview() {
    )
  }
 }
+
+@NightPreview
+@Composable
+private fun CallScreenAdditionalActionsScreenSharingPreview() {
+  Previews.Preview {
+    AdditionalActionsPopupContent(
+      state = AdditionalActionsState(
+        isGroupCall = false,
+        displayScreenShareToggle = true,
+        isShown = false,
+        reactions = persistentListOf(
+          "\u2764\ufe0f",
+          "\ud83d\udc4d",
+          "\ud83d\udc4e",
+          "\ud83d\ude02",
+          "\ud83d\ude2e",
+          "\ud83d\ude22"
+        ),
+        isSelfHandRaised = false,
+        listener = AdditionalActionsListener.Empty,
+        triggerAlignedPopupState = TriggerAlignedPopupState.rememberTriggerAlignedPopupState()
+      )
+    )
+  }
+}
@@ -82,7 +82,7 @@ fun CallControls(
      }

      val hasCameraPermission = ContextCompat.checkSelfPermission(LocalContext.current, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
-      if (callControlsState.displayVideoToggle) {
+      if (callControlsState.displayVideoToggle && !callControlsState.isLocalScreenSharing) {
        CallScreenTooltipBox(
          text = stringResource(R.string.WebRtcCallActivity__tap_here_to_turn_on_your_video),
          displayTooltip = displayVideoTooltip,
@@ -211,10 +211,12 @@ data class CallControlsState(
  val displayGroupRingingToggle: Boolean = false,
  val isGroupRingingEnabled: Boolean = false,
  val isGroupRingingAllowed: Boolean = false,
+  val isGroupCall: Boolean = false,
  val displayAdditionalActions: Boolean = false,
  val displayStartCallButton: Boolean = false,
  val startCallButtonText: Int = R.string.WebRtcCallView__start_call,
-  val displayEndCallButton: Boolean = false
+  val displayEndCallButton: Boolean = false,
+  val isLocalScreenSharing: Boolean = false
 ) {

  val hasAnyControls: Boolean
@@ -235,7 +237,8 @@ data class CallControlsState(
      callParticipantsState: CallParticipantsState,
      webRtcControls: WebRtcControls,
      groupMemberCount: Int,
-      isAudioDeviceChangePending: Boolean = false
+      isAudioDeviceChangePending: Boolean = false,
+      isLocalScreenSharing: Boolean = false
    ): CallControlsState {
      return CallControlsState(
        isEarpieceAvailable = webRtcControls.isEarpieceAvailableForAudioToggle,
@@ -250,12 +253,14 @@ data class CallControlsState(
        displayMicToggle = webRtcControls.displayMuteAudio(),
        isMicEnabled = callParticipantsState.localParticipant.isMicrophoneEnabled,
        displayGroupRingingToggle = webRtcControls.displayRingToggle(),
+        isGroupCall = webRtcControls.isGroupCall,
        isGroupRingingEnabled = callParticipantsState.ringGroup,
        isGroupRingingAllowed = groupMemberCount <= RemoteConfig.maxGroupCallRingSize,
        displayAdditionalActions = webRtcControls.displayOverflow(),
        displayStartCallButton = webRtcControls.displayStartCallControls(),
        startCallButtonText = webRtcControls.startCallButtonText,
-        displayEndCallButton = webRtcControls.displayEndCall()
+        displayEndCallButton = webRtcControls.displayEndCall(),
+        isLocalScreenSharing = isLocalScreenSharing
      )
    }
  }
@@ -22,7 +22,7 @@ sealed interface CallEvent {
  data class StartCall(val isVideoCall: Boolean) : CallEvent
  data class ShowGroupCallSafetyNumberChange(val identityRecords: List<IdentityRecord>) : CallEvent
  data object SwitchToSpeaker : CallEvent
-  data object ShowSwipeToSpeakerHint : CallEvent
+  data object ShowSwipeToScreenShareHint : CallEvent
  data object ShowLargeGroupAutoMuteToast : CallEvent
  data class ShowRemoteMuteToast(private val muted: Recipient, private val mutedBy: Recipient) : CallEvent {
    fun getDescription(context: Context): String {
@@ -15,7 +15,6 @@ import androidx.compose.material3.Surface
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.movableContentOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
@@ -52,67 +51,55 @@ fun CallParticipantsPager(
    callParticipantsPagerState.callParticipants.firstOrNull()?.videoSink
  )

-  // Use movableContentOf to preserve CallGrid state when switching between
-  // single participant (no pager) and multiple participants (with pager)
-  val callGridContent = remember {
-    movableContentOf { state: CallParticipantsPagerState, mod: Modifier, aspectRatio: Float? ->
-      CallGrid(
-        items = state.callParticipants,
-        singleParticipantAspectRatio = aspectRatio,
-        modifier = mod,
-        itemKey = { it.callParticipantId }
-      ) { participant, itemModifier ->
-        val longPressModifier = if (!participant.recipient.isSelf && currentOnLongPress.value != null) {
-          var itemWindowOrigin by remember(participant.callParticipantId) { mutableStateOf(Offset.Zero) }
-          itemModifier
-            .onGloballyPositioned { coords -> itemWindowOrigin = coords.positionInRoot() }
-            .pointerInput(participant.callParticipantId) {
-              detectTapGestures(
-                onTap = { currentOnTap.value?.invoke() },
-                onLongPress = { local -> currentOnLongPress.value?.invoke(participant, itemWindowOrigin + local) }
-              )
-            }
-        } else {
-          itemModifier
-        }
+  VerticalPager(
+    state = pagerState,
+    modifier = modifier
+      .displayCutoutPadding()
+      .statusBarsPadding()
+  ) { page ->
+    when (page) {
+      0 -> {
+        CallGrid(
+          items = callParticipantsPagerState.callParticipants,
+          singleParticipantAspectRatio = firstParticipantAR,
+          modifier = Modifier.fillMaxSize(),
+          itemKey = { it.callParticipantId }
+        ) { participant, itemModifier ->
+          val longPressModifier = if (!participant.recipient.isSelf && currentOnLongPress.value != null) {
+            var itemWindowOrigin by remember(participant.callParticipantId) { mutableStateOf(Offset.Zero) }
+            itemModifier
+              .onGloballyPositioned { coords -> itemWindowOrigin = coords.positionInRoot() }
+              .pointerInput(participant.callParticipantId) {
+                detectTapGestures(
+                  onTap = { currentOnTap.value?.invoke() },
+                  onLongPress = { local -> currentOnLongPress.value?.invoke(participant, itemWindowOrigin + local) }
+                )
+              }
+          } else {
+            itemModifier
+          }

-        RemoteParticipantContent(
-          participant = participant,
-          renderInPip = state.isRenderInPip,
-          raiseHandAllowed = false,
-          onInfoMoreInfoClick = null,
-          showAudioIndicator = state.callParticipants.size > 1,
-          modifier = longPressModifier
-        )
-      }
-    }
-  }
-
-  if (callParticipantsPagerState.callParticipants.size > 1) {
-    VerticalPager(
-      state = pagerState,
-      modifier = modifier
-        .displayCutoutPadding()
-        .statusBarsPadding()
-    ) { page ->
-      when (page) {
-        0 -> {
-          callGridContent(callParticipantsPagerState, Modifier.fillMaxSize(), firstParticipantAR)
-        }
-
-        1 -> {
          RemoteParticipantContent(
-            participant = callParticipantsPagerState.focusedParticipant,
+            participant = participant,
            renderInPip = callParticipantsPagerState.isRenderInPip,
            raiseHandAllowed = false,
            onInfoMoreInfoClick = null,
-            modifier = Modifier.fillMaxSize()
+            showAudioIndicator = callParticipantsPagerState.callParticipants.size > 1,
+            modifier = longPressModifier
          )
        }
      }
+
+      1 -> {
+        RemoteParticipantContent(
+          participant = callParticipantsPagerState.focusedParticipant,
+          renderInPip = callParticipantsPagerState.isRenderInPip,
+          raiseHandAllowed = false,
+          onInfoMoreInfoClick = null,
+          modifier = Modifier.fillMaxSize()
+        )
+      }
    }
-  } else {
-    callGridContent(callParticipantsPagerState, modifier, firstParticipantAR)
  }
 }

@@ -81,6 +81,7 @@ import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.ringrtc.CameraState
 import org.thoughtcrime.securesms.service.webrtc.PendingParticipantCollection
+import org.thoughtcrime.securesms.util.RemoteConfig
 import kotlin.math.max
 import kotlin.math.round
 import kotlin.time.Duration.Companion.milliseconds
@@ -103,8 +104,10 @@ fun CallScreen(
  savedLocalParticipantLandscape: Boolean = false,
  callScreenState: CallScreenState,
  callControlsState: CallControlsState,
+  callParticipantsPagerState: CallParticipantsPagerState,
  callScreenController: CallScreenController = CallScreenController.rememberCallScreenController(
    skipHiddenState = callControlsState.skipHiddenState,
+    hasMultipleRemoteParticipants = callParticipantsPagerState.callParticipants.size > 1,
    onControlsToggled = {},
    callControlsState = callControlsState,
    callControlsListener = CallScreenControlsListener.Empty
@@ -112,7 +115,6 @@ fun CallScreen(
  callScreenControlsListener: CallScreenControlsListener = CallScreenControlsListener.Empty,
  callScreenSheetDisplayListener: CallScreenSheetDisplayListener = CallScreenSheetDisplayListener.Empty,
  additionalActionsListener: AdditionalActionsListener = AdditionalActionsListener.Empty,
-  callParticipantsPagerState: CallParticipantsPagerState,
  pendingParticipantsListener: PendingParticipantsListener = PendingParticipantsListener.Empty,
  callParticipantUpdatePopupController: CallParticipantUpdatePopupController,
  overflowParticipants: List<CallParticipant>,
@@ -171,11 +173,16 @@ fun CallScreen(
  val additionalActionsPopupState = TriggerAlignedPopupState.rememberTriggerAlignedPopupState()
  val additionalActionsState = remember(
    callScreenState.reactions,
-    localParticipant.isHandRaised
+    localParticipant.isHandRaised,
+    callScreenState.isLocalScreenSharing,
+    callControlsState.displayEndCallButton
  ) {
    AdditionalActionsState(
      reactions = callScreenState.reactions,
      isSelfHandRaised = localParticipant.isHandRaised,
+      isScreenSharing = callScreenState.isLocalScreenSharing,
+      displayScreenShareToggle = callControlsState.displayEndCallButton && RemoteConfig.screenSharing,
+      isGroupCall = callControlsState.isGroupCall,
      listener = additionalActionsListener,
      triggerAlignedPopupState = additionalActionsPopupState
    )
@@ -505,7 +512,7 @@ fun CallScreen(
  )

  SwipeToSpeakerHintPopup(
-    visible = callScreenState.displaySwipeToSpeakerHint,
+    hintType = callScreenState.swipeHint,
    onDismiss = onSwipeToSpeakerHintDismissed,
    modifier = Modifier
      .statusBarsPadding()
@@ -77,11 +77,13 @@ class CallScreenController private constructor(
    @Composable
    fun rememberCallScreenController(
      skipHiddenState: Boolean,
+      hasMultipleRemoteParticipants: Boolean,
      onControlsToggled: (Boolean) -> Unit,
      callControlsState: CallControlsState,
      callControlsListener: CallScreenControlsListener
    ): CallScreenController {
      val skip by rememberUpdatedState(skipHiddenState)
+      val hasMultipleRemoteParticipantsState = rememberUpdatedState(hasMultipleRemoteParticipants)
      val valueChangeOperation: (SheetValue) -> Boolean = remember {
        {
          !(it == SheetValue.Hidden && skip)
@@ -130,7 +132,7 @@ class CallScreenController private constructor(

      val callParticipantsVerticalPagerState = rememberPagerState(
        initialPage = 0,
-        pageCount = { 2 }
+        pageCount = { if (hasMultipleRemoteParticipantsState.value) 2 else 1 }
      )

      return remember(scaffoldState, callParticipantsVerticalPagerState, audioOutputPickerController) {
@@ -36,6 +36,7 @@ interface CallScreenControlsListener {
  fun onNavigateUpClicked()
  fun toggleControls()
  fun onAudioPermissionsRequested(onGranted: Runnable?)
+  fun onScreenShareChanged(sharing: Boolean)

  object Empty : CallScreenControlsListener {
    override fun onStartCall(isVideoCall: Boolean) = Unit
@@ -58,5 +59,6 @@ interface CallScreenControlsListener {
    override fun onNavigateUpClicked() = Unit
    override fun toggleControls() = Unit
    override fun onAudioPermissionsRequested(onGranted: Runnable?) = Unit
+    override fun onScreenShareChanged(sharing: Boolean) = Unit
  }
 }
@@ -43,6 +43,7 @@ interface CallScreenMediator {
  fun enableRingGroup(canRing: Boolean)
  fun showSpeakerViewHint()
  fun hideSpeakerViewHint()
+  fun showScreenShareHint()
  fun showVideoTooltip(): Dismissible
  fun showCameraTooltip(): Dismissible
  fun onCallStateUpdate(callControlsChange: CallControlsChange)
@@ -25,7 +25,7 @@ data class CallScreenState(
  val isDisplayingAudioToggleSheet: Boolean = false,
  val displaySwitchCameraTooltip: Boolean = false,
  val displayVideoTooltip: Boolean = false,
-  val displaySwipeToSpeakerHint: Boolean = false,
+  val swipeHint: SwipeHintType = SwipeHintType.NONE,
  val displayWifiToCellularPopup: Boolean = false,
  val remoteMuteToastMessage: String? = null,
  val displayAdditionalActionsDialog: Boolean = false,
@@ -34,7 +34,14 @@ data class CallScreenState(
  val isParticipantUpdatePopupEnabled: Boolean = true,
  val isCallStateUpdatePopupEnabled: Boolean = false,
  val isWaitingToBeLetIn: Boolean = false,
-  val reactions: PersistentList<String> = persistentListOf()
+  val reactions: PersistentList<String> = persistentListOf(),
+  val isLocalScreenSharing: Boolean = false
 ) {
  fun isDisplayingControlMenu(): Boolean = isDisplayingAudioToggleSheet || displayAdditionalActionsDialog
 }
+
+enum class SwipeHintType {
+  NONE,
+  SPEAKER_VIEW,
+  SCREEN_SHARE
+}
@@ -14,6 +14,7 @@ import androidx.activity.enableEdgeToEdge
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.lifecycle.ViewModel
@@ -110,6 +111,7 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo
      val recipient by viewModel.getRecipientFlow().collectAsStateWithLifecycle(Recipient.UNKNOWN)
      val webRtcCallState by callScreenViewModel.callState.collectAsStateWithLifecycle()
      val callScreenState by callScreenViewModel.callScreenState.collectAsStateWithLifecycle()
+      val isLocalScreenSharing by viewModel.isLocalScreenSharing.collectAsStateWithLifecycle()
      val callControlsState by viewModel.getCallControlsState().collectAsStateWithLifecycle(CallControlsState())
      val callParticipantsViewState by callScreenViewModel.callParticipantsViewState.collectAsStateWithLifecycle()
      val callParticipantsState = remember(callParticipantsViewState) { callParticipantsViewState.callParticipantsState }
@@ -162,6 +164,7 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo

      val callScreenController = CallScreenController.rememberCallScreenController(
        skipHiddenState = callControlsState.skipHiddenState,
+        hasMultipleRemoteParticipants = callParticipantsPagerState.callParticipants.size > 1,
        onControlsToggled = onControlsToggled,
        callControlsState = callControlsState,
        callControlsListener = callScreenControlsListener
@@ -173,6 +176,22 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo
        }
      }

+      LaunchedEffect(isLocalScreenSharing) {
+        callScreenViewModel.callScreenState.update { it.copy(isLocalScreenSharing = isLocalScreenSharing) }
+      }
+
+      LaunchedEffect(callScreenController, callScreenControlsListener) {
+        snapshotFlow { callScreenController.callParticipantsVerticalPagerState.settledPage }
+          .collect { page ->
+            val selected = if (page == 1) {
+              CallParticipantsState.SelectedPage.FOCUSED
+            } else {
+              CallParticipantsState.SelectedPage.GRID
+            }
+            callScreenControlsListener.onPageChanged(selected)
+          }
+      }
+
      val controlAndInfoState by controlsAndInfoViewModel.state

      SignalTheme(isDarkMode = true) {
@@ -217,7 +236,7 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo
          onControlsToggled = onControlsToggled,
          onCallScreenDialogDismissed = { callScreenViewModel.dialog.update { CallScreenDialogType.NONE } },
          onWifiToCellularPopupDismissed = { callScreenViewModel.callScreenState.update { it.copy(displayWifiToCellularPopup = false) } },
-          onSwipeToSpeakerHintDismissed = { callScreenViewModel.callScreenState.update { it.copy(displaySwipeToSpeakerHint = false) } },
+          onSwipeToSpeakerHintDismissed = { callScreenViewModel.callScreenState.update { it.copy(swipeHint = SwipeHintType.NONE) } },
          onRemoteMuteToastDismissed = { callScreenViewModel.callScreenState.update { it.copy(remoteMuteToastMessage = null) } },
          callParticipantUpdatePopupController = callParticipantUpdatePopupController,
          isSelfAdmin = controlAndInfoState.isSelfAdmin(),
@@ -322,11 +341,15 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo
  }

  override fun showSpeakerViewHint() {
-    callScreenViewModel.callScreenState.update { it.copy(displaySwipeToSpeakerHint = true) }
+    callScreenViewModel.callScreenState.update { it.copy(swipeHint = SwipeHintType.SPEAKER_VIEW) }
  }

  override fun hideSpeakerViewHint() {
-    callScreenViewModel.callScreenState.update { it.copy(displaySwipeToSpeakerHint = false) }
+    callScreenViewModel.callScreenState.update { it.copy(swipeHint = SwipeHintType.NONE) }
+  }
+
+  override fun showScreenShareHint() {
+    callScreenViewModel.callScreenState.update { it.copy(swipeHint = SwipeHintType.SCREEN_SHARE) }
  }

  override fun showVideoTooltip(): Dismissible {
@@ -393,6 +416,11 @@ class ComposeCallScreenMediator(private val activity: WebRtcCallActivity, viewMo
    callScreenViewModel.callScreenState.update { it.copy(displayAdditionalActionsDialog = false) }
  }

+  override fun onScreenShareClick(sharing: Boolean) {
+    callScreenViewModel.callScreenState.update { it.copy(displayAdditionalActionsDialog = false) }
+    controlsListener.value.onScreenShareChanged(sharing)
+  }
+
  private fun handleFailure() {
    Toast.makeText(activity, R.string.CallLinkDetailsFragment__couldnt_save_changes, Toast.LENGTH_LONG).show()
  }
@@ -5,6 +5,7 @@

 package org.thoughtcrime.securesms.components.webrtc.v2

+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -25,16 +26,23 @@ import kotlin.time.Duration.Companion.seconds
 import org.signal.core.ui.R as CoreUiR

 /**
- * Popup shown to hint the user that they can swipe to view screen share.
+ * Popup shown to hint the user that they should swipe between the grid view and
+ * the focused page for speaker/screen share when available.
 */
@Composable
 fun SwipeToSpeakerHintPopup(
-  visible: Boolean,
+  hintType: SwipeHintType,
  onDismiss: () -> Unit,
  modifier: Modifier = Modifier
 ) {
+  val textResId = when (hintType) {
+    SwipeHintType.SCREEN_SHARE -> R.string.CallToastPopupWindow__swipe_to_view_screen_share
+    SwipeHintType.SPEAKER_VIEW,
+    SwipeHintType.NONE -> R.string.CallToastPopupWindow__swipe_to_view_speaker
+  }
+
  CallScreenPopup(
-    visible = visible,
+    visible = hintType != SwipeHintType.NONE,
    onDismiss = onDismiss,
    displayDuration = 3.seconds,
    modifier = modifier
@@ -51,7 +59,7 @@ fun SwipeToSpeakerHintPopup(
      )

      Text(
-        text = stringResource(R.string.CallToastPopupWindow__swipe_to_view_screen_share),
+        text = stringResource(textResId),
        color = colorResource(CoreUiR.color.signal_light_colorOnSecondaryContainer),
        modifier = Modifier.padding(start = 8.dp)
      )
@@ -63,9 +71,16 @@ fun SwipeToSpeakerHintPopup(
@Composable
 private fun SwipeToSpeakerHintPopupPreview() {
  Previews.Preview {
-    SwipeToSpeakerHintPopup(
-      visible = true,
-      onDismiss = {}
-    )
+    Column {
+      SwipeToSpeakerHintPopup(
+        hintType = SwipeHintType.SPEAKER_VIEW,
+        onDismiss = {}
+      )
+
+      SwipeToSpeakerHintPopup(
+        hintType = SwipeHintType.SCREEN_SHARE,
+        onDismiss = {}
+      )
+    }
  }
 }
@@ -14,6 +14,8 @@ import android.content.Intent
 import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.media.AudioManager
+import android.media.projection.MediaProjectionConfig
+import android.media.projection.MediaProjectionManager
 import android.os.Build
 import android.os.Bundle
 import android.util.Rational
@@ -22,6 +24,7 @@ import android.view.ViewGroup
 import android.view.Window
 import android.view.WindowManager
 import androidx.activity.OnBackPressedCallback
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.annotation.RequiresApi
 import androidx.appcompat.app.AppCompatDelegate
@@ -38,6 +41,7 @@ import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.disposables.Disposable
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.launch
 import org.greenrobot.eventbus.EventBus
@@ -123,6 +127,11 @@ class WebRtcCallActivity : BaseActivity(), SafetyNumberChangeDialog.Callback, Re
  private var ephemeralStateDisposable = Disposable.empty()
  private val callPermissionsDialogController = CallPermissionsDialogController()
  private val eventBusSubscriber = EventBusSubscriber()
+  private val mediaProjectionLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+    if (result.resultCode == RESULT_OK && result.data != null) {
+      AppDependencies.signalCallManager.startScreenShare(result.data!!)
+    }
+  }

  override fun attachBaseContext(newBase: Context) {
    delegate.localNightMode = AppCompatDelegate.MODE_NIGHT_YES
@@ -210,6 +219,17 @@ class WebRtcCallActivity : BaseActivity(), SafetyNumberChangeDialog.Callback, Re
        callScreen.setMicEnabled(viewModel.microphoneEnabled.value)
      }
    }
+
+    lifecycleScope.launch {
+      viewModel
+        .isLocalScreenSharing
+        .drop(1)
+        .collect { sharing ->
+          if (!sharing && !lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
+            AppDependencies.signalCallManager.setEnableVideo(false)
+          }
+        }
+    }
  }

  override fun onRestoreInstanceState(savedInstanceState: Bundle) {
@@ -312,7 +332,7 @@ class WebRtcCallActivity : BaseActivity(), SafetyNumberChangeDialog.Callback, Re
      requestNewSizesThrottle.clear()
    }

-    if (!isChangingConfigurations && !isInMultiWindowModeCompat()) {
+    if (!isChangingConfigurations && !isInMultiWindowModeCompat() && !viewModel.isLocalScreenSharing.value) {
      AppDependencies.signalCallManager.setEnableVideo(false)
    }

@@ -985,7 +1005,7 @@ class WebRtcCallActivity : BaseActivity(), SafetyNumberChangeDialog.Callback, Re
      is CallEvent.StartCall -> startCall(event.isVideoCall)
      is CallEvent.ShowGroupCallSafetyNumberChange -> SafetyNumberBottomSheet.forGroupCall(event.identityRecords).show(supportFragmentManager)
      is CallEvent.SwitchToSpeaker -> callScreen.switchToSpeakerView()
-      is CallEvent.ShowSwipeToSpeakerHint -> callScreen.showSpeakerViewHint()
+      is CallEvent.ShowSwipeToScreenShareHint -> callScreen.showScreenShareHint()
      is CallEvent.ShowRemoteMuteToast -> callScreen.showRemoteMuteToast(event.getDescription(this))
      is CallEvent.ShowLargeGroupAutoMuteToast -> {
        callScreen.onCallStateUpdate(CallControlsChange.MIC_OFF)
@@ -1390,6 +1410,20 @@ class WebRtcCallActivity : BaseActivity(), SafetyNumberChangeDialog.Callback, Re
    override fun onAudioPermissionsRequested(onGranted: Runnable?) {
      askAudioPermissions { onGranted?.run() }
    }
+
+    override fun onScreenShareChanged(sharing: Boolean) {
+      if (sharing) {
+        val mediaProjectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+        val intent = if (Build.VERSION.SDK_INT >= 34) {
+          mediaProjectionManager.createScreenCaptureIntent(MediaProjectionConfig.createConfigForDefaultDisplay())
+        } else {
+          mediaProjectionManager.createScreenCaptureIntent()
+        }
+        mediaProjectionLauncher.launch(intent)
+      } else {
+        AppDependencies.signalCallManager.stopScreenShare()
+      }
+    }
  }

  private inner class PendingParticipantsViewListener : PendingParticipantsListener {
@@ -70,6 +70,9 @@ class WebRtcCallViewModel : ViewModel() {
  private val ephemeralState = MutableStateFlow<WebRtcEphemeralState?>(null)
  private val remoteMutesReported = MutableStateFlow(HashSet<CallParticipantId>())

+  private val _isLocalScreenSharing = MutableStateFlow(false)
+  val isLocalScreenSharing: StateFlow<Boolean> = _isLocalScreenSharing
+
  private val controlsWithFoldableState: Flow<WebRtcControls> = combine(foldableState, webRtcControls, this::updateControlsFoldableState)
  private val realWebRtcControls: StateFlow<WebRtcControls> = combine(isInPipMode, controlsWithFoldableState, this::getRealWebRtcControls)
    .stateIn(viewModelScope, SharingStarted.Eagerly, WebRtcControls.NONE)
@@ -100,6 +103,7 @@ class WebRtcCallViewModel : ViewModel() {
  private var callConnectedTime = -1L
  private var answerWithVideoAvailable = false
  private var previousParticipantList = Collections.emptyList<CallParticipant>()
+  private var hasSeededParticipantList = false
  private var switchOnFirstScreenShare = true
  private var showScreenShareTip = true
  private var hasShownAutoMuteToast = false
@@ -181,9 +185,10 @@ class WebRtcCallViewModel : ViewModel() {
      callParticipantsState,
      getWebRtcControls(),
      groupSize,
-      isAudioDeviceChangePending
-    ) { participantsState, controls, groupMemberCount, audioChangePending ->
-      CallControlsState.fromViewModelData(participantsState, controls, groupMemberCount, audioChangePending)
+      isAudioDeviceChangePending,
+      _isLocalScreenSharing
+    ) { participantsState, controls, groupMemberCount, audioChangePending, isLocalScreenSharing ->
+      CallControlsState.fromViewModelData(participantsState, controls, groupMemberCount, audioChangePending, isLocalScreenSharing)
    }
  }

@@ -263,7 +268,7 @@ class WebRtcCallViewModel : ViewModel() {
    ) {
      showScreenShareTip = false
      viewModelScope.launch {
-        events.emit(CallEvent.ShowSwipeToSpeakerHint)
+        events.emit(CallEvent.ShowSwipeToScreenShareHint)
      }
    }

@@ -319,6 +324,7 @@ class WebRtcCallViewModel : ViewModel() {
    val wasMicrophoneEnabled = internalMicrophoneEnabled.value
    internalMicrophoneEnabled.value = localParticipant.isMicrophoneEnabled
    isAudioDeviceChangePending.value = webRtcViewModel.isAudioDeviceChangePending
+    _isLocalScreenSharing.value = webRtcViewModel.isLocalScreenSharing

    if (internalMicrophoneEnabled.value) {
      remoteMutedBy.update { null }
@@ -347,12 +353,13 @@ class WebRtcCallViewModel : ViewModel() {
    }

    if (webRtcViewModel.groupState.isConnected) {
-      if (!containsPlaceholders(previousParticipantList)) {
+      if (!containsPlaceholders(previousParticipantList) && hasSeededParticipantList) {
        val update = CallParticipantListUpdate.computeDeltaUpdate(previousParticipantList, webRtcViewModel.remoteParticipants)
        viewModelScope.launch {
          callParticipantListUpdate.emit(update)
        }
      }
+      hasSeededParticipantList = true

      for (remote in webRtcViewModel.remoteParticipants) {
        if (remote.remotelyMutedBy == null) {
@@ -9,36 +9,39 @@ import android.content.Context
 import android.view.View
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.State
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.viewinterop.AndroidView
 import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentManager
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.collections.immutable.persistentHashMapOf
 import org.signal.core.ui.compose.DayNightPreviews
+import org.signal.core.ui.compose.FastScrollerState
+import org.signal.core.ui.compose.LazyColumnFastScroller
+import org.signal.core.ui.compose.LocalFragmentManager
 import org.signal.core.ui.compose.Previews
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.contacts.paged.ContactSearchView.RecyclerViewReadyCallback
+import org.thoughtcrime.securesms.components.emoji.Emojifier
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.stories.settings.custom.PrivateStorySettingsFragment
 import org.thoughtcrime.securesms.stories.settings.my.MyStorySettingsFragment
 import org.thoughtcrime.securesms.stories.settings.privacy.ChooseInitialMyStoryMembershipBottomSheetDialogFragment
 import org.thoughtcrime.securesms.util.SpanUtil
-import org.thoughtcrime.securesms.util.adapter.mapping.PagingMappingAdapter
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingEntryProvider
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingLazyColumn
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingLazyListController
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.rememberMappingEntryProvider
 import org.signal.core.ui.R as CoreUiR

 /**
@@ -50,26 +53,16 @@ import org.signal.core.ui.R as CoreUiR
 * 2. Via [ContactSearchView] in XML/View-based layouts — [ContactSearchView] creates the ViewModel
 *    and delegates its `Content()` to this function.
 *
- * The [PagingMappingAdapter] is created internally via `remember` and re-created if
- * [displayOptions] or [adapterFactory] change.
- *
 * @param viewModel               Drives the list — managed by the caller.
 * @param mapStateToConfiguration Maps the current [ContactSearchState] to the active
 *                                [ContactSearchConfiguration], re-evaluated whenever state changes.
 * @param modifier                Modifier applied to the composable root.
 * @param displayOptions          Controls checkbox and secondary-info visibility.
 * @param callbacks               Hooks for filtering and reacting to selection changes.
- * @param storyFragmentManager    [FragmentManager] used to show story-related dialogs.
- *                                Pass `null` to disable story context menus and dialogs.
 * @param onListCommitted         Called after each list commit with the committed item count.
- * @param itemDecorations         [RecyclerView.ItemDecoration]s added to the internal list.
- * @param contentBottomPadding    Extra bottom padding so last items scroll above overlaid UI.
- *                                Automatically disables `clipToPadding` when non-zero.
- * @param adapterFactory          Factory for the adapter — swap for custom adapters (e.g.
- *                                [ContactSelectionListAdapter]).
- * @param scrollListeners         [RecyclerView.OnScrollListener]s attached to the inner list.
- * @param onRecyclerViewReady     Called once with the inner [RecyclerView] after first composition.
- *                                Useful for attaching fast-scrollers or custom item animators.
+ * @param additionalEntries       Extra [MappingEntryProvider] entries layered on top of the base
+ *                                set from [ContactSearchModels.composeEntries]. The base set is
+ *                                always applied; on key collisions the base entry wins.
 */
@Composable
 fun ContactSearch(
@@ -77,99 +70,151 @@ fun ContactSearch(
  mapStateToConfiguration: (ContactSearchState) -> ContactSearchConfiguration,
  modifier: Modifier = Modifier,
  displayOptions: ContactSearchAdapter.DisplayOptions = ContactSearchAdapter.DisplayOptions(),
-  callbacks: ContactSearchCallbacks = remember { ContactSearchCallbacks.Simple() },
-  storyFragmentManager: FragmentManager? = null,
  onListCommitted: (Int) -> Unit = {},
-  itemDecorations: List<RecyclerView.ItemDecoration> = emptyList(),
-  contentBottomPadding: Dp = 0.dp,
-  adapterFactory: ContactSearchAdapter.AdapterFactory = ContactSearchAdapter.DefaultAdapterFactory,
-  scrollListeners: List<RecyclerView.OnScrollListener> = emptyList(),
-  onRecyclerViewReady: RecyclerViewReadyCallback? = null
+  additionalEntries: MappingEntryProvider<Any> = persistentHashMapOf(),
+  lazyListState: LazyListState = rememberLazyListState(),
+  callbacks: ContactSearchCallbacks = remember { ContactSearchCallbacks.Simple() },
+  clickCallbacks: ContactSearchAdapter.ClickCallbacks = rememberDefaultContactSearchItemClickCallbacks(viewModel, callbacks),
+  longClickCallbacks: ContactSearchAdapter.LongClickCallbacks = rememberDefaultContactSearchItemLongClickCallbacks(),
+  storyContextMenuCallbacks: ContactSearchAdapter.StoryContextMenuCallbacks = rememberDefaultContactSearchItemStoryContextMenuCallbacks(viewModel),
+  callButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks = rememberDefaultContactSearchItemCallButtonClickCallbacks()
 ) {
  val mappingModels by viewModel.mappingModels.collectAsStateWithLifecycle()
  val controller by viewModel.controller.collectAsStateWithLifecycle()
  val configState by viewModel.configurationState.collectAsStateWithLifecycle()
+  val totalCount by viewModel.totalCount.collectAsStateWithLifecycle()
+  val fastScrollerEnabled by viewModel.fastScrollerEnabled.collectAsStateWithLifecycle()
+  val isDisplayingContextMenu by viewModel.isDisplayingContextMenu.collectAsStateWithLifecycle()

  val currentMapStateToConfiguration by rememberUpdatedState(mapStateToConfiguration)
  val currentOnListCommitted by rememberUpdatedState(onListCommitted)
-  // Held as State references (not delegated) so click-callback lambdas captured inside
-  // remember() always read the latest value without recreating the adapter.
-  val currentCallbacks = rememberUpdatedState(callbacks)
-  val currentStoryFragmentManager = rememberUpdatedState(storyFragmentManager)
-
-  val context = LocalContext.current
-  val contextState = rememberUpdatedState(context)
-
-  val adapter = remember(viewModel.fixedContacts, displayOptions, adapterFactory) {
-    adapterFactory.create(
-      context = context,
-      fixedContacts = viewModel.fixedContacts,
-      displayOptions = displayOptions,
-      callbacks = DefaultClickCallbacks(viewModel, currentCallbacks, currentStoryFragmentManager),
-      longClickCallbacks = ContactSearchAdapter.LongClickCallbacksAdapter(),
-      storyContextMenuCallbacks = DefaultStoryContextMenuCallbacks(viewModel, currentStoryFragmentManager, contextState),
-      callButtonClickCallbacks = ContactSearchAdapter.EmptyCallButtonClickCallbacks
-    )
-  }
-
-  LaunchedEffect(mappingModels) {
-    adapter.submitList(mappingModels) {
-      currentOnListCommitted(mappingModels.size)
-    }
-  }
-
-  LaunchedEffect(controller) {
-    controller?.let { adapter.setPagingController(it) }
-  }

  LaunchedEffect(configState) {
    viewModel.setConfiguration(currentMapStateToConfiguration(configState))
  }

-  val recyclerView = remember(context) {
-    RecyclerView(context).apply {
-      layoutManager = LinearLayoutManager(context)
+  LaunchedEffect(lazyListState) {
+    viewModel.scrollRequests.collect {
+      lazyListState.requestScrollToItem(0)
    }
  }

-  DisposableEffect(recyclerView, itemDecorations) {
-    itemDecorations.forEach { recyclerView.addItemDecoration(it) }
-    onDispose {
-      itemDecorations.forEach { recyclerView.removeItemDecoration(it) }
-    }
-  }
-
-  DisposableEffect(recyclerView, scrollListeners) {
-    scrollListeners.forEach { recyclerView.addOnScrollListener(it) }
-    onDispose {
-      scrollListeners.forEach { recyclerView.removeOnScrollListener(it) }
-    }
-  }
-
-  val bottomPaddingPx = with(LocalDensity.current) { contentBottomPadding.roundToPx() }
-
-  LaunchedEffect(recyclerView) {
-    onRecyclerViewReady?.onRecyclerViewReady(recyclerView)
-  }
-
-  AndroidView(
-    factory = { recyclerView },
-    update = { rv ->
-      if (rv.adapter !== adapter) {
-        rv.adapter = adapter
-      }
-      rv.setPadding(0, 0, 0, bottomPaddingPx)
-      rv.clipToPadding = bottomPaddingPx == 0
-      rv.clipChildren = bottomPaddingPx == 0
-    },
-    modifier = modifier.fillMaxSize()
+  val baseProvider = rememberContactSearchMappingEntryProvider(
+    fixedContacts = viewModel.fixedContacts,
+    displayOptions = displayOptions,
+    callbacks = clickCallbacks,
+    longClickCallbacks = longClickCallbacks,
+    storyContextMenuCallbacks = storyContextMenuCallbacks,
+    callButtonClickCallbacks = callButtonClickCallbacks
  )
+
+  val provider = remember(baseProvider, additionalEntries) {
+    additionalEntries.putAll(baseProvider)
+  }
+
+  val mappingCtrl = remember {
+    MappingLazyListController(
+      entryProvider = provider
+    )
+  }
+
+  LaunchedEffect(controller) {
+    controller?.run {
+      mappingCtrl.pagingController = this
+    }
+  }
+
+  LaunchedEffect(mappingModels) {
+    mappingCtrl.items = mappingModels
+    currentOnListCommitted(mappingModels.size)
+  }
+
+  val fastScrollerState = remember(mappingModels, totalCount) {
+    FastScrollerState(items = mappingModels, totalCount = totalCount)
+  }
+
+  LazyColumnFastScroller(
+    enabled = fastScrollerEnabled,
+    userScrollEnabled = !isDisplayingContextMenu,
+    fastScrollerState = fastScrollerState,
+    lazyListState = lazyListState,
+    modifier = modifier.fillMaxSize(),
+    letterContent = {
+      Emojifier(text = it.toString()) { annotatedText, inlineContent ->
+        Text(
+          text = annotatedText,
+          inlineContent = inlineContent,
+          style = MaterialTheme.typography.headlineLarge,
+          color = MaterialTheme.colorScheme.onPrimaryContainer
+        )
+      }
+    }
+  ) {
+    MappingLazyColumn(
+      userScrollEnabled = !isDisplayingContextMenu,
+      controller = mappingCtrl,
+      lazyListState = it,
+      modifier = Modifier.fillMaxSize()
+    )
+  }
+}
+
+@Composable
+private fun rememberContactSearchMappingEntryProvider(
+  fixedContacts: Set<ContactSearchKey>,
+  displayOptions: ContactSearchAdapter.DisplayOptions,
+  callbacks: ContactSearchAdapter.ClickCallbacks,
+  longClickCallbacks: ContactSearchAdapter.LongClickCallbacks,
+  storyContextMenuCallbacks: ContactSearchAdapter.StoryContextMenuCallbacks?,
+  callButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks
+): MappingEntryProvider<Any> {
+  return rememberMappingEntryProvider {
+    // Subclass-registered models (Message, Thread, Empty, GroupWithMembers) and
+    // ArbitraryRepository-backed models are handled separately.
+    provider<Any>(
+      ContactSearchModels.composeEntries(
+        fixedContacts = fixedContacts,
+        displayOptions = displayOptions,
+        callbacks = callbacks,
+        longClickCallbacks = longClickCallbacks,
+        storyContextMenuCallbacks = storyContextMenuCallbacks,
+        callButtonClickCallbacks = callButtonClickCallbacks
+      )
+    )
+  }
+}
+
+@Composable
+fun rememberDefaultContactSearchItemClickCallbacks(viewModel: ContactSearchViewModel, callbacks: ContactSearchCallbacks): ContactSearchAdapter.ClickCallbacks {
+  val fragmentManager = LocalFragmentManager.current
+
+  return remember(callbacks) {
+    DefaultClickCallbacks(viewModel, callbacks, fragmentManager)
+  }
+}
+
+@Composable
+fun rememberDefaultContactSearchItemLongClickCallbacks(): ContactSearchAdapter.LongClickCallbacks {
+  return remember { ContactSearchAdapter.LongClickCallbacksAdapter() }
+}
+
+@Composable
+fun rememberDefaultContactSearchItemStoryContextMenuCallbacks(viewModel: ContactSearchViewModel): ContactSearchAdapter.StoryContextMenuCallbacks {
+  val context = LocalContext.current
+  val fragmentManager = LocalFragmentManager.current
+
+  return remember { DefaultStoryContextMenuCallbacks(viewModel, fragmentManager, context) }
+}
+
+@Composable
+fun rememberDefaultContactSearchItemCallButtonClickCallbacks(): ContactSearchAdapter.CallButtonClickCallbacks {
+  return remember { ContactSearchAdapter.EmptyCallButtonClickCallbacks }
 }

 private class DefaultClickCallbacks(
  private val viewModel: ContactSearchViewModel,
-  private val callbacks: State<ContactSearchCallbacks>,
-  private val fragmentManager: State<FragmentManager?>
+  private val callbacks: ContactSearchCallbacks,
+  private val fragmentManager: FragmentManager?
 ) : ContactSearchAdapter.ClickCallbacks {

  companion object {
@@ -179,7 +224,7 @@ private class DefaultClickCallbacks(
  override fun onStoryClicked(view: View, story: ContactSearchData.Story, isSelected: Boolean) {
    Log.d(TAG, "onStoryClicked()")
    if (story.recipient.isMyStory && !SignalStore.story.userHasBeenNotifiedAboutStories) {
-      fragmentManager.value?.let { ChooseInitialMyStoryMembershipBottomSheetDialogFragment.show(it) }
+      fragmentManager?.let { ChooseInitialMyStoryMembershipBottomSheetDialogFragment.show(it) }
    } else {
      toggle(view, story, isSelected)
    }
@@ -200,30 +245,30 @@ private class DefaultClickCallbacks(
    if (isSelected) {
      viewModel.setKeysNotSelected(setOf(chatTypeRow.contactSearchKey))
    } else {
-      viewModel.setKeysSelected(callbacks.value.onBeforeContactsSelected(view, setOf(chatTypeRow.contactSearchKey)))
+      viewModel.setKeysSelected(callbacks.onBeforeContactsSelected(view, setOf(chatTypeRow.contactSearchKey)))
    }
  }

  private fun toggle(view: View, data: ContactSearchData, isSelected: Boolean) {
    if (isSelected) {
      Log.d(TAG, "toggle(OFF) ${data.contactSearchKey}")
-      callbacks.value.onContactDeselected(view, data.contactSearchKey)
+      callbacks.onContactDeselected(view, data.contactSearchKey)
      viewModel.setKeysNotSelected(setOf(data.contactSearchKey))
    } else {
      Log.d(TAG, "toggle(ON) ${data.contactSearchKey}")
-      viewModel.setKeysSelected(callbacks.value.onBeforeContactsSelected(view, setOf(data.contactSearchKey)))
+      viewModel.setKeysSelected(callbacks.onBeforeContactsSelected(view, setOf(data.contactSearchKey)))
    }
  }
 }

 private class DefaultStoryContextMenuCallbacks(
  private val viewModel: ContactSearchViewModel,
-  private val fragmentManager: State<FragmentManager?>,
-  private val context: State<Context>
+  private val fragmentManager: FragmentManager?,
+  private val context: Context
 ) : ContactSearchAdapter.StoryContextMenuCallbacks {

  override fun onOpenStorySettings(story: ContactSearchData.Story) {
-    val fm = fragmentManager.value ?: return
+    val fm = fragmentManager ?: return
    if (story.recipient.isMyStory) {
      MyStorySettingsFragment.createAsDialog().show(fm, null)
    } else {
@@ -232,8 +277,8 @@ private class DefaultStoryContextMenuCallbacks(
  }

  override fun onRemoveGroupStory(story: ContactSearchData.Story, isSelected: Boolean) {
-    fragmentManager.value ?: return
-    MaterialAlertDialogBuilder(context.value)
+    fragmentManager ?: return
+    MaterialAlertDialogBuilder(context)
      .setTitle(R.string.ContactSearchMediator__remove_group_story)
      .setMessage(R.string.ContactSearchMediator__this_will_remove)
      .setPositiveButton(R.string.ContactSearchMediator__remove) { _, _ -> viewModel.removeGroupStory(story) }
@@ -242,8 +287,8 @@ private class DefaultStoryContextMenuCallbacks(
  }

  override fun onDeletePrivateStory(story: ContactSearchData.Story, isSelected: Boolean) {
-    fragmentManager.value ?: return
-    val ctx = context.value
+    fragmentManager ?: return
+    val ctx = context
    MaterialAlertDialogBuilder(ctx)
      .setTitle(R.string.ContactSearchMediator__delete_story)
      .setMessage(ctx.getString(R.string.ContactSearchMediator__delete_the_custom, story.recipient.getDisplayName(ctx)))
@@ -1,47 +1,15 @@
 package org.thoughtcrime.securesms.contacts.paged

 import android.content.Context
-import android.text.SpannableStringBuilder
 import android.view.View
-import android.view.ViewGroup
-import android.widget.CheckBox
-import android.widget.ImageView
-import android.widget.TextView
-import androidx.appcompat.widget.AppCompatImageView
-import androidx.core.content.ContextCompat
-import com.google.android.material.button.MaterialButton
-import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
-import io.reactivex.rxjava3.core.Observable
-import io.reactivex.rxjava3.disposables.Disposable
-import org.signal.core.util.BreakIteratorCompat
-import org.signal.core.util.requireDrawable
-import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.avatar.fallback.FallbackAvatar
-import org.thoughtcrime.securesms.avatar.view.AvatarView
-import org.thoughtcrime.securesms.badges.BadgeImageView
-import org.thoughtcrime.securesms.components.AvatarImageView
-import org.thoughtcrime.securesms.components.FromTextView
+import org.signal.core.ui.compose.FastScrollCharacterProvider
 import org.thoughtcrime.securesms.components.RecyclerViewFastScroller.FastScrollAdapter
-import org.thoughtcrime.securesms.components.emoji.EmojiUtil
-import org.thoughtcrime.securesms.components.menu.ActionItem
-import org.thoughtcrime.securesms.components.menu.SignalContextMenu
-import org.thoughtcrime.securesms.contacts.LetterHeaderDecoration
-import org.thoughtcrime.securesms.database.model.DistributionListPrivacyMode
-import org.thoughtcrime.securesms.database.model.StoryViewState
-import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.util.SpanUtil
-import org.thoughtcrime.securesms.util.adapter.mapping.LayoutFactory
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingModelList
-import org.thoughtcrime.securesms.util.adapter.mapping.MappingViewHolder
 import org.thoughtcrime.securesms.util.adapter.mapping.PagingMappingAdapter
-import org.thoughtcrime.securesms.util.visible
-import org.signal.core.ui.R as CoreUiR

 /**
- * Default contact search adapter, using the models defined in `ContactSearchItems`
+ * Default contact search adapter. View holders, mapping models, and the helpers that register them
+ * live in [ContactSearchModels].
 */
@Suppress("LeakingThis")
 open class ContactSearchAdapter(
@@ -55,12 +23,12 @@ open class ContactSearchAdapter(
 ) : PagingMappingAdapter<ContactSearchKey>(), FastScrollAdapter {

  init {
-    registerStoryItems(this, displayOptions.displayCheckBox, onClickCallbacks::onStoryClicked, storyContextMenuCallbacks, displayOptions.displayStoryRing)
-    registerKnownRecipientItems(this, fixedContacts, displayOptions, onClickCallbacks::onKnownRecipientClicked, longClickCallbacks::onKnownRecipientLongClick, callButtonClickCallbacks)
-    registerHeaders(this)
-    registerExpands(this, onClickCallbacks::onExpandClicked)
-    registerChatTypeItems(this, onClickCallbacks::onChatTypeClicked)
-    registerFactory(UnknownRecipientModel::class.java, LayoutFactory({ UnknownRecipientViewHolder(it, onClickCallbacks::onUnknownRecipientClicked, displayOptions.displayCheckBox) }, R.layout.contact_search_unknown_item))
+    ContactSearchModels.registerStoryItems(this, displayOptions.displayCheckBox, onClickCallbacks::onStoryClicked, storyContextMenuCallbacks, displayOptions.displayStoryRing)
+    ContactSearchModels.registerKnownRecipientItems(this, fixedContacts, displayOptions, onClickCallbacks::onKnownRecipientClicked, longClickCallbacks::onKnownRecipientLongClick, callButtonClickCallbacks)
+    ContactSearchModels.registerHeaders(this)
+    ContactSearchModels.registerExpands(this, onClickCallbacks::onExpandClicked)
+    ContactSearchModels.registerChatTypeItems(this, onClickCallbacks::onChatTypeClicked)
+    ContactSearchModels.registerUnknownRecipientItems(this, onClickCallbacks::onUnknownRecipientClicked, displayOptions.displayCheckBox)
  }

  override fun getBubbleText(position: Int): CharSequence {
@@ -72,701 +40,6 @@ open class ContactSearchAdapter(
    }
  }

-  interface FastScrollCharacterProvider {
-    fun getFastScrollCharacter(context: Context): CharSequence
-  }
-
-  companion object {
-    fun registerStoryItems(
-      mappingAdapter: MappingAdapter,
-      displayCheckBox: Boolean = false,
-      storyListener: OnClickedCallback<ContactSearchData.Story>,
-      storyContextMenuCallbacks: StoryContextMenuCallbacks? = null,
-      showStoryRing: Boolean = false
-    ) {
-      mappingAdapter.registerFactory(
-        StoryModel::class.java,
-        LayoutFactory({ StoryViewHolder(it, displayCheckBox, storyListener, storyContextMenuCallbacks, showStoryRing) }, R.layout.contact_search_story_item)
-      )
-    }
-
-    fun registerKnownRecipientItems(
-      mappingAdapter: MappingAdapter,
-      fixedContacts: Set<ContactSearchKey>,
-      displayOptions: DisplayOptions,
-      recipientListener: OnClickedCallback<ContactSearchData.KnownRecipient>,
-      recipientLongClickCallback: OnLongClickedCallback<ContactSearchData.KnownRecipient>,
-      recipientCallButtonClickCallbacks: CallButtonClickCallbacks
-    ) {
-      mappingAdapter.registerFactory(
-        RecipientModel::class.java,
-        LayoutFactory({
-          KnownRecipientViewHolder(it, fixedContacts, displayOptions, recipientListener, recipientLongClickCallback, recipientCallButtonClickCallbacks)
-        }, R.layout.contact_search_item)
-      )
-    }
-
-    fun registerHeaders(mappingAdapter: MappingAdapter) {
-      mappingAdapter.registerFactory(
-        HeaderModel::class.java,
-        LayoutFactory({ HeaderViewHolder(it) }, R.layout.contact_search_section_header)
-      )
-    }
-
-    fun registerExpands(mappingAdapter: MappingAdapter, expandListener: (ContactSearchData.Expand) -> Unit) {
-      mappingAdapter.registerFactory(
-        ExpandModel::class.java,
-        LayoutFactory({ ExpandViewHolder(it, expandListener) }, R.layout.contacts_expand_item)
-      )
-    }
-
-    fun registerChatTypeItems(mappingAdapter: MappingAdapter, chatTypeRowListener: OnClickedCallback<ContactSearchData.ChatTypeRow>) {
-      mappingAdapter.registerFactory(
-        ChatTypeModel::class.java,
-        LayoutFactory({ ChatTypeViewHolder(it, chatTypeRowListener) }, R.layout.contact_search_chat_type_item)
-      )
-    }
-
-    fun toMappingModelList(contactSearchData: List<ContactSearchData?>, selection: Set<ContactSearchKey>, arbitraryRepository: ArbitraryRepository?): MappingModelList {
-      return MappingModelList(
-        contactSearchData.filterNotNull().map {
-          when (it) {
-            is ContactSearchData.Story -> StoryModel(it, selection.contains(it.contactSearchKey), SignalStore.story.userHasBeenNotifiedAboutStories)
-            is ContactSearchData.KnownRecipient -> RecipientModel(it, selection.contains(it.contactSearchKey), it.shortSummary)
-            is ContactSearchData.Expand -> ExpandModel(it)
-            is ContactSearchData.Header -> HeaderModel(it)
-            is ContactSearchData.TestRow -> error("This row exists for testing only.")
-            is ContactSearchData.Arbitrary -> arbitraryRepository?.getMappingModel(it) ?: error("This row must be handled manually")
-            is ContactSearchData.Message -> MessageModel(it)
-            is ContactSearchData.Thread -> ThreadModel(it)
-            is ContactSearchData.Empty -> EmptyModel(it)
-            is ContactSearchData.GroupWithMembers -> GroupWithMembersModel(it)
-            is ContactSearchData.UnknownRecipient -> UnknownRecipientModel(it)
-            is ContactSearchData.ChatTypeRow -> ChatTypeModel(it, selection.contains(it.contactSearchKey))
-          }
-        }
-      )
-    }
-  }
-
-  /**
-   * Story Model
-   */
-  class StoryModel(val story: ContactSearchData.Story, val isSelected: Boolean, val hasBeenNotified: Boolean) : MappingModel<StoryModel> {
-
-    override fun areItemsTheSame(newItem: StoryModel): Boolean {
-      return newItem.story == story
-    }
-
-    override fun areContentsTheSame(newItem: StoryModel): Boolean {
-      return story.recipient.hasSameContent(newItem.story.recipient) &&
-        isSelected == newItem.isSelected &&
-        hasBeenNotified == newItem.hasBeenNotified
-    }
-
-    override fun getChangePayload(newItem: StoryModel): Any? {
-      return if (story.recipient.hasSameContent(newItem.story.recipient) &&
-        hasBeenNotified == newItem.hasBeenNotified &&
-        newItem.isSelected != isSelected
-      ) {
-        0
-      } else {
-        null
-      }
-    }
-  }
-
-  private class StoryViewHolder(
-    itemView: View,
-    val displayCheckBox: Boolean,
-    val onClick: OnClickedCallback<ContactSearchData.Story>,
-    private val storyContextMenuCallbacks: StoryContextMenuCallbacks?,
-    private val showStoryRing: Boolean = false
-  ) : MappingViewHolder<StoryModel>(itemView) {
-
-    val avatar: AvatarView = itemView.findViewById(R.id.contact_photo_image)
-    val badge: BadgeImageView = itemView.findViewById(R.id.contact_badge)
-    val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
-    val name: FromTextView = itemView.findViewById(R.id.name)
-    val number: TextView = itemView.findViewById(R.id.number)
-    val groupStoryIndicator: AppCompatImageView = itemView.findViewById(R.id.group_story_indicator)
-    var storyViewState: Observable<StoryViewState>? = null
-    var storyDisposable: Disposable? = null
-
-    override fun bind(model: StoryModel) {
-      itemView.setOnClickListener { onClick.onClicked(avatar, getData(model), isSelected(model)) }
-      bindLongPress(model)
-
-      bindCheckbox(model)
-
-      if (payload.isNotEmpty()) {
-        return
-      }
-
-      storyViewState = if (showStoryRing) StoryViewState.getForRecipientId(getRecipient(model).id) else null
-      avatar.setStoryRingFromState(StoryViewState.NONE)
-      groupStoryIndicator.isActivated = false
-
-      name.setText(getRecipient(model))
-      badge.setBadgeFromRecipient(getRecipient(model))
-
-      bindAvatar(model)
-      bindNumberField(model)
-    }
-
-    fun isSelected(model: StoryModel): Boolean = model.isSelected
-    fun getData(model: StoryModel): ContactSearchData.Story = model.story
-    fun getRecipient(model: StoryModel): Recipient = model.story.recipient
-
-    fun bindNumberField(model: StoryModel) {
-      number.visible = true
-
-      val count = if (model.story.recipient.isGroup) {
-        model.story.recipient.participantIds.size
-      } else {
-        model.story.count
-      }
-
-      if (model.story.recipient.isMyStory && !model.hasBeenNotified) {
-        number.setText(R.string.ContactSearchItems__tap_to_choose_your_viewers)
-        number.setSingleLine(false)
-      } else {
-        number.setSingleLine(true)
-        number.text = when {
-          model.story.recipient.isGroup -> context.resources.getQuantityString(R.plurals.ContactSearchItems__group_story_d_viewers, count, count)
-          model.story.recipient.isMyStory -> {
-            if (model.story.privacyMode == DistributionListPrivacyMode.ALL_EXCEPT) {
-              context.resources.getQuantityString(R.plurals.ContactSearchItems__my_story_s_dot_d_excluded, count, presentPrivacyMode(DistributionListPrivacyMode.ALL), count)
-            } else {
-              context.resources.getQuantityString(R.plurals.ContactSearchItems__my_story_s_dot_d_viewers, count, presentPrivacyMode(model.story.privacyMode), count)
-            }
-          }
-
-          else -> context.resources.getQuantityString(R.plurals.ContactSearchItems__custom_story_d_viewers, count, count)
-        }
-      }
-    }
-
-    fun bindCheckbox(model: StoryModel) {
-      checkbox.visible = displayCheckBox
-      checkbox.isChecked = isSelected(model)
-    }
-
-    fun bindAvatar(model: StoryModel) {
-      if (model.story.recipient.isMyStory) {
-        avatar.setFallbackAvatarProvider(MyStoryFallbackAvatarProvider)
-        avatar.displayProfileAvatar(Recipient.self())
-      } else {
-        avatar.setFallbackAvatarProvider(null)
-        avatar.displayChatAvatar(getRecipient(model))
-      }
-      groupStoryIndicator.visible = showStoryRing && model.story.recipient.isGroup
-    }
-
-    fun bindLongPress(model: StoryModel) {
-      if (storyContextMenuCallbacks == null) {
-        return
-      }
-
-      itemView.setOnLongClickListener {
-        val actions: List<ActionItem> = when {
-          model.story.recipient.isMyStory -> getMyStoryContextMenuActions(model, storyContextMenuCallbacks)
-          model.story.recipient.isGroup -> getGroupStoryContextMenuActions(model, storyContextMenuCallbacks)
-          model.story.recipient.isDistributionList -> getPrivateStoryContextMenuActions(model, storyContextMenuCallbacks)
-          else -> error("Unsupported story target. Not a group or distribution list.")
-        }
-
-        SignalContextMenu.Builder(itemView, itemView.rootView as ViewGroup)
-          .offsetX(context.resources.getDimensionPixelSize(R.dimen.dsl_settings_gutter))
-          .show(actions)
-
-        true
-      }
-    }
-
-    private fun getMyStoryContextMenuActions(model: StoryModel, callbacks: StoryContextMenuCallbacks): List<ActionItem> {
-      return listOf(
-        ActionItem(CoreUiR.drawable.symbol_settings_android_24, context.getString(R.string.ContactSearchItems__story_settings)) {
-          callbacks.onOpenStorySettings(model.story)
-        }
-      )
-    }
-
-    private fun getGroupStoryContextMenuActions(model: StoryModel, callbacks: StoryContextMenuCallbacks): List<ActionItem> {
-      return listOf(
-        ActionItem(R.drawable.symbol_minus_circle_24, context.getString(R.string.ContactSearchItems__remove_story)) {
-          callbacks.onRemoveGroupStory(model.story, model.isSelected)
-        }
-      )
-    }
-
-    private fun getPrivateStoryContextMenuActions(model: StoryModel, callbacks: StoryContextMenuCallbacks): List<ActionItem> {
-      return listOf(
-        ActionItem(CoreUiR.drawable.symbol_settings_android_24, context.getString(R.string.ContactSearchItems__story_settings)) {
-          callbacks.onOpenStorySettings(model.story)
-        },
-        ActionItem(CoreUiR.drawable.symbol_trash_24, context.getString(R.string.ContactSearchItems__delete_story), CoreUiR.color.signal_colorError) {
-          callbacks.onDeletePrivateStory(model.story, model.isSelected)
-        }
-      )
-    }
-
-    private fun presentPrivacyMode(privacyMode: DistributionListPrivacyMode): String {
-      return when (privacyMode) {
-        DistributionListPrivacyMode.ONLY_WITH -> context.getString(R.string.ContactSearchItems__only_share_with)
-        DistributionListPrivacyMode.ALL_EXCEPT -> context.getString(R.string.ChooseInitialMyStoryMembershipFragment__all_except)
-        DistributionListPrivacyMode.ALL -> context.getString(R.string.ChooseInitialMyStoryMembershipFragment__all_signal_connections)
-      }
-    }
-
-    private object MyStoryFallbackAvatarProvider : AvatarImageView.FallbackAvatarProvider {
-      override fun getFallbackAvatar(recipient: Recipient): FallbackAvatar {
-        if (recipient.isSelf) {
-          return FallbackAvatar.Resource.Person(recipient.avatarColor)
-        }
-
-        return super.getFallbackAvatar(recipient)
-      }
-    }
-
-    override fun onAttachedToWindow() {
-      storyDisposable = storyViewState?.observeOn(AndroidSchedulers.mainThread())?.subscribe {
-        avatar.setStoryRingFromState(it)
-        when (it) {
-          StoryViewState.UNVIEWED -> groupStoryIndicator.isActivated = true
-          else -> groupStoryIndicator.isActivated = false
-        }
-      }
-    }
-
-    override fun onDetachedFromWindow() {
-      storyDisposable?.dispose()
-    }
-  }
-
-  /**
-   * Recipient model
-   */
-  class RecipientModel(
-    val knownRecipient: ContactSearchData.KnownRecipient,
-    val isSelected: Boolean,
-    val shortSummary: Boolean
-  ) : MappingModel<RecipientModel>, FastScrollCharacterProvider {
-
-    override fun getFastScrollCharacter(context: Context): CharSequence {
-      val name = if (knownRecipient.recipient.isSelf) {
-        context.getString(R.string.note_to_self)
-      } else {
-        knownRecipient.recipient.getDisplayName(context)
-      }
-
-      val letter: CharSequence = BreakIteratorCompat.getInstance()
-        .apply { setText(name) }
-        .asSequence()
-        .map { charSequence -> charSequence.trim { it <= ' ' } }
-        .filter { it.isNotEmpty() }
-        .mapNotNull {
-          when {
-            EmojiUtil.isEmoji(it.toString()) -> it
-            Character.isLetterOrDigit(it[0]) -> it[0].uppercaseChar().toString()
-            else -> null
-          }
-        }
-        .firstOrNull() ?: "#"
-
-      return letter
-    }
-
-    override fun areItemsTheSame(newItem: RecipientModel): Boolean {
-      return newItem.knownRecipient == knownRecipient
-    }
-
-    override fun areContentsTheSame(newItem: RecipientModel): Boolean {
-      return knownRecipient.recipient.hasSameContent(newItem.knownRecipient.recipient) && isSelected == newItem.isSelected
-    }
-
-    override fun getChangePayload(newItem: RecipientModel): Any? {
-      return if (knownRecipient.recipient.hasSameContent(newItem.knownRecipient.recipient) && newItem.isSelected != isSelected) {
-        0
-      } else {
-        null
-      }
-    }
-  }
-
-  class UnknownRecipientModel(val data: ContactSearchData.UnknownRecipient) : MappingModel<UnknownRecipientModel> {
-    override fun areItemsTheSame(newItem: UnknownRecipientModel): Boolean = true
-
-    override fun areContentsTheSame(newItem: UnknownRecipientModel): Boolean = data == newItem.data
-  }
-
-  private class UnknownRecipientViewHolder(
-    itemView: View,
-    private val onClick: OnClickedCallback<ContactSearchData.UnknownRecipient>,
-    private val displayCheckBox: Boolean
-  ) : MappingViewHolder<UnknownRecipientModel>(itemView) {
-
-    private val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
-    private val name: FromTextView = itemView.findViewById(R.id.name)
-    private val number: TextView = itemView.findViewById(R.id.number)
-    private val headerGroup: View = itemView.findViewById(R.id.contact_header)
-    private val headerText: TextView = itemView.findViewById(R.id.section_header)
-
-    override fun bind(model: UnknownRecipientModel) {
-      checkbox.visible = displayCheckBox
-      checkbox.isSelected = false
-      val nameText = when (model.data.mode) {
-        ContactSearchConfiguration.NewRowMode.NEW_CALL -> R.string.contact_selection_list__new_call
-        ContactSearchConfiguration.NewRowMode.NEW_CONVERSATION -> -1
-        ContactSearchConfiguration.NewRowMode.BLOCK -> R.string.contact_selection_list__unknown_contact_block
-        ContactSearchConfiguration.NewRowMode.ADD_TO_GROUP -> R.string.contact_selection_list__unknown_contact_add_to_group
-      }
-
-      if (nameText > 0) {
-        name.setText(nameText)
-        number.text = model.data.query
-        number.visible = true
-      } else {
-        name.text = model.data.query
-        number.visible = false
-      }
-
-      if (model.data.mode == ContactSearchConfiguration.NewRowMode.NEW_CONVERSATION) {
-        headerGroup.visible = true
-        headerText.setText(
-          if (model.data.sectionKey == ContactSearchConfiguration.SectionKey.PHONE_NUMBER) {
-            R.string.FindByActivity__find_by_phone_number
-          } else {
-            R.string.FindByActivity__find_by_username
-          }
-        )
-      } else {
-        headerGroup.visible = false
-      }
-
-      itemView.setOnClickListener {
-        onClick.onClicked(itemView, model.data, false)
-      }
-    }
-  }
-
-  private class KnownRecipientViewHolder(
-    itemView: View,
-    private val fixedContacts: Set<ContactSearchKey>,
-    displayOptions: DisplayOptions,
-    onClick: OnClickedCallback<ContactSearchData.KnownRecipient>,
-    private val onLongClick: OnLongClickedCallback<ContactSearchData.KnownRecipient>,
-    callButtonClickCallbacks: CallButtonClickCallbacks
-  ) : BaseRecipientViewHolder<RecipientModel, ContactSearchData.KnownRecipient>(itemView, displayOptions, onClick, callButtonClickCallbacks), LetterHeaderDecoration.LetterHeaderItem {
-
-    private var headerLetter: String? = null
-
-    override fun isSelected(model: RecipientModel): Boolean = model.isSelected
-    override fun getData(model: RecipientModel): ContactSearchData.KnownRecipient = model.knownRecipient
-    override fun getRecipient(model: RecipientModel): Recipient = model.knownRecipient.recipient
-    override fun bindNumberField(model: RecipientModel) {
-      val recipient = getRecipient(model)
-      if (model.knownRecipient.sectionKey == ContactSearchConfiguration.SectionKey.GROUP_MEMBERS) {
-        number.text = model.knownRecipient.groupsInCommon.toDisplayText(context, displayGroupsLimit = 2)
-        number.visible = true
-      } else if (model.shortSummary && recipient.isGroup) {
-        val count = recipient.participantIds.size
-        number.text = context.resources.getQuantityString(R.plurals.ContactSearchItems__group_d_members, count, count)
-        number.visible = true
-      } else if (displayOptions.displaySecondaryInformation == DisplaySecondaryInformation.ALWAYS && recipient.combinedAboutAndEmoji != null) {
-        number.text = recipient.combinedAboutAndEmoji
-        number.visible = true
-      } else if (displayOptions.displaySecondaryInformation == DisplaySecondaryInformation.ALWAYS && recipient.hasE164) {
-        number.visible = false
-      } else {
-        super.bindNumberField(model)
-      }
-
-      headerLetter = model.knownRecipient.headerLetter
-    }
-
-    override fun bindCheckbox(model: RecipientModel) {
-      super.bindCheckbox(model)
-
-      if (fixedContacts.contains(model.knownRecipient.contactSearchKey)) {
-        checkbox.isChecked = true
-      }
-      checkbox.isEnabled = !fixedContacts.contains(model.knownRecipient.contactSearchKey)
-    }
-
-    override fun isEnabled(model: RecipientModel): Boolean {
-      return !fixedContacts.contains(model.knownRecipient.contactSearchKey)
-    }
-
-    override fun getHeaderLetter(): String? {
-      return headerLetter
-    }
-
-    override fun bindLongPress(model: RecipientModel) {
-      itemView.setOnLongClickListener { onLongClick.onLongClicked(itemView, model.knownRecipient) }
-    }
-  }
-
-  /**
-   * Base Recipient View Holder
-   */
-  abstract class BaseRecipientViewHolder<T : MappingModel<T>, D : ContactSearchData>(
-    itemView: View,
-    val displayOptions: DisplayOptions,
-    val onClick: OnClickedCallback<D>,
-    val onCallButtonClickCallbacks: CallButtonClickCallbacks
-  ) : MappingViewHolder<T>(itemView) {
-
-    protected val avatar: AvatarImageView = itemView.findViewById(R.id.contact_photo_image)
-    protected val badge: BadgeImageView = itemView.findViewById(R.id.contact_badge)
-    protected val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
-    protected val name: FromTextView = itemView.findViewById(R.id.name)
-    protected val number: TextView = itemView.findViewById(R.id.number)
-    protected val label: TextView = itemView.findViewById(R.id.label)
-    private val startAudio: View = itemView.findViewById(R.id.start_audio)
-    private val startVideo: View = itemView.findViewById(R.id.start_video)
-
-    override fun bind(model: T) {
-      if (isEnabled(model)) {
-        itemView.setOnClickListener { onClick.onClicked(avatar, getData(model), isSelected(model)) }
-        bindLongPress(model)
-      } else {
-        itemView.setOnClickListener(null)
-      }
-
-      bindCheckbox(model)
-
-      if (payload.isNotEmpty()) {
-        return
-      }
-
-      val recipient = getRecipient(model)
-      val suffix: CharSequence? = if (recipient.isSystemContact && !recipient.showVerified) {
-        SpannableStringBuilder().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)
-        }
-      } else {
-        null
-      }
-      name.setText(recipient, suffix)
-
-      badge.setBadgeFromRecipient(getRecipient(model))
-
-      bindAvatar(model)
-      bindNumberField(model)
-      bindLabelField(model)
-      bindCallButtons(model)
-    }
-
-    protected open fun bindCheckbox(model: T) {
-      checkbox.visible = displayOptions.displayCheckBox
-      checkbox.isChecked = isSelected(model)
-    }
-
-    protected open fun isEnabled(model: T): Boolean = true
-
-    protected open fun bindAvatar(model: T) {
-      avatar.setAvatar(getRecipient(model))
-    }
-
-    protected open fun bindNumberField(model: T) {
-      number.visible = getRecipient(model).isGroup
-      if (getRecipient(model).isGroup) {
-        number.text = getRecipient(model).participantIds
-          .take(10)
-          .map { id ->
-            val recipient = Recipient.resolved(id)
-            RecipientDisplayName(
-              recipient = recipient,
-              displayName = if (recipient.isSelf) {
-                context.getString(R.string.ConversationTitleView_you)
-              } else {
-                recipient.getShortDisplayName(context)
-              }
-            )
-          }
-          .sortedWith(compareBy({ it.recipient.isUnregistered }, { it.recipient.isSelf }, { it.displayName }))
-          .joinToString(", ") { it.displayName }
-      }
-    }
-
-    protected open fun bindLabelField(model: T) {
-      label.visible = false
-    }
-
-    protected open fun bindLongPress(model: T) = Unit
-
-    private fun bindCallButtons(model: T) {
-      val recipient = getRecipient(model)
-      if (displayOptions.displayCallButtons && (recipient.isPushGroup || recipient.isRegistered)) {
-        startVideo.visible = true
-        startAudio.visible = !recipient.isPushGroup
-
-        startVideo.setOnClickListener {
-          onCallButtonClickCallbacks.onVideoCallButtonClicked(recipient)
-        }
-
-        startAudio.setOnClickListener {
-          onCallButtonClickCallbacks.onAudioCallButtonClicked(recipient)
-        }
-      } else {
-        startVideo.visible = false
-        startAudio.visible = false
-      }
-    }
-
-    abstract fun isSelected(model: T): Boolean
-    abstract fun getData(model: T): D
-    abstract fun getRecipient(model: T): Recipient
-  }
-
-  /**
-   * Mapping Model for section headers
-   */
-  class HeaderModel(val header: ContactSearchData.Header) : MappingModel<HeaderModel> {
-    override fun areItemsTheSame(newItem: HeaderModel): Boolean {
-      return header.sectionKey == newItem.header.sectionKey
-    }
-
-    override fun areContentsTheSame(newItem: HeaderModel): Boolean {
-      return areItemsTheSame(newItem) &&
-        header.action?.icon == newItem.header.action?.icon &&
-        header.action?.label == newItem.header.action?.label
-    }
-  }
-
-  /**
-   * Mapping Model for messages
-   */
-  class MessageModel(val message: ContactSearchData.Message) : MappingModel<MessageModel> {
-    override fun areItemsTheSame(newItem: MessageModel): Boolean = message.contactSearchKey == newItem.message.contactSearchKey
-
-    override fun areContentsTheSame(newItem: MessageModel): Boolean {
-      return message == newItem.message
-    }
-  }
-
-  /**
-   * Mapping Model for threads
-   */
-  class ThreadModel(val thread: ContactSearchData.Thread) : MappingModel<ThreadModel> {
-    override fun areItemsTheSame(newItem: ThreadModel): Boolean = thread.contactSearchKey == newItem.thread.contactSearchKey
-    override fun areContentsTheSame(newItem: ThreadModel): Boolean {
-      return thread == newItem.thread
-    }
-  }
-
-  class EmptyModel(val empty: ContactSearchData.Empty) : MappingModel<EmptyModel> {
-    override fun areItemsTheSame(newItem: EmptyModel): Boolean = true
-    override fun areContentsTheSame(newItem: EmptyModel): Boolean = newItem.empty == empty
-  }
-
-  /**
-   * Mapping Model for [ContactSearchData.GroupWithMembers]
-   */
-  class GroupWithMembersModel(val groupWithMembers: ContactSearchData.GroupWithMembers) : MappingModel<GroupWithMembersModel> {
-    override fun areContentsTheSame(newItem: GroupWithMembersModel): Boolean = newItem.groupWithMembers == groupWithMembers
-
-    override fun areItemsTheSame(newItem: GroupWithMembersModel): Boolean = newItem.groupWithMembers.contactSearchKey == groupWithMembers.contactSearchKey
-  }
-
-  /**
-   * View Holder for section headers
-   */
-  private class HeaderViewHolder(itemView: View) : MappingViewHolder<HeaderModel>(itemView) {
-
-    private val headerTextView: TextView = itemView.findViewById(R.id.section_header)
-    private val headerActionView: MaterialButton = itemView.findViewById(R.id.section_header_action)
-
-    override fun bind(model: HeaderModel) {
-      headerTextView.setText(
-        when (model.header.sectionKey) {
-          ContactSearchConfiguration.SectionKey.STORIES -> R.string.ContactsCursorLoader_my_stories
-          ContactSearchConfiguration.SectionKey.RECENTS -> R.string.ContactsCursorLoader_recent_chats
-          ContactSearchConfiguration.SectionKey.INDIVIDUALS -> R.string.ContactsCursorLoader_contacts
-          ContactSearchConfiguration.SectionKey.GROUPS -> R.string.ContactsCursorLoader_groups
-          ContactSearchConfiguration.SectionKey.GROUP_MEMBERS -> R.string.ContactsCursorLoader_group_members
-          ContactSearchConfiguration.SectionKey.CHATS -> R.string.ContactsCursorLoader__chats
-          ContactSearchConfiguration.SectionKey.MESSAGES -> R.string.ContactsCursorLoader__messages
-          ContactSearchConfiguration.SectionKey.GROUPS_WITH_MEMBERS -> R.string.ContactsCursorLoader_group_members
-          ContactSearchConfiguration.SectionKey.CONTACTS_WITHOUT_THREADS -> R.string.ContactsCursorLoader_contacts
-          ContactSearchConfiguration.SectionKey.CHAT_TYPES -> R.string.ContactsCursorLoader__chat_types
-          else -> error("This section does not support HEADER")
-        }
-      )
-
-      if (model.header.action != null) {
-        headerActionView.visible = true
-        headerActionView.setIconResource(model.header.action.icon)
-        headerActionView.setText(model.header.action.label)
-        headerActionView.setOnClickListener { model.header.action.action.run() }
-      } else {
-        headerActionView.visible = false
-      }
-    }
-  }
-
-  /**
-   * Mapping Model for expandable content rows.
-   */
-  class ExpandModel(val expand: ContactSearchData.Expand) : MappingModel<ExpandModel> {
-    override fun areItemsTheSame(newItem: ExpandModel): Boolean {
-      return expand.contactSearchKey == newItem.expand.contactSearchKey
-    }
-
-    override fun areContentsTheSame(newItem: ExpandModel): Boolean {
-      return areItemsTheSame(newItem)
-    }
-  }
-
-  /**
-   * View Holder for expandable content rows.
-   */
-  private class ExpandViewHolder(itemView: View, private val expandListener: (ContactSearchData.Expand) -> Unit) : MappingViewHolder<ExpandModel>(itemView) {
-    override fun bind(model: ExpandModel) {
-      itemView.setOnClickListener { expandListener.invoke(model.expand) }
-    }
-  }
-
-  /**
-   * Mapping Model for chat types.
-   */
-  class ChatTypeModel(val data: ContactSearchData.ChatTypeRow, val isSelected: Boolean) : MappingModel<ChatTypeModel> {
-    override fun areItemsTheSame(newItem: ChatTypeModel): Boolean = data == newItem.data
-    override fun areContentsTheSame(newItem: ChatTypeModel): Boolean = data == newItem.data && isSelected == newItem.isSelected
-  }
-
-  /**
-   * View Holder for chat types
-   */
-  private class ChatTypeViewHolder(
-    itemView: View,
-    val onClick: OnClickedCallback<ContactSearchData.ChatTypeRow>
-  ) : MappingViewHolder<ChatTypeModel>(itemView) {
-
-    val image: ImageView = itemView.findViewById(R.id.image)
-    val name: TextView = itemView.findViewById(R.id.name)
-    val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
-
-    override fun bind(model: ChatTypeModel) {
-      itemView.setOnClickListener { onClick.onClicked(itemView, model.data, model.isSelected) }
-
-      image.setImageResource(model.data.imageResId)
-
-      if (model.data.chatType == ChatType.INDIVIDUAL) {
-        name.text = context.getString(R.string.ChatFoldersFragment__one_on_one_chats)
-      }
-      if (model.data.chatType == ChatType.GROUPS) {
-        name.text = context.getString(R.string.ChatFoldersFragment__groups)
-      }
-
-      checkbox.isChecked = model.isSelected
-    }
-  }
-
  interface StoryContextMenuCallbacks {
    fun onOpenStorySettings(story: ContactSearchData.Story)
    fun onRemoveGroupStory(story: ContactSearchData.Story, isSelected: Boolean)
@@ -857,5 +130,3 @@ open class ContactSearchAdapter(
    }
  }
 }
-
-private data class RecipientDisplayName(val recipient: Recipient, val displayName: String)
@@ -36,7 +36,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.Story]
-     * Model: [ContactSearchAdapter.StoryModel]
+     * Model: [ContactSearchModels.StoryModel]
     */
    data class Stories(
      val groupStories: Set<ContactSearchData.Story> = emptySet(),
@@ -50,7 +50,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.KnownRecipient]
-     * Model: [ContactSearchAdapter.RecipientModel]
+     * Model: [ContactSearchModels.RecipientModel]
     */
    data class Recents(
      val limit: Int = 25,
@@ -76,12 +76,13 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.KnownRecipient]
-     * Model: [ContactSearchAdapter.RecipientModel]
+     * Model: [ContactSearchModels.RecipientModel]
     */
    data class Individuals(
      val includeSelfMode: RecipientTable.IncludeSelfMode,
      val transportType: TransportType,
      override val includeHeader: Boolean,
+      override val headerAction: HeaderAction? = null,
      override val expandConfig: ExpandConfig? = null,
      val includeLetterHeaders: Boolean = false,
      val pushSearchResultsSortOrder: ContactSearchSortOrder = ContactSearchSortOrder.NATURAL
@@ -92,7 +93,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.KnownRecipient]
-     * Model: [ContactSearchAdapter.RecipientModel]
+     * Model: [ContactSearchModels.RecipientModel]
     */
    data class Groups(
      val includeMms: Boolean = false,
@@ -126,7 +127,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.KnownRecipient]
-     * Model: [ContactSearchAdapter.RecipientModel]
+     * Model: [ContactSearchModels.RecipientModel]
     */
    data class GroupMembers(
      override val includeHeader: Boolean = true,
@@ -139,7 +140,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.GroupWithMembers]
     * Data: [ContactSearchData.GroupWithMembers]
-     * Model: [ContactSearchAdapter.GroupWithMembersModel]
+     * Model: [ContactSearchModels.GroupWithMembersModel]
     */
    data class GroupsWithMembers(
      override val includeHeader: Boolean = true,
@@ -152,7 +153,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.Thread]
     * Data: [ContactSearchData.Thread]
-     * Model: [ContactSearchAdapter.ThreadModel]
+     * Model: [ContactSearchModels.ThreadModel]
     */
    data class Chats(
      val isUnreadOnly: Boolean = false,
@@ -166,7 +167,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.Message]
     * Data: [ContactSearchData.Message]
-     * Model: [ContactSearchAdapter.MessageModel]
+     * Model: [ContactSearchModels.MessageModel]
     */
    data class Messages(
      override val includeHeader: Boolean = true,
@@ -180,7 +181,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.RecipientSearchKey]
     * Data: [ContactSearchData.KnownRecipient]
-     * Model: [ContactSearchAdapter.RecipientModel]
+     * Model: [ContactSearchModels.RecipientModel]
     */
    data class ContactsWithoutThreads(
      override val includeHeader: Boolean = true,
@@ -202,7 +203,7 @@ class ContactSearchConfiguration private constructor(
     *
     * Key: [ContactSearchKey.ChatTypeSearchKey]
     * Data: [ContactSearchData.ChatTypeRow]
-     * Model: [ContactSearchAdapter.ChatTypeModel]
+     * Model: [ContactSearchModels.ChatTypeModel]
     */
    data class ChatTypes(
      override val includeHeader: Boolean = true,
@@ -0,0 +1,869 @@
+/*
+ * Copyright 2026 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.thoughtcrime.securesms.contacts.paged
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import android.view.View
+import android.view.ViewGroup
+import android.widget.CheckBox
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.appcompat.widget.AppCompatImageView
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.res.dimensionResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import com.google.android.material.button.MaterialButton
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.Disposable
+import org.signal.core.ui.compose.FastScrollCharacterProvider
+import org.signal.core.util.BreakIteratorCompat
+import org.signal.core.util.requireDrawable
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.avatar.fallback.FallbackAvatar
+import org.thoughtcrime.securesms.avatar.view.AvatarView
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.components.AvatarImageView
+import org.thoughtcrime.securesms.components.FromTextView
+import org.thoughtcrime.securesms.components.emoji.EmojiUtil
+import org.thoughtcrime.securesms.components.menu.ActionItem
+import org.thoughtcrime.securesms.components.menu.SignalContextMenu
+import org.thoughtcrime.securesms.contacts.LetterHeaderDecoration
+import org.thoughtcrime.securesms.database.model.DistributionListPrivacyMode
+import org.thoughtcrime.securesms.database.model.StoryViewState
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.util.SpanUtil
+import org.thoughtcrime.securesms.util.adapter.mapping.LayoutFactory
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingModelList
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingViewHolder
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingEntryProvider
+import org.thoughtcrime.securesms.util.adapter.mapping.compose.MappingEntryProviderBuilder
+import org.thoughtcrime.securesms.util.visible
+import org.signal.core.ui.R as CoreUiR
+
+/**
+ * Holds the [MappingModel]s and [MappingViewHolder]s used by [ContactSearchAdapter], along with
+ * helpers for registering them on a [MappingAdapter] (RecyclerView) or building a
+ * [MappingEntryProvider] (Compose).
+ */
+object ContactSearchModels {
+
+  fun registerStoryItems(
+    mappingAdapter: MappingAdapter,
+    displayCheckBox: Boolean = false,
+    storyListener: ContactSearchAdapter.OnClickedCallback<ContactSearchData.Story>,
+    storyContextMenuCallbacks: ContactSearchAdapter.StoryContextMenuCallbacks? = null,
+    showStoryRing: Boolean = false
+  ) {
+    mappingAdapter.registerFactory(
+      StoryModel::class.java,
+      LayoutFactory({ StoryViewHolder(it, displayCheckBox, storyListener, storyContextMenuCallbacks, showStoryRing) }, R.layout.contact_search_story_item)
+    )
+  }
+
+  fun registerKnownRecipientItems(
+    mappingAdapter: MappingAdapter,
+    fixedContacts: Set<ContactSearchKey>,
+    displayOptions: ContactSearchAdapter.DisplayOptions,
+    recipientListener: ContactSearchAdapter.OnClickedCallback<ContactSearchData.KnownRecipient>,
+    recipientLongClickCallback: ContactSearchAdapter.OnLongClickedCallback<ContactSearchData.KnownRecipient>,
+    recipientCallButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks
+  ) {
+    mappingAdapter.registerFactory(
+      RecipientModel::class.java,
+      LayoutFactory({
+        KnownRecipientViewHolder(it, fixedContacts, displayOptions, recipientListener, recipientLongClickCallback, recipientCallButtonClickCallbacks)
+      }, R.layout.contact_search_item)
+    )
+  }
+
+  fun registerUnknownRecipientItems(
+    mappingAdapter: MappingAdapter,
+    onClick: ContactSearchAdapter.OnClickedCallback<ContactSearchData.UnknownRecipient>,
+    displayCheckBox: Boolean
+  ) {
+    mappingAdapter.registerFactory(
+      UnknownRecipientModel::class.java,
+      LayoutFactory({ UnknownRecipientViewHolder(it, onClick, displayCheckBox) }, R.layout.contact_search_unknown_item)
+    )
+  }
+
+  fun registerHeaders(mappingAdapter: MappingAdapter) {
+    mappingAdapter.registerFactory(
+      HeaderModel::class.java,
+      LayoutFactory({ HeaderViewHolder(it) }, R.layout.contact_search_section_header)
+    )
+  }
+
+  fun registerExpands(mappingAdapter: MappingAdapter, expandListener: (ContactSearchData.Expand) -> Unit) {
+    mappingAdapter.registerFactory(
+      ExpandModel::class.java,
+      LayoutFactory({ ExpandViewHolder(it, expandListener) }, R.layout.contacts_expand_item)
+    )
+  }
+
+  fun registerChatTypeItems(mappingAdapter: MappingAdapter, chatTypeRowListener: ContactSearchAdapter.OnClickedCallback<ContactSearchData.ChatTypeRow>) {
+    mappingAdapter.registerFactory(
+      ChatTypeModel::class.java,
+      LayoutFactory({ ChatTypeViewHolder(it, chatTypeRowListener) }, R.layout.contact_search_chat_type_item)
+    )
+  }
+
+  /**
+   * Returns a [MappingEntryProvider] containing the same set of view holders registered by the
+   * adapter-side `register*` methods, suitable for use with a Compose `MappingLazyColumn`.
+   * Compose-side callers can merge this with their own provider via
+   * [MappingEntryProviderBuilder.provider].
+   */
+  fun composeEntries(
+    fixedContacts: Set<ContactSearchKey>,
+    displayOptions: ContactSearchAdapter.DisplayOptions,
+    callbacks: ContactSearchAdapter.ClickCallbacks,
+    longClickCallbacks: ContactSearchAdapter.LongClickCallbacks,
+    storyContextMenuCallbacks: ContactSearchAdapter.StoryContextMenuCallbacks? = null,
+    callButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks
+  ): MappingEntryProvider<Any> {
+    return MappingEntryProviderBuilder<Any>().apply {
+      viewHolder<StoryModel>(
+        key = { model -> "StoryModel${model.story.recipient.id}" }
+      ) { ctx ->
+        LayoutFactory(
+          { view -> StoryViewHolder(view, displayOptions.displayCheckBox, callbacks::onStoryClicked, storyContextMenuCallbacks, displayOptions.displayStoryRing) },
+          R.layout.contact_search_story_item
+        ).createViewHolder(FrameLayout(ctx))
+      }
+      entry<RecipientModel>(
+        key = { model -> model.knownRecipient.recipient.id }
+      ) { model ->
+        Column(modifier = Modifier.fillMaxWidth()) {
+          val letter = model.knownRecipient.headerLetter
+          if (letter != null) {
+            Text(
+              text = letter,
+              color = colorResource(R.color.signal_text_primary),
+              fontFamily = FontFamily.SansSerif,
+              fontWeight = FontWeight.Medium,
+              fontSize = 16.sp,
+              modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                  start = dimensionResource(R.dimen.dsl_settings_gutter),
+                  end = dimensionResource(R.dimen.dsl_settings_gutter),
+                  top = 16.dp,
+                  bottom = 12.dp
+                )
+            )
+          }
+          var viewHolder: MappingViewHolder<RecipientModel>? by remember { mutableStateOf(null) }
+          AndroidView(
+            factory = { ctx ->
+              val holder = LayoutFactory(
+                { view -> KnownRecipientViewHolder(view, fixedContacts, displayOptions, callbacks::onKnownRecipientClicked, longClickCallbacks::onKnownRecipientLongClick, callButtonClickCallbacks) },
+                R.layout.contact_search_item
+              ).createViewHolder(FrameLayout(ctx))
+              viewHolder = holder
+              holder.itemView
+            },
+            update = {
+              viewHolder?.bind(model)
+            }
+          )
+        }
+      }
+      viewHolder<UnknownRecipientModel> { ctx ->
+        LayoutFactory(
+          { view -> UnknownRecipientViewHolder(view, callbacks::onUnknownRecipientClicked, displayOptions.displayCheckBox) },
+          R.layout.contact_search_unknown_item
+        ).createViewHolder(FrameLayout(ctx))
+      }
+      viewHolder<HeaderModel>(
+        key = { model -> "HEADER${model.header.sectionKey}" }
+      ) { ctx ->
+        LayoutFactory(
+          { view -> HeaderViewHolder(view) },
+          R.layout.contact_search_section_header
+        ).createViewHolder(FrameLayout(ctx))
+      }
+      viewHolder<ExpandModel>(
+        key = { model -> "EXPAND${model.expand.sectionKey}" }
+      ) { ctx ->
+        LayoutFactory(
+          { view -> ExpandViewHolder(view, callbacks::onExpandClicked) },
+          R.layout.contacts_expand_item
+        ).createViewHolder(FrameLayout(ctx))
+      }
+      viewHolder<ChatTypeModel>(
+        key = { model -> "ChatType${model.data.chatType}" }
+      ) { ctx ->
+        LayoutFactory(
+          { view -> ChatTypeViewHolder(view, callbacks::onChatTypeClicked) },
+          R.layout.contact_search_chat_type_item
+        ).createViewHolder(FrameLayout(ctx))
+      }
+    }.build()
+  }
+
+  fun toMappingModelList(contactSearchData: List<ContactSearchData?>, selection: Set<ContactSearchKey>, arbitraryRepository: ArbitraryRepository?): MappingModelList {
+    return MappingModelList(
+      contactSearchData.filterNotNull().map {
+        when (it) {
+          is ContactSearchData.Story -> StoryModel(it, selection.contains(it.contactSearchKey), SignalStore.story.userHasBeenNotifiedAboutStories)
+          is ContactSearchData.KnownRecipient -> RecipientModel(it, selection.contains(it.contactSearchKey), it.shortSummary)
+          is ContactSearchData.Expand -> ExpandModel(it)
+          is ContactSearchData.Header -> HeaderModel(it)
+          is ContactSearchData.TestRow -> error("This row exists for testing only.")
+          is ContactSearchData.Arbitrary -> arbitraryRepository?.getMappingModel(it) ?: error("This row must be handled manually")
+          is ContactSearchData.Message -> MessageModel(it)
+          is ContactSearchData.Thread -> ThreadModel(it)
+          is ContactSearchData.Empty -> EmptyModel(it)
+          is ContactSearchData.GroupWithMembers -> GroupWithMembersModel(it)
+          is ContactSearchData.UnknownRecipient -> UnknownRecipientModel(it)
+          is ContactSearchData.ChatTypeRow -> ChatTypeModel(it, selection.contains(it.contactSearchKey))
+        }
+      }
+    )
+  }
+
+  /**
+   * Story Model
+   */
+  class StoryModel(val story: ContactSearchData.Story, val isSelected: Boolean, val hasBeenNotified: Boolean) : MappingModel<StoryModel> {
+
+    override fun areItemsTheSame(newItem: StoryModel): Boolean {
+      return newItem.story == story
+    }
+
+    override fun areContentsTheSame(newItem: StoryModel): Boolean {
+      return story.recipient.hasSameContent(newItem.story.recipient) &&
+        isSelected == newItem.isSelected &&
+        hasBeenNotified == newItem.hasBeenNotified
+    }
+
+    override fun getChangePayload(newItem: StoryModel): Any? {
+      return if (story.recipient.hasSameContent(newItem.story.recipient) &&
+        hasBeenNotified == newItem.hasBeenNotified &&
+        newItem.isSelected != isSelected
+      ) {
+        0
+      } else {
+        null
+      }
+    }
+  }
+
+  private class StoryViewHolder(
+    itemView: View,
+    val displayCheckBox: Boolean,
+    val onClick: ContactSearchAdapter.OnClickedCallback<ContactSearchData.Story>,
+    private val storyContextMenuCallbacks: ContactSearchAdapter.StoryContextMenuCallbacks?,
+    private val showStoryRing: Boolean = false
+  ) : MappingViewHolder<StoryModel>(itemView) {
+
+    val avatar: AvatarView = itemView.findViewById(R.id.contact_photo_image)
+    val badge: BadgeImageView = itemView.findViewById(R.id.contact_badge)
+    val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
+    val name: FromTextView = itemView.findViewById(R.id.name)
+    val number: TextView = itemView.findViewById(R.id.number)
+    val groupStoryIndicator: AppCompatImageView = itemView.findViewById(R.id.group_story_indicator)
+    var storyViewState: Observable<StoryViewState>? = null
+    var storyDisposable: Disposable? = null
+
+    override fun bind(model: StoryModel) {
+      itemView.setOnClickListener { onClick.onClicked(avatar, getData(model), isSelected(model)) }
+      bindLongPress(model)
+
+      bindCheckbox(model)
+
+      if (payload.isNotEmpty()) {
+        return
+      }
+
+      storyViewState = if (showStoryRing) StoryViewState.getForRecipientId(getRecipient(model).id) else null
+      avatar.setStoryRingFromState(StoryViewState.NONE)
+      groupStoryIndicator.isActivated = false
+
+      name.setText(getRecipient(model))
+      badge.setBadgeFromRecipient(getRecipient(model))
+
+      bindAvatar(model)
+      bindNumberField(model)
+    }
+
+    fun isSelected(model: StoryModel): Boolean = model.isSelected
+    fun getData(model: StoryModel): ContactSearchData.Story = model.story
+    fun getRecipient(model: StoryModel): Recipient = model.story.recipient
+
+    fun bindNumberField(model: StoryModel) {
+      number.visible = true
+
+      val count = if (model.story.recipient.isGroup) {
+        model.story.recipient.participantIds.size
+      } else {
+        model.story.count
+      }
+
+      if (model.story.recipient.isMyStory && !model.hasBeenNotified) {
+        number.setText(R.string.ContactSearchItems__tap_to_choose_your_viewers)
+        number.setSingleLine(false)
+      } else {
+        number.setSingleLine(true)
+        number.text = when {
+          model.story.recipient.isGroup -> context.resources.getQuantityString(R.plurals.ContactSearchItems__group_story_d_viewers, count, count)
+          model.story.recipient.isMyStory -> {
+            if (model.story.privacyMode == DistributionListPrivacyMode.ALL_EXCEPT) {
+              context.resources.getQuantityString(R.plurals.ContactSearchItems__my_story_s_dot_d_excluded, count, presentPrivacyMode(DistributionListPrivacyMode.ALL), count)
+            } else {
+              context.resources.getQuantityString(R.plurals.ContactSearchItems__my_story_s_dot_d_viewers, count, presentPrivacyMode(model.story.privacyMode), count)
+            }
+          }
+
+          else -> context.resources.getQuantityString(R.plurals.ContactSearchItems__custom_story_d_viewers, count, count)
+        }
+      }
+    }
+
+    fun bindCheckbox(model: StoryModel) {
+      checkbox.visible = displayCheckBox
+      checkbox.isChecked = isSelected(model)
+    }
+
+    fun bindAvatar(model: StoryModel) {
+      if (model.story.recipient.isMyStory) {
+        avatar.setFallbackAvatarProvider(MyStoryFallbackAvatarProvider)
+        avatar.displayProfileAvatar(Recipient.self())
+      } else {
+        avatar.setFallbackAvatarProvider(null)
+        avatar.displayChatAvatar(getRecipient(model))
+      }
+      groupStoryIndicator.visible = showStoryRing && model.story.recipient.isGroup
+    }
+
+    fun bindLongPress(model: StoryModel) {
+      if (storyContextMenuCallbacks == null) {
+        return
+      }
+
+      itemView.setOnLongClickListener {
+        val actions: List<ActionItem> = when {
+          model.story.recipient.isMyStory -> getMyStoryContextMenuActions(model, storyContextMenuCallbacks)
+          model.story.recipient.isGroup -> getGroupStoryContextMenuActions(model, storyContextMenuCallbacks)
+          model.story.recipient.isDistributionList -> getPrivateStoryContextMenuActions(model, storyContextMenuCallbacks)
+          else -> error("Unsupported story target. Not a group or distribution list.")
+        }
+
+        SignalContextMenu.Builder(itemView, itemView.rootView as ViewGroup)
+          .offsetX(context.resources.getDimensionPixelSize(R.dimen.dsl_settings_gutter))
+          .show(actions)
+
+        true
+      }
+    }
+
+    private fun getMyStoryContextMenuActions(model: StoryModel, callbacks: ContactSearchAdapter.StoryContextMenuCallbacks): List<ActionItem> {
+      return listOf(
+        ActionItem(CoreUiR.drawable.symbol_settings_android_24, context.getString(R.string.ContactSearchItems__story_settings)) {
+          callbacks.onOpenStorySettings(model.story)
+        }
+      )
+    }
+
+    private fun getGroupStoryContextMenuActions(model: StoryModel, callbacks: ContactSearchAdapter.StoryContextMenuCallbacks): List<ActionItem> {
+      return listOf(
+        ActionItem(R.drawable.symbol_minus_circle_24, context.getString(R.string.ContactSearchItems__remove_story)) {
+          callbacks.onRemoveGroupStory(model.story, model.isSelected)
+        }
+      )
+    }
+
+    private fun getPrivateStoryContextMenuActions(model: StoryModel, callbacks: ContactSearchAdapter.StoryContextMenuCallbacks): List<ActionItem> {
+      return listOf(
+        ActionItem(CoreUiR.drawable.symbol_settings_android_24, context.getString(R.string.ContactSearchItems__story_settings)) {
+          callbacks.onOpenStorySettings(model.story)
+        },
+        ActionItem(CoreUiR.drawable.symbol_trash_24, context.getString(R.string.ContactSearchItems__delete_story), CoreUiR.color.signal_colorError) {
+          callbacks.onDeletePrivateStory(model.story, model.isSelected)
+        }
+      )
+    }
+
+    private fun presentPrivacyMode(privacyMode: DistributionListPrivacyMode): String {
+      return when (privacyMode) {
+        DistributionListPrivacyMode.ONLY_WITH -> context.getString(R.string.ContactSearchItems__only_share_with)
+        DistributionListPrivacyMode.ALL_EXCEPT -> context.getString(R.string.ChooseInitialMyStoryMembershipFragment__all_except)
+        DistributionListPrivacyMode.ALL -> context.getString(R.string.ChooseInitialMyStoryMembershipFragment__all_signal_connections)
+      }
+    }
+
+    private object MyStoryFallbackAvatarProvider : AvatarImageView.FallbackAvatarProvider {
+      override fun getFallbackAvatar(recipient: Recipient): FallbackAvatar {
+        if (recipient.isSelf) {
+          return FallbackAvatar.Resource.Person(recipient.avatarColor)
+        }
+
+        return super.getFallbackAvatar(recipient)
+      }
+    }
+
+    override fun onAttachedToWindow() {
+      storyDisposable = storyViewState?.observeOn(AndroidSchedulers.mainThread())?.subscribe {
+        avatar.setStoryRingFromState(it)
+        when (it) {
+          StoryViewState.UNVIEWED -> groupStoryIndicator.isActivated = true
+          else -> groupStoryIndicator.isActivated = false
+        }
+      }
+    }
+
+    override fun onDetachedFromWindow() {
+      storyDisposable?.dispose()
+    }
+  }
+
+  /**
+   * Recipient model
+   */
+  class RecipientModel(
+    val knownRecipient: ContactSearchData.KnownRecipient,
+    val isSelected: Boolean,
+    val shortSummary: Boolean
+  ) : MappingModel<RecipientModel>, FastScrollCharacterProvider {
+
+    override fun getFastScrollCharacter(context: Context): CharSequence {
+      val name = if (knownRecipient.recipient.isSelf) {
+        context.getString(R.string.note_to_self)
+      } else {
+        knownRecipient.recipient.getDisplayName(context)
+      }
+
+      val letter: CharSequence = BreakIteratorCompat.getInstance()
+        .apply { setText(name) }
+        .asSequence()
+        .map { charSequence -> charSequence.trim { it <= ' ' } }
+        .filter { it.isNotEmpty() }
+        .mapNotNull {
+          when {
+            EmojiUtil.isEmoji(it.toString()) -> it
+            Character.isLetterOrDigit(it[0]) -> it[0].uppercaseChar().toString()
+            else -> null
+          }
+        }
+        .firstOrNull() ?: "#"
+
+      return letter
+    }
+
+    override fun areItemsTheSame(newItem: RecipientModel): Boolean {
+      return newItem.knownRecipient == knownRecipient
+    }
+
+    override fun areContentsTheSame(newItem: RecipientModel): Boolean {
+      return knownRecipient.recipient.hasSameContent(newItem.knownRecipient.recipient) && isSelected == newItem.isSelected
+    }
+
+    override fun getChangePayload(newItem: RecipientModel): Any? {
+      return if (knownRecipient.recipient.hasSameContent(newItem.knownRecipient.recipient) && newItem.isSelected != isSelected) {
+        0
+      } else {
+        null
+      }
+    }
+  }
+
+  class UnknownRecipientModel(val data: ContactSearchData.UnknownRecipient) : MappingModel<UnknownRecipientModel> {
+    override fun areItemsTheSame(newItem: UnknownRecipientModel): Boolean = true
+
+    override fun areContentsTheSame(newItem: UnknownRecipientModel): Boolean = data == newItem.data
+  }
+
+  private class UnknownRecipientViewHolder(
+    itemView: View,
+    private val onClick: ContactSearchAdapter.OnClickedCallback<ContactSearchData.UnknownRecipient>,
+    private val displayCheckBox: Boolean
+  ) : MappingViewHolder<UnknownRecipientModel>(itemView) {
+
+    private val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
+    private val name: FromTextView = itemView.findViewById(R.id.name)
+    private val number: TextView = itemView.findViewById(R.id.number)
+    private val headerGroup: View = itemView.findViewById(R.id.contact_header)
+    private val headerText: TextView = itemView.findViewById(R.id.section_header)
+
+    override fun bind(model: UnknownRecipientModel) {
+      checkbox.visible = displayCheckBox
+      checkbox.isSelected = false
+      val nameText = when (model.data.mode) {
+        ContactSearchConfiguration.NewRowMode.NEW_CALL -> R.string.contact_selection_list__new_call
+        ContactSearchConfiguration.NewRowMode.NEW_CONVERSATION -> -1
+        ContactSearchConfiguration.NewRowMode.BLOCK -> R.string.contact_selection_list__unknown_contact_block
+        ContactSearchConfiguration.NewRowMode.ADD_TO_GROUP -> R.string.contact_selection_list__unknown_contact_add_to_group
+      }
+
+      if (nameText > 0) {
+        name.setText(nameText)
+        number.text = model.data.query
+        number.visible = true
+      } else {
+        name.text = model.data.query
+        number.visible = false
+      }
+
+      if (model.data.mode == ContactSearchConfiguration.NewRowMode.NEW_CONVERSATION) {
+        headerGroup.visible = true
+        headerText.setText(
+          if (model.data.sectionKey == ContactSearchConfiguration.SectionKey.PHONE_NUMBER) {
+            R.string.FindByActivity__find_by_phone_number
+          } else {
+            R.string.FindByActivity__find_by_username
+          }
+        )
+      } else {
+        headerGroup.visible = false
+      }
+
+      itemView.setOnClickListener {
+        onClick.onClicked(itemView, model.data, false)
+      }
+    }
+  }
+
+  private class KnownRecipientViewHolder(
+    itemView: View,
+    private val fixedContacts: Set<ContactSearchKey>,
+    displayOptions: ContactSearchAdapter.DisplayOptions,
+    onClick: ContactSearchAdapter.OnClickedCallback<ContactSearchData.KnownRecipient>,
+    private val onLongClick: ContactSearchAdapter.OnLongClickedCallback<ContactSearchData.KnownRecipient>,
+    callButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks
+  ) : BaseRecipientViewHolder<RecipientModel, ContactSearchData.KnownRecipient>(itemView, displayOptions, onClick, callButtonClickCallbacks), LetterHeaderDecoration.LetterHeaderItem {
+
+    private var headerLetter: String? = null
+
+    override fun isSelected(model: RecipientModel): Boolean = model.isSelected
+    override fun getData(model: RecipientModel): ContactSearchData.KnownRecipient = model.knownRecipient
+    override fun getRecipient(model: RecipientModel): Recipient = model.knownRecipient.recipient
+    override fun bindNumberField(model: RecipientModel) {
+      val recipient = getRecipient(model)
+      if (model.knownRecipient.sectionKey == ContactSearchConfiguration.SectionKey.GROUP_MEMBERS) {
+        number.text = model.knownRecipient.groupsInCommon.toDisplayText(context, displayGroupsLimit = 2)
+        number.visible = true
+      } else if (model.shortSummary && recipient.isGroup) {
+        val count = recipient.participantIds.size
+        number.text = context.resources.getQuantityString(R.plurals.ContactSearchItems__group_d_members, count, count)
+        number.visible = true
+      } else if (displayOptions.displaySecondaryInformation == ContactSearchAdapter.DisplaySecondaryInformation.ALWAYS && recipient.combinedAboutAndEmoji != null) {
+        number.text = recipient.combinedAboutAndEmoji
+        number.visible = true
+      } else if (displayOptions.displaySecondaryInformation == ContactSearchAdapter.DisplaySecondaryInformation.ALWAYS && recipient.hasE164) {
+        number.visible = false
+      } else {
+        super.bindNumberField(model)
+      }
+
+      headerLetter = model.knownRecipient.headerLetter
+    }
+
+    override fun bindCheckbox(model: RecipientModel) {
+      super.bindCheckbox(model)
+
+      if (fixedContacts.contains(model.knownRecipient.contactSearchKey)) {
+        checkbox.isChecked = true
+      }
+      checkbox.isEnabled = !fixedContacts.contains(model.knownRecipient.contactSearchKey)
+    }
+
+    override fun isEnabled(model: RecipientModel): Boolean {
+      return !fixedContacts.contains(model.knownRecipient.contactSearchKey)
+    }
+
+    override fun getHeaderLetter(): String? {
+      return headerLetter
+    }
+
+    override fun bindLongPress(model: RecipientModel) {
+      itemView.setOnLongClickListener { onLongClick.onLongClicked(itemView, model.knownRecipient) }
+    }
+  }
+
+  /**
+   * Base Recipient View Holder
+   */
+  abstract class BaseRecipientViewHolder<T : MappingModel<T>, D : ContactSearchData>(
+    itemView: View,
+    val displayOptions: ContactSearchAdapter.DisplayOptions,
+    val onClick: ContactSearchAdapter.OnClickedCallback<D>,
+    val onCallButtonClickCallbacks: ContactSearchAdapter.CallButtonClickCallbacks
+  ) : MappingViewHolder<T>(itemView) {
+
+    protected val avatar: AvatarImageView = itemView.findViewById(R.id.contact_photo_image)
+    protected val badge: BadgeImageView = itemView.findViewById(R.id.contact_badge)
+    protected val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
+    protected val name: FromTextView = itemView.findViewById(R.id.name)
+    protected val number: TextView = itemView.findViewById(R.id.number)
+    protected val label: TextView = itemView.findViewById(R.id.label)
+    private val startAudio: View = itemView.findViewById(R.id.start_audio)
+    private val startVideo: View = itemView.findViewById(R.id.start_video)
+
+    override fun bind(model: T) {
+      if (isEnabled(model)) {
+        itemView.setOnClickListener { onClick.onClicked(avatar, getData(model), isSelected(model)) }
+        bindLongPress(model)
+      } else {
+        itemView.setOnClickListener(null)
+      }
+
+      bindCheckbox(model)
+
+      if (payload.isNotEmpty()) {
+        return
+      }
+
+      val recipient = getRecipient(model)
+      val suffix: CharSequence? = if (recipient.isSystemContact && !recipient.showVerified) {
+        SpannableStringBuilder().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)
+        }
+      } else {
+        null
+      }
+      name.setText(recipient, suffix)
+
+      badge.setBadgeFromRecipient(getRecipient(model))
+
+      bindAvatar(model)
+      bindNumberField(model)
+      bindLabelField(model)
+      bindCallButtons(model)
+    }
+
+    protected open fun bindCheckbox(model: T) {
+      checkbox.visible = displayOptions.displayCheckBox
+      checkbox.isChecked = isSelected(model)
+    }
+
+    protected open fun isEnabled(model: T): Boolean = true
+
+    protected open fun bindAvatar(model: T) {
+      avatar.setAvatar(getRecipient(model))
+    }
+
+    protected open fun bindNumberField(model: T) {
+      number.visible = getRecipient(model).isGroup
+      if (getRecipient(model).isGroup) {
+        number.text = getRecipient(model).participantIds
+          .take(10)
+          .map { id ->
+            val recipient = Recipient.resolved(id)
+            RecipientDisplayName(
+              recipient = recipient,
+              displayName = if (recipient.isSelf) {
+                context.getString(R.string.ConversationTitleView_you)
+              } else {
+                recipient.getShortDisplayName(context)
+              }
+            )
+          }
+          .sortedWith(compareBy({ it.recipient.isUnregistered }, { it.recipient.isSelf }, { it.displayName }))
+          .joinToString(", ") { it.displayName }
+      }
+    }
+
+    protected open fun bindLabelField(model: T) {
+      label.visible = false
+    }
+
+    protected open fun bindLongPress(model: T) = Unit
+
+    private fun bindCallButtons(model: T) {
+      val recipient = getRecipient(model)
+      if (displayOptions.displayCallButtons && (recipient.isPushGroup || recipient.isRegistered)) {
+        startVideo.visible = true
+        startAudio.visible = !recipient.isPushGroup
+
+        startVideo.setOnClickListener {
+          onCallButtonClickCallbacks.onVideoCallButtonClicked(recipient)
+        }
+
+        startAudio.setOnClickListener {
+          onCallButtonClickCallbacks.onAudioCallButtonClicked(recipient)
+        }
+      } else {
+        startVideo.visible = false
+        startAudio.visible = false
+      }
+    }
+
+    abstract fun isSelected(model: T): Boolean
+    abstract fun getData(model: T): D
+    abstract fun getRecipient(model: T): Recipient
+  }
+
+  /**
+   * Mapping Model for section headers
+   */
+  class HeaderModel(val header: ContactSearchData.Header) : MappingModel<HeaderModel> {
+    override fun areItemsTheSame(newItem: HeaderModel): Boolean {
+      return header.sectionKey == newItem.header.sectionKey
+    }
+
+    override fun areContentsTheSame(newItem: HeaderModel): Boolean {
+      return areItemsTheSame(newItem) &&
+        header.action?.icon == newItem.header.action?.icon &&
+        header.action?.label == newItem.header.action?.label
+    }
+  }
+
+  /**
+   * Mapping Model for messages
+   */
+  class MessageModel(val message: ContactSearchData.Message) : MappingModel<MessageModel> {
+    override fun areItemsTheSame(newItem: MessageModel): Boolean = message.contactSearchKey == newItem.message.contactSearchKey
+
+    override fun areContentsTheSame(newItem: MessageModel): Boolean {
+      return message == newItem.message
+    }
+  }
+
+  /**
+   * Mapping Model for threads
+   */
+  class ThreadModel(val thread: ContactSearchData.Thread) : MappingModel<ThreadModel> {
+    override fun areItemsTheSame(newItem: ThreadModel): Boolean = thread.contactSearchKey == newItem.thread.contactSearchKey
+    override fun areContentsTheSame(newItem: ThreadModel): Boolean {
+      return thread == newItem.thread
+    }
+  }
+
+  class EmptyModel(val empty: ContactSearchData.Empty) : MappingModel<EmptyModel> {
+    override fun areItemsTheSame(newItem: EmptyModel): Boolean = true
+    override fun areContentsTheSame(newItem: EmptyModel): Boolean = newItem.empty == empty
+  }
+
+  /**
+   * Mapping Model for [ContactSearchData.GroupWithMembers]
+   */
+  class GroupWithMembersModel(val groupWithMembers: ContactSearchData.GroupWithMembers) : MappingModel<GroupWithMembersModel> {
+    override fun areContentsTheSame(newItem: GroupWithMembersModel): Boolean = newItem.groupWithMembers == groupWithMembers
+
+    override fun areItemsTheSame(newItem: GroupWithMembersModel): Boolean = newItem.groupWithMembers.contactSearchKey == groupWithMembers.contactSearchKey
+  }
+
+  /**
+   * View Holder for section headers
+   */
+  private class HeaderViewHolder(itemView: View) : MappingViewHolder<HeaderModel>(itemView) {
+
+    private val headerTextView: TextView = itemView.findViewById(R.id.section_header)
+    private val headerActionView: MaterialButton = itemView.findViewById(R.id.section_header_action)
+
+    override fun bind(model: HeaderModel) {
+      headerTextView.setText(
+        when (model.header.sectionKey) {
+          ContactSearchConfiguration.SectionKey.STORIES -> R.string.ContactsCursorLoader_my_stories
+          ContactSearchConfiguration.SectionKey.RECENTS -> R.string.ContactsCursorLoader_recent_chats
+          ContactSearchConfiguration.SectionKey.INDIVIDUALS -> R.string.ContactsCursorLoader_contacts
+          ContactSearchConfiguration.SectionKey.GROUPS -> R.string.ContactsCursorLoader_groups
+          ContactSearchConfiguration.SectionKey.GROUP_MEMBERS -> R.string.ContactsCursorLoader_group_members
+          ContactSearchConfiguration.SectionKey.CHATS -> R.string.ContactsCursorLoader__chats
+          ContactSearchConfiguration.SectionKey.MESSAGES -> R.string.ContactsCursorLoader__messages
+          ContactSearchConfiguration.SectionKey.GROUPS_WITH_MEMBERS -> R.string.ContactsCursorLoader_group_members
+          ContactSearchConfiguration.SectionKey.CONTACTS_WITHOUT_THREADS -> R.string.ContactsCursorLoader_contacts
+          ContactSearchConfiguration.SectionKey.CHAT_TYPES -> R.string.ContactsCursorLoader__chat_types
+          else -> error("This section does not support HEADER")
+        }
+      )
+
+      if (model.header.action != null) {
+        headerActionView.visible = true
+        headerActionView.setIconResource(model.header.action.icon)
+        headerActionView.setText(model.header.action.label)
+        headerActionView.setOnClickListener { model.header.action.action.run() }
+      } else {
+        headerActionView.visible = false
+      }
+    }
+  }
+
+  /**
+   * Mapping Model for expandable content rows.
+   */
+  class ExpandModel(val expand: ContactSearchData.Expand) : MappingModel<ExpandModel> {
+    override fun areItemsTheSame(newItem: ExpandModel): Boolean {
+      return expand.contactSearchKey == newItem.expand.contactSearchKey
+    }
+
+    override fun areContentsTheSame(newItem: ExpandModel): Boolean {
+      return areItemsTheSame(newItem)
+    }
+  }
+
+  /**
+   * View Holder for expandable content rows.
+   */
+  private class ExpandViewHolder(itemView: View, private val expandListener: (ContactSearchData.Expand) -> Unit) : MappingViewHolder<ExpandModel>(itemView) {
+    override fun bind(model: ExpandModel) {
+      itemView.setOnClickListener { expandListener.invoke(model.expand) }
+    }
+  }
+
+  /**
+   * Mapping Model for chat types.
+   */
+  class ChatTypeModel(val data: ContactSearchData.ChatTypeRow, val isSelected: Boolean) : MappingModel<ChatTypeModel> {
+    override fun areItemsTheSame(newItem: ChatTypeModel): Boolean = data == newItem.data
+    override fun areContentsTheSame(newItem: ChatTypeModel): Boolean = data == newItem.data && isSelected == newItem.isSelected
+  }
+
+  /**
+   * View Holder for chat types
+   */
+  private class ChatTypeViewHolder(
+    itemView: View,
+    val onClick: ContactSearchAdapter.OnClickedCallback<ContactSearchData.ChatTypeRow>
+  ) : MappingViewHolder<ChatTypeModel>(itemView) {
+
+    val image: ImageView = itemView.findViewById(R.id.image)
+    val name: TextView = itemView.findViewById(R.id.name)
+    val checkbox: CheckBox = itemView.findViewById(R.id.check_box)
+
+    override fun bind(model: ChatTypeModel) {
+      itemView.setOnClickListener { onClick.onClicked(itemView, model.data, model.isSelected) }
+
+      image.setImageResource(model.data.imageResId)
+
+      if (model.data.chatType == ChatType.INDIVIDUAL) {
+        name.text = context.getString(R.string.ChatFoldersFragment__one_on_one_chats)
+      }
+      if (model.data.chatType == ChatType.GROUPS) {
+        name.text = context.getString(R.string.ChatFoldersFragment__groups)
+      }
+
+      checkbox.isChecked = model.isSelected
+    }
+  }
+
+  private data class RecipientDisplayName(val recipient: Recipient, val displayName: String)
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jeffrey-signal	792d86f4d8	Bump version to 8.12.1	2026-05-21 17:06:28 -04:00
jeffrey-signal	849856cde8	Update baseline profile.	2026-05-21 16:58:59 -04:00
jeffrey-signal	0646418d4d	Update translations and other static files.	2026-05-21 16:36:58 -04:00
Alex Hart	ed540a2f9e	Update model key entry.	2026-05-21 16:57:14 -03:00
Cody Henthorne	00d86101f5	Fix crash when no recent recipients for profile refresh. Fixes #14791	2026-05-21 15:38:37 -04:00
jeffrey-signal	86e49cd564	Bump version to 8.12.0	2026-05-21 11:12:07 -04:00
jeffrey-signal	21b7d64fcd	Update baseline profile.	2026-05-21 10:50:28 -04:00
jeffrey-signal	42c0044096	Update translations and other static files.	2026-05-21 10:43:07 -04:00
Michelle Tang	f2e8b83604	Update reg v5 UI for quick restore.	2026-05-21 10:38:23 -04:00
Michelle Tang	46b8ac6561	Update reg v5 UI for local backup v1 account.	2026-05-21 10:38:22 -04:00
Michelle Tang	9089cc393e	Update reg v5 UI for locked account.	2026-05-21 10:38:22 -04:00
Alex Hart	2ea59bef68	Handle PniChangeNumber sync on linked devices.	2026-05-21 10:38:22 -04:00
Alex Hart	698fc38aed	Migrate ContactSearch RV to MappingLazyColumn.	2026-05-21 10:38:22 -04:00
Michelle Tang	1d74b00b91	Update local backups reg v5 UI.	2026-05-21 10:38:21 -04:00
Greyson Parrelli	ea861fff49	Remove unnecessary link test.	2026-05-21 10:38:21 -04:00
Cody Henthorne	3b93edcdaf	Add verification code requested alert handling.	2026-05-21 10:38:21 -04:00
Cody Henthorne	6722a28f98	Fix broken linkify unit tests.	2026-05-21 10:38:21 -04:00
Cody Henthorne	16de2efa9e	Fix non-instrumentation variants not being able to run unit tests.	2026-05-21 10:38:20 -04:00
Michelle Tang	4d0919c9a8	Fix minor safety number UI issues.	2026-05-21 10:38:20 -04:00
Greyson Parrelli	01e1cb4d67	Hide keyboard before navigating to chat settings.	2026-05-21 10:38:20 -04:00
Michelle Tang	9d1d5142da	Turn on key transparency.	2026-05-21 10:38:20 -04:00
Alex Hart	49f0c2502b	Add IncomingMessageObserver integration test infrastructure.	2026-05-21 10:38:19 -04:00
Michelle Tang	71ffc36e7f	Update key transparency string.	2026-05-21 10:38:19 -04:00
Greyson Parrelli	5941ff814d	Improve perf for backup info in debuglogs.	2026-05-21 10:38:19 -04:00
Cody Henthorne	1661f3b5f7	Improve profile fetch performance for large groups.	2026-05-21 10:38:18 -04:00
Cody Henthorne	d682de08d2	Sort pinned chats like chat list for shortcut list.	2026-05-21 10:38:18 -04:00
Cody Henthorne	5321f8124a	Add additional download checks to long message text attachments.	2026-05-21 10:38:18 -04:00
Michelle Tang	5052f22d44	Fix local restore crash from file selection.	2026-05-21 10:38:18 -04:00
Michelle Tang	9a8cb1785b	Update reg v5 to use new scaffold.	2026-05-21 10:38:17 -04:00
Cody Henthorne	a2065becdd	fixup! Fix chat bubbles not rendering due to ConstraintLayout bug.	2026-05-21 10:38:17 -04:00
Greyson Parrelli	e85637a58d	Inline useBinaryId remote config.	2026-05-21 10:38:17 -04:00
Greyson Parrelli	73c3d141e3	Remove USE_STRING_ID build config.	2026-05-21 10:38:17 -04:00
jeffrey-signal	eafba156ba	RegistrationScaffold will automatically add top padding when there is no header.	2026-05-21 10:38:17 -04:00
Greyson Parrelli	e6beafd612	Update video demo project to support batch transcoding.	2026-05-21 10:38:16 -04:00
Cody Henthorne	a9649fd017	Enforce change number post registration delay.	2026-05-21 10:38:16 -04:00
adel-signal	4decae274b	Update to RingRTC v2.69.1	2026-05-21 10:38:16 -04:00
gram-signal	dbb83d86e3	Add remote config for requirePqRatio.	2026-05-21 10:38:15 -04:00
Greyson Parrelli	2aa27df95b	Add SignalRestClient.	2026-05-21 10:38:15 -04:00
Cody Henthorne	ec47b83f76	Add sync message encrypt local metric to send flows.	2026-05-21 10:38:15 -04:00
Cody Henthorne	6eea4ba937	Sync release note channel settings with storage service.	2026-05-21 10:38:15 -04:00
Cody Henthorne	9f608337f1	Add friendly toasts for forced remote config refresh.	2026-05-21 10:38:14 -04:00
jeffrey-signal	28edcdf62d	Update regV5 permissions screen to use RegistrationScaffold.	2026-05-21 10:38:14 -04:00
jeffrey-signal	10d969ea35	Add two pane registration scaffold.	2026-05-21 10:38:14 -04:00
jeffrey-signal	38bac16640	Add separate window breakpoints for windows with large widths vs large heights.	2026-05-21 10:36:50 -04:00
jeffrey-signal	93077ac457	Bump version to 8.11.4	2026-05-21 10:24:18 -04:00
jeffrey-signal	c069eb1b88	Update baseline profile.	2026-05-21 10:08:50 -04:00
jeffrey-signal	e5cd18bf1e	Update translations and other static files.	2026-05-21 10:02:16 -04:00
Alex Hart	9e8ae7e26a	Only update desktop activity timestamp for user-initiated sync messages. Co-authored-by: Greyson Parrelli <greyson@signal.org>	2026-05-20 12:42:52 -03:00
Cody Henthorne	00042b9579	Stop screen sharing when disabled from system UI.	2026-05-20 10:06:18 -04:00
Greyson Parrelli	e750b81a31	Disable dnsjava hosts file parsing to fix NPE race condition.	2026-05-20 10:05:39 -04:00
Greyson Parrelli	daec317f52	Don't auto-snooze donation megaphones.	2026-05-20 10:02:35 -04:00
Greyson Parrelli	112514c221	Remove persistent play services error notification. Fixes #14786	2026-05-19 18:05:05 -04:00
Cody Henthorne	f43db8ace0	Fix chat bubbles not rendering due to ConstraintLayout bug. Resolves signalapp/Signal-Android#14774	2026-05-19 18:05:04 -04:00
jeffrey-signal	54df95727b	Bump version to 8.11.3	2026-05-19 12:12:47 -04:00
jeffrey-signal	022b4d9508	Update baseline profile.	2026-05-19 11:58:37 -04:00
jeffrey-signal	7411e725ec	Update translations and other static files.	2026-05-19 11:51:57 -04:00
Alex Hart	83a279f422	Fix display bug with donation type.	2026-05-19 11:42:12 -04:00
Michelle Tang	523066d093	Turn off key transparency.	2026-05-19 10:39:06 -04:00
Michelle Tang	de27343c24	Update key transparency api.	2026-05-19 10:38:08 -04:00
Michelle Tang	c36179293e	Fix missing safety number dialog.	2026-05-18 14:13:59 -04:00
andrew-signal	a79a91bafb	Bump to libsignal v0.94.1	2026-05-18 14:09:27 -04:00
Michelle Tang	13de1ede90	Bump version to 8.11.2	2026-05-15 16:32:54 -04:00
Michelle Tang	b94f420393	Update translations and other static files.	2026-05-15 16:29:45 -04:00
Michelle Tang	4909f130cc	Animate safety number once.	2026-05-15 16:21:45 -04:00
Michelle Tang	0010386b9e	Bump version to 8.11.1	2026-05-14 15:20:56 -04:00
Michelle Tang	02c760945d	Update translations and other static files.	2026-05-14 14:58:23 -04:00
Greyson Parrelli	a0247bb8cc	Add R8 keep rule for org.signal.network to fix Jackson deserialization.	2026-05-14 14:43:36 -04:00
Greyson Parrelli	bcfec5de50	Fix benchmark build.	2026-05-14 14:36:10 -04:00
Cody Henthorne	b2215915ef	Switch to speaker and disable proximity when screen sharing.	2026-05-14 14:36:10 -04:00
Michelle Tang	a0577cd8a2	Bump version to 8.11.0	2026-05-14 13:41:16 -04:00
Michelle Tang	9438646814	Update translations and other static files.	2026-05-14 13:28:56 -04:00
Cody Henthorne	9dcf68581d	Improve screen share capture dimension calculation and use remote config.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	4dd57460de	Move a bunch of files into the network modules.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	6339b38dee	Move RemoteConfigResponse.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	1ce41edc7f	Move CertificateApi and RateLimitChallengeApi deps.	2026-05-14 13:23:16 -04:00
Michelle Tang	3087116618	Move hardcoded reg strings to strings.xml.	2026-05-14 13:23:16 -04:00
Michelle Tang	8fd2065253	Revert "Use adaptive bitmap for dynamic shortcut icons to remove white border." This reverts commit b98452f7b3c99bdf5d4e02ba5129a63846ed563a.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	09822d3ae9	More changes to fix reproducible build issues.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	10b0221e98	Add support for a better AEP character set.	2026-05-14 13:23:16 -04:00
Cody Henthorne	db4def45f9	Reduce blocking calls in happy network call path.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	7dd6829bfa	Automatically snooze megaphones after 3 days.	2026-05-14 13:23:16 -04:00
jeffrey-signal	0e40acfdaa	Fix permissions screen button background elevation for medium/large layout.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	c2e8cec042	Upgrade to SQLCipher 4.16.0	2026-05-14 13:23:16 -04:00
Cody Henthorne	04d2b3b0fe	Improve prekey fetch performance.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	64cdff4638	Remove support for END_SESSION flag.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	59b42ac546	Prompt permission for scheduled sends in media flow.	2026-05-14 13:23:16 -04:00
Cody Henthorne	2e9fd87b06	Reduce thrashing on multiple identity change events.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	0cf7705d4f	Convert megaphone database and repository to kotlin.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	5bcbbdf339	React to availability of Play Services at app start.	2026-05-14 13:23:16 -04:00
jeffrey-signal	a796316ad6	Add click handling for regV5 welcome screen terms button.	2026-05-14 13:23:16 -04:00
Greyson Parrelli	5655fcf973	Create new linkifier. Co-authored-by: Cody Henthorne <cody@signal.org>	2026-05-12 10:05:38 -04:00
Alex Hart	f4bd5fbe8b	Add log line for ignored payment transcript.	2026-05-12 10:53:43 -03:00
Alex Hart	fc448ecb59	Fix call screen crash when participant count drops during speaker view.	2026-05-12 10:47:28 -03:00
Michelle Tang	c4e7841ea3	Fix missing chevron.	2026-05-12 09:46:19 -04:00
Cody Henthorne	e248aee25c	Improve quote query performance for conversation open.	2026-05-11 16:32:26 -04:00
Michelle Tang	7c9268e326	Turn on key transparency.	2026-05-11 16:32:26 -04:00
Alex Hart	8ffc2e7ab8	Handle SUBSCRIPTION_STATUS FetchLatest sync message.	2026-05-11 16:32:26 -04:00
andrew-signal	b4404bb5b4	Bump to libsignal v0.94.0	2026-05-11 16:32:26 -04:00
Michelle Tang	155bba2f81	Expand touch area for key transparency bottom sheet.	2026-05-11 16:32:26 -04:00
adel-signal	639438b863	Update RingRTC version to v2.69.0	2026-05-11 16:32:26 -04:00
Alex Hart	b374a90ffe	Allow donations on linked devices.	2026-05-11 16:32:26 -04:00
Cody Henthorne	d333503838	Migrate to new staging SVR2 enclave.	2026-05-11 16:32:26 -04:00
Alex Hart	2efc115410	Add intrumented testing and a small fix for nav from shortcuts.	2026-05-11 16:32:26 -04:00
Cody Henthorne	43a1c93961	Make network calling infrastructure more coroutine friendly.	2026-05-11 16:32:26 -04:00
Cody Henthorne	39529af4e9	Add screen share to 1:1 and group calling.	2026-05-11 16:32:24 -04:00
Cody Henthorne	d1e2fc0423	Use trimmed video start for thumbnail generation.	2026-05-11 16:31:32 -04:00
Alex Hart	5e4865be73	Add a sync after rotating a subscriber id.	2026-05-11 16:31:32 -04:00
Cody Henthorne	5903c1bbf5	Update reproducible build dependencies.	2026-05-11 16:31:32 -04:00
Alex Hart	45da9fbfc0	Skip slow deviceheuristics for linked devices.	2026-05-11 16:31:32 -04:00
Greyson Parrelli	0dacc4e8dc	Ensure we use the correct index for starred messages.	2026-05-11 16:31:32 -04:00
Cody Henthorne	74935c963a	Refresh thread snippet after view-once attachment is viewed. Co-authored-by: Greyson Parrelli <greyson@signal.org>	2026-05-11 16:31:32 -04:00
Greyson Parrelli	02d245ac0c	Manually draw location on google map.	2026-05-11 16:31:32 -04:00
Cody Henthorne	e100ffbc14	Fix crash during group call peek with unknown members.	2026-05-11 16:31:32 -04:00
Cody Henthorne	d4b3328151	Fix IllegalArgumentException crash when dismissing progress dialog.	2026-05-11 16:31:32 -04:00
Cody Henthorne	0e82a43be7	Cycle use REST fallback remote config to try without it again.	2026-05-11 16:31:32 -04:00
Alex Hart	0960c0dfea	Skip processing backfill requests on linked devices.	2026-05-11 16:31:32 -04:00
jeffrey-signal	8503c49db0	Prevent input panel quote author name from overlapping the dismiss button.	2026-05-11 16:31:32 -04:00
Greyson Parrelli	88b95ce6a5	Ignore lint error in keyboard layout.	2026-05-11 16:31:32 -04:00
Greyson Parrelli	6a1d06486c	Treat unparseable shortcut recipient ids as invalid shortcuts.	2026-05-11 16:31:32 -04:00
Greyson Parrelli	824f0af00b	Reject unknown share-target recipient ids.	2026-05-11 16:31:32 -04:00
Greyson Parrelli	03a6d8c12f	Fix crash when handling malformed URI's.	2026-05-11 16:31:32 -04:00
Alex Hart	f1b231ca38	Wire in inactive-primary websocket alert.	2026-05-11 16:31:31 -04:00
Greyson Parrelli	dca4351b8b	Update some gradle properties that are giving warnings.	2026-05-11 16:31:31 -04:00
andrew-signal	b2a18f7202	Make chat list tap state slightly darker.	2026-05-11 16:31:31 -04:00