Bump version to 6.18.0

Use setAutoEnterEnable to true for smooth transition to
Picture-in-Picture when in gestural navigation mode.

Closes #12878

.github/workflows/android.yml

@@ -14,7 +14,7 @@ permissions:
 jobs:
   build:
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest-8-cores
 
     steps:
     - uses: actions/checkout@v3
@@ -24,15 +24,13 @@ jobs:
       with:
         distribution: temurin
         java-version: 11
+        cache: gradle
 
     - name: Validate Gradle Wrapper
       uses: gradle/wrapper-validation-action@v1
 
-    - name: Remove Android 31 (S)
-      run: $ANDROID_HOME/tools/bin/sdkmanager --uninstall "platforms;android-31"
-
     - name: Build with Gradle
-      run: ./gradlew qa
+      run: ./gradlew qa --parallel
 
     - name: Archive reports for failed build
       if: ${{ failure() }}

app/build.gradle

@@ -11,9 +11,9 @@ plugins {
     id 'kotlin-parcelize'
     id 'com.squareup.wire'
     id 'android-constants'
+    id 'translations'
 }
 
-apply from: 'translations.gradle'
 apply from: 'static-ips.gradle'
 
 protobuf {
@@ -46,8 +46,8 @@ ktlint {
     version = "0.47.1"
 }
 
-def canonicalVersionCode = 1224
-def canonicalVersionName = "6.13.4"
+def canonicalVersionCode = 1243
+def canonicalVersionName = "6.18.0"
 
 def postFixSize = 100
 def abiPostFix = ['universal'   : 0,
@@ -67,10 +67,13 @@ def selectableVariants = [
         'nightlyPnpRelease',
         'playProdDebug',
         'playProdSpinner',
+        'playProdCanary',
         'playProdPerf',
+        'playProdBenchmark',
         'playProdInstrumentation',
         'playProdRelease',
         'playStagingDebug',
+        'playStagingCanary',
         'playStagingSpinner',
         'playStagingPerf',
         'playStagingInstrumentation',
@@ -84,15 +87,15 @@ def selectableVariants = [
 android {
     namespace 'org.thoughtcrime.securesms'
 
-    buildToolsVersion BUILD_TOOLS_VERSION
-    compileSdkVersion COMPILE_SDK_VERSION
+    buildToolsVersion = signalBuildToolsVersion
+    compileSdkVersion = signalCompileSdkVersion
 
     flavorDimensions 'distribution', 'environment'
     useLibrary 'org.apache.http.legacy'
     testBuildType 'instrumentation'
 
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = "11"
         freeCompilerArgs = ["-Xallow-result-return-type"]
     }
 
@@ -139,12 +142,13 @@ android {
 
     compileOptions {
         coreLibraryDesugaringEnabled true
-        sourceCompatibility JAVA_VERSION
-        targetCompatibility JAVA_VERSION
+        sourceCompatibility signalJavaVersion
+        targetCompatibility signalJavaVersion
     }
+
     packagingOptions {
         resources {
-            excludes += ['LICENSE.txt', 'LICENSE', 'NOTICE', 'asm-license.txt', 'META-INF/LICENSE', 'META-INF/NOTICE', 'META-INF/proguard/androidx-annotations.pro', 'libsignal_jni.dylib', 'signal_jni.dll']
+            excludes += ['LICENSE.txt', 'LICENSE', 'NOTICE', 'asm-license.txt', 'META-INF/LICENSE', 'META-INF/LICENSE.md', 'META-INF/NOTICE', 'META-INF/LICENSE-notice.md', 'META-INF/proguard/androidx-annotations.pro', 'libsignal_jni.dylib', 'signal_jni.dll']
         }
     }
 
@@ -162,8 +166,8 @@ android {
         versionCode canonicalVersionCode * postFixSize
         versionName canonicalVersionName
 
-        minSdkVersion MIN_SDK_VERSION
-        targetSdkVersion TARGET_SDK_VERSION
+        minSdkVersion signalMinSdkVersion
+        targetSdkVersion signalTargetSdkVersion
 
         multiDexEnabled true
 
@@ -218,6 +222,7 @@ android {
         buildConfigField "String", "BUILD_VARIANT_TYPE", "\"unset\""
         buildConfigField "String", "BADGE_STATIC_ROOT", "\"https://updates2.signal.org/static/badges/\""
         buildConfigField "String", "STRIPE_PUBLISHABLE_KEY", "\"pk_live_6cmGZopuTsV8novGgJJW9JpC00vLIgtQ1D\""
+        buildConfigField "boolean", "TRACING_ENABLED", "false"
 
         ndk {
             abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
@@ -227,7 +232,7 @@ android {
 
         splits {
             abi {
-                enable true
+                enable !project.hasProperty('generateBaselineProfile')
                 reset()
                 include 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
                 universalApk true
@@ -303,6 +308,25 @@ android {
             minifyEnabled true
             matchingFallbacks = ['debug']
             buildConfigField "String", "BUILD_VARIANT_TYPE", "\"Perf\""
+            buildConfigField "boolean", "TRACING_ENABLED", "true"
+        }
+
+        benchmark {
+            initWith debug
+            isDefault false
+            debuggable false
+            minifyEnabled true
+            matchingFallbacks = ['debug']
+            buildConfigField "String", "BUILD_VARIANT_TYPE", "\"Benchmark\""
+            buildConfigField "boolean", "TRACING_ENABLED", "true"
+        }
+
+        canary {
+            initWith debug
+            isDefault false
+            minifyEnabled false
+            matchingFallbacks = ['debug']
+            buildConfigField "String", "BUILD_VARIANT_TYPE", "\"Canary\""
         }
     }
 
@@ -431,7 +455,7 @@ dependencies {
 
     implementation (libs.androidx.appcompat) {
         version {
-            strictly '1.5.1'
+            strictly '1.6.1'
         }
     }
     implementation libs.androidx.window.window
@@ -439,7 +463,6 @@ dependencies {
     implementation libs.androidx.recyclerview
     implementation libs.material.material
     implementation libs.androidx.legacy.support
-    implementation libs.androidx.cardview
     implementation libs.androidx.preference
     implementation libs.androidx.legacy.preference
     implementation libs.androidx.gridlayout
@@ -462,6 +485,9 @@ dependencies {
     implementation libs.androidx.autofill
     implementation libs.androidx.biometric
     implementation libs.androidx.sharetarget
+    implementation libs.androidx.profileinstaller
+    implementation libs.androidx.asynclayoutinflater
+    implementation libs.androidx.asynclayoutinflater.appcompat
 
     implementation (libs.firebase.messaging) {
         exclude group: 'com.google.firebase', module: 'firebase-core'
@@ -540,9 +566,11 @@ dependencies {
         exclude group: 'org.freemarker'
     }
     implementation libs.dnsjava
+    implementation libs.kotlinx.collections.immutable
 
     spinnerImplementation project(":spinner")
-    spinnerImplementation libs.square.leakcanary
+
+    canaryImplementation libs.square.leakcanary
 
     testImplementation testLibs.junit.junit
     testImplementation testLibs.assertj.core
@@ -569,6 +597,7 @@ dependencies {
     androidTestImplementation testLibs.androidx.test.ext.junit.ktx
     androidTestImplementation testLibs.mockito.android
     androidTestImplementation testLibs.mockito.kotlin
+    androidTestImplementation testLibs.mockk.android
     androidTestImplementation testLibs.square.okhttp.mockserver
 
     instrumentationImplementation (libs.androidx.fragment.testing) {

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

@@ -1,15 +1,40 @@
 package org.thoughtcrime.securesms
 
+import org.signal.core.util.concurrent.SignalExecutors
+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.database.LogDatabase
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencyProvider
 import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
+import org.thoughtcrime.securesms.logging.CustomSignalProtocolLogger
+import org.thoughtcrime.securesms.logging.PersistentLogger
+import org.thoughtcrime.securesms.testing.InMemoryLogger
 
 /**
  * Application context for running instrumentation tests (aka androidTests).
  */
 class SignalInstrumentationApplicationContext : ApplicationContext() {
+
+  val inMemoryLogger: InMemoryLogger = InMemoryLogger()
+
   override fun initializeAppDependencies() {
     val default = ApplicationDependencyProvider(this)
     ApplicationDependencies.init(this, InstrumentationApplicationDependencyProvider(this, default))
+    ApplicationDependencies.getDeadlockDetector().start()
+  }
+
+  override fun initializeLogging() {
+    persistentLogger = PersistentLogger(this)
+
+    Log.initialize({ true }, AndroidLogger(), persistentLogger, inMemoryLogger)
+
+    SignalProtocolLoggerProvider.setProvider(CustomSignalProtocolLogger())
+
+    SignalExecutors.UNBOUNDED.execute {
+      Log.blockUntilAllWritesFinished()
+      LogDatabase.getInstance(this).trimToSize()
+    }
   }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/components/settings/app/changenumber/ChangeNumberViewModelTest.kt

@@ -22,6 +22,7 @@ import org.thoughtcrime.securesms.registration.VerifyAccountRepository
 import org.thoughtcrime.securesms.registration.VerifyResponseProcessor
 import org.thoughtcrime.securesms.testing.Get
 import org.thoughtcrime.securesms.testing.MockProvider
+import org.thoughtcrime.securesms.testing.Post
 import org.thoughtcrime.securesms.testing.Put
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.testing.assertIs
@@ -82,8 +83,10 @@ class ChangeNumberViewModelTest {
     lateinit var setPreKeysRequest: PreKeyState
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { r ->
+      Put("/v2/accounts/number") { r ->
         changeNumberRequest = r.parsedRequestBody()
         MockResponse().success(MockProvider.createVerifyAccountResponse(aci, newPni))
       },
@@ -95,6 +98,7 @@ class ChangeNumberViewModelTest {
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet().resultOrThrow
 
     // THEN
@@ -112,11 +116,14 @@ class ChangeNumberViewModelTest {
     val oldE164 = Recipient.self().requireE164()
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { MockResponse().failure(500) }
+      Put("/v2/accounts/number") { MockResponse().failure(500) }
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     val processor: VerifyResponseProcessor = viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet()
 
     // THEN
@@ -142,12 +149,15 @@ class ChangeNumberViewModelTest {
     val oldE164 = Recipient.self().requireE164()
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { MockResponse().connectionFailure() },
+      Put("/v2/accounts/number") { MockResponse().connectionFailure() },
       Get("/v1/accounts/whoami") { MockResponse().success(MockProvider.createWhoAmIResponse(aci, oldPni, oldE164)) }
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     val processor: VerifyResponseProcessor = viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet()
 
     // THEN
@@ -181,8 +191,10 @@ class ChangeNumberViewModelTest {
     lateinit var setPreKeysRequest: PreKeyState
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { r ->
+      Put("/v2/accounts/number") { r ->
         changeNumberRequest = r.parsedRequestBody()
         MockResponse().timeout()
       },
@@ -195,6 +207,7 @@ class ChangeNumberViewModelTest {
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     val processor: VerifyResponseProcessor = viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet()
 
     // THEN
@@ -225,8 +238,10 @@ class ChangeNumberViewModelTest {
     MockProvider.mockGetRegistrationLockStringFlow(kbsRepository)
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { r ->
+      Put("/v2/accounts/number") { r ->
         changeNumberRequest = r.parsedRequestBody()
         if (changeNumberRequest.registrationLock.isNullOrEmpty()) {
           MockResponse().failure(423, MockProvider.lockedFailure)
@@ -242,6 +257,7 @@ class ChangeNumberViewModelTest {
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet().also { processor ->
       processor.registrationLock() assertIs true
       Recipient.self().requirePni() assertIsNot newPni
@@ -263,8 +279,10 @@ class ChangeNumberViewModelTest {
     lateinit var setPreKeysRequest: PreKeyState
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
       Get("/v1/devices") { MockResponse().success(MockProvider.primaryOnlyDeviceList) },
-      Put("/v1/accounts/number") { r ->
+      Put("/v2/accounts/number") { r ->
         changeNumberRequest = r.parsedRequestBody()
         if (changeNumberRequest.deviceMessages.isEmpty()) {
           MockResponse().failure(
@@ -289,6 +307,7 @@ class ChangeNumberViewModelTest {
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet().resultOrThrow
 
     // THEN
@@ -307,7 +326,9 @@ class ChangeNumberViewModelTest {
     MockProvider.mockGetRegistrationLockStringFlow(kbsRepository)
 
     InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(
-      Put("/v1/accounts/number") { r ->
+      Post("/v1/verification/session") { MockResponse().success(MockProvider.sessionMetadataJson.copy(verified = false)) },
+      Put("/v1/verification/session/${MockProvider.sessionMetadataJson.id}/code") { MockResponse().success(MockProvider.sessionMetadataJson) },
+      Put("/v2/accounts/number") { r ->
         changeNumberRequest = r.parsedRequestBody()
         if (changeNumberRequest.registrationLock.isNullOrEmpty()) {
           MockResponse().failure(423, MockProvider.lockedFailure)
@@ -345,6 +366,7 @@ class ChangeNumberViewModelTest {
     )
 
     // WHEN
+    viewModel.requestVerificationCode(VerifyAccountRepository.Mode.SMS_WITHOUT_LISTENER, null, null).blockingGet().resultOrThrow
     viewModel.verifyCodeWithoutRegistrationLock("123456").blockingGet().also { processor ->
       processor.registrationLock() assertIs true
       Recipient.self().requirePni() assertIsNot newPni

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

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.database
 
 import android.net.Uri
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.FlakyTest
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotEquals
 import org.junit.Before
@@ -34,6 +35,7 @@ class AttachmentTableTest {
     assertEquals(attachment2.fileName, attachment.fileName)
   }
 
+  @FlakyTest
   @Test
   fun givenABlobAndDifferentTransformQuality_whenIInsert2AttachmentsForPreUpload_thenIExpectDifferentFileInfos() {
     val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()
@@ -61,6 +63,7 @@ class AttachmentTableTest {
     assertNotEquals(attachment1Info, attachment2Info)
   }
 
+  @FlakyTest
   @Test
   fun givenIdenticalAttachmentsInsertedForPreUpload_whenIUpdateAttachmentDataAndSpecifyOnlyModifyThisAttachment_thenIExpectDifferentFileInfos() {
     val blob = BlobProvider.getInstance().forData(byteArrayOf(1, 2, 3, 4, 5)).createForSingleSessionInMemory()

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

@@ -0,0 +1,781 @@
+package org.thoughtcrime.securesms.database
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.ringrtc.CallId
+import org.signal.ringrtc.CallManager
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+
+@RunWith(AndroidJUnit4::class)
+class CallTableTest {
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  @Test
+  fun givenACall_whenISetTimestamp_thenIExpectUpdatedTimestamp() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    val now = System.currentTimeMillis()
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      now
+    )
+
+    SignalDatabase.calls.setTimestamp(callId, conversationId, -1L)
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(-1L, call?.timestamp)
+
+    val messageRecord = SignalDatabase.messages.getMessageRecord(call!!.messageId!!)
+    assertEquals(-1L, messageRecord.dateReceived)
+    assertEquals(-1L, messageRecord.dateSent)
+  }
+
+  @Test
+  fun givenPreExistingEvent_whenIDeleteGroupCall_thenIMarkDeletedAndSetTimestamp() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    val now = System.currentTimeMillis()
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      now
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    SignalDatabase.calls.deleteGroupCall(call!!)
+
+    val deletedCall = SignalDatabase.calls.getCallById(callId, conversationId)
+    val oldestDeletionTimestamp = SignalDatabase.calls.getOldestDeletionTimestamp()
+
+    assertEquals(CallTable.Event.DELETE, deletedCall?.event)
+    assertNotEquals(0L, oldestDeletionTimestamp)
+    assertNull(deletedCall!!.messageId)
+  }
+
+  @Test
+  fun givenNoPreExistingEvent_whenIDeleteGroupCall_thenIInsertAndMarkCallDeleted() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertDeletedGroupCallFromSyncEvent(
+      callId,
+      harness.others[0],
+      CallTable.Direction.OUTGOING,
+      System.currentTimeMillis()
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+
+    val oldestDeletionTimestamp = SignalDatabase.calls.getOldestDeletionTimestamp()
+
+    assertEquals(CallTable.Event.DELETE, call?.event)
+    assertNotEquals(oldestDeletionTimestamp, 0)
+    assertNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenIInsertAcceptedOutgoingGroupCall_thenIExpectLocalRingerAndOutgoingRing() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.OUTGOING,
+      System.currentTimeMillis()
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.OUTGOING_RING, call?.event)
+    assertEquals(harness.self.id, call?.ringerRecipient)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenIInsertAcceptedIncomingGroupCall_thenIExpectJoined() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      System.currentTimeMillis()
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.JOINED, call?.event)
+    assertNull(call?.ringerRecipient)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenARingingCall_whenIAcceptedIncomingGroupCall_thenIExpectAccepted() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      ringId = callId,
+      groupRecipientId = harness.others[0],
+      ringerRecipient = harness.others[1],
+      dateReceived = System.currentTimeMillis(),
+      ringState = CallManager.RingUpdate.REQUESTED
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.RINGING, call?.event)
+
+    SignalDatabase.calls.acceptIncomingGroupCall(
+      call!!
+    )
+
+    val acceptedCall = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertEquals(CallTable.Event.ACCEPTED, acceptedCall?.event)
+  }
+
+  @Test
+  fun givenAMissedCall_whenIAcceptedIncomingGroupCall_thenIExpectAccepted() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      ringId = callId,
+      groupRecipientId = harness.others[0],
+      ringerRecipient = harness.others[1],
+      dateReceived = System.currentTimeMillis(),
+      ringState = CallManager.RingUpdate.EXPIRED_REQUEST
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+
+    SignalDatabase.calls.acceptIncomingGroupCall(
+      call!!
+    )
+
+    val acceptedCall = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertEquals(CallTable.Event.ACCEPTED, acceptedCall?.event)
+  }
+
+  @Test
+  fun givenADeclinedCall_whenIAcceptedIncomingGroupCall_thenIExpectAccepted() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      ringId = callId,
+      groupRecipientId = harness.others[0],
+      ringerRecipient = harness.others[1],
+      dateReceived = System.currentTimeMillis(),
+      ringState = CallManager.RingUpdate.DECLINED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.DECLINED, call?.event)
+
+    SignalDatabase.calls.acceptIncomingGroupCall(
+      call!!
+    )
+
+    val acceptedCall = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertEquals(CallTable.Event.ACCEPTED, acceptedCall?.event)
+  }
+
+  @Test
+  fun givenAGenericGroupCall_whenIAcceptedIncomingGroupCall_thenIExpectAccepted() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = System.currentTimeMillis(),
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.GENERIC_GROUP_CALL, call?.event)
+
+    SignalDatabase.calls.acceptIncomingGroupCall(
+      call!!
+    )
+
+    val acceptedCall = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertEquals(CallTable.Event.JOINED, acceptedCall?.event)
+  }
+
+  @Test
+  fun givenNoPriorCallEvent_whenIReceiveAGroupCallUpdateMessage_thenIExpectAGenericGroupCall() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = System.currentTimeMillis(),
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.GENERIC_GROUP_CALL, call?.event)
+  }
+
+  @Test
+  fun givenAPriorCallEventWithNewerTimestamp_whenIReceiveAGroupCallUpdateMessage_thenIExpectAnUpdatedTimestamp() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.getCallById(callId, conversationId).let {
+      assertNotNull(it)
+      assertEquals(now, it?.timestamp)
+    }
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = 1L,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.GENERIC_GROUP_CALL, call?.event)
+    assertEquals(1L, call?.timestamp)
+  }
+
+  @Test
+  fun givenADeletedCallEvent_whenIReceiveARingUpdate_thenIIgnoreTheRingUpdate() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertDeletedGroupCallFromSyncEvent(
+      callId = callId,
+      recipientId = harness.others[0],
+      direction = CallTable.Direction.INCOMING,
+      timestamp = System.currentTimeMillis()
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      ringId = callId,
+      groupRecipientId = harness.others[0],
+      ringerRecipient = harness.others[1],
+      dateReceived = System.currentTimeMillis(),
+      ringState = CallManager.RingUpdate.REQUESTED
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.DELETE, call?.event)
+  }
+
+  @Test
+  fun givenAGenericCallEvent_whenRingRequested_thenISetRingerAndMoveToRingingState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.RINGING, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+  }
+
+  @Test
+  fun givenAJoinedCallEvent_whenRingRequested_thenISetRingerAndMoveToRingingState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      now
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.ACCEPTED, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+  }
+
+  @Test
+  fun givenAGenericCallEvent_whenRingExpired_thenISetRingerAndMoveToMissedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.EXPIRED_REQUEST
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+  }
+
+  @Test
+  fun givenARingingCallEvent_whenRingExpired_thenISetRingerAndMoveToMissedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.EXPIRED_REQUEST
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+  }
+
+  @Test
+  fun givenAJoinedCallEvent_whenRingIsCancelledBecauseUserIsBusyLocally_thenIMoveToAcceptedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      now
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_LOCALLY
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.ACCEPTED, call?.event)
+  }
+
+  @Test
+  fun givenAJoinedCallEvent_whenRingIsCancelledBecauseUserIsBusyOnAnotherDevice_thenIMoveToAcceptedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.INCOMING,
+      now
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.ACCEPTED, call?.event)
+  }
+
+  @Test
+  fun givenARingingCallEvent_whenRingCancelledBecauseUserIsBusyLocally_thenIMoveToMissedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_LOCALLY
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+  }
+
+  @Test
+  fun givenARingingCallEvent_whenRingCancelledBecauseUserIsBusyOnAnotherDevice_thenIMoveToMissedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+  }
+
+  @Test
+  fun givenACallEvent_whenRingIsAcceptedOnAnotherDevice_thenIMoveToAcceptedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val now = System.currentTimeMillis()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromLocalEvent(
+      groupRecipientId = harness.others[0],
+      sender = harness.others[1],
+      timestamp = now,
+      peekGroupCallEraId = "aaa",
+      peekJoinedUuids = emptyList(),
+      isCallFull = false
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.ACCEPTED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.ACCEPTED, call?.event)
+  }
+
+  @Test
+  fun givenARingingCallEvent_whenRingDeclinedOnAnotherDevice_thenIMoveToDeclinedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.DECLINED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.DECLINED, call?.event)
+  }
+
+  @Test
+  fun givenAMissedCallEvent_whenRingDeclinedOnAnotherDevice_thenIMoveToDeclinedState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.EXPIRED_REQUEST
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.DECLINED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.DECLINED, call?.event)
+  }
+
+  @Test
+  fun givenAnOutgoingRingCallEvent_whenRingDeclinedOnAnotherDevice_thenIDoNotChangeState() {
+    val era = "aaa"
+    val callId = CallId.fromEra(era).longValue()
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+
+    SignalDatabase.calls.insertAcceptedGroupCall(
+      callId,
+      harness.others[0],
+      CallTable.Direction.OUTGOING,
+      System.currentTimeMillis()
+    )
+
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.DECLINED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.OUTGOING_RING, call?.event)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingRequested_thenICreateAnEventInTheRingingStateAndSetRinger() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.REQUESTED
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.RINGING, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingExpired_thenICreateAnEventInTheMissedStateAndSetRinger() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.EXPIRED_REQUEST
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingCancelledByRinger_thenICreateAnEventInTheMissedStateAndSetRinger() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.CANCELLED_BY_RINGER
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertEquals(harness.others[1], call?.ringerRecipient)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingCancelledBecauseUserIsBusyLocally_thenICreateAnEventInTheMissedState() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_LOCALLY
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingCancelledBecauseUserIsBusyOnAnotherDevice_thenICreateAnEventInTheMissedState() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.BUSY_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.MISSED, call?.event)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingAcceptedOnAnotherDevice_thenICreateAnEventInTheAcceptedState() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.ACCEPTED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.ACCEPTED, call?.event)
+    assertNotNull(call?.messageId)
+  }
+
+  @Test
+  fun givenNoPriorEvent_whenRingDeclinedOnAnotherDevice_thenICreateAnEventInTheDeclinedState() {
+    val callId = 1L
+    val conversationId = CallTable.CallConversationId.Peer(harness.others[0])
+    SignalDatabase.calls.insertOrUpdateGroupCallFromRingState(
+      callId,
+      harness.others[0],
+      harness.others[1],
+      System.currentTimeMillis(),
+      CallManager.RingUpdate.DECLINED_ON_ANOTHER_DEVICE
+    )
+
+    val call = SignalDatabase.calls.getCallById(callId, conversationId)
+    assertNotNull(call)
+    assertEquals(CallTable.Event.DECLINED, call?.event)
+    assertNotNull(call?.messageId)
+  }
+}

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

@@ -119,7 +119,7 @@ class GroupTableTest {
     }
 
     val groupRecord = groupTable.getGroup(v2Group).get()
-    assertEquals(groupRecord.members.toSet(), setOf(harness.self.id, harness.others[1]))
+    assertEquals(setOf(harness.self.id, harness.others[1]), groupRecord.members.toSet())
   }
 
   @Test

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

@@ -247,6 +247,12 @@ class RecipientTableTest_getAndPossiblyMerge {
       expectSessionSwitchoverEvent(E164_A)
     }
 
+    test("e164 matches, e164 + aci provided") {
+      given(E164_A, PNI_A, null)
+      process(E164_A, null, ACI_A)
+      expect(E164_A, PNI_A, ACI_A)
+    }
+
     test("pni matches, all provided, no pni session") {
       given(null, PNI_A, null)
       process(E164_A, PNI_A, ACI_A)
@@ -359,6 +365,18 @@ class RecipientTableTest_getAndPossiblyMerge {
       expectSessionSwitchoverEvent(id2, E164_B)
     }
 
+    test("steal, e164+pni+aci & e164+aci, no pni provided, change number") {
+      given(E164_A, PNI_A, ACI_A)
+      given(E164_B, null, ACI_B)
+
+      process(E164_A, null, ACI_B)
+
+      expect(null, PNI_A, ACI_A)
+      expect(E164_A, null, ACI_B)
+
+      expectChangeNumberEvent()
+    }
+
     test("merge, e164 & pni & aci, all provided") {
       given(E164_A, null, null)
       given(null, PNI_A, null)

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

@@ -2,20 +2,27 @@ package org.thoughtcrime.securesms.dependencies
 
 import android.app.Application
 import okhttp3.ConnectionSpec
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
 import okhttp3.mockwebserver.Dispatcher
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import okhttp3.mockwebserver.RecordedRequest
+import okio.ByteString
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
+import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.BuildConfig
 import org.thoughtcrime.securesms.KbsEnclave
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess
 import org.thoughtcrime.securesms.push.SignalServiceTrustStore
 import org.thoughtcrime.securesms.recipients.LiveRecipientCache
+import org.thoughtcrime.securesms.testing.Get
 import org.thoughtcrime.securesms.testing.Verb
 import org.thoughtcrime.securesms.testing.runSync
+import org.thoughtcrime.securesms.testing.success
 import org.thoughtcrime.securesms.util.Base64
 import org.whispersystems.signalservice.api.KeyBackupService
 import org.whispersystems.signalservice.api.SignalServiceAccountManager
@@ -47,13 +54,20 @@ class InstrumentationApplicationDependencyProvider(application: Application, def
     runSync {
       webServer = MockWebServer()
       baseUrl = webServer.url("").toString()
+
+      addMockWebRequestHandlers(
+        Get("/v1/websocket/?login=") {
+          MockResponse().success().withWebSocketUpgrade(mockIdentifiedWebSocket)
+        },
+        Get("/v1/websocket", { !it.path.contains("login") }) {
+          MockResponse().success().withWebSocketUpgrade(object : WebSocketListener() {})
+        }
+      )
     }
 
     webServer.setDispatcher(object : Dispatcher() {
       override fun dispatch(request: RecordedRequest): MockResponse {
-        val handler = handlers.firstOrNull {
-          request.method == it.verb && request.path.startsWith("/${it.path}")
-        }
+        val handler = handlers.firstOrNull { it.requestPredicate(request) }
         return handler?.responseFactory?.invoke(request) ?: MockResponse().setResponseCode(500)
       }
     })
@@ -97,18 +111,51 @@ class InstrumentationApplicationDependencyProvider(application: Application, def
     return recipientCache
   }
 
+  class MockWebSocket : WebSocketListener() {
+    private val TAG = "MockWebSocket"
+
+    var webSocket: WebSocket? = null
+      private set
+
+    override fun onOpen(webSocket: WebSocket, response: Response) {
+      Log.i(TAG, "onOpen(${webSocket.hashCode()})")
+      this.webSocket = webSocket
+    }
+
+    override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+      Log.i(TAG, "onClosing(${webSocket.hashCode()}): $code, $reason")
+      this.webSocket = null
+    }
+
+    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+      Log.i(TAG, "onClosed(${webSocket.hashCode()}): $code, $reason")
+      this.webSocket = null
+    }
+
+    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+      Log.w(TAG, "onFailure(${webSocket.hashCode()})", t)
+      this.webSocket = null
+    }
+  }
+
   companion object {
     lateinit var webServer: MockWebServer
       private set
     lateinit var baseUrl: String
       private set
 
+    val mockIdentifiedWebSocket = MockWebSocket()
+
     private val handlers: MutableList<Verb> = mutableListOf()
 
     fun addMockWebRequestHandlers(vararg verbs: Verb) {
       handlers.addAll(verbs)
     }
 
+    fun injectWebSocketMessage(value: ByteString) {
+      mockIdentifiedWebSocket.webSocket!!.send(value)
+    }
+
     fun clearHandlers() {
       handlers.clear()
     }

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

@@ -0,0 +1,375 @@
+package org.thoughtcrime.securesms.messages
+
+import android.database.Cursor
+import android.util.Base64
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.core.util.ThreadUtil
+import org.signal.core.util.readToList
+import org.signal.core.util.select
+import org.signal.core.util.toSingleLine
+import org.signal.core.util.withinTransaction
+import org.thoughtcrime.securesms.database.AttachmentTable
+import org.thoughtcrime.securesms.database.MessageTable
+import org.thoughtcrime.securesms.database.MessageTypes
+import org.thoughtcrime.securesms.database.MessageTypes.isOutgoingMessageType
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.ThreadTable
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.testing.Entry
+import org.thoughtcrime.securesms.testing.InMemoryLogger
+import org.thoughtcrime.securesms.testing.MessageContentFuzzer
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.assertIs
+import org.whispersystems.signalservice.api.crypto.EnvelopeMetadata
+import org.whispersystems.signalservice.api.messages.SignalServiceContent
+import org.whispersystems.signalservice.api.messages.SignalServiceMetadata
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+import org.whispersystems.signalservice.internal.serialize.SignalServiceAddressProtobufSerializer
+import org.whispersystems.signalservice.internal.serialize.SignalServiceMetadataProtobufSerializer
+import org.whispersystems.signalservice.internal.serialize.protos.SignalServiceContentProto
+import java.util.Optional
+
+@RunWith(AndroidJUnit4::class)
+class MessageContentProcessorTestV2 {
+
+  companion object {
+    private val TAGS = listOf(MessageContentProcessor.TAG, MessageContentProcessorV2.TAG, AttachmentTable.TAG)
+
+    private val GENERALIZE_TAG = mapOf(
+      MessageContentProcessor.TAG to "MCP",
+      MessageContentProcessorV2.TAG to "MCP",
+      AttachmentTable.TAG to AttachmentTable.TAG
+    )
+
+    private val IGNORE_MESSAGE_COLUMNS = listOf(
+      MessageTable.DATE_RECEIVED,
+      MessageTable.NOTIFIED_TIMESTAMP,
+      MessageTable.REACTIONS_LAST_SEEN,
+      MessageTable.NOTIFIED
+    )
+
+    private val IGNORE_ATTACHMENT_COLUMNS = listOf(
+      AttachmentTable.UNIQUE_ID,
+      AttachmentTable.TRANSFER_FILE
+    )
+  }
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  private lateinit var processorV1: MessageContentProcessor
+  private lateinit var processorV2: MessageContentProcessorV2
+  private lateinit var testResult: TestResults
+  private var envelopeTimestamp: Long = 0
+
+  @Before
+  fun setup() {
+    processorV1 = MessageContentProcessor(harness.context)
+    processorV2 = MessageContentProcessorV2(harness.context)
+    envelopeTimestamp = System.currentTimeMillis()
+    testResult = TestResults()
+  }
+
+  @Test
+  fun textMessage() {
+    var start = envelopeTimestamp
+
+    val messages: List<TestMessage> = (0 until 100).map {
+      start += 200
+      TestMessage(
+        envelope = MessageContentFuzzer.envelope(start),
+        content = MessageContentFuzzer.fuzzTextMessage(),
+        metadata = MessageContentFuzzer.envelopeMetadata(harness.others[0], harness.self.id),
+        serverDeliveredTimestamp = MessageContentFuzzer.fuzzServerDeliveredTimestamp(start)
+      )
+    }
+
+    testResult.runV2(messages)
+    testResult.runV1(messages)
+
+    testResult.assert()
+  }
+
+  @Test
+  fun mediaMessage() {
+    var start = envelopeTimestamp
+
+    val textMessages: List<TestMessage> = (0 until 10).map {
+      start += 200
+      TestMessage(
+        envelope = MessageContentFuzzer.envelope(start),
+        content = MessageContentFuzzer.fuzzTextMessage(),
+        metadata = MessageContentFuzzer.envelopeMetadata(harness.others[0], harness.self.id),
+        serverDeliveredTimestamp = MessageContentFuzzer.fuzzServerDeliveredTimestamp(start)
+      )
+    }
+
+    val firstBatchMediaMessages: List<TestMessage> = (0 until 10).map {
+      start += 200
+      TestMessage(
+        envelope = MessageContentFuzzer.envelope(start),
+        content = MessageContentFuzzer.fuzzMediaMessageWithBody(textMessages),
+        metadata = MessageContentFuzzer.envelopeMetadata(harness.others[0], harness.self.id),
+        serverDeliveredTimestamp = MessageContentFuzzer.fuzzServerDeliveredTimestamp(start)
+      )
+    }
+
+    val secondBatchNoContentMediaMessages: List<TestMessage> = (0 until 10).map {
+      start += 200
+      TestMessage(
+        envelope = MessageContentFuzzer.envelope(start),
+        content = MessageContentFuzzer.fuzzMediaMessageNoContent(textMessages + firstBatchMediaMessages),
+        metadata = MessageContentFuzzer.envelopeMetadata(harness.others[0], harness.self.id),
+        serverDeliveredTimestamp = MessageContentFuzzer.fuzzServerDeliveredTimestamp(start)
+      )
+    }
+
+    val thirdBatchNoTextMediaMessagesMessages: List<TestMessage> = (0 until 10).map {
+      start += 200
+      TestMessage(
+        envelope = MessageContentFuzzer.envelope(start),
+        content = MessageContentFuzzer.fuzzMediaMessageNoText(textMessages + firstBatchMediaMessages),
+        metadata = MessageContentFuzzer.envelopeMetadata(harness.others[0], harness.self.id),
+        serverDeliveredTimestamp = MessageContentFuzzer.fuzzServerDeliveredTimestamp(start)
+      )
+    }
+
+    testResult.runV2(textMessages + firstBatchMediaMessages + secondBatchNoContentMediaMessages + thirdBatchNoTextMediaMessagesMessages)
+    testResult.runV1(textMessages + firstBatchMediaMessages + secondBatchNoContentMediaMessages + thirdBatchNoTextMediaMessagesMessages)
+
+    testResult.assert()
+  }
+
+  private inner class TestResults {
+
+    private lateinit var v1Logs: List<Entry>
+    private lateinit var v1Messages: List<List<Pair<String, String?>>>
+    private lateinit var v1Attachments: List<List<Pair<String, String?>>>
+    private lateinit var v2Logs: List<Entry>
+    private lateinit var v2Messages: List<List<Pair<String, String?>>>
+    private lateinit var v2Attachments: List<List<Pair<String, String?>>>
+
+    fun runV1(messages: List<TestMessage>) {
+      messages.forEach { (envelope, content, metadata, serverDeliveredTimestamp) ->
+        if (content.hasDataMessage()) {
+          processorV1.process(
+            MessageContentProcessor.MessageState.DECRYPTED_OK,
+            toSignalServiceContent(envelope, content, metadata, serverDeliveredTimestamp),
+            null,
+            envelope.timestamp,
+            -1
+          )
+          ThreadUtil.sleep(1)
+        }
+      }
+
+      v1Logs = harness.inMemoryLogger.logs()
+      harness.inMemoryLogger.clear()
+
+      v1Messages = dumpMessages()
+      v1Attachments = dumpAttachments()
+    }
+
+    fun runV2(messages: List<TestMessage>) {
+      messages.forEach { (envelope, content, metadata, serverDeliveredTimestamp) ->
+        if (content.hasDataMessage()) {
+          processorV2.process(
+            envelope,
+            content,
+            metadata,
+            serverDeliveredTimestamp,
+            false
+          )
+          ThreadUtil.sleep(1)
+        }
+      }
+
+      v2Logs = harness.inMemoryLogger.logs()
+      harness.inMemoryLogger.clear()
+
+      v2Messages = dumpMessages()
+      v2Attachments = dumpAttachments()
+
+      cleanup()
+    }
+
+    fun cleanup() {
+      SignalDatabase.rawDatabase.withinTransaction { db ->
+        SignalDatabase.threads.deleteAllConversations()
+        db.execSQL("DELETE FROM sqlite_sequence WHERE name = '${MessageTable.TABLE_NAME}'")
+        db.execSQL("DELETE FROM sqlite_sequence WHERE name = '${ThreadTable.TABLE_NAME}'")
+        db.execSQL("DELETE FROM sqlite_sequence WHERE name = '${AttachmentTable.TABLE_NAME}'")
+      }
+    }
+
+    fun assert() {
+      v2Logs.zip(v1Logs)
+        .forEach { (v2, v1) ->
+          GENERALIZE_TAG[v2.tag]!!.assertIs(GENERALIZE_TAG[v1.tag]!!)
+
+          if (v2.tag != AttachmentTable.TAG) {
+            if (v2.message?.startsWith("[") == true && v1.message?.startsWith("[") == false) {
+              v2.message!!.substring(v2.message!!.indexOf(']') + 2).assertIs(v1.message)
+            } else {
+              v2.message.assertIs(v1.message)
+            }
+          } else {
+            if (v2.message?.startsWith("Inserted attachment at ID: AttachmentId::") == true) {
+              v2.message!!
+                .substring(0, v2.message!!.indexOf(','))
+                .assertIs(
+                  v1.message!!
+                    .substring(0, v1.message!!.indexOf(','))
+                )
+            } else {
+              v2.message.assertIs(v1.message)
+            }
+          }
+          v2.throwable.assertIs(v1.throwable)
+        }
+
+      v2Messages.zip(v1Messages)
+        .forEach { (v2, v1) ->
+          v2.assertIs(v1)
+        }
+
+      v2Attachments.zip(v1Attachments)
+        .forEach { (v2, v1) ->
+          v2.assertIs(v1)
+        }
+    }
+
+    private fun InMemoryLogger.logs(): List<Entry> {
+      return entries()
+        .filter { TAGS.contains(it.tag) }
+    }
+
+    private fun dumpMessages(): List<List<Pair<String, String?>>> {
+      return dumpTable(MessageTable.TABLE_NAME)
+        .map { row ->
+          val newRow = row.toMutableList()
+          newRow.removeIf { IGNORE_MESSAGE_COLUMNS.contains(it.first) }
+          newRow
+        }
+    }
+
+    private fun dumpAttachments(): List<List<Pair<String, String?>>> {
+      return dumpTable(AttachmentTable.TABLE_NAME)
+        .map { row ->
+          val newRow = row.toMutableList()
+          newRow.removeIf { IGNORE_ATTACHMENT_COLUMNS.contains(it.first) }
+          newRow
+        }
+    }
+
+    private fun dumpTable(table: String): List<List<Pair<String, String?>>> {
+      return SignalDatabase.rawDatabase
+        .select()
+        .from(table)
+        .run()
+        .readToList { cursor ->
+          val map: List<Pair<String, String?>> = cursor.columnNames.map { column ->
+            val index = cursor.getColumnIndex(column)
+            var data: String? = when (cursor.getType(index)) {
+              Cursor.FIELD_TYPE_BLOB -> Base64.encodeToString(cursor.getBlob(index), 0)
+              else -> cursor.getString(index)
+            }
+            if (table == MessageTable.TABLE_NAME && column == MessageTable.TYPE) {
+              data = typeColumnToString(cursor.getLong(index))
+            }
+
+            column to data
+          }
+          map
+        }
+    }
+  }
+
+  private fun toSignalServiceContent(envelope: SignalServiceProtos.Envelope, content: SignalServiceProtos.Content, metadata: EnvelopeMetadata, serverDeliveredTimestamp: Long): SignalServiceContent {
+    val localAddress = SignalServiceAddress(metadata.destinationServiceId, Optional.ofNullable(SignalStore.account().e164))
+    val signalServiceMetadata = SignalServiceMetadata(
+      SignalServiceAddress(metadata.sourceServiceId, Optional.ofNullable(metadata.sourceE164)),
+      metadata.sourceDeviceId,
+      envelope.timestamp,
+      envelope.serverTimestamp,
+      serverDeliveredTimestamp,
+      metadata.sealedSender,
+      envelope.serverGuid,
+      Optional.ofNullable(metadata.groupId),
+      metadata.destinationServiceId.toString()
+    )
+
+    val contentProto = SignalServiceContentProto.newBuilder()
+      .setLocalAddress(SignalServiceAddressProtobufSerializer.toProtobuf(localAddress))
+      .setMetadata(SignalServiceMetadataProtobufSerializer.toProtobuf(signalServiceMetadata))
+      .setContent(content)
+      .build()
+
+    return SignalServiceContent.createFromProto(contentProto)!!
+  }
+
+  fun typeColumnToString(type: Long): String {
+    return """
+      isOutgoingMessageType:${isOutgoingMessageType(type)}
+      isForcedSms:${type and MessageTypes.MESSAGE_FORCE_SMS_BIT != 0L}
+      isDraftMessageType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_DRAFT_TYPE}
+      isFailedMessageType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_SENT_FAILED_TYPE}
+      isPendingMessageType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_OUTBOX_TYPE || type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_SENDING_TYPE}
+      isSentType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_SENT_TYPE}
+      isPendingSmsFallbackType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_PENDING_INSECURE_SMS_FALLBACK || type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_PENDING_SECURE_SMS_FALLBACK}
+      isPendingSecureSmsFallbackType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_PENDING_SECURE_SMS_FALLBACK}
+      isPendingInsecureSmsFallbackType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_PENDING_INSECURE_SMS_FALLBACK}
+      isInboxType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BASE_INBOX_TYPE}
+      isJoinedType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.JOINED_TYPE}
+      isUnsupportedMessageType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.UNSUPPORTED_MESSAGE_TYPE}
+      isInvalidMessageType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.INVALID_MESSAGE_TYPE}
+      isBadDecryptType:${type and MessageTypes.BASE_TYPE_MASK == MessageTypes.BAD_DECRYPT_TYPE}
+      isSecureType:${type and MessageTypes.SECURE_MESSAGE_BIT != 0L}
+      isPushType:${type and MessageTypes.PUSH_MESSAGE_BIT != 0L}
+      isEndSessionType:${type and MessageTypes.END_SESSION_BIT != 0L}
+      isKeyExchangeType:${type and MessageTypes.KEY_EXCHANGE_BIT != 0L}
+      isIdentityVerified:${type and MessageTypes.KEY_EXCHANGE_IDENTITY_VERIFIED_BIT != 0L}
+      isIdentityDefault:${type and MessageTypes.KEY_EXCHANGE_IDENTITY_DEFAULT_BIT != 0L}
+      isCorruptedKeyExchange:${type and MessageTypes.KEY_EXCHANGE_CORRUPTED_BIT != 0L}
+      isInvalidVersionKeyExchange:${type and MessageTypes.KEY_EXCHANGE_INVALID_VERSION_BIT != 0L}
+      isBundleKeyExchange:${type and MessageTypes.KEY_EXCHANGE_BUNDLE_BIT != 0L}
+      isContentBundleKeyExchange:${type and MessageTypes.KEY_EXCHANGE_CONTENT_FORMAT != 0L}
+      isIdentityUpdate:${type and MessageTypes.KEY_EXCHANGE_IDENTITY_UPDATE_BIT != 0L}
+      isRateLimited:${type and MessageTypes.MESSAGE_RATE_LIMITED_BIT != 0L}
+      isExpirationTimerUpdate:${type and MessageTypes.EXPIRATION_TIMER_UPDATE_BIT != 0L}
+      isIncomingAudioCall:${type == MessageTypes.INCOMING_AUDIO_CALL_TYPE}
+      isIncomingVideoCall:${type == MessageTypes.INCOMING_VIDEO_CALL_TYPE}
+      isOutgoingAudioCall:${type == MessageTypes.OUTGOING_AUDIO_CALL_TYPE}
+      isOutgoingVideoCall:${type == MessageTypes.OUTGOING_VIDEO_CALL_TYPE}
+      isMissedAudioCall:${type == MessageTypes.MISSED_AUDIO_CALL_TYPE}
+      isMissedVideoCall:${type == MessageTypes.MISSED_VIDEO_CALL_TYPE}
+      isGroupCall:${type == MessageTypes.GROUP_CALL_TYPE}
+      isGroupUpdate:${type and MessageTypes.GROUP_UPDATE_BIT != 0L}
+      isGroupV2:${type and MessageTypes.GROUP_V2_BIT != 0L}
+      isGroupQuit:${type and MessageTypes.GROUP_LEAVE_BIT != 0L && type and MessageTypes.GROUP_V2_BIT == 0L}
+      isChatSessionRefresh:${type and MessageTypes.ENCRYPTION_REMOTE_FAILED_BIT != 0L}
+      isDuplicateMessageType:${type and MessageTypes.ENCRYPTION_REMOTE_DUPLICATE_BIT != 0L}
+      isDecryptInProgressType:${type and 0x40000000 != 0L}
+      isNoRemoteSessionType:${type and MessageTypes.ENCRYPTION_REMOTE_NO_SESSION_BIT != 0L}
+      isLegacyType:${type and MessageTypes.ENCRYPTION_REMOTE_LEGACY_BIT != 0L || type and MessageTypes.ENCRYPTION_REMOTE_BIT != 0L}
+      isProfileChange:${type == MessageTypes.PROFILE_CHANGE_TYPE}
+      isGroupV1MigrationEvent:${type == MessageTypes.GV1_MIGRATION_TYPE}
+      isChangeNumber:${type == MessageTypes.CHANGE_NUMBER_TYPE}
+      isBoostRequest:${type == MessageTypes.BOOST_REQUEST_TYPE}
+      isThreadMerge:${type == MessageTypes.THREAD_MERGE_TYPE}
+      isSmsExport:${type == MessageTypes.SMS_EXPORT_TYPE}
+      isGroupV2LeaveOnly:${type and MessageTypes.GROUP_V2_LEAVE_BITS == MessageTypes.GROUP_V2_LEAVE_BITS}
+      isSpecialType:${type and MessageTypes.SPECIAL_TYPES_MASK != 0L}
+      isStoryReaction:${type and MessageTypes.SPECIAL_TYPES_MASK == MessageTypes.SPECIAL_TYPE_STORY_REACTION}
+      isGiftBadge:${type and MessageTypes.SPECIAL_TYPES_MASK == MessageTypes.SPECIAL_TYPE_GIFT_BADGE}
+      isPaymentsNotificaiton:${type and MessageTypes.SPECIAL_TYPES_MASK == MessageTypes.SPECIAL_TYPE_PAYMENTS_NOTIFICATION}
+      isRequestToActivatePayments:${type and MessageTypes.SPECIAL_TYPES_MASK == MessageTypes.SPECIAL_TYPE_PAYMENTS_ACTIVATE_REQUEST}
+      isPaymentsActivated:${type and MessageTypes.SPECIAL_TYPES_MASK == MessageTypes.SPECIAL_TYPE_PAYMENTS_ACTIVATED}
+    """.trimIndent().replace(Regex("is[A-Z][A-Za-z0-9]*:false\n?"), "").toSingleLine()
+  }
+}

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

@@ -0,0 +1,209 @@
+package org.thoughtcrime.securesms.messages
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.mockk.every
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.unmockkStatic
+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.util.logging.Log
+import org.signal.libsignal.protocol.ecc.Curve
+import org.signal.libsignal.protocol.ecc.ECKeyPair
+import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.crypto.UnidentifiedAccessUtil
+import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.testing.AliceClient
+import org.thoughtcrime.securesms.testing.BobClient
+import org.thoughtcrime.securesms.testing.Entry
+import org.thoughtcrime.securesms.testing.FakeClientHelpers
+import org.thoughtcrime.securesms.testing.SignalActivityRule
+import org.thoughtcrime.securesms.testing.awaitFor
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
+import org.whispersystems.signalservice.internal.websocket.WebSocketProtos.WebSocketMessage
+import org.whispersystems.signalservice.internal.websocket.WebSocketProtos.WebSocketRequestMessage
+import java.util.regex.Pattern
+import kotlin.random.Random
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+import android.util.Log as AndroidLog
+
+/**
+ * Sends N messages from Bob to Alice to track performance of Alice's processing of messages.
+ */
+// @Ignore("Ignore test in normal testing as it's a performance test with no assertions")
+@RunWith(AndroidJUnit4::class)
+class MessageProcessingPerformanceTest {
+
+  companion object {
+    private val TAG = Log.tag(MessageProcessingPerformanceTest::class.java)
+    private val TIMING_TAG = "TIMING_$TAG".substring(0..23)
+
+    private val DECRYPTION_TIME_PATTERN = Pattern.compile("^Decrypted (?<count>\\d+) envelopes in (?<duration>\\d+) ms.*$")
+  }
+
+  @get:Rule
+  val harness = SignalActivityRule()
+
+  private val trustRoot: ECKeyPair = Curve.generateKeyPair()
+
+  @Before
+  fun setup() {
+    mockkStatic(UnidentifiedAccessUtil::class)
+    every { UnidentifiedAccessUtil.getCertificateValidator() } returns FakeClientHelpers.noOpCertificateValidator
+
+    mockkObject(MessageContentProcessorV2)
+    every { MessageContentProcessorV2.create(harness.application) } returns TimingMessageContentProcessorV2(harness.application)
+  }
+
+  @After
+  fun after() {
+    unmockkStatic(UnidentifiedAccessUtil::class)
+    unmockkStatic(MessageContentProcessorV2::class)
+  }
+
+  @Test
+  fun testPerformance() {
+    val aliceClient = AliceClient(
+      serviceId = harness.self.requireServiceId(),
+      e164 = harness.self.requireE164(),
+      trustRoot = trustRoot
+    )
+
+    val bob = Recipient.resolved(harness.others[0])
+    val bobClient = BobClient(
+      serviceId = bob.requireServiceId(),
+      e164 = bob.requireE164(),
+      identityKeyPair = harness.othersKeys[0],
+      trustRoot = trustRoot,
+      profileKey = ProfileKey(bob.profileKey)
+    )
+
+    // Send the initial messages to get past the prekey phase
+    establishSession(aliceClient, bobClient, bob)
+
+    // Have Bob generate N messages that will be received by Alice
+    val messageCount = 100
+    val envelopes = generateInboundEnvelopes(bobClient, messageCount)
+    val firstTimestamp = envelopes.first().timestamp
+    val lastTimestamp = envelopes.last().timestamp
+
+    // Inject the envelopes into the websocket
+    Thread {
+      for (envelope in envelopes) {
+        Log.i(TIMING_TAG, "Retrieved envelope! ${envelope.timestamp}")
+        InstrumentationApplicationDependencyProvider.injectWebSocketMessage(envelope.toWebSocketPayload())
+      }
+      InstrumentationApplicationDependencyProvider.injectWebSocketMessage(webSocketTombstone())
+    }.start()
+
+    // Wait until they've all been fully decrypted + processed
+    harness
+      .inMemoryLogger
+      .getLockForUntil(TimingMessageContentProcessorV2.endTagPredicate(lastTimestamp))
+      .awaitFor(1.minutes)
+
+    harness.inMemoryLogger.flush()
+
+    // Process logs for timing data
+    val entries = harness.inMemoryLogger.entries()
+
+    // Calculate decryption average
+    val totalDecryptDuration: Long = entries
+      .mapNotNull { entry -> entry.message?.let { DECRYPTION_TIME_PATTERN.matcher(it) } }
+      .filter { it.matches() }
+      .drop(1) // Ignore the first message, which represents the prekey exchange
+      .sumOf { it.group("duration")!!.toLong() }
+
+    AndroidLog.w(TAG, "Decryption: Average runtime: ${totalDecryptDuration.toFloat() / messageCount.toFloat()}ms")
+
+    // Calculate MessageContentProcessor
+
+    val takeLast: List<Entry> = entries.filter { it.tag == TimingMessageContentProcessorV2.TAG }.drop(2)
+    val iterator = takeLast.iterator()
+    var processCount = 0L
+    var processDuration = 0L
+    while (iterator.hasNext()) {
+      val start = iterator.next()
+      val end = iterator.next()
+      processCount++
+      processDuration += end.timestamp - start.timestamp
+    }
+
+    AndroidLog.w(TAG, "MessageContentProcessor.process: Average runtime: ${processDuration.toFloat() / processCount.toFloat()}ms")
+
+    // Calculate messages per second from "retrieving" first message post session initialization to processing last message
+
+    val start = entries.first { it.message == "Retrieved envelope! $firstTimestamp" }
+    val end = entries.first { it.message == TimingMessageContentProcessorV2.endTag(lastTimestamp) }
+
+    val duration = (end.timestamp - start.timestamp).toFloat() / 1000f
+    val messagePerSecond = messageCount.toFloat() / duration
+
+    AndroidLog.w(TAG, "Processing $messageCount messages took ${duration}s or ${messagePerSecond}m/s")
+  }
+
+  private fun establishSession(aliceClient: AliceClient, bobClient: BobClient, bob: Recipient) {
+    // Send message from Bob to Alice (self)
+    val firstPreKeyMessageTimestamp = System.currentTimeMillis()
+    val encryptedEnvelope = bobClient.encrypt(firstPreKeyMessageTimestamp)
+
+    val aliceProcessFirstMessageLatch = harness
+      .inMemoryLogger
+      .getLockForUntil(TimingMessageContentProcessorV2.endTagPredicate(firstPreKeyMessageTimestamp))
+
+    Thread { aliceClient.process(encryptedEnvelope, System.currentTimeMillis()) }.start()
+    aliceProcessFirstMessageLatch.awaitFor(15.seconds)
+
+    // Send message from Alice to Bob
+    val aliceNow = System.currentTimeMillis()
+    bobClient.decrypt(aliceClient.encrypt(aliceNow, bob), aliceNow)
+  }
+
+  private fun generateInboundEnvelopes(bobClient: BobClient, count: Int): List<Envelope> {
+    val envelopes = ArrayList<Envelope>(count)
+    var now = System.currentTimeMillis()
+    for (i in 0..count) {
+      envelopes += bobClient.encrypt(now)
+      now += 3
+    }
+
+    return envelopes
+  }
+
+  private fun webSocketTombstone(): ByteString {
+    return WebSocketMessage
+      .newBuilder()
+      .setRequest(
+        WebSocketRequestMessage.newBuilder()
+          .setVerb("PUT")
+          .setPath("/api/v1/queue/empty")
+      )
+      .build()
+      .toByteArray()
+      .toByteString()
+  }
+
+  private fun Envelope.toWebSocketPayload(): ByteString {
+    return WebSocketMessage
+      .newBuilder()
+      .setType(WebSocketMessage.Type.REQUEST)
+      .setRequest(
+        WebSocketRequestMessage.newBuilder()
+          .setVerb("PUT")
+          .setPath("/api/v1/message")
+          .setId(Random(System.currentTimeMillis()).nextLong())
+          .addHeaders("X-Signal-Timestamp: ${this.timestamp}")
+          .setBody(this.toByteString())
+      )
+      .build()
+      .toByteArray()
+      .toByteString()
+  }
+}

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

@@ -0,0 +1,11 @@
+package org.thoughtcrime.securesms.messages
+
+import org.whispersystems.signalservice.api.crypto.EnvelopeMetadata
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+
+data class TestMessage(
+  val envelope: SignalServiceProtos.Envelope,
+  val content: SignalServiceProtos.Content,
+  val metadata: EnvelopeMetadata,
+  val serverDeliveredTimestamp: Long
+)

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

@@ -0,0 +1,26 @@
+package org.thoughtcrime.securesms.messages
+
+import android.content.Context
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.testing.LogPredicate
+import org.whispersystems.signalservice.api.crypto.EnvelopeMetadata
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+
+class TimingMessageContentProcessorV2(context: Context) : MessageContentProcessorV2(context) {
+  companion object {
+    val TAG = Log.tag(TimingMessageContentProcessorV2::class.java)
+
+    fun endTagPredicate(timestamp: Long): LogPredicate = { entry ->
+      entry.tag == TAG && entry.message == endTag(timestamp)
+    }
+
+    private fun startTag(timestamp: Long) = "$timestamp start"
+    fun endTag(timestamp: Long) = "$timestamp end"
+  }
+
+  override fun process(envelope: SignalServiceProtos.Envelope, content: SignalServiceProtos.Content, metadata: EnvelopeMetadata, serverDeliveredTimestamp: Long, processingEarlyContent: Boolean) {
+    Log.d(TAG, startTag(envelope.timestamp))
+    super.process(envelope, content, metadata, serverDeliveredTimestamp, processingEarlyContent)
+    Log.d(TAG, endTag(envelope.timestamp))
+  }
+}

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

@@ -0,0 +1,59 @@
+package org.thoughtcrime.securesms.testing
+
+import org.signal.core.util.logging.Log
+import org.signal.libsignal.protocol.ecc.ECKeyPair
+import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.messages.protocol.BufferedProtocolStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.testing.FakeClientHelpers.toEnvelope
+import org.whispersystems.signalservice.api.push.ServiceId
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
+
+/**
+ * Welcome to Alice's Client.
+ *
+ * Alice represent the Android instrumentation test user. Unlike [BobClient] much less is needed here
+ * as it can make use of the standard Signal Android App infrastructure.
+ */
+class AliceClient(val serviceId: ServiceId, val e164: String, val trustRoot: ECKeyPair) {
+
+  companion object {
+    val TAG = Log.tag(AliceClient::class.java)
+  }
+
+  private val aliceSenderCertificate = FakeClientHelpers.createCertificateFor(
+    trustRoot = trustRoot,
+    uuid = serviceId.uuid(),
+    e164 = e164,
+    deviceId = 1,
+    identityKey = SignalStore.account().aciIdentityKey.publicKey.publicKey,
+    expires = 31337
+  )
+
+  fun process(envelope: Envelope, serverDeliveredTimestamp: Long) {
+    val start = System.currentTimeMillis()
+    val bufferedStore = BufferedProtocolStore.create()
+    ApplicationDependencies.getIncomingMessageObserver()
+      .processEnvelope(bufferedStore, envelope, serverDeliveredTimestamp)
+      ?.mapNotNull { it.run() }
+      ?.forEach { ApplicationDependencies.getJobManager().add(it) }
+
+    bufferedStore.flushToDisk()
+    val end = System.currentTimeMillis()
+    Log.d(TAG, "${end - start}")
+  }
+
+  fun encrypt(now: Long, destination: Recipient): Envelope {
+    return ApplicationDependencies.getSignalServiceMessageSender().getEncryptedMessage(
+      SignalServiceAddress(destination.requireServiceId(), destination.requireE164()),
+      FakeClientHelpers.getTargetUnidentifiedAccess(ProfileKeyUtil.getSelfProfileKey(), ProfileKey(destination.profileKey), aliceSenderCertificate),
+      1,
+      FakeClientHelpers.encryptedTextMessage(now),
+      false
+    ).toEnvelope(now, destination.requireServiceId())
+  }
+}

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

@@ -0,0 +1,167 @@
+package org.thoughtcrime.securesms.testing
+
+import org.signal.core.util.readToSingleInt
+import org.signal.core.util.select
+import org.signal.libsignal.protocol.IdentityKey
+import org.signal.libsignal.protocol.IdentityKeyPair
+import org.signal.libsignal.protocol.SessionBuilder
+import org.signal.libsignal.protocol.SignalProtocolAddress
+import org.signal.libsignal.protocol.ecc.ECKeyPair
+import org.signal.libsignal.protocol.groups.state.SenderKeyRecord
+import org.signal.libsignal.protocol.state.IdentityKeyStore
+import org.signal.libsignal.protocol.state.PreKeyBundle
+import org.signal.libsignal.protocol.state.PreKeyRecord
+import org.signal.libsignal.protocol.state.SessionRecord
+import org.signal.libsignal.protocol.state.SignedPreKeyRecord
+import org.signal.libsignal.protocol.util.KeyHelper
+import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
+import org.thoughtcrime.securesms.crypto.UnidentifiedAccessUtil
+import org.thoughtcrime.securesms.database.OneTimePreKeyTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.SignedPreKeyTable
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.testing.FakeClientHelpers.toEnvelope
+import org.whispersystems.signalservice.api.SignalServiceAccountDataStore
+import org.whispersystems.signalservice.api.SignalSessionLock
+import org.whispersystems.signalservice.api.crypto.SignalServiceCipher
+import org.whispersystems.signalservice.api.crypto.SignalSessionBuilder
+import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess
+import org.whispersystems.signalservice.api.push.DistributionId
+import org.whispersystems.signalservice.api.push.ServiceId
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+import java.util.Optional
+import java.util.UUID
+import java.util.concurrent.locks.ReentrantLock
+
+/**
+ * Welcome to Bob's Client.
+ *
+ * Bob is a "fake" client that can start a session with the Android instrumentation test user (Alice).
+ *
+ * Bob can create a new session using a prekey bundle created from Alice's prekeys, send a message, decrypt
+ * a return message from Alice, and that'll start a standard Signal session with normal keys/ratcheting.
+ */
+class BobClient(val serviceId: ServiceId, val e164: String, val identityKeyPair: IdentityKeyPair, val trustRoot: ECKeyPair, val profileKey: ProfileKey) {
+
+  private val serviceAddress = SignalServiceAddress(serviceId, e164)
+  private val registrationId = KeyHelper.generateRegistrationId(false)
+  private val aciStore = BobSignalServiceAccountDataStore(registrationId, identityKeyPair)
+  private val senderCertificate = FakeClientHelpers.createCertificateFor(trustRoot, serviceId.uuid(), e164, 1, identityKeyPair.publicKey.publicKey, 31337)
+  private val sessionLock = object : SignalSessionLock {
+    private val lock = ReentrantLock()
+
+    override fun acquire(): SignalSessionLock.Lock {
+      lock.lock()
+      return SignalSessionLock.Lock { lock.unlock() }
+    }
+  }
+
+  /** Inspired by SignalServiceMessageSender#getEncryptedMessage */
+  fun encrypt(now: Long): SignalServiceProtos.Envelope {
+    val envelopeContent = FakeClientHelpers.encryptedTextMessage(now)
+
+    val cipher = SignalServiceCipher(serviceAddress, 1, aciStore, sessionLock, null)
+
+    if (!aciStore.containsSession(getAliceProtocolAddress())) {
+      val sessionBuilder = SignalSessionBuilder(sessionLock, SessionBuilder(aciStore, getAliceProtocolAddress()))
+      sessionBuilder.process(getAlicePreKeyBundle())
+    }
+
+    return cipher.encrypt(getAliceProtocolAddress(), getAliceUnidentifiedAccess(), envelopeContent)
+      .toEnvelope(envelopeContent.content.get().dataMessage.timestamp, getAliceServiceId())
+  }
+
+  fun decrypt(envelope: SignalServiceProtos.Envelope, serverDeliveredTimestamp: Long) {
+    val cipher = SignalServiceCipher(serviceAddress, 1, aciStore, sessionLock, UnidentifiedAccessUtil.getCertificateValidator())
+    cipher.decrypt(envelope, serverDeliveredTimestamp)
+  }
+
+  private fun getAliceServiceId(): ServiceId {
+    return SignalStore.account().requireAci()
+  }
+
+  private fun getAlicePreKeyBundle(): PreKeyBundle {
+    val selfPreKeyId = SignalDatabase.rawDatabase
+      .select(OneTimePreKeyTable.KEY_ID)
+      .from(OneTimePreKeyTable.TABLE_NAME)
+      .where("${OneTimePreKeyTable.ACCOUNT_ID} = ?", getAliceServiceId().toString())
+      .run()
+      .readToSingleInt(-1)
+
+    val selfPreKeyRecord = SignalDatabase.oneTimePreKeys.get(getAliceServiceId(), selfPreKeyId)!!
+
+    val selfSignedPreKeyId = SignalDatabase.rawDatabase
+      .select(SignedPreKeyTable.KEY_ID)
+      .from(SignedPreKeyTable.TABLE_NAME)
+      .where("${SignedPreKeyTable.ACCOUNT_ID} = ?", getAliceServiceId().toString())
+      .run()
+      .readToSingleInt(-1)
+
+    val selfSignedPreKeyRecord = SignalDatabase.signedPreKeys.get(getAliceServiceId(), selfSignedPreKeyId)!!
+
+    return PreKeyBundle(
+      SignalStore.account().registrationId,
+      1,
+      selfPreKeyId,
+      selfPreKeyRecord.keyPair.publicKey,
+      selfSignedPreKeyId,
+      selfSignedPreKeyRecord.keyPair.publicKey,
+      selfSignedPreKeyRecord.signature,
+      getAlicePublicKey()
+    )
+  }
+
+  private fun getAliceProtocolAddress(): SignalProtocolAddress {
+    return SignalProtocolAddress(SignalStore.account().requireAci().toString(), 1)
+  }
+
+  private fun getAlicePublicKey(): IdentityKey {
+    return SignalStore.account().aciIdentityKey.publicKey
+  }
+
+  private fun getAliceProfileKey(): ProfileKey {
+    return ProfileKeyUtil.getSelfProfileKey()
+  }
+
+  private fun getAliceUnidentifiedAccess(): Optional<UnidentifiedAccess> {
+    return FakeClientHelpers.getTargetUnidentifiedAccess(profileKey, getAliceProfileKey(), senderCertificate)
+  }
+
+  private class BobSignalServiceAccountDataStore(private val registrationId: Int, private val identityKeyPair: IdentityKeyPair) : SignalServiceAccountDataStore {
+    private var aliceSessionRecord: SessionRecord? = null
+
+    override fun getIdentityKeyPair(): IdentityKeyPair = identityKeyPair
+
+    override fun getLocalRegistrationId(): Int = registrationId
+    override fun isTrustedIdentity(address: SignalProtocolAddress?, identityKey: IdentityKey?, direction: IdentityKeyStore.Direction?): Boolean = true
+    override fun loadSession(address: SignalProtocolAddress?): SessionRecord = aliceSessionRecord ?: SessionRecord()
+    override fun saveIdentity(address: SignalProtocolAddress?, identityKey: IdentityKey?): Boolean = false
+    override fun storeSession(address: SignalProtocolAddress?, record: SessionRecord?) { aliceSessionRecord = record }
+    override fun getSubDeviceSessions(name: String?): List<Int> = emptyList()
+    override fun containsSession(address: SignalProtocolAddress?): Boolean = aliceSessionRecord != null
+    override fun getIdentity(address: SignalProtocolAddress?): IdentityKey = SignalStore.account().aciIdentityKey.publicKey
+
+    override fun loadPreKey(preKeyId: Int): PreKeyRecord = throw UnsupportedOperationException()
+    override fun storePreKey(preKeyId: Int, record: PreKeyRecord?) = throw UnsupportedOperationException()
+    override fun containsPreKey(preKeyId: Int): Boolean = throw UnsupportedOperationException()
+    override fun removePreKey(preKeyId: Int) = throw UnsupportedOperationException()
+    override fun loadExistingSessions(addresses: MutableList<SignalProtocolAddress>?): MutableList<SessionRecord> = throw UnsupportedOperationException()
+    override fun deleteSession(address: SignalProtocolAddress?) = throw UnsupportedOperationException()
+    override fun deleteAllSessions(name: String?) = throw UnsupportedOperationException()
+    override fun loadSignedPreKey(signedPreKeyId: Int): SignedPreKeyRecord = throw UnsupportedOperationException()
+    override fun loadSignedPreKeys(): MutableList<SignedPreKeyRecord> = throw UnsupportedOperationException()
+    override fun storeSignedPreKey(signedPreKeyId: Int, record: SignedPreKeyRecord?) = throw UnsupportedOperationException()
+    override fun containsSignedPreKey(signedPreKeyId: Int): Boolean = throw UnsupportedOperationException()
+    override fun removeSignedPreKey(signedPreKeyId: Int) = throw UnsupportedOperationException()
+    override fun storeSenderKey(sender: SignalProtocolAddress?, distributionId: UUID?, record: SenderKeyRecord?) = throw UnsupportedOperationException()
+    override fun loadSenderKey(sender: SignalProtocolAddress?, distributionId: UUID?): SenderKeyRecord = throw UnsupportedOperationException()
+    override fun archiveSession(address: SignalProtocolAddress?) = throw UnsupportedOperationException()
+    override fun getAllAddressesWithActiveSessions(addressNames: MutableList<String>?): MutableSet<SignalProtocolAddress> = throw UnsupportedOperationException()
+    override fun getSenderKeySharedWith(distributionId: DistributionId?): MutableSet<SignalProtocolAddress> = throw UnsupportedOperationException()
+    override fun markSenderKeySharedWith(distributionId: DistributionId?, addresses: MutableCollection<SignalProtocolAddress>?) = throw UnsupportedOperationException()
+    override fun clearSenderKeySharedWith(addresses: MutableCollection<SignalProtocolAddress>?) = throw UnsupportedOperationException()
+    override fun isMultiDevice(): Boolean = throw UnsupportedOperationException()
+  }
+}

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

@@ -0,0 +1,79 @@
+package org.thoughtcrime.securesms.testing
+
+import org.signal.libsignal.internal.Native
+import org.signal.libsignal.internal.NativeHandleGuard
+import org.signal.libsignal.metadata.certificate.CertificateValidator
+import org.signal.libsignal.metadata.certificate.SenderCertificate
+import org.signal.libsignal.metadata.certificate.ServerCertificate
+import org.signal.libsignal.protocol.ecc.Curve
+import org.signal.libsignal.protocol.ecc.ECKeyPair
+import org.signal.libsignal.protocol.ecc.ECPublicKey
+import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.database.model.toProtoByteString
+import org.whispersystems.signalservice.api.crypto.ContentHint
+import org.whispersystems.signalservice.api.crypto.EnvelopeContent
+import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess
+import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair
+import org.whispersystems.signalservice.api.push.ServiceId
+import org.whispersystems.signalservice.internal.push.OutgoingPushMessage
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
+import org.whispersystems.util.Base64
+import java.util.Optional
+import java.util.UUID
+
+object FakeClientHelpers {
+
+  val noOpCertificateValidator = object : CertificateValidator(null) {
+    override fun validate(certificate: SenderCertificate, validationTime: Long) = Unit
+  }
+
+  fun createCertificateFor(trustRoot: ECKeyPair, uuid: UUID, e164: String, deviceId: Int, identityKey: ECPublicKey, expires: Long): SenderCertificate {
+    val serverKey: ECKeyPair = Curve.generateKeyPair()
+    NativeHandleGuard(serverKey.publicKey).use { serverPublicGuard ->
+      NativeHandleGuard(trustRoot.privateKey).use { trustRootPrivateGuard ->
+        val serverCertificate = ServerCertificate(Native.ServerCertificate_New(1, serverPublicGuard.nativeHandle(), trustRootPrivateGuard.nativeHandle()))
+        NativeHandleGuard(identityKey).use { identityGuard ->
+          NativeHandleGuard(serverCertificate).use { serverCertificateGuard ->
+            NativeHandleGuard(serverKey.privateKey).use { serverPrivateGuard ->
+              return SenderCertificate(Native.SenderCertificate_New(uuid.toString(), e164, deviceId, identityGuard.nativeHandle(), expires, serverCertificateGuard.nativeHandle(), serverPrivateGuard.nativeHandle()))
+            }
+          }
+        }
+      }
+    }
+  }
+
+  fun getTargetUnidentifiedAccess(myProfileKey: ProfileKey, theirProfileKey: ProfileKey, senderCertificate: SenderCertificate): Optional<UnidentifiedAccess> {
+    val selfUnidentifiedAccessKey = UnidentifiedAccess.deriveAccessKeyFrom(myProfileKey)
+    val themUnidentifiedAccessKey = UnidentifiedAccess.deriveAccessKeyFrom(theirProfileKey)
+
+    return UnidentifiedAccessPair(UnidentifiedAccess(selfUnidentifiedAccessKey, senderCertificate.serialized), UnidentifiedAccess(themUnidentifiedAccessKey, senderCertificate.serialized)).targetUnidentifiedAccess
+  }
+
+  fun encryptedTextMessage(now: Long, message: String = "Test body message"): EnvelopeContent {
+    val content = SignalServiceProtos.Content.newBuilder().apply {
+      setDataMessage(
+        SignalServiceProtos.DataMessage.newBuilder().apply {
+          body = message
+          timestamp = now
+        }
+      )
+    }
+    return EnvelopeContent.encrypted(content.build(), ContentHint.RESENDABLE, Optional.empty())
+  }
+
+  fun OutgoingPushMessage.toEnvelope(timestamp: Long, destination: ServiceId): Envelope {
+    return Envelope.newBuilder()
+      .setType(Envelope.Type.valueOf(this.type))
+      .setSourceDevice(1)
+      .setTimestamp(timestamp)
+      .setServerTimestamp(timestamp + 1)
+      .setDestinationUuid(destination.toString())
+      .setServerGuid(UUID.randomUUID().toString())
+      .setContent(Base64.decode(this.content).toProtoByteString())
+      .setUrgent(true)
+      .setStory(false)
+      .build()
+  }
+}

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

@@ -0,0 +1,97 @@
+package org.thoughtcrime.securesms.testing
+
+import org.signal.core.util.ThreadUtil
+import org.signal.core.util.concurrent.SignalExecutors
+import org.signal.core.util.logging.Log
+import java.util.concurrent.CountDownLatch
+
+typealias LogPredicate = (Entry) -> Boolean
+
+/**
+ * Logging implementation that holds logs in memory as they are added to be retrieve at a later time by a test.
+ * Can also be used for multithreaded synchronization and waiting until certain logs are emitted before continuing
+ * a test.
+ */
+class InMemoryLogger : Log.Logger() {
+
+  private val executor = SignalExecutors.newCachedSingleThreadExecutor("inmemory-logger", ThreadUtil.PRIORITY_BACKGROUND_THREAD)
+  private val predicates = mutableListOf<LogPredicate>()
+  private val logEntries = mutableListOf<Entry>()
+
+  override fun v(tag: String, message: String?, t: Throwable?, keepLonger: Boolean) = add(Verbose(tag, message, t, System.currentTimeMillis()))
+  override fun d(tag: String, message: String?, t: Throwable?, keepLonger: Boolean) = add(Debug(tag, message, t, System.currentTimeMillis()))
+  override fun i(tag: String, message: String?, t: Throwable?, keepLonger: Boolean) = add(Info(tag, message, t, System.currentTimeMillis()))
+  override fun w(tag: String, message: String?, t: Throwable?, keepLonger: Boolean) = add(Warn(tag, message, t, System.currentTimeMillis()))
+  override fun e(tag: String, message: String?, t: Throwable?, keepLonger: Boolean) = add(Error(tag, message, t, System.currentTimeMillis()))
+
+  override fun flush() {
+    val latch = CountDownLatch(1)
+    executor.execute { latch.countDown() }
+    latch.await()
+  }
+
+  fun clear() {
+    val latch = CountDownLatch(1)
+    executor.execute {
+      predicates.clear()
+      logEntries.clear()
+      latch.countDown()
+    }
+    latch.await()
+  }
+
+  private fun add(entry: Entry) {
+    executor.execute {
+      logEntries += entry
+
+      val iterator = predicates.iterator()
+      while (iterator.hasNext()) {
+        val predicate = iterator.next()
+        if (predicate(entry)) {
+          iterator.remove()
+        }
+      }
+    }
+  }
+
+  /** Blocks until a snapshot of all log entries can be taken in a thread-safe way. */
+  fun entries(): List<Entry> {
+    val latch = CountDownLatch(1)
+    var entries: List<Entry> = emptyList()
+    executor.execute {
+      entries = logEntries.toList()
+      latch.countDown()
+    }
+    latch.await()
+    return entries
+  }
+
+  /** Returns a countdown latch that'll fire at a future point when an [Entry] is received that matches the predicate. */
+  fun getLockForUntil(predicate: LogPredicate): CountDownLatch {
+    val latch = CountDownLatch(1)
+    executor.execute {
+      predicates += { entry ->
+        if (predicate(entry)) {
+          latch.countDown()
+          true
+        } else {
+          false
+        }
+      }
+    }
+    return latch
+  }
+}
+
+sealed interface Entry {
+  val tag: String
+  val message: String?
+  val throwable: Throwable?
+  val timestamp: Long
+}
+
+data class Verbose(override val tag: String, override val message: String?, override val throwable: Throwable?, override val timestamp: Long) : Entry
+data class Debug(override val tag: String, override val message: String?, override val throwable: Throwable?, override val timestamp: Long) : Entry
+data class Info(override val tag: String, override val message: String?, override val throwable: Throwable?, override val timestamp: Long) : Entry
+data class Warn(override val tag: String, override val message: String?, override val throwable: Throwable?, override val timestamp: Long) : Entry
+data class Error(override val tag: String, override val message: String?, override val throwable: Throwable?, override val timestamp: Long) : Entry

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

@@ -0,0 +1,234 @@
+package org.thoughtcrime.securesms.testing
+
+import com.google.protobuf.ByteString
+import org.thoughtcrime.securesms.database.model.toProtoByteString
+import org.thoughtcrime.securesms.messages.TestMessage
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.whispersystems.signalservice.api.crypto.EnvelopeMetadata
+import org.whispersystems.signalservice.api.util.UuidUtil
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.AttachmentPointer
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Content
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.DataMessage
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
+import java.util.UUID
+import kotlin.random.Random
+import kotlin.random.nextInt
+import kotlin.time.Duration.Companion.days
+
+/**
+ * Random but deterministic fuzzer for create various message content protos.
+ */
+object MessageContentFuzzer {
+
+  private val mediaTypes = listOf("image/png", "image/jpeg", "image/heic", "image/heif", "image/avif", "image/webp", "image/gif", "audio/aac", "audio/*", "video/mp4", "video/*", "text/x-vcard", "text/x-signal-plain", "application/x-signal-view-once", "*/*", "application/octet-stream")
+  private val emojis = listOf("😂", "❤️", "🔥", "😍", "👀", "🤔", "🙏", "👍", "🤷", "🥺")
+
+  private val random = Random(1)
+
+  /**
+   * Create an [Envelope].
+   */
+  fun envelope(timestamp: Long): Envelope {
+    return Envelope.newBuilder()
+      .setTimestamp(timestamp)
+      .setServerTimestamp(timestamp + 5)
+      .setServerGuidBytes(UuidUtil.toByteString(UUID.randomUUID()))
+      .build()
+  }
+
+  /**
+   * Create metadata to match an [Envelope].
+   */
+  fun envelopeMetadata(source: RecipientId, destination: RecipientId): EnvelopeMetadata {
+    return EnvelopeMetadata(
+      sourceServiceId = Recipient.resolved(source).requireServiceId(),
+      sourceE164 = null,
+      sourceDeviceId = 1,
+      sealedSender = true,
+      groupId = null,
+      destinationServiceId = Recipient.resolved(destination).requireServiceId()
+    )
+  }
+
+  /**
+   * Create a random text message that will contain a body but may also contain
+   * - An expire timer value
+   * - Bold style body ranges
+   */
+  fun fuzzTextMessage(): Content {
+    return Content.newBuilder()
+      .setDataMessage(
+        DataMessage.newBuilder().run {
+          body = string()
+          if (random.nextBoolean()) {
+            expireTimer = random.nextInt(0..28.days.inWholeSeconds.toInt())
+          }
+          if (random.nextBoolean()) {
+            addBodyRanges(
+              SignalServiceProtos.BodyRange.newBuilder().run {
+                start = 0
+                length = 1
+                style = SignalServiceProtos.BodyRange.Style.BOLD
+                build()
+              }
+            )
+          }
+          build()
+        }
+      )
+      .build()
+  }
+
+  /**
+   * Create a random media message that may be:
+   * - A text body
+   * - A text body with a quote that references an existing message
+   * - A text body with a quote that references a non existing message
+   * - A message with 0-2 attachment pointers and may contain a text body
+   */
+  fun fuzzMediaMessageWithBody(quoteAble: List<TestMessage> = emptyList()): Content {
+    return Content.newBuilder()
+      .setDataMessage(
+        DataMessage.newBuilder().run {
+          if (random.nextBoolean()) {
+            body = string()
+          }
+
+          if (random.nextBoolean() && quoteAble.isNotEmpty()) {
+            body = string()
+            val quoted = quoteAble.random(random)
+            quote = DataMessage.Quote.newBuilder().run {
+              id = quoted.envelope.timestamp
+              authorUuid = quoted.metadata.sourceServiceId.toString()
+              text = quoted.content.dataMessage.body
+              addAllAttachments(quoted.content.dataMessage.attachmentsList)
+              addAllBodyRanges(quoted.content.dataMessage.bodyRangesList)
+              type = DataMessage.Quote.Type.NORMAL
+              build()
+            }
+          }
+
+          if (random.nextFloat() < 0.1 && quoteAble.isNotEmpty()) {
+            val quoted = quoteAble.random(random)
+            quote = DataMessage.Quote.newBuilder().run {
+              id = random.nextLong(quoted.envelope.timestamp - 1000000, quoted.envelope.timestamp)
+              authorUuid = quoted.metadata.sourceServiceId.toString()
+              text = quoted.content.dataMessage.body
+              build()
+            }
+          }
+
+          if (random.nextFloat() < 0.25) {
+            val total = random.nextInt(1, 2)
+            (0..total).forEach { _ -> addAttachments(attachmentPointer()) }
+          }
+
+          build()
+        }
+      )
+      .build()
+  }
+
+  /**
+   * Creates a random media message that contains no traditional media content. It may be:
+   * - A reaction to a prior message
+   */
+  fun fuzzMediaMessageNoContent(previousMessages: List<TestMessage> = emptyList()): Content {
+    return Content.newBuilder()
+      .setDataMessage(
+        DataMessage.newBuilder().run {
+          if (random.nextFloat() < 0.25) {
+            val reactTo = previousMessages.random(random)
+            reaction = DataMessage.Reaction.newBuilder().run {
+              emoji = emojis.random(random)
+              remove = false
+              targetAuthorUuid = reactTo.metadata.sourceServiceId.toString()
+              targetSentTimestamp = reactTo.envelope.timestamp
+              build()
+            }
+          }
+
+          build()
+        }
+      ).build()
+  }
+
+  /**
+   * Create a random media message that can never contain a text body. It may be:
+   * - A sticker
+   */
+  fun fuzzMediaMessageNoText(previousMessages: List<TestMessage> = emptyList()): Content {
+    return Content.newBuilder()
+      .setDataMessage(
+        DataMessage.newBuilder().run {
+          if (random.nextFloat() < 0.9) {
+            sticker = DataMessage.Sticker.newBuilder().run {
+              packId = byteString(length = 24)
+              packKey = byteString(length = 128)
+              stickerId = random.nextInt()
+              data = attachmentPointer()
+              emoji = emojis.random(random)
+              build()
+            }
+          }
+          build()
+        }
+      ).build()
+  }
+
+  /**
+   * Generate a random [String].
+   */
+  fun string(length: Int = 10, allowNullString: Boolean = false): String {
+    var string = ""
+
+    if (allowNullString && random.nextBoolean()) {
+      return string
+    }
+
+    for (i in 0 until length) {
+      string += random.nextInt(65..90).toChar()
+    }
+    return string
+  }
+
+  /**
+   * Generate a random [ByteString].
+   */
+  fun byteString(length: Int = 512): ByteString {
+    return random.nextBytes(length).toProtoByteString()
+  }
+
+  /**
+   * Generate a random [AttachmentPointer].
+   */
+  fun attachmentPointer(): AttachmentPointer {
+    return AttachmentPointer.newBuilder().run {
+      cdnKey = string()
+      contentType = mediaTypes.random(random)
+      key = byteString()
+      size = random.nextInt(1024 * 1024 * 50)
+      thumbnail = byteString()
+      digest = byteString()
+      fileName = string()
+      flags = 0
+      width = random.nextInt(until = 1024)
+      height = random.nextInt(until = 1024)
+      caption = string(allowNullString = true)
+      blurHash = string()
+      uploadTimestamp = random.nextLong()
+      cdnNumber = 1
+
+      build()
+    }
+  }
+
+  /**
+   * Creates a server delivered timestamp that is always later than the envelope and server "received" timestamp.
+   */
+  fun fuzzServerDeliveredTimestamp(envelopeTimestamp: Long): Long {
+    return envelopeTimestamp + 10
+  }
+}

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

@@ -32,6 +32,7 @@ import org.whispersystems.signalservice.internal.push.PreKeyEntity
 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
@@ -56,6 +57,16 @@ object MockProvider {
     )
   }
 
+  val sessionMetadataJson = RegistrationSessionMetadataJson(
+    id = "asdfasdfasdfasdf",
+    nextCall = null,
+    nextSms = null,
+    nextVerificationAttempt = null,
+    allowedToRequestCode = true,
+    requestedInformation = emptyList(),
+    verified = true
+  )
+
   fun createVerifyAccountResponse(aci: ServiceId, newPni: ServiceId): VerifyAccountResponse {
     return VerifyAccountResponse().apply {
       uuid = aci.toString()

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

@@ -7,15 +7,20 @@ import org.thoughtcrime.securesms.util.JsonUtils
 import java.util.concurrent.TimeUnit
 
 typealias ResponseFactory = (request: RecordedRequest) -> MockResponse
+typealias RequestPredicate = (request: RecordedRequest) -> Boolean
 
 /**
  * Represent an HTTP verb for mocking web requests.
  */
-sealed class Verb(val verb: String, val path: String, val responseFactory: ResponseFactory)
+sealed class Verb(val requestPredicate: RequestPredicate, val responseFactory: ResponseFactory)
 
-class Get(path: String, responseFactory: ResponseFactory) : Verb("GET", path, responseFactory)
+class Get(path: String, predicate: RequestPredicate, responseFactory: ResponseFactory) : Verb(defaultRequestPredicate("GET", path, predicate), responseFactory) {
+  constructor(path: String, responseFactory: ResponseFactory) : this(path, { true }, responseFactory)
+}
 
-class Put(path: String, responseFactory: ResponseFactory) : Verb("PUT", path, responseFactory)
+class Put(path: String, responseFactory: ResponseFactory) : Verb(defaultRequestPredicate("PUT", path), responseFactory)
+
+class Post(path: String, responseFactory: ResponseFactory) : Verb(defaultRequestPredicate("POST", path), responseFactory)
 
 fun MockResponse.success(response: Any? = null): MockResponse {
   return setResponseCode(200).apply {
@@ -46,3 +51,7 @@ inline fun <reified T> RecordedRequest.parsedRequestBody(): T {
   val bodyString = String(body.readByteArray())
   return JsonUtils.fromJson(bodyString, T::class.java)
 }
+
+private fun defaultRequestPredicate(verb: String, path: String, predicate: RequestPredicate = { true }): RequestPredicate = { request ->
+  request.method == verb && request.path.startsWith("/$path") && predicate(request)
+}

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

@@ -11,7 +11,9 @@ import androidx.test.platform.app.InstrumentationRegistry
 import okhttp3.mockwebserver.MockResponse
 import org.junit.rules.ExternalResource
 import org.signal.libsignal.protocol.IdentityKey
+import org.signal.libsignal.protocol.IdentityKeyPair
 import org.signal.libsignal.protocol.SignalProtocolAddress
+import org.thoughtcrime.securesms.SignalInstrumentationApplicationContext
 import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
 import org.thoughtcrime.securesms.crypto.MasterSecretUtil
 import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
@@ -20,7 +22,6 @@ import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor
 import org.thoughtcrime.securesms.profiles.ProfileName
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
@@ -54,18 +55,23 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
     private set
   lateinit var others: List<RecipientId>
     private set
+  lateinit var othersKeys: List<IdentityKeyPair>
+
+  val inMemoryLogger: InMemoryLogger
+    get() = (application as SignalInstrumentationApplicationContext).inMemoryLogger
 
   override fun before() {
     context = InstrumentationRegistry.getInstrumentation().targetContext
     self = setupSelf()
-    others = setupOthers()
+
+    val setupOthers = setupOthers()
+    others = setupOthers.first
+    othersKeys = setupOthers.second
 
     InstrumentationApplicationDependencyProvider.clearHandlers()
   }
 
   private fun setupSelf(): Recipient {
-    DeviceTransferBlockingInterceptor.getInstance().blockNetwork()
-
     PreferenceManager.getDefaultSharedPreferences(application).edit().putBoolean("pref_prompted_push_registration", true).commit()
     val masterSecret = MasterSecretUtil.generateMasterSecret(application, MasterSecretUtil.UNENCRYPTED_PASSPHRASE)
     MasterSecretUtil.generateAsymmetricMasterSecret(application, masterSecret)
@@ -83,22 +89,27 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
         registrationId = registrationRepository.registrationId,
         profileKey = registrationRepository.getProfileKey("+15555550101"),
         fcmToken = null,
-        pniRegistrationId = registrationRepository.pniRegistrationId
+        pniRegistrationId = registrationRepository.pniRegistrationId,
+        recoveryPassword = "asdfasdfasdfasdf"
       ),
-      VerifyResponse(VerifyAccountResponse(UUID.randomUUID().toString(), UUID.randomUUID().toString(), false), null, null)
+      VerifyResponse(VerifyAccountResponse(UUID.randomUUID().toString(), UUID.randomUUID().toString(), false), null, null),
+      false
     ).blockingGet()
 
     ServiceResponseProcessor.DefaultProcessor(response).resultOrThrow
 
     SignalStore.kbsValues().optOut()
-    RegistrationUtil.maybeMarkRegistrationComplete(application)
+    RegistrationUtil.maybeMarkRegistrationComplete()
     SignalDatabase.recipients.setProfileName(Recipient.self().id, ProfileName.fromParts("Tester", "McTesterson"))
 
+    SignalStore.settings().isMessageNotificationsEnabled = false
+
     return Recipient.self()
   }
 
-  private fun setupOthers(): List<RecipientId> {
+  private fun setupOthers(): Pair<List<RecipientId>, List<IdentityKeyPair>> {
     val others = mutableListOf<RecipientId>()
+    val othersKeys = mutableListOf<IdentityKeyPair>()
 
     if (othersCount !in 0 until 1000) {
       throw IllegalArgumentException("$othersCount must be between 0 and 1000")
@@ -112,11 +123,13 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
       SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true, true, true, true, true, true, true, true))
       SignalDatabase.recipients.setProfileSharing(recipientId, true)
       SignalDatabase.recipients.markRegistered(recipientId, aci)
-      ApplicationDependencies.getProtocolStore().aci().saveIdentity(SignalProtocolAddress(aci.toString(), 0), IdentityKeyUtil.generateIdentityKeyPair().publicKey)
+      val otherIdentity = IdentityKeyUtil.generateIdentityKeyPair()
+      ApplicationDependencies.getProtocolStore().aci().saveIdentity(SignalProtocolAddress(aci.toString(), 0), otherIdentity.publicKey)
       others += recipientId
+      othersKeys += otherIdentity
     }
 
-    return others
+    return others to othersKeys
   }
 
   inline fun <reified T : Activity> launchActivity(initIntent: Intent.() -> Unit = {}): ActivityScenario<T> {

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

@@ -7,6 +7,9 @@ import org.hamcrest.Matchers.not
 import org.hamcrest.Matchers.notNullValue
 import org.hamcrest.Matchers.nullValue
 import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+import kotlin.time.Duration
 
 /**
  * Run the given [runnable] on a new thread and wait for it to finish.
@@ -33,7 +36,7 @@ fun <T : Any?> T.assertIsNotNull() {
   assertThat(this, notNullValue())
 }
 
-infix fun <T : Any> T.assertIs(expected: T) {
+infix fun <T : Any?> T.assertIs(expected: T) {
   assertThat(this, `is`(expected))
 }
 
@@ -44,3 +47,9 @@ infix fun <T : Any> T.assertIsNot(expected: T) {
 infix fun <E, T : Collection<E>> T.assertIsSize(expected: Int) {
   assertThat(this, hasSize(expected))
 }
+
+fun CountDownLatch.awaitFor(duration: Duration) {
+  if (!await(duration.inWholeMilliseconds, TimeUnit.MILLISECONDS)) {
+    throw TimeoutException("Latch await took longer than ${duration.inWholeMilliseconds}ms")
+  }
+}

app/src/benchmark/AndroidManifest.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+        <profileable android:shell="true" />
+
+        <activity android:name="org.signal.benchmark.BenchmarkSetupActivity"
+            android:launchMode="singleTask"
+            android:theme="@style/Theme.Signal.DayNight.NoActionBar"
+            android:windowSoftInputMode="stateHidden"
+            android:exported="true"
+            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
+
+    </application>
+
+</manifest>

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

@@ -0,0 +1,66 @@
+package org.signal.benchmark
+
+import android.os.Bundle
+import android.widget.TextView
+import org.signal.benchmark.setup.TestMessages
+import org.signal.benchmark.setup.TestUsers
+import org.thoughtcrime.securesms.BaseActivity
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.model.MediaMmsMessageRecord
+import org.thoughtcrime.securesms.mms.QuoteModel
+import org.thoughtcrime.securesms.recipients.Recipient
+
+class BenchmarkSetupActivity : BaseActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    when (intent.extras!!.getString("setup-type")) {
+      "cold-start" -> setupColdStart()
+      "conversation-open" -> setupConversationOpen()
+    }
+
+    val textView: TextView = TextView(this).apply {
+      text = "done"
+    }
+    setContentView(textView)
+  }
+
+  private fun setupColdStart() {
+    TestUsers.setupSelf()
+    TestUsers.setupTestRecipients(50).forEach {
+      val recipient: Recipient = Recipient.resolved(it)
+
+      TestMessages.insertIncomingTextMessage(other = recipient, body = "Cool text message?!?!")
+      TestMessages.insertIncomingImageMessage(other = recipient, attachmentCount = 1)
+      TestMessages.insertIncomingImageMessage(other = recipient, attachmentCount = 2, body = "Album")
+      TestMessages.insertIncomingImageMessage(other = recipient, body = "Test", attachmentCount = 1, failed = true)
+
+      SignalDatabase.messages.setAllMessagesRead()
+
+      SignalDatabase.threads.update(SignalDatabase.threads.getOrCreateThreadIdFor(recipient = recipient), true)
+    }
+  }
+
+  private fun setupConversationOpen() {
+    TestUsers.setupSelf()
+    TestUsers.setupTestRecipient().let {
+      val recipient: Recipient = Recipient.resolved(it)
+      val messagesToAdd = 1000
+      val generator: TestMessages.TimestampGenerator = TestMessages.TimestampGenerator(System.currentTimeMillis() - (messagesToAdd * 2000L) - 60_000L)
+
+      for (i in 0 until messagesToAdd) {
+        TestMessages.insertIncomingTextMessage(other = recipient, body = "Test message $i", timestamp = generator.nextTimestamp())
+        TestMessages.insertOutgoingTextMessage(other = recipient, body = "Test message $i", timestamp = generator.nextTimestamp())
+      }
+
+      val voiceMessageId = TestMessages.insertIncomingVoiceMessage(other = recipient, timestamp = generator.nextTimestamp())
+      val mmsRecord = SignalDatabase.messages.getMessageRecord(voiceMessageId) as MediaMmsMessageRecord
+      TestMessages.insertOutgoingImageMessage(other = recipient, body = "test", 2, generator.nextTimestamp())
+      TestMessages.insertIncomingTextMessage(other = recipient, "reply to the test message", generator.nextTimestamp())
+      TestMessages.insertIncomingQuoteTextMessage(other = recipient, quote = QuoteModel(mmsRecord.timestamp, recipient.id, "Fake voice message text", false, mmsRecord.slideDeck.asAttachments(), null, QuoteModel.Type.NORMAL, null), body = "Here is a cool quote", timestamp = generator.nextTimestamp())
+      TestMessages.insertOutgoingTextMessage(other = recipient, body = "longaweorijoaijwerijoiajwer", timestamp = generator.nextTimestamp())
+
+      SignalDatabase.threads.update(SignalDatabase.threads.getOrCreateThreadIdFor(recipient = recipient), true)
+    }
+  }
+}

app/src/benchmark/java/org/signal/benchmark/DummyAccountManagerFactory.kt

@@ -0,0 +1,43 @@
+package org.signal.benchmark
+
+import android.content.Context
+import org.signal.libsignal.protocol.IdentityKey
+import org.signal.libsignal.protocol.state.PreKeyRecord
+import org.signal.libsignal.protocol.state.SignedPreKeyRecord
+import org.thoughtcrime.securesms.BuildConfig
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.push.AccountManagerFactory
+import org.thoughtcrime.securesms.util.FeatureFlags
+import org.whispersystems.signalservice.api.SignalServiceAccountManager
+import org.whispersystems.signalservice.api.push.ACI
+import org.whispersystems.signalservice.api.push.PNI
+import org.whispersystems.signalservice.api.push.ServiceIdType
+import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration
+import java.io.IOException
+import java.util.Optional
+
+class DummyAccountManagerFactory : AccountManagerFactory() {
+  override fun createAuthenticated(context: Context, aci: ACI, pni: PNI, number: String, deviceId: Int, password: String): SignalServiceAccountManager {
+    return DummyAccountManager(
+      ApplicationDependencies.getSignalServiceNetworkAccess().getConfiguration(number),
+      aci,
+      pni,
+      number,
+      deviceId,
+      password,
+      BuildConfig.SIGNAL_AGENT,
+      FeatureFlags.okHttpAutomaticRetry(),
+      FeatureFlags.groupLimits().hardLimit
+    )
+  }
+
+  private class DummyAccountManager(configuration: SignalServiceConfiguration?, aci: ACI?, pni: PNI?, e164: String?, deviceId: Int, password: String?, signalAgent: String?, automaticNetworkRetry: Boolean, maxGroupSize: Int) : SignalServiceAccountManager(configuration, aci, pni, e164, deviceId, password, signalAgent, automaticNetworkRetry, maxGroupSize) {
+    @Throws(IOException::class)
+    override fun setGcmId(gcmRegistrationId: Optional<String>) {
+    }
+
+    @Throws(IOException::class)
+    override fun setPreKeys(serviceIdType: ServiceIdType, identityKey: IdentityKey, signedPreKey: SignedPreKeyRecord, oneTimePreKeys: List<PreKeyRecord>) {
+    }
+  }
+}

app/src/benchmark/java/org/signal/benchmark/setup/TestMessages.kt

@@ -0,0 +1,189 @@
+package org.signal.benchmark.setup
+
+import org.thoughtcrime.securesms.attachments.PointerAttachment
+import org.thoughtcrime.securesms.database.AttachmentTable
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.database.TestDbUtils
+import org.thoughtcrime.securesms.mms.IncomingMediaMessage
+import org.thoughtcrime.securesms.mms.OutgoingMessage
+import org.thoughtcrime.securesms.mms.QuoteModel
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.releasechannel.ReleaseChannel
+import org.whispersystems.signalservice.api.messages.SignalServiceAttachment
+import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer
+import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId
+import java.util.Collections
+import java.util.Optional
+
+object TestMessages {
+  fun insertOutgoingTextMessage(other: Recipient, body: String, timestamp: Long = System.currentTimeMillis()) {
+    insertOutgoingMessage(
+      recipient = other,
+      message = OutgoingMessage(
+        recipient = other,
+        body = body,
+        timestamp = timestamp,
+        isSecure = true
+      ),
+      timestamp = timestamp
+    )
+  }
+
+  fun insertOutgoingImageMessage(other: Recipient, body: String? = null, attachmentCount: Int, timestamp: Long = System.currentTimeMillis()): Long {
+    val attachments: List<SignalServiceAttachmentPointer> = (0 until attachmentCount).map {
+      imageAttachment()
+    }
+    val message = OutgoingMessage(
+      recipient = other,
+      body = body,
+      attachments = PointerAttachment.forPointers(Optional.of(attachments)),
+      timestamp = timestamp,
+      isSecure = true
+    )
+    return insertOutgoingMediaMessage(recipient = other, message = message, timestamp = timestamp)
+  }
+
+  private fun insertOutgoingMediaMessage(recipient: Recipient, message: OutgoingMessage, timestamp: Long): Long {
+    val insert = insertOutgoingMessage(recipient, message = message, timestamp = timestamp)
+    setMessageMediaTransfered(insert)
+
+    return insert
+  }
+
+  private fun insertOutgoingMessage(recipient: Recipient, message: OutgoingMessage, timestamp: Long? = null): Long {
+    val insert = SignalDatabase.messages.insertMessageOutbox(
+      message,
+      SignalDatabase.threads.getOrCreateThreadIdFor(recipient),
+      false,
+      null
+    )
+    if (timestamp != null) {
+      TestDbUtils.setMessageReceived(insert, timestamp)
+    }
+    SignalDatabase.messages.markAsSent(insert, true)
+
+    return insert
+  }
+  fun insertIncomingTextMessage(other: Recipient, body: String, timestamp: Long? = null) {
+    val message = IncomingMediaMessage(
+      from = other.id,
+      body = body,
+      sentTimeMillis = timestamp ?: System.currentTimeMillis(),
+      serverTimeMillis = timestamp ?: System.currentTimeMillis(),
+      receivedTimeMillis = timestamp ?: System.currentTimeMillis()
+    )
+
+    SignalDatabase.messages.insertSecureDecryptedMessageInbox(message, SignalDatabase.threads.getOrCreateThreadIdFor(other)).get().messageId
+  }
+  fun insertIncomingQuoteTextMessage(other: Recipient, body: String, quote: QuoteModel, timestamp: Long?) {
+    val message = IncomingMediaMessage(
+      from = other.id,
+      body = body,
+      sentTimeMillis = timestamp ?: System.currentTimeMillis(),
+      serverTimeMillis = timestamp ?: System.currentTimeMillis(),
+      receivedTimeMillis = timestamp ?: System.currentTimeMillis(),
+      quote = quote
+    )
+    insertIncomingMessage(other, message = message)
+  }
+  fun insertIncomingImageMessage(other: Recipient, body: String? = null, attachmentCount: Int, timestamp: Long? = null, failed: Boolean = false): Long {
+    val attachments: List<SignalServiceAttachmentPointer> = (0 until attachmentCount).map {
+      imageAttachment()
+    }
+    val message = IncomingMediaMessage(
+      from = other.id,
+      sentTimeMillis = timestamp ?: System.currentTimeMillis(),
+      serverTimeMillis = timestamp ?: System.currentTimeMillis(),
+      receivedTimeMillis = timestamp ?: System.currentTimeMillis(),
+      attachments = PointerAttachment.forPointers(Optional.of(attachments))
+    )
+    return insertIncomingMediaMessage(recipient = other, message = message, failed = failed)
+  }
+
+  fun insertIncomingVoiceMessage(other: Recipient, timestamp: Long? = null): Long {
+    val message = IncomingMediaMessage(
+      from = other.id,
+      sentTimeMillis = timestamp ?: System.currentTimeMillis(),
+      serverTimeMillis = timestamp ?: System.currentTimeMillis(),
+      receivedTimeMillis = timestamp ?: System.currentTimeMillis(),
+      attachments = PointerAttachment.forPointers(Optional.of(Collections.singletonList(voiceAttachment()) as List<SignalServiceAttachment>))
+    )
+    return insertIncomingMediaMessage(recipient = other, message = message, failed = false)
+  }
+
+  private fun insertIncomingMediaMessage(recipient: Recipient, message: IncomingMediaMessage, failed: Boolean = false): Long {
+    val id = insertIncomingMessage(recipient = recipient, message = message)
+    if (failed) {
+      setMessageMediaFailed(id)
+    } else {
+      setMessageMediaTransfered(id)
+    }
+
+    return id
+  }
+
+  private fun insertIncomingMessage(recipient: Recipient, message: IncomingMediaMessage): Long {
+    return SignalDatabase.messages.insertSecureDecryptedMessageInbox(message, SignalDatabase.threads.getOrCreateThreadIdFor(recipient)).get().messageId
+  }
+
+  private fun setMessageMediaFailed(messageId: Long) {
+    SignalDatabase.attachments.getAttachmentsForMessage(messageId).forEachIndexed { index, attachment ->
+      SignalDatabase.attachments.setTransferProgressPermanentFailure(attachment.attachmentId, messageId)
+    }
+  }
+
+  private fun setMessageMediaTransfered(messageId: Long) {
+    SignalDatabase.attachments.getAttachmentsForMessage(messageId).forEachIndexed { _, attachment ->
+      SignalDatabase.attachments.setTransferState(messageId, attachment.attachmentId, AttachmentTable.TRANSFER_PROGRESS_DONE)
+    }
+  }
+  private fun imageAttachment(): SignalServiceAttachmentPointer {
+    return SignalServiceAttachmentPointer(
+      ReleaseChannel.CDN_NUMBER,
+      SignalServiceAttachmentRemoteId.from(""),
+      "image/webp",
+      null,
+      Optional.empty(),
+      Optional.empty(),
+      1024,
+      1024,
+      Optional.empty(),
+      Optional.of("/not-there.jpg"),
+      false,
+      false,
+      false,
+      Optional.empty(),
+      Optional.empty(),
+      System.currentTimeMillis()
+    )
+  }
+
+  private fun voiceAttachment(): SignalServiceAttachmentPointer {
+    return SignalServiceAttachmentPointer(
+      ReleaseChannel.CDN_NUMBER,
+      SignalServiceAttachmentRemoteId.from(""),
+      "audio/aac",
+      null,
+      Optional.empty(),
+      Optional.empty(),
+      1024,
+      1024,
+      Optional.empty(),
+      Optional.of("/not-there.aac"),
+      true,
+      false,
+      false,
+      Optional.empty(),
+      Optional.empty(),
+      System.currentTimeMillis()
+    )
+  }
+
+  class TimestampGenerator(private var start: Long = System.currentTimeMillis()) {
+    fun nextTimestamp(): Long {
+      start += 500L
+
+      return start
+    }
+  }
+}

app/src/benchmark/java/org/signal/benchmark/setup/TestUsers.kt

@@ -0,0 +1,103 @@
+package org.signal.benchmark.setup
+
+import android.app.Application
+import android.content.SharedPreferences
+import android.preference.PreferenceManager
+import org.signal.benchmark.DummyAccountManagerFactory
+import org.signal.libsignal.protocol.SignalProtocolAddress
+import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
+import org.thoughtcrime.securesms.crypto.MasterSecretUtil
+import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor
+import org.thoughtcrime.securesms.profiles.ProfileName
+import org.thoughtcrime.securesms.push.AccountManagerFactory
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.registration.RegistrationData
+import org.thoughtcrime.securesms.registration.RegistrationRepository
+import org.thoughtcrime.securesms.registration.RegistrationUtil
+import org.thoughtcrime.securesms.registration.VerifyResponse
+import org.thoughtcrime.securesms.util.Util
+import org.whispersystems.signalservice.api.profiles.SignalServiceProfile
+import org.whispersystems.signalservice.api.push.ACI
+import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.ServiceResponse
+import org.whispersystems.signalservice.internal.ServiceResponseProcessor
+import org.whispersystems.signalservice.internal.push.VerifyAccountResponse
+import java.util.UUID
+
+object TestUsers {
+
+  private var generatedOthers: Int = 0
+
+  fun setupSelf(): Recipient {
+    val application: Application = ApplicationDependencies.getApplication()
+    DeviceTransferBlockingInterceptor.getInstance().blockNetwork()
+
+    PreferenceManager.getDefaultSharedPreferences(application).edit().putBoolean("pref_prompted_push_registration", true).commit()
+    val masterSecret = MasterSecretUtil.generateMasterSecret(application, MasterSecretUtil.UNENCRYPTED_PASSPHRASE)
+    MasterSecretUtil.generateAsymmetricMasterSecret(application, masterSecret)
+    val preferences: SharedPreferences = application.getSharedPreferences(MasterSecretUtil.PREFERENCES_NAME, 0)
+    preferences.edit().putBoolean("passphrase_initialized", true).commit()
+
+    val registrationRepository = RegistrationRepository(application)
+    val registrationData = RegistrationData(
+      code = "123123",
+      e164 = "+15555550101",
+      password = Util.getSecret(18),
+      registrationId = registrationRepository.registrationId,
+      profileKey = registrationRepository.getProfileKey("+15555550101"),
+      fcmToken = "fcm-token",
+      pniRegistrationId = registrationRepository.pniRegistrationId,
+      recoveryPassword = "asdfasdfasdfasdf"
+    )
+    val verifyResponse = VerifyResponse(VerifyAccountResponse(UUID.randomUUID().toString(), UUID.randomUUID().toString(), false), null, null)
+    AccountManagerFactory.setInstance(DummyAccountManagerFactory())
+    val response: ServiceResponse<VerifyResponse> = registrationRepository.registerAccount(
+      registrationData,
+      verifyResponse,
+      false
+    ).blockingGet()
+    ServiceResponseProcessor.DefaultProcessor(response).resultOrThrow
+
+    SignalStore.kbsValues().optOut()
+    RegistrationUtil.maybeMarkRegistrationComplete()
+    SignalDatabase.recipients.setProfileName(Recipient.self().id, ProfileName.fromParts("Tester", "McTesterson"))
+
+    return Recipient.self()
+  }
+
+  fun setupTestRecipient(): RecipientId {
+    return setupTestRecipients(1).first()
+  }
+
+  fun setupTestRecipients(othersCount: Int): List<RecipientId> {
+    val others = mutableListOf<RecipientId>()
+    synchronized(this) {
+      if (generatedOthers + othersCount !in 0 until 1000) {
+        throw IllegalArgumentException("$othersCount must be between 0 and 1000")
+      }
+
+      for (i in generatedOthers until generatedOthers + othersCount) {
+        val aci = ACI.from(UUID.randomUUID())
+        val recipientId = RecipientId.from(SignalServiceAddress(aci, "+15555551%03d".format(i)))
+        SignalDatabase.recipients.setProfileName(recipientId, ProfileName.fromParts("Buddy", "#$i"))
+        SignalDatabase.recipients.setProfileKeyIfAbsent(recipientId, ProfileKeyUtil.createNew())
+        SignalDatabase.recipients.setCapabilities(recipientId, SignalServiceProfile.Capabilities(true, true, true, true, true, true, true, true, true))
+        SignalDatabase.recipients.setProfileSharing(recipientId, true)
+        SignalDatabase.recipients.markRegistered(recipientId, aci)
+        val otherIdentity = IdentityKeyUtil.generateIdentityKeyPair()
+        ApplicationDependencies.getProtocolStore().aci().saveIdentity(SignalProtocolAddress(aci.toString(), 0), otherIdentity.publicKey)
+
+        others += recipientId
+      }
+
+      generatedOthers += othersCount
+    }
+
+    return others
+  }
+}

app/src/benchmark/java/org/thoughtcrime/securesms/database/TestDbUtils.kt

@@ -0,0 +1,14 @@
+package org.thoughtcrime.securesms.database
+
+import android.content.ContentValues
+import org.signal.core.util.SqlUtil.buildArgs
+
+object TestDbUtils {
+
+  fun setMessageReceived(messageId: Long, timestamp: Long) {
+    val database: SQLiteDatabase = SignalDatabase.messages.databaseHelper.signalWritableDatabase
+    val contentValues = ContentValues()
+    contentValues.put(MessageTable.DATE_RECEIVED, timestamp)
+    val rowsUpdated = database.update(MessageTable.TABLE_NAME, contentValues, DatabaseTable.ID_WHERE, buildArgs(messageId))
+  }
+}

app/src/canary/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:name=".CanaryApplicationContext"
+        tools:replace="android:name" />
+
+</manifest>

app/src/canary/java/org/thoughtcrime/securesms/CanaryApplicationContext.kt

@@ -0,0 +1,65 @@
+package org.thoughtcrime.securesms
+
+import android.os.StrictMode
+import android.os.StrictMode.ThreadPolicy
+import leakcanary.LeakCanary
+import shark.AndroidReferenceMatchers
+
+class CanaryApplicationContext : ApplicationContext() {
+  override fun onCreate() {
+    super.onCreate()
+
+    StrictMode.setThreadPolicy(
+      ThreadPolicy.Builder()
+        .detectDiskReads()
+        .detectDiskWrites()
+        .detectNetwork()
+        .penaltyLog()
+        .build()
+    )
+
+    try {
+      Class.forName("dalvik.system.CloseGuard")
+        .getMethod("setEnabled", Boolean::class.javaPrimitiveType)
+        .invoke(null, true)
+    } catch (e: ReflectiveOperationException) {
+      throw RuntimeException(e)
+    }
+
+    LeakCanary.config = LeakCanary.config.copy(
+      referenceMatchers = AndroidReferenceMatchers.appDefaults +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "android.service.media.MediaBrowserService\$ServiceBinder",
+          fieldName = "this\$0"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "androidx.media.MediaBrowserServiceCompat\$MediaBrowserServiceImplApi26\$MediaBrowserServiceApi26",
+          fieldName = "mBase"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "android.support.v4.media.MediaBrowserCompat",
+          fieldName = "mImpl"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "android.support.v4.media.session.MediaControllerCompat",
+          fieldName = "mToken"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "android.support.v4.media.session.MediaControllerCompat",
+          fieldName = "mImpl"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "org.thoughtcrime.securesms.components.voice.VoiceNotePlaybackService",
+          fieldName = "mApplication"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "org.thoughtcrime.securesms.service.GenericForegroundService\$LocalBinder",
+          fieldName = "this\$0"
+        ) +
+        AndroidReferenceMatchers.ignoredInstanceField(
+          className = "org.thoughtcrime.securesms.contacts.ContactsSyncAdapter",
+          fieldName = "mContext"
+        )
+    )
+  }
+}

app/src/main/AndroidManifest.xml

@@ -354,6 +354,11 @@
               android:windowSoftInputMode="stateAlwaysVisible"
               android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
 
+    <activity android:name=".calls.new.NewCallActivity"
+            android:theme="@style/Theme.Signal.DayNight.NoActionBar"
+            android:windowSoftInputMode="stateAlwaysVisible"
+            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
+
     <activity android:name=".PushContactSelectionActivity"
           android:label="@string/AndroidManifest__select_contacts"
           android:windowSoftInputMode="stateHidden"
@@ -368,7 +373,7 @@
             android:theme="@style/TextSecure.DarkNoActionBar"
             android:windowSoftInputMode="stateAlwaysHidden|adjustNothing"
             android:launchMode="singleTop"
-            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
+            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize|uiMode"/>
 
         <activity android:name=".conversation.mutiselect.forward.MultiselectForwardActivity"
             android:theme="@style/Signal.DayNight.NoActionBar"
@@ -436,6 +441,12 @@
             android:windowSoftInputMode="stateAlwaysHidden">
         </activity>
 
+        <activity android:name=".components.settings.conversation.CallInfoActivity"
+            android:configChanges="touchscreen|keyboard|keyboardHidden|screenLayout|screenSize"
+            android:theme="@style/Signal.DayNight.NoActionBar"
+            android:windowSoftInputMode="stateAlwaysHidden">
+        </activity>
+
         <activity android:name=".badges.gifts.flow.GiftFlowActivity"
             android:configChanges="touchscreen|keyboard|keyboardHidden|screenLayout|screenSize"
             android:theme="@style/Signal.DayNight.NoActionBar"
@@ -503,6 +514,13 @@
               android:windowSoftInputMode="stateHidden"
               android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
 
+    <activity
+              android:name=".avatar.photo.PhotoEditorActivity"
+              android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize|uiMode"
+              android:label="@string/AndroidManifest__media_preview"
+              android:theme="@style/TextSecure.DarkNoActionBar"
+              android:windowSoftInputMode="stateHidden" />
+
     <activity android:name=".mediaoverview.MediaOverviewActivity"
               android:theme="@style/Theme.Signal.DayNight.NoActionBar"
               android:windowSoftInputMode="stateHidden"
@@ -597,12 +615,6 @@
             android:windowSoftInputMode="adjustResize"
             android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
 
-    <activity android:name=".ClearAvatarPromptActivity"
-              android:theme="@style/Theme.AppCompat.Dialog.Alert"
-              android:icon="@drawable/clear_profile_avatar"
-              android:label="@string/AndroidManifest_remove_photo"
-              android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
-
     <activity android:name=".contacts.TurnOffContactJoinedNotificationsActivity"
               android:theme="@style/Theme.AppCompat.Dialog.Alert" />
 
@@ -699,6 +711,7 @@
     <service android:enabled="true" android:name=".service.webrtc.WebRtcCallService" android:foregroundServiceType="camera|microphone"/>
     <service android:enabled="true" android:exported="false" android:name=".service.KeyCachingService"/>
     <service android:enabled="true" android:name=".messages.IncomingMessageObserver$ForegroundService"/>
+    <service android:enabled="true" android:name=".messages.IncomingMessageObserver$BackgroundService"/>
     <service android:name=".service.webrtc.AndroidCallConnectionService"
         android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
         android:exported="true">

app/src/main/java/org/signal/glide/common/executor/FrameDecoderExecutor.java

@@ -8,6 +8,8 @@ package org.signal.glide.common.executor;
 import android.os.HandlerThread;
 import android.os.Looper;
 
+import org.signal.core.util.ThreadUtil;
+
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -39,7 +41,7 @@ public class FrameDecoderExecutor {
     public Looper getLooper(int taskId) {
         int idx = taskId % sPoolNumber;
         if (idx >= mHandlerThreadGroup.size()) {
-            HandlerThread handlerThread = new HandlerThread("FrameDecoderExecutor-" + idx);
+            HandlerThread handlerThread = new HandlerThread("FrameDecoderExecutor-" + idx, ThreadUtil.PRIORITY_BACKGROUND_THREAD);
             handlerThread.start();
 
             mHandlerThreadGroup.add(handlerThread);

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

@@ -11,16 +11,16 @@ object AppCapabilities {
   @JvmStatic
   fun getCapabilities(storageCapable: Boolean): AccountAttributes.Capabilities {
     return AccountAttributes.Capabilities(
-      isUuid = false,
-      isGv2 = true,
-      isStorage = storageCapable,
-      isGv1Migration = true,
-      isSenderKey = true,
-      isAnnouncementGroup = true,
-      isChangeNumber = true,
-      isStories = true,
-      isGiftBadges = true,
-      isPnp = FeatureFlags.phoneNumberPrivacy(),
+      uuid = false,
+      gv2 = true,
+      storage = storageCapable,
+      gv1Migration = true,
+      senderKey = true,
+      announcementGroup = true,
+      changeNumber = true,
+      stories = true,
+      giftBadges = true,
+      pni = FeatureFlags.phoneNumberPrivacy(),
       paymentActivation = true
     )
   }

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

@@ -73,6 +73,7 @@ import org.thoughtcrime.securesms.logging.CustomSignalProtocolLogger;
 import org.thoughtcrime.securesms.logging.PersistentLogger;
 import org.thoughtcrime.securesms.messageprocessingalarm.MessageProcessReceiver;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrations;
+import org.thoughtcrime.securesms.mms.GlideApp;
 import org.thoughtcrime.securesms.mms.SignalGlideComponents;
 import org.thoughtcrime.securesms.mms.SignalGlideModule;
 import org.thoughtcrime.securesms.providers.BlobProvider;
@@ -125,7 +126,8 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
 
   private static final String TAG = Log.tag(ApplicationContext.class);
 
-  private PersistentLogger persistentLogger;
+  @VisibleForTesting
+  protected PersistentLogger persistentLogger;
 
   public static ApplicationContext getInstance(Context context) {
     return (ApplicationContext)context.getApplicationContext();
@@ -162,7 +164,7 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
                             .addBlocking("app-dependencies", this::initializeAppDependencies)
                             .addBlocking("first-launch", this::initializeFirstEverAppLaunch)
                             .addBlocking("app-migrations", this::initializeApplicationMigrations)
-                            .addBlocking("mark-registration", () -> RegistrationUtil.maybeMarkRegistrationComplete(this))
+                            .addBlocking("mark-registration", () -> RegistrationUtil.maybeMarkRegistrationComplete())
                             .addBlocking("lifecycle-observer", () -> ApplicationDependencies.getAppForegroundObserver().addListener(this))
                             .addBlocking("message-retriever", this::initializeMessageRetrieval)
                             .addBlocking("dynamic-theme", () -> DynamicTheme.setDefaultDayNightMode(this))
@@ -176,6 +178,7 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
                             .addBlocking("feature-flags", FeatureFlags::init)
                             .addBlocking("ring-rtc", this::initializeRingRtc)
                             .addBlocking("glide", () -> SignalGlideModule.setRegisterGlideComponents(new SignalGlideComponents()))
+                            .addNonBlocking(() -> GlideApp.get(this))
                             .addNonBlocking(this::checkIsGooglePayReady)
                             .addNonBlocking(this::cleanAvatarStorage)
                             .addNonBlocking(this::initializeRevealableMessageManager)
@@ -194,6 +197,7 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
                             .addNonBlocking(() -> ApplicationDependencies.getGiphyMp4Cache().onAppStart(this))
                             .addNonBlocking(this::ensureProfileUploaded)
                             .addNonBlocking(() -> ApplicationDependencies.getExpireStoriesManager().scheduleIfNecessary())
+                            .addPostRender(() -> ApplicationDependencies.getDeletedCallEventManager().scheduleIfNecessary())
                             .addPostRender(() -> RateLimitUtil.retryAllRateLimitedMessages(this))
                             .addPostRender(this::initializeExpiringMessageManager)
                             .addPostRender(() -> SignalStore.settings().setDefaultSms(Util.isDefaultSmsProvider(this)))
@@ -211,7 +215,7 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
                             .addPostRender(StoryOnboardingDownloadJob.Companion::enqueueIfNeeded)
                             .addPostRender(PnpInitializeDevicesJob::enqueueIfNecessary)
                             .addPostRender(() -> ApplicationDependencies.getExoPlayerPool().getPoolStats().getMaxUnreserved())
-                            .addPostRender(() -> SignalDatabase.groupCallRings().removeOldRings())
+                            .addPostRender(() -> ApplicationDependencies.getRecipientCache().warmUp())
                             .execute();
 
     Log.d(TAG, "onCreate() took " + (System.currentTimeMillis() - startTime) + " ms");
@@ -231,7 +235,6 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
 
     SignalExecutors.BOUNDED.execute(() -> {
       FeatureFlags.refreshIfNecessary();
-      ApplicationDependencies.getRecipientCache().warmUp();
       RetrieveProfileJob.enqueueRoutineFetchIfNecessary(this);
       executePendingContactSync();
       KeyCachingService.onAppForegrounded(this);
@@ -297,7 +300,8 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
     }
   }
 
-  private void initializeLogging() {
+  @VisibleForTesting
+  protected void initializeLogging() {
     persistentLogger = new PersistentLogger(this);
     org.signal.core.util.logging.Log.initialize(FeatureFlags::internalUser, new AndroidLogger(), persistentLogger);
 

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

@@ -1,48 +0,0 @@
-package org.thoughtcrime.securesms;
-
-
-import android.app.Activity;
-import android.content.Intent;
-import android.view.ContextThemeWrapper;
-
-import androidx.appcompat.app.AlertDialog;
-
-import org.thoughtcrime.securesms.dependencies.ApplicationDependencies;
-import org.thoughtcrime.securesms.util.DynamicTheme;
-
-public final class ClearAvatarPromptActivity extends Activity {
-
-  private static final String ARG_TITLE = "arg_title";
-
-  public static Intent createForUserProfilePhoto() {
-    Intent intent = new Intent(ApplicationDependencies.getApplication(), ClearAvatarPromptActivity.class);
-    intent.putExtra(ARG_TITLE, R.string.ClearProfileActivity_remove_profile_photo);
-    return intent;
-  }
-
-  public static Intent createForGroupProfilePhoto() {
-    Intent intent = new Intent(ApplicationDependencies.getApplication(), ClearAvatarPromptActivity.class);
-    intent.putExtra(ARG_TITLE, R.string.ClearProfileActivity_remove_group_photo);
-    return intent;
-  }
-
-  @Override
-  public void onResume() {
-    super.onResume();
-
-    int message = getIntent().getIntExtra(ARG_TITLE, 0);
-
-    new AlertDialog.Builder(new ContextThemeWrapper(this, DynamicTheme.isDarkTheme(this) ? R.style.TextSecure_DarkTheme : R.style.TextSecure_LightTheme))
-                   .setMessage(message)
-                   .setNegativeButton(android.R.string.cancel, (dialog, which) -> finish())
-                   .setPositiveButton(R.string.ClearProfileActivity_remove, (dialog, which) -> {
-                     Intent result = new Intent();
-                     result.putExtra("delete", true);
-                     setResult(Activity.RESULT_OK, result);
-                     finish();
-                   })
-                   .setOnCancelListener(dialog -> finish())
-                   .show();
-  }
-
-}

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

@@ -125,7 +125,7 @@ public abstract class ContactSelectionActivity extends PassphraseRequiredActivit
   }
 
   @Override
-  public void onBeforeContactSelected(@NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
+  public void onBeforeContactSelected(boolean isFromUnknownSearchKey, @NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
     callback.accept(true);
   }
 

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

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms
 
 import android.content.Context
 import android.view.View
+import android.widget.TextView
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchAdapter
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchConfiguration
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchData
@@ -13,17 +14,19 @@ import org.thoughtcrime.securesms.util.adapter.mapping.MappingViewHolder
 class ContactSelectionListAdapter(
   context: Context,
   fixedContacts: Set<ContactSearchKey>,
-  displayCheckBox: Boolean,
-  displaySmsTag: DisplaySmsTag,
-  displaySecondaryInformation: DisplaySecondaryInformation,
+  displayOptions: DisplayOptions,
   onClickCallbacks: OnContactSelectionClick,
   longClickCallbacks: LongClickCallbacks,
-  storyContextMenuCallbacks: StoryContextMenuCallbacks
-) : ContactSearchAdapter(context, fixedContacts, displayCheckBox, displaySmsTag, displaySecondaryInformation, onClickCallbacks, longClickCallbacks, storyContextMenuCallbacks) {
+  storyContextMenuCallbacks: StoryContextMenuCallbacks,
+  callButtonClickCallbacks: CallButtonClickCallbacks
+) : 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(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))
   }
 
   class NewGroupModel : MappingModel<NewGroupModel> {
@@ -36,6 +39,17 @@ class ContactSelectionListAdapter(
     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 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() }
@@ -52,11 +66,39 @@ class ContactSelectionListAdapter(
     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 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)
+    }
+  }
+
   class ArbitraryRepository : org.thoughtcrime.securesms.contacts.paged.ArbitraryRepository {
 
     enum class ArbitraryRow(val code: String) {
       NEW_GROUP("new-group"),
-      INVITE_TO_SIGNAL("invite-to-signal");
+      INVITE_TO_SIGNAL("invite-to-signal"),
+      MORE_HEADING("more-heading"),
+      REFRESH_CONTACTS("refresh-contacts");
 
       companion object {
         fun fromCode(code: String) = values().first { it.code == code }
@@ -64,7 +106,7 @@ class ContactSelectionListAdapter(
     }
 
     override fun getSize(section: ContactSearchConfiguration.Section.Arbitrary, query: String?): Int {
-      return if (query.isNullOrEmpty()) section.types.size else 0
+      return section.types.size
     }
 
     override fun getData(section: ContactSearchConfiguration.Section.Arbitrary, query: String?, startIndex: Int, endIndex: Int, totalSearchSize: Int): List<ContactSearchData.Arbitrary> {
@@ -73,10 +115,11 @@ class ContactSelectionListAdapter(
     }
 
     override fun getMappingModel(arbitrary: ContactSearchData.Arbitrary): MappingModel<*> {
-      val code = ArbitraryRow.fromCode(arbitrary.type)
-      return when (code) {
+      return when (ArbitraryRow.fromCode(arbitrary.type)) {
         ArbitraryRow.NEW_GROUP -> NewGroupModel()
         ArbitraryRow.INVITE_TO_SIGNAL -> InviteToSignalModel()
+        ArbitraryRow.MORE_HEADING -> MoreHeaderModel()
+        ArbitraryRow.REFRESH_CONTACTS -> RefreshContactsModel()
       }
     }
   }
@@ -84,5 +127,6 @@ class ContactSelectionListAdapter(
   interface OnContactSelectionClick : ClickCallbacks {
     fun onNewGroupClicked()
     fun onInviteToSignalClicked()
+    fun onRefreshContactsClicked()
   }
 }

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

@@ -47,8 +47,6 @@ import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 import androidx.transition.AutoTransition;
 import androidx.transition.TransitionManager;
 
-import com.annimon.stream.Collectors;
-import com.annimon.stream.Stream;
 import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 import com.pnikosis.materialishprogress.ProgressWheel;
 
@@ -74,6 +72,7 @@ import org.thoughtcrime.securesms.groups.ui.GroupLimitDialog;
 import org.thoughtcrime.securesms.permissions.Permissions;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
+import org.thoughtcrime.securesms.util.CommunicationActions;
 import org.thoughtcrime.securesms.util.LifecycleDisposable;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.thoughtcrime.securesms.util.UsernameUtil;
@@ -98,8 +97,7 @@ import kotlin.Unit;
  *
  * @author Moxie Marlinspike
  */
-public final class ContactSelectionListFragment extends LoggingFragment
-{
+public final class ContactSelectionListFragment extends LoggingFragment {
   @SuppressWarnings("unused")
   private static final String TAG = Log.tag(ContactSelectionListFragment.class);
 
@@ -119,41 +117,47 @@ public final class ContactSelectionListFragment extends LoggingFragment
   public static final String RV_PADDING_BOTTOM = "recycler_view_padding_bottom";
   public static final String RV_CLIP           = "recycler_view_clipping";
 
-  private ConstraintLayout                            constraintLayout;
-  private TextView                                    emptyText;
-  private OnContactSelectedListener                   onContactSelectedListener;
-  private SwipeRefreshLayout                          swipeRefresh;
-  private View                                        showContactsLayout;
-  private Button                                      showContactsButton;
-  private TextView                                    showContactsDescription;
-  private ProgressWheel                               showContactsProgress;
-  private String                                      cursorFilter;
-  private RecyclerView                                recyclerView;
-  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 ContactSearchMediator                       contactSearchMediator;
+  private ConstraintLayout                constraintLayout;
+  private TextView                        emptyText;
+  private OnContactSelectedListener       onContactSelectedListener;
+  private SwipeRefreshLayout              swipeRefresh;
+  private View                            showContactsLayout;
+  private Button                          showContactsButton;
+  private TextView                        showContactsDescription;
+  private ProgressWheel                   showContactsProgress;
+  private String                          cursorFilter;
+  private RecyclerView                    recyclerView;
+  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 ContactSearchMediator           contactSearchMediator;
 
-  @Nullable private ListCallback            listCallback;
-  @Nullable private ScrollCallback          scrollCallback;
-  @Nullable private OnItemLongClickListener onItemLongClickListener;
-  private           SelectionLimits         selectionLimit = SelectionLimits.NO_LIMITS;
-  private           Set<RecipientId>        currentSelection;
-  private           boolean                 isMulti;
-  private           boolean                 canSelectSelf;
-  private           ListClickListener       listClickListener = new ListClickListener();
+  @Nullable private NewConversationCallback              newConversationCallback;
+  @Nullable private NewCallCallback                      newCallCallback;
+  @Nullable private ScrollCallback                       scrollCallback;
+  @Nullable private OnItemLongClickListener              onItemLongClickListener;
+  private           SelectionLimits                      selectionLimit    = SelectionLimits.NO_LIMITS;
+  private           Set<RecipientId>                     currentSelection;
+  private           boolean                              isMulti;
+  private           boolean                              canSelectSelf;
+  private           ListClickListener                    listClickListener = new ListClickListener();
+  @Nullable private SwipeRefreshLayout.OnRefreshListener onRefreshListener;
 
   @Override
   public void onAttach(@NonNull Context context) {
     super.onAttach(context);
 
-    if (context instanceof ListCallback) {
-      listCallback = (ListCallback) context;
+    if (context instanceof NewConversationCallback) {
+      newConversationCallback = (NewConversationCallback) context;
+    }
+
+    if (context instanceof NewCallCallback) {
+      newCallCallback = (NewCallCallback) context;
     }
 
     if (getParentFragment() instanceof ScrollCallback) {
@@ -234,17 +238,17 @@ public final class ContactSelectionListFragment extends LoggingFragment
   public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
     View view = inflater.inflate(R.layout.contact_selection_list_fragment, container, false);
 
-    emptyText                = view.findViewById(android.R.id.empty);
-    recyclerView             = view.findViewById(R.id.recycler_view);
-    swipeRefresh             = view.findViewById(R.id.swipe_refresh);
-    fastScroller             = view.findViewById(R.id.fast_scroller);
-    showContactsLayout       = view.findViewById(R.id.show_contacts_container);
-    showContactsButton       = view.findViewById(R.id.show_contacts_button);
-    showContactsDescription  = view.findViewById(R.id.show_contacts_description);
-    showContactsProgress     = view.findViewById(R.id.progress);
-    chipRecycler             = view.findViewById(R.id.chipRecycler);
-    constraintLayout         = view.findViewById(R.id.container);
-    headerActionView         = view.findViewById(R.id.header_action);
+    emptyText               = view.findViewById(android.R.id.empty);
+    recyclerView            = view.findViewById(R.id.recycler_view);
+    swipeRefresh            = view.findViewById(R.id.swipe_refresh);
+    fastScroller            = view.findViewById(R.id.fast_scroller);
+    showContactsLayout      = view.findViewById(R.id.show_contacts_container);
+    showContactsButton      = view.findViewById(R.id.show_contacts_button);
+    showContactsDescription = view.findViewById(R.id.show_contacts_description);
+    showContactsProgress    = view.findViewById(R.id.progress);
+    chipRecycler            = view.findViewById(R.id.chipRecycler);
+    constraintLayout        = view.findViewById(R.id.container);
+    headerActionView        = view.findViewById(R.id.header_action);
 
     final LinearLayoutManager layoutManager = new LinearLayoutManager(requireContext());
 
@@ -337,9 +341,13 @@ public final class ContactSelectionListFragment extends LoggingFragment
                         .map(r -> new ContactSearchKey.RecipientSearchKey(r, false))
                         .collect(java.util.stream.Collectors.toSet()),
         selectionLimit,
-        isMulti,
-        ContactSearchAdapter.DisplaySmsTag.DEFAULT,
-        ContactSearchAdapter.DisplaySecondaryInformation.ALWAYS,
+        new ContactSearchAdapter.DisplayOptions(
+            isMulti,
+            ContactSearchAdapter.DisplaySmsTag.DEFAULT,
+            ContactSearchAdapter.DisplaySecondaryInformation.ALWAYS,
+            newCallCallback != null,
+            false
+        ),
         this::mapStateToConfiguration,
         new ContactSearchMediator.SimpleCallbacks() {
           @Override
@@ -348,21 +356,33 @@ public final class ContactSelectionListFragment extends LoggingFragment
           }
         },
         false,
-        (context, fixedContacts, displayCheckBox, displaySmsTag, displaySecondaryInformation, callbacks, longClickCallbacks, storyContextMenuCallbacks) -> new ContactSelectionListAdapter(
+        (context, fixedContacts, displayOptions, callbacks, longClickCallbacks, storyContextMenuCallbacks, callButtonClickCallbacks) -> new ContactSelectionListAdapter(
             context,
             fixedContacts,
-            displayCheckBox,
-            displaySmsTag,
-            displaySecondaryInformation,
+            displayOptions,
             new ContactSelectionListAdapter.OnContactSelectionClick() {
+              @Override
+              public void onRefreshContactsClicked() {
+                if (onRefreshListener != null) {
+                  setRefreshing(true);
+                  onRefreshListener.onRefresh();
+                }
+              }
+
               @Override
               public void onNewGroupClicked() {
-                listCallback.onNewGroup(false);
+                newConversationCallback.onNewGroup(false);
               }
 
               @Override
               public void onInviteToSignalClicked() {
-                listCallback.onInvite();
+                if (newConversationCallback != null) {
+                  newConversationCallback.onInvite();
+                }
+
+                if (newCallCallback != null) {
+                  newCallCallback.onInvite();
+                }
               }
 
               @Override
@@ -386,7 +406,9 @@ public final class ContactSelectionListFragment extends LoggingFragment
               }
             },
             (anchorView, data) -> listClickListener.onItemLongClick(anchorView, data.getContactSearchKey()),
-            storyContextMenuCallbacks
+            storyContextMenuCallbacks,
+            new CallButtonClickCallbacks()
+
         ),
         new ContactSelectionListAdapter.ArbitraryRepository()
     );
@@ -398,6 +420,7 @@ public final class ContactSelectionListFragment extends LoggingFragment
   public void onDestroyView() {
     super.onDestroyView();
     constraintLayout = null;
+    onRefreshListener = null;
   }
 
   private @NonNull Bundle safeArguments() {
@@ -620,6 +643,7 @@ public final class ContactSelectionListFragment extends LoggingFragment
 
   private class ListClickListener {
     public void onItemClick(ContactSearchKey contact) {
+      boolean         isUnknown       = contact instanceof ContactSearchKey.UnknownRecipientKey;
       SelectedContact selectedContact = contact.requireSelectedContact();
 
       if (!canSelectSelf && !selectedContact.hasUsername() && Recipient.self().getId().equals(selectedContact.getOrCreateRecipientId(requireContext()))) {
@@ -650,7 +674,7 @@ public final class ContactSelectionListFragment extends LoggingFragment
               SelectedContact selected  = SelectedContact.forUsername(recipient.getId(), username);
 
               if (onContactSelectedListener != null) {
-                onContactSelectedListener.onBeforeContactSelected(Optional.of(recipient.getId()), null, allowed -> {
+                onContactSelectedListener.onBeforeContactSelected(true, Optional.of(recipient.getId()), null, allowed -> {
                   if (allowed) {
                     markContactSelected(selected);
                   }
@@ -668,7 +692,11 @@ public final class ContactSelectionListFragment extends LoggingFragment
           });
         } else {
           if (onContactSelectedListener != null) {
-            onContactSelectedListener.onBeforeContactSelected(Optional.ofNullable(selectedContact.getRecipientId()), selectedContact.getNumber(), allowed -> {
+            onContactSelectedListener.onBeforeContactSelected(
+                isUnknown,
+                Optional.ofNullable(selectedContact.getRecipientId()),
+                selectedContact.getNumber(),
+                allowed -> {
               if (allowed) {
                 markContactSelected(selectedContact);
               }
@@ -783,6 +811,7 @@ public final class ContactSelectionListFragment extends LoggingFragment
   }
 
   public void setOnRefreshListener(SwipeRefreshLayout.OnRefreshListener onRefreshListener) {
+    this.onRefreshListener = onRefreshListener;
     this.swipeRefresh.setOnRefreshListener(onRefreshListener);
   }
 
@@ -805,6 +834,8 @@ public final class ContactSelectionListFragment extends LoggingFragment
     boolean includeRecentsHeader       = !flagSet(displayMode, ContactSelectionDisplayMode.FLAG_HIDE_RECENT_HEADER);
     boolean includeGroupsAfterContacts = flagSet(displayMode, ContactSelectionDisplayMode.FLAG_GROUPS_AFTER_CONTACTS);
     boolean blocked                    = flagSet(displayMode, ContactSelectionDisplayMode.FLAG_BLOCK);
+    boolean includeGroupMembers        = flagSet(displayMode, ContactSelectionDisplayMode.FLAG_GROUP_MEMBERS);
+    boolean hasQuery                   = !TextUtils.isEmpty(contactSearchState.getQuery());
 
     ContactSearchConfiguration.TransportType        transportType = resolveTransportType(includePushContacts, includeSmsContacts);
     ContactSearchConfiguration.Section.Recents.Mode mode          = resolveRecentsMode(transportType, includeActiveGroups);
@@ -813,12 +844,12 @@ public final class ContactSelectionListFragment extends LoggingFragment
     return ContactSearchConfiguration.build(builder -> {
       builder.setQuery(contactSearchState.getQuery());
 
-      if (listCallback != null) {
+      if (newConversationCallback != null) {
         builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.NEW_GROUP.getCode());
       }
 
       if (transportType != null) {
-        if (TextUtils.isEmpty(contactSearchState.getQuery()) && includeRecents) {
+        if (!hasQuery && includeRecents) {
           builder.addSection(new ContactSearchConfiguration.Section.Recents(
               25,
               mode,
@@ -834,13 +865,13 @@ public final class ContactSelectionListFragment extends LoggingFragment
         builder.addSection(new ContactSearchConfiguration.Section.Individuals(
             includeSelf,
             transportType,
-            true,
+            newCallCallback == null,
             null,
             !hideLetterHeaders()
         ));
       }
 
-      if ((includeGroupsAfterContacts || !TextUtils.isEmpty(contactSearchState.getQuery())) && includeActiveGroups) {
+      if ((includeGroupsAfterContacts || hasQuery) && includeActiveGroups) {
         builder.addSection(new ContactSearchConfiguration.Section.Groups(
             includeSmsContacts,
             includeV1Groups,
@@ -853,18 +884,34 @@ public final class ContactSelectionListFragment extends LoggingFragment
         ));
       }
 
-      if (listCallback != null) {
-        builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.INVITE_TO_SIGNAL.getCode());
+      if (hasQuery && includeGroupMembers) {
+        builder.addSection(new ContactSearchConfiguration.Section.GroupMembers());
       }
 
       if (includeNew) {
         builder.phone(newRowMode);
         builder.username(newRowMode);
       }
+
+      if (newCallCallback != null || newConversationCallback != null) {
+        addMoreSection(builder);
+        builder.withEmptyState(emptyBuilder -> {
+          emptyBuilder.addSection(ContactSearchConfiguration.Section.Empty.INSTANCE);
+          addMoreSection(emptyBuilder);
+          return Unit.INSTANCE;
+        });
+      }
+
       return Unit.INSTANCE;
     });
   }
 
+  private void addMoreSection(@NonNull ContactSearchConfiguration.Builder builder) {
+    builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.MORE_HEADING.getCode());
+    builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.REFRESH_CONTACTS.getCode());
+    builder.arbitrary(ContactSelectionListAdapter.ArbitraryRepository.ArbitraryRow.INVITE_TO_SIGNAL.getCode());
+  }
+
   private static @Nullable ContactSearchConfiguration.TransportType resolveTransportType(boolean includePushContacts, boolean includeSmsContacts) {
     if (includePushContacts && includeSmsContacts) {
       return ContactSearchConfiguration.TransportType.ALL;
@@ -887,9 +934,11 @@ public final class ContactSelectionListFragment extends LoggingFragment
     }
   }
 
-  private static @NonNull ContactSearchConfiguration.NewRowMode resolveNewRowMode(boolean isBlocked, boolean isActiveGroups) {
+  private @NonNull ContactSearchConfiguration.NewRowMode resolveNewRowMode(boolean isBlocked, boolean isActiveGroups) {
     if (isBlocked) {
       return ContactSearchConfiguration.NewRowMode.BLOCK;
+    } else if (newCallCallback != null) {
+      return ContactSearchConfiguration.NewRowMode.NEW_CALL;
     } else if (isActiveGroups) {
       return ContactSearchConfiguration.NewRowMode.NEW_CONVERSATION;
     } else {
@@ -901,11 +950,23 @@ public final class ContactSelectionListFragment extends LoggingFragment
     return (mode & flag) > 0;
   }
 
+  private class CallButtonClickCallbacks implements ContactSearchAdapter.CallButtonClickCallbacks {
+    @Override
+    public void onVideoCallButtonClicked(@NonNull Recipient recipient) {
+      CommunicationActions.startVideoCall(ContactSelectionListFragment.this, recipient);
+    }
+
+    @Override
+    public void onAudioCallButtonClicked(@NonNull Recipient recipient) {
+      CommunicationActions.startVoiceCall(ContactSelectionListFragment.this, recipient);
+    }
+  }
+
   public interface OnContactSelectedListener {
     /**
      * Provides an opportunity to disallow selecting an item. Call the callback with false to disallow, or true to allow it.
      */
-    void onBeforeContactSelected(@NonNull Optional<RecipientId> recipientId, @Nullable String number, @NonNull Consumer<Boolean> callback);
+    void onBeforeContactSelected(boolean isFromUnknownSearchKey, @NonNull Optional<RecipientId> recipientId, @Nullable String number, @NonNull Consumer<Boolean> callback);
 
     void onContactDeselected(@NonNull Optional<RecipientId> recipientId, @Nullable String number);
 
@@ -918,12 +979,16 @@ public final class ContactSelectionListFragment extends LoggingFragment
     void onHardLimitReached(int limit);
   }
 
-  public interface ListCallback {
+  public interface NewConversationCallback {
     void onInvite();
 
     void onNewGroup(boolean forceV1);
   }
 
+  public interface NewCallCallback {
+    void onInvite();
+  }
+
   public interface ScrollCallback {
     void onBeginScroll();
   }

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

@@ -136,7 +136,7 @@ public class InviteActivity extends PassphraseRequiredActivity implements Contac
   }
 
   @Override
-  public void onBeforeContactSelected(@NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
+  public void onBeforeContactSelected(boolean isFromUnknownSearchKey, @NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
     updateSmsButtonText(contactsFragment.getSelectedContacts().size() + 1);
     callback.accept(true);
   }

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

@@ -6,6 +6,7 @@ import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
 import android.view.View;
+import android.view.ViewTreeObserver;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -14,6 +15,7 @@ import androidx.lifecycle.ViewModelProvider;
 
 import org.thoughtcrime.securesms.components.voice.VoiceNoteMediaController;
 import org.thoughtcrime.securesms.components.voice.VoiceNoteMediaControllerOwner;
+import org.thoughtcrime.securesms.conversationlist.RelinkDevicesReminderBottomSheetFragment;
 import org.thoughtcrime.securesms.devicetransfer.olddevice.OldDeviceTransferLockedDialog;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.stories.Stories;
@@ -24,6 +26,7 @@ import org.thoughtcrime.securesms.util.CachedInflater;
 import org.thoughtcrime.securesms.util.CommunicationActions;
 import org.thoughtcrime.securesms.util.DynamicNoActionBarTheme;
 import org.thoughtcrime.securesms.util.DynamicTheme;
+import org.thoughtcrime.securesms.util.FeatureFlags;
 import org.thoughtcrime.securesms.util.SplashScreenUtil;
 import org.thoughtcrime.securesms.util.WindowUtil;
 
@@ -37,6 +40,8 @@ public class MainActivity extends PassphraseRequiredActivity implements VoiceNot
   private VoiceNoteMediaController      mediaController;
   private ConversationListTabsViewModel conversationListTabsViewModel;
 
+  private boolean onFirstRender = false;
+
   public static @NonNull Intent clearTop(@NonNull Context context) {
     Intent intent = new Intent(context, MainActivity.class);
 
@@ -53,8 +58,23 @@ public class MainActivity extends PassphraseRequiredActivity implements VoiceNot
     super.onCreate(savedInstanceState, ready);
 
     setContentView(R.layout.main_activity);
+    final View content = findViewById(android.R.id.content);
+    content.getViewTreeObserver().addOnPreDrawListener(
+        new ViewTreeObserver.OnPreDrawListener() {
+          @Override
+          public boolean onPreDraw() {
+            // Use pre draw listener to delay drawing frames till conversation list is ready
+            if (onFirstRender) {
+              content.getViewTreeObserver().removeOnPreDrawListener(this);
+              return true;
+            } else {
+              return false;
+            }
+          }
+        });
 
-    mediaController = new VoiceNoteMediaController(this);
+
+    mediaController = new VoiceNoteMediaController(this, true);
 
     ConversationListTabRepository         repository = new ConversationListTabRepository();
     ConversationListTabsViewModel.Factory factory    = new ConversationListTabsViewModel.Factory(repository);
@@ -98,6 +118,11 @@ public class MainActivity extends PassphraseRequiredActivity implements VoiceNot
       OldDeviceTransferLockedDialog.show(getSupportFragmentManager());
     }
 
+    if (SignalStore.misc().getShouldShowLinkedDevicesReminder()) {
+      SignalStore.misc().setShouldShowLinkedDevicesReminder(false);
+      RelinkDevicesReminderBottomSheetFragment.show(getSupportFragmentManager());
+    }
+
     updateTabVisibility();
   }
 
@@ -123,7 +148,7 @@ public class MainActivity extends PassphraseRequiredActivity implements VoiceNot
   }
 
   private void updateTabVisibility() {
-    if (Stories.isFeatureEnabled()) {
+    if (Stories.isFeatureEnabled() || FeatureFlags.callsTab()) {
       findViewById(R.id.conversation_list_tabs).setVisibility(View.VISIBLE);
       WindowUtil.setNavigationBarColor(this, ContextCompat.getColor(this, R.color.signal_colorSurface2));
     } else {
@@ -158,6 +183,10 @@ public class MainActivity extends PassphraseRequiredActivity implements VoiceNot
     }
   }
 
+  public void onFirstRender() {
+    onFirstRender = true;
+  }
+
   @Override
   public @NonNull VoiceNoteMediaController getVoiceNoteMediaController() {
     return mediaController;

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

@@ -69,7 +69,7 @@ import java.util.stream.Stream;
  * @author Moxie Marlinspike
  */
 public class NewConversationActivity extends ContactSelectionActivity
-    implements ContactSelectionListFragment.ListCallback, ContactSelectionListFragment.OnItemLongClickListener
+    implements ContactSelectionListFragment.NewConversationCallback, ContactSelectionListFragment.OnItemLongClickListener
 {
 
   @SuppressWarnings("unused")
@@ -93,7 +93,7 @@ public class NewConversationActivity extends ContactSelectionActivity
     ContactsManagementViewModel.Factory factory    = new ContactsManagementViewModel.Factory(repository);
 
     contactLauncher = registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), activityResult -> {
-      if (activityResult.getResultCode() == RESULT_OK) {
+      if (activityResult.getResultCode() != RESULT_CANCELED) {
         handleManualRefresh();
       }
     });
@@ -102,7 +102,7 @@ public class NewConversationActivity extends ContactSelectionActivity
   }
 
   @Override
-  public void onBeforeContactSelected(@NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
+  public void onBeforeContactSelected(boolean isFromUnknownSearchKey, @NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
     boolean smsSupported = SignalStore.misc().getSmsExportPhase().allowSmsFeatures();
 
     if (recipientId.isPresent()) {
@@ -177,22 +177,23 @@ public class NewConversationActivity extends ContactSelectionActivity
   public boolean onOptionsItemSelected(MenuItem item) {
     super.onOptionsItemSelected(item);
 
-    switch (item.getItemId()) {
-      case android.R.id.home:
-        super.onBackPressed();
-        return true;
-      case R.id.menu_refresh:
-        handleManualRefresh();
-        return true;
-      case R.id.menu_new_group:
-        handleCreateGroup();
-        return true;
-      case R.id.menu_invite:
-        handleInvite();
-        return true;
-    }
+    int itemId = item.getItemId();
 
-    return false;
+    if (itemId == android.R.id.home) {
+      super.onBackPressed();
+      return true;
+    } else if (itemId == R.id.menu_refresh) {
+      handleManualRefresh();
+      return true;
+    } else if (itemId == R.id.menu_new_group) {
+      handleCreateGroup();
+      return true;
+    } else if (itemId == R.id.menu_invite) {
+      handleInvite();
+      return true;
+    } else {
+      return false;
+    }
   }
 
   private void handleManualRefresh() {

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

@@ -20,20 +20,17 @@ import org.thoughtcrime.securesms.crypto.MasterSecretUtil;
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies;
 import org.thoughtcrime.securesms.devicetransfer.olddevice.OldDeviceTransferActivity;
 import org.thoughtcrime.securesms.jobs.PushNotificationReceiveJob;
-import org.thoughtcrime.securesms.keyvalue.PhoneNumberPrivacyValues;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.lock.v2.CreateKbsPinActivity;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrationActivity;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrations;
 import org.thoughtcrime.securesms.pin.PinRestoreActivity;
 import org.thoughtcrime.securesms.profiles.edit.EditProfileActivity;
-import org.thoughtcrime.securesms.profiles.username.AddAUsernameActivity;
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.registration.RegistrationNavigationActivity;
 import org.thoughtcrime.securesms.service.KeyCachingService;
 import org.thoughtcrime.securesms.util.AppStartup;
-import org.thoughtcrime.securesms.util.FeatureFlags;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 
 import java.util.Locale;
@@ -55,7 +52,6 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
   private static final int STATE_TRANSFER_ONGOING    = 8;
   private static final int STATE_TRANSFER_LOCKED     = 9;
   private static final int STATE_CHANGE_NUMBER_LOCK  = 10;
-  private static final int STATE_CREATE_USERNAME     = 11;
 
   private SignalServiceNetworkAccess networkAccess;
   private BroadcastReceiver          clearKeyReceiver;
@@ -160,7 +156,6 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
       case STATE_TRANSFER_ONGOING:    return getOldDeviceTransferIntent();
       case STATE_TRANSFER_LOCKED:     return getOldDeviceTransferLockedIntent();
       case STATE_CHANGE_NUMBER_LOCK:  return getChangeNumberLockIntent();
-      case STATE_CREATE_USERNAME:     return getCreateUsernameIntent();
       default:                        return null;
     }
   }
@@ -180,8 +175,6 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
       return STATE_CREATE_SIGNAL_PIN;
     } else if (userMustSetProfileName()) {
       return STATE_CREATE_PROFILE_NAME;
-    } else if (shouldAskUserToCreateUsername()) {
-      return STATE_CREATE_USERNAME;
     } else if (userMustCreateSignalPin()) {
       return STATE_CREATE_SIGNAL_PIN;
     } else if (EventBus.getDefault().getStickyEvent(TransferStatus.class) != null && getClass() != OldDeviceTransferActivity.class) {
@@ -207,13 +200,6 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
     return !SignalStore.registrationValues().isRegistrationComplete() && Recipient.self().getProfileName().isEmpty();
   }
 
-  private boolean shouldAskUserToCreateUsername() {
-    return FeatureFlags.usernames() &&
-           FeatureFlags.phoneNumberPrivacy() &&
-           !SignalStore.uiHints().hasSetOrSkippedUsernameCreation() &&
-           SignalStore.phoneNumberPrivacy().getPhoneNumberListingMode() == PhoneNumberPrivacyValues.PhoneNumberListingMode.UNLISTED;
-  }
-
   private Intent getCreatePassphraseIntent() {
     return getRoutedIntent(PassphraseCreateActivity.class, getIntent());
   }
@@ -273,10 +259,6 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
     return ChangeNumberLockActivity.createIntent(this);
   }
 
-  private Intent getCreateUsernameIntent() {
-    return getRoutedIntent(AddAUsernameActivity.class, getIntent());
-  }
-
   private Intent getRoutedIntent(Intent destination, @Nullable Intent nextIntent) {
     if (nextIntent != null)   destination.putExtra("next_intent", nextIntent);
     return destination;

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

@@ -31,10 +31,9 @@ import android.os.Bundle;
 import android.util.Rational;
 import android.view.Window;
 import android.view.WindowManager;
-import android.widget.Toast;
 
 import androidx.annotation.NonNull;
-import androidx.appcompat.app.AlertDialog;
+import androidx.annotation.RequiresApi;
 import androidx.appcompat.app.AppCompatDelegate;
 import androidx.core.content.ContextCompat;
 import androidx.core.util.Consumer;
@@ -58,6 +57,7 @@ import org.thoughtcrime.securesms.components.TooltipPopup;
 import org.thoughtcrime.securesms.components.sensors.DeviceOrientationMonitor;
 import org.thoughtcrime.securesms.components.webrtc.CallParticipantsListUpdatePopupWindow;
 import org.thoughtcrime.securesms.components.webrtc.CallParticipantsState;
+import org.thoughtcrime.securesms.components.webrtc.CallStateUpdatePopupWindow;
 import org.thoughtcrime.securesms.components.webrtc.CallToastPopupWindow;
 import org.thoughtcrime.securesms.components.webrtc.GroupCallSafetyNumberChangeNotificationUtil;
 import org.thoughtcrime.securesms.components.webrtc.WebRtcAudioOutput;
@@ -112,6 +112,7 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
   public static final String EXTRA_STARTED_FROM_FULLSCREEN   = WebRtcCallActivity.class.getCanonicalName() + ".STARTED_FROM_FULLSCREEN";
 
   private CallParticipantsListUpdatePopupWindow participantUpdateWindow;
+  private CallStateUpdatePopupWindow            callStateUpdatePopupWindow;
   private WifiToCellularPopupWindow             wifiToCellularPopupWindow;
   private DeviceOrientationMonitor              deviceOrientationMonitor;
 
@@ -124,6 +125,7 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
   private WindowLayoutInfoConsumer         windowLayoutInfoConsumer;
   private WindowInfoTrackerCallbackAdapter windowInfoTrackerCallbackAdapter;
   private ThrottledDebouncer               requestNewSizesThrottle;
+  private PictureInPictureParams.Builder   pipBuilderParams;
 
   private Disposable ephemeralStateDisposable = Disposable.empty();
 
@@ -155,6 +157,7 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
 
     initializeResources();
     initializeViewModel(isLandscapeEnabled);
+    initializePictureInPictureParams();
 
     processIntent(getIntent());
 
@@ -274,14 +277,16 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
   }
 
   private boolean enterPipModeIfPossible() {
-    if (viewModel.canEnterPipMode() && isSystemPipEnabledAndAvailable()) {
-      PictureInPictureParams params = new PictureInPictureParams.Builder()
-          .setAspectRatio(new Rational(9, 16))
-          .build();
-      enterPictureInPictureMode(params);
-      CallParticipantsListDialog.dismiss(getSupportFragmentManager());
+    if (isSystemPipEnabledAndAvailable()) {
+      if (viewModel.canEnterPipMode()) {
+        enterPictureInPictureMode(pipBuilderParams.build());
+        CallParticipantsListDialog.dismiss(getSupportFragmentManager());
 
-      return true;
+        return true;
+      }
+      if (Build.VERSION.SDK_INT >= 31) {
+        pipBuilderParams.setAutoEnterEnabled(false);
+      }
     }
     return false;
   }
@@ -312,8 +317,9 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
     callScreen = findViewById(R.id.callScreen);
     callScreen.setControlsListener(new ControlsListener());
 
-    participantUpdateWindow   = new CallParticipantsListUpdatePopupWindow(callScreen);
-    wifiToCellularPopupWindow = new WifiToCellularPopupWindow(callScreen);
+    participantUpdateWindow    = new CallParticipantsListUpdatePopupWindow(callScreen);
+    callStateUpdatePopupWindow = new CallStateUpdatePopupWindow(callScreen);
+    wifiToCellularPopupWindow  = new WifiToCellularPopupWindow(callScreen);
   }
 
   private void initializeViewModel(boolean isLandscapeEnabled) {
@@ -356,9 +362,23 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
     addOnPictureInPictureModeChangedListener(info -> {
       viewModel.setIsInPipMode(info.isInPictureInPictureMode());
       participantUpdateWindow.setEnabled(!info.isInPictureInPictureMode());
+      callStateUpdatePopupWindow.setEnabled(!info.isInPictureInPictureMode());
     });
   }
 
+  private void initializePictureInPictureParams() {
+    if (isSystemPipEnabledAndAvailable()) {
+      pipBuilderParams = new PictureInPictureParams.Builder();
+      pipBuilderParams.setAspectRatio(new Rational(9, 16));
+      if (Build.VERSION.SDK_INT >= 31) {
+        pipBuilderParams.setAutoEnterEnabled(true);
+      }
+      if (Build.VERSION.SDK_INT >= 26) {
+        setPictureInPictureParams(pipBuilderParams.build());
+      }
+    }
+  }
+
   private void handleViewModelEvent(@NonNull WebRtcCallViewModel.Event event) {
     if (event instanceof WebRtcCallViewModel.Event.StartCall) {
       startCall(((WebRtcCallViewModel.Event.StartCall) event).isVideoCall());
@@ -412,15 +432,19 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
   }
 
   private void handleSetAudioHandset() {
-    ApplicationDependencies.getSignalCallManager().selectAudioDevice(SignalAudioManager.AudioDevice.EARPIECE);
+    ApplicationDependencies.getSignalCallManager().selectAudioDevice(new SignalAudioManager.ChosenAudioDeviceIdentifier(SignalAudioManager.AudioDevice.EARPIECE));
   }
 
   private void handleSetAudioSpeaker() {
-    ApplicationDependencies.getSignalCallManager().selectAudioDevice(SignalAudioManager.AudioDevice.SPEAKER_PHONE);
+    ApplicationDependencies.getSignalCallManager().selectAudioDevice(new SignalAudioManager.ChosenAudioDeviceIdentifier(SignalAudioManager.AudioDevice.SPEAKER_PHONE));
   }
 
   private void handleSetAudioBluetooth() {
-    ApplicationDependencies.getSignalCallManager().selectAudioDevice(SignalAudioManager.AudioDevice.BLUETOOTH);
+    ApplicationDependencies.getSignalCallManager().selectAudioDevice(new SignalAudioManager.ChosenAudioDeviceIdentifier(SignalAudioManager.AudioDevice.BLUETOOTH));
+  }
+
+  private void handleSetAudioWiredHeadset() {
+    ApplicationDependencies.getSignalCallManager().selectAudioDevice(new SignalAudioManager.ChosenAudioDeviceIdentifier(SignalAudioManager.AudioDevice.WIRED_HEADSET));
   }
 
   private void handleSetMuteAudio(boolean enabled) {
@@ -565,7 +589,7 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
 
   private void handleNoSuchUser(final @NonNull WebRtcViewModel event) {
     if (isFinishing()) return; // XXX Stuart added this check above, not sure why, so I'm repeating in ignorance. - moxie
-    new AlertDialog.Builder(this)
+    new MaterialAlertDialogBuilder(this)
         .setTitle(R.string.RedPhone_number_not_registered)
         .setIcon(R.drawable.ic_warning)
         .setMessage(R.string.RedPhone_the_number_you_dialed_does_not_support_secure_voice)
@@ -782,17 +806,26 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
         case HANDSET:
           handleSetAudioHandset();
           break;
-        case HEADSET:
+        case BLUETOOTH_HEADSET:
           handleSetAudioBluetooth();
           break;
         case SPEAKER:
           handleSetAudioSpeaker();
           break;
+        case WIRED_HEADSET:
+          handleSetAudioWiredHeadset();
+          break;
         default:
           throw new IllegalStateException("Unknown output: " + audioOutput);
       }
     }
 
+    @RequiresApi(31)
+    @Override
+    public void onAudioOutputChanged31(@NonNull int audioDeviceInfo) {
+      ApplicationDependencies.getSignalCallManager().selectAudioDevice(new SignalAudioManager.ChosenAudioDeviceIdentifier(audioDeviceInfo));
+    }
+
     @Override
     public void onVideoChanged(boolean isVideoEnabled) {
       handleSetMuteVideo(!isVideoEnabled);
@@ -800,6 +833,8 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
 
     @Override
     public void onMicChanged(boolean isMicEnabled) {
+      callStateUpdatePopupWindow.onCallStateUpdate(isMicEnabled ? CallStateUpdatePopupWindow.CallStateUpdate.MIC_ON
+                                                                : CallStateUpdatePopupWindow.CallStateUpdate.MIC_OFF);
       handleSetMuteAudio(!isMicEnabled);
     }
 
@@ -832,11 +867,6 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
       }
     }
 
-    @Override
-    public void onShowParticipantsList() {
-      CallParticipantsListDialog.show(getSupportFragmentManager());
-    }
-
     @Override
     public void onPageChanged(@NonNull CallParticipantsState.SelectedPage page) {
       viewModel.setIsViewingFocusedParticipant(page);
@@ -851,11 +881,23 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
     public void onRingGroupChanged(boolean ringGroup, boolean ringingAllowed) {
       if (ringingAllowed) {
         ApplicationDependencies.getSignalCallManager().setRingGroup(ringGroup);
+        callStateUpdatePopupWindow.onCallStateUpdate(ringGroup ? CallStateUpdatePopupWindow.CallStateUpdate.RINGING_ON
+                                                               : CallStateUpdatePopupWindow.CallStateUpdate.RINGING_OFF);
       } else {
         ApplicationDependencies.getSignalCallManager().setRingGroup(false);
-        Toast.makeText(WebRtcCallActivity.this, R.string.WebRtcCallActivity__group_is_too_large_to_ring_the_participants, Toast.LENGTH_SHORT).show();
+        callStateUpdatePopupWindow.onCallStateUpdate(CallStateUpdatePopupWindow.CallStateUpdate.RINGING_DISABLED);
       }
     }
+
+    @Override
+    public void onCallInfoClicked() {
+      CallParticipantsListDialog.show(getSupportFragmentManager());
+    }
+
+    @Override
+    public void onNavigateUpClicked() {
+      onBackPressed();
+    }
   }
 
   private class WindowLayoutInfoConsumer implements Consumer<WindowLayoutInfo> {

app/src/main/java/org/thoughtcrime/securesms/animation/transitions/CircleSquareImageViewTransition.java

@@ -13,7 +13,6 @@ import android.widget.ImageView;
 
 import androidx.core.graphics.drawable.RoundedBitmapDrawable;
 
-@TargetApi(21)
 abstract class CircleSquareImageViewTransition extends Transition {
 
   private static final String CIRCLE_RATIO = "CIRCLE_RATIO";

app/src/main/java/org/thoughtcrime/securesms/animation/transitions/CircleToSquareImageViewTransition.java

@@ -7,7 +7,6 @@ import android.util.AttributeSet;
 /**
  * Will only transition {@link android.widget.ImageView}s that contain a {@link androidx.core.graphics.drawable.RoundedBitmapDrawable}.
  */
-@TargetApi(21)
 public final class CircleToSquareImageViewTransition extends CircleSquareImageViewTransition {
   public CircleToSquareImageViewTransition(Context context, AttributeSet attrs) {
     super(false);

app/src/main/java/org/thoughtcrime/securesms/animation/transitions/SquareToCircleImageViewTransition.java

@@ -7,7 +7,6 @@ import android.util.AttributeSet;
 /**
  * Will only transition {@link android.widget.ImageView}s that contain a {@link androidx.core.graphics.drawable.RoundedBitmapDrawable}.
  */
-@TargetApi(21)
 public final class SquareToCircleImageViewTransition extends CircleSquareImageViewTransition {
   public SquareToCircleImageViewTransition(Context context, AttributeSet attrs) {
     super(true);

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

@@ -9,8 +9,11 @@ import org.thoughtcrime.securesms.blurhash.BlurHash;
 import org.thoughtcrime.securesms.database.AttachmentTable;
 import org.thoughtcrime.securesms.stickers.StickerLocator;
 import org.thoughtcrime.securesms.util.Base64;
+import org.whispersystems.signalservice.api.InvalidMessageStructureException;
 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
+import org.whispersystems.signalservice.api.util.AttachmentPointerUtil;
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -145,4 +148,33 @@ public class PointerAttachment extends Attachment {
                                              null,
                                              null));
   }
+
+  public static Optional<Attachment> forPointer(SignalServiceProtos.DataMessage.Quote.QuotedAttachment quotedAttachment) {
+    SignalServiceAttachment thumbnail;
+    try {
+      thumbnail = quotedAttachment.hasThumbnail() ? AttachmentPointerUtil.createSignalAttachmentPointer(quotedAttachment.getThumbnail()) : null;
+    } catch (InvalidMessageStructureException e) {
+      return Optional.empty();
+    }
+
+    return Optional.of(new PointerAttachment(quotedAttachment.getContentType(),
+                                             AttachmentTable.TRANSFER_PROGRESS_PENDING,
+                                             thumbnail != null ? thumbnail.asPointer().getSize().orElse(0) : 0,
+                                             quotedAttachment.getFileName(),
+                                             thumbnail != null ? thumbnail.asPointer().getCdnNumber() : 0,
+                                             thumbnail != null ? thumbnail.asPointer().getRemoteId().toString() : "0",
+                                             thumbnail != null && thumbnail.asPointer().getKey() != null ? Base64.encodeBytes(thumbnail.asPointer().getKey()) : null,
+                                             null,
+                                             thumbnail != null ? thumbnail.asPointer().getDigest().orElse(null) : null,
+                                             null,
+                                             false,
+                                             false,
+                                             false,
+                                             thumbnail != null ? thumbnail.asPointer().getWidth() : 0,
+                                             thumbnail != null ? thumbnail.asPointer().getHeight() : 0,
+                                             thumbnail != null ? thumbnail.asPointer().getUploadTimestamp() : 0,
+                                             thumbnail != null ? thumbnail.asPointer().getCaption().orElse(null) : null,
+                                             null,
+                                             null));
+  }
 }

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

@@ -7,6 +7,7 @@ import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
 import android.media.MediaRecorder;
 import android.os.ParcelFileDescriptor;
+import android.os.Process;
 
 import org.signal.core.util.StreamUtil;
 import org.signal.core.util.logging.Log;
@@ -65,6 +66,7 @@ public class AudioCodec implements Recorder {
     new Thread(new Runnable() {
       @Override
       public void run() {
+        Process.setThreadPriority(Process.THREAD_PRIORITY_AUDIO);
         MediaCodec.BufferInfo bufferInfo         = new MediaCodec.BufferInfo();
         byte[]                audioRecordData    = new byte[bufferSize];
         ByteBuffer[]          codecInputBuffers  = mediaCodec.getInputBuffers();

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

@@ -9,6 +9,7 @@ import android.os.ParcelFileDescriptor;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
+import org.signal.core.util.ThreadUtil;
 import org.signal.core.util.concurrent.SignalExecutors;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.components.voice.VoiceNoteDraft;
@@ -25,7 +26,7 @@ public class AudioRecorder {
 
   private static final String TAG = Log.tag(AudioRecorder.class);
 
-  private static final ExecutorService executor = SignalExecutors.newCachedSingleThreadExecutor("signal-AudioRecorder");
+  private static final ExecutorService executor = SignalExecutors.newCachedSingleThreadExecutor("signal-AudioRecorder", ThreadUtil.PRIORITY_UI_BLOCKING_THREAD);
 
   private final Context                   context;
   private final AudioRecordingHandler     uiHandler;
@@ -68,7 +69,8 @@ public class AudioRecorder {
       Log.i(TAG, "Running startRecording() + " + Thread.currentThread().getId());
       try {
         if (recorder != null) {
-          throw new AssertionError("We can only record once at a time.");
+          recordingSingle.onError(new IllegalStateException("We can only do one recording at a time!"));
+          return;
         }
 
         ParcelFileDescriptor fds[] = ParcelFileDescriptor.createPipe();

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

@@ -1,6 +1,7 @@
 package org.thoughtcrime.securesms.audio;
 
 import android.media.MediaRecorder;
+import android.os.Build;
 import android.os.ParcelFileDescriptor;
 
 import org.signal.core.util.logging.Log;
@@ -30,7 +31,7 @@ public class MediaRecorderWrapper implements Recorder {
       recorder.setOutputFormat(MediaRecorder.OutputFormat.AAC_ADTS);
       recorder.setOutputFile(fileDescriptor.getFileDescriptor());
       recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
-      recorder.setAudioSamplingRate(SAMPLE_RATE);
+      recorder.setAudioSamplingRate(getSampleRate());
       recorder.setAudioEncodingBitRate(BIT_RATE);
       recorder.setAudioChannels(CHANNELS);
       recorder.prepare();
@@ -62,4 +63,12 @@ public class MediaRecorderWrapper implements Recorder {
       recorder = null;
     }
   }
+
+  private static int getSampleRate() {
+    if ("Xiaomi".equals(Build.MANUFACTURER) && "Mi 9T".equals(Build.MODEL)) {
+      // Recordings sound robotic with the standard sample rate.
+      return 44000;
+    }
+    return SAMPLE_RATE;
+  }
 }

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

@@ -1,6 +1,8 @@
 package org.thoughtcrime.securesms.avatar
 
+import android.net.Uri
 import android.os.Bundle
+import org.signal.core.util.getParcelableCompat
 
 /**
  * Utility class which encapsulates reading and writing Avatar objects to and from Bundles.
@@ -33,7 +35,7 @@ object AvatarBundler {
   }
 
   fun extractPhoto(bundle: Bundle): Avatar.Photo = Avatar.Photo(
-    uri = requireNotNull(bundle.getParcelable(URI)),
+    uri = requireNotNull(bundle.getParcelableCompat(URI, Uri::class.java)),
     size = bundle.getLong(SIZE),
     databaseId = bundle.getDatabaseId()
   )

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

@@ -0,0 +1,50 @@
+package org.thoughtcrime.securesms.avatar.photo
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.fragment.app.Fragment
+import org.thoughtcrime.securesms.avatar.Avatar
+import org.thoughtcrime.securesms.avatar.AvatarBundler
+import org.thoughtcrime.securesms.components.FragmentWrapperActivity
+
+class PhotoEditorActivity : FragmentWrapperActivity() {
+
+  override fun attachBaseContext(newBase: Context) {
+    delegate.localNightMode = AppCompatDelegate.MODE_NIGHT_YES
+    super.attachBaseContext(newBase)
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?, ready: Boolean) {
+    super.onCreate(savedInstanceState, ready)
+
+    supportFragmentManager.setFragmentResultListener(PhotoEditorFragment.REQUEST_KEY_EDIT, this) { _, bundle ->
+      setResult(Activity.RESULT_OK, Intent().putExtras(bundle))
+      finishAfterTransition()
+    }
+  }
+
+  override fun getFragment(): Fragment = PhotoEditorFragment().apply {
+    arguments = intent.extras
+  }
+
+  class Contract : ActivityResultContract<Avatar.Photo, Avatar.Photo?>() {
+    override fun createIntent(context: Context, input: Avatar.Photo): Intent {
+      return Intent(context, PhotoEditorActivity::class.java).apply {
+        putExtras(PhotoEditorActivityArgs.Builder(AvatarBundler.bundlePhoto(input)).build().toBundle())
+      }
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): Avatar.Photo? {
+      val extras = intent?.extras
+      if (resultCode != Activity.RESULT_OK || extras == null) {
+        return null
+      }
+
+      return AvatarBundler.extractPhoto(extras)
+    }
+  }
+}

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

@@ -5,7 +5,6 @@ import android.view.View
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.commit
 import androidx.fragment.app.setFragmentResult
-import androidx.navigation.Navigation
 import org.signal.core.util.ThreadUtil
 import org.signal.core.util.concurrent.SignalExecutors
 import org.thoughtcrime.securesms.R
@@ -18,7 +17,7 @@ import org.thoughtcrime.securesms.scribbles.ImageEditorFragment
 class PhotoEditorFragment : Fragment(R.layout.avatar_photo_editor_fragment), ImageEditorFragment.Controller {
 
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-    val args = PhotoEditorFragmentArgs.fromBundle(requireArguments())
+    val args = PhotoEditorActivityArgs.fromBundle(requireArguments())
     val photo = AvatarBundler.extractPhoto(args.photoAvatar)
     val imageEditorFragment = ImageEditorFragment.newInstanceForAvatarEdit(photo.uri)
 
@@ -34,7 +33,7 @@ class PhotoEditorFragment : Fragment(R.layout.avatar_photo_editor_fragment), Ima
   }
 
   override fun onDoneEditing() {
-    val args = PhotoEditorFragmentArgs.fromBundle(requireArguments())
+    val args = PhotoEditorActivityArgs.fromBundle(requireArguments())
     val applicationContext = requireContext().applicationContext
     val imageEditorFragment: ImageEditorFragment = childFragmentManager.findFragmentByTag(IMAGE_EDITOR) as ImageEditorFragment
 
@@ -52,13 +51,12 @@ class PhotoEditorFragment : Fragment(R.layout.avatar_photo_editor_fragment), Ima
 
       ThreadUtil.runOnMain {
         setFragmentResult(REQUEST_KEY_EDIT, AvatarBundler.bundlePhoto(newPhoto))
-        Navigation.findNavController(requireView()).popBackStack()
       }
     }
   }
 
   override fun onCancelEditing() {
-    Navigation.findNavController(requireView()).popBackStack()
+    requireActivity().finishAfterTransition()
   }
 
   override fun restoreState() {

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

@@ -8,6 +8,7 @@ import android.view.Gravity
 import android.view.View
 import android.widget.PopupMenu
 import android.widget.Toast
+import androidx.activity.result.ActivityResultLauncher
 import androidx.appcompat.widget.Toolbar
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.setFragmentResult
@@ -16,9 +17,11 @@ import androidx.fragment.app.viewModels
 import androidx.navigation.Navigation
 import androidx.recyclerview.widget.RecyclerView
 import org.signal.core.util.ThreadUtil
+import org.signal.core.util.getParcelableExtraCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.avatar.Avatar
 import org.thoughtcrime.securesms.avatar.AvatarBundler
+import org.thoughtcrime.securesms.avatar.photo.PhotoEditorActivity
 import org.thoughtcrime.securesms.avatar.photo.PhotoEditorFragment
 import org.thoughtcrime.securesms.avatar.text.TextAvatarCreationFragment
 import org.thoughtcrime.securesms.avatar.vector.VectorAvatarCreationFragment
@@ -49,6 +52,7 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
   private val viewModel: AvatarPickerViewModel by viewModels(factoryProducer = this::createFactory)
 
   private lateinit var recycler: RecyclerView
+  private lateinit var photoEditorLauncher: ActivityResultLauncher<Avatar.Photo>
 
   private fun createFactory(): AvatarPickerViewModel.Factory {
     val args = AvatarPickerFragmentArgs.fromBundle(requireArguments())
@@ -137,8 +141,12 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
     }
 
     setFragmentResultListener(PhotoEditorFragment.REQUEST_KEY_EDIT) { _, bundle ->
-      val photo = AvatarBundler.extractPhoto(bundle)
-      viewModel.onAvatarEditCompleted(photo)
+    }
+
+    photoEditorLauncher = registerForActivityResult(PhotoEditorActivity.Contract()) { photo ->
+      if (photo != null) {
+        viewModel.onAvatarEditCompleted(photo)
+      }
     }
   }
 
@@ -147,10 +155,9 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
     ViewUtil.hideKeyboard(requireContext(), requireView())
   }
 
-  @Suppress("DEPRECATION")
   override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
     if (requestCode == REQUEST_CODE_SELECT_IMAGE && resultCode == Activity.RESULT_OK && data != null) {
-      val media: Media = requireNotNull(data.getParcelableExtra(AvatarSelectionActivity.EXTRA_MEDIA))
+      val media: Media = requireNotNull(data.getParcelableExtraCompat(AvatarSelectionActivity.EXTRA_MEDIA, Media::class.java))
       viewModel.onAvatarPhotoSelectionCompleted(media)
     } else {
       super.onActivityResult(requestCode, resultCode, data)
@@ -197,8 +204,7 @@ class AvatarPickerFragment : Fragment(R.layout.avatar_picker_fragment) {
   }
 
   private fun openPhotoEditor(photo: Avatar.Photo) {
-    Navigation.findNavController(requireView())
-      .safeNavigate(AvatarPickerFragmentDirections.actionAvatarPickerFragmentToAvatarPhotoEditorFragment(AvatarBundler.bundlePhoto(photo)))
+    photoEditorLauncher.launch(photo)
   }
 
   private fun openVectorEditor(vector: Avatar.Vector) {

app/src/main/java/org/thoughtcrime/securesms/avatar/view/AvatarView.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.AttributeSet
 import android.view.View
 import android.widget.FrameLayout
+import androidx.core.content.res.use
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.AvatarImageView
 import org.thoughtcrime.securesms.database.model.StoryViewState
@@ -20,10 +21,12 @@ class AvatarView @JvmOverloads constructor(
   attrs: AttributeSet? = null
 ) : FrameLayout(context, attrs) {
 
+  private var storyRingScale = 0.8f
   init {
     inflate(context, R.layout.avatar_view, this)
 
     isClickable = false
+    storyRingScale = context.theme.obtainStyledAttributes(attrs, R.styleable.AvatarView, 0, 0).use { it.getFloat(R.styleable.AvatarView_storyRingScale, storyRingScale) }
   }
 
   private val avatar: AvatarImageView = findViewById<AvatarImageView>(R.id.avatar_image_view).apply {
@@ -40,8 +43,8 @@ class AvatarView @JvmOverloads constructor(
     storyRing.visible = true
     storyRing.isActivated = hasUnreadStory
 
-    avatar.scaleX = 0.8f
-    avatar.scaleY = 0.8f
+    avatar.scaleX = storyRingScale
+    avatar.scaleY = storyRingScale
   }
 
   private fun hideStoryRing() {

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

@@ -130,6 +130,7 @@ public class BackupDialog {
                                      Intent.FLAG_GRANT_READ_URI_PERMISSION);
 
                     try {
+                       Log.d(TAG, "Starting choose backup location dialog");
                        fragment.startActivityForResult(intent, requestCode);
                      } catch (ActivityNotFoundException e) {
                        Toast.makeText(fragment.requireContext(), R.string.BackupDialog_no_file_picker_available, Toast.LENGTH_LONG)

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

@@ -282,6 +282,8 @@ public class FullBackupExporter extends FullBackupBase {
   {
     List<String> tablesInOrder = getTablesToExportInOrder(input);
 
+    Log.i(TAG, "Exporting tables in the following order: " + tablesInOrder);
+
     Map<String, String> createStatementsByTable = new HashMap<>();
 
     try (Cursor cursor = input.rawQuery("SELECT sql, name, type FROM sqlite_master WHERE type = 'table' AND sql NOT NULL", null)) {
@@ -328,12 +330,16 @@ public class FullBackupExporter extends FullBackupBase {
                                  .sorted()
                                  .collect(Collectors.toList());
 
-    
     Map<String, Set<String>> dependsOn = new LinkedHashMap<>();
     for (String table : tables) {
       dependsOn.put(table, SqlUtil.getForeignKeyDependencies(input, table));
     }
-    
+
+    for (String table : tables) {
+      Set<String> dependsOnTable = dependsOn.keySet().stream().filter(t -> dependsOn.get(t).contains(table)).collect(Collectors.toSet());
+      Log.i(TAG, "Tables that depend on " + table + ": " + dependsOnTable);
+    }
+
     return computeTableOrder(dependsOn);
   }
 
@@ -396,6 +402,8 @@ public class FullBackupExporter extends FullBackupBase {
                                  @NonNull BackupCancellationSignal cancellationSignal)
       throws IOException
   {
+    Log.d(TAG, "Exporting table: " + table);
+
     String template = "INSERT INTO " + table + " VALUES ";
 
     try (Cursor cursor = input.rawQuery("SELECT * FROM " + table, null)) {

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

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.badges.gifts
 
 import android.os.Bundle
 import androidx.fragment.app.FragmentManager
+import org.signal.core.util.getParcelableCompat
 import org.thoughtcrime.securesms.badges.gifts.ExpiredGiftSheetConfiguration.forExpiredBadge
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
@@ -28,7 +29,7 @@ class ExpiredGiftSheet : DSLSettingsBottomSheetFragment() {
   }
 
   private val badge: Badge
-    get() = requireArguments().getParcelable(ARG_BADGE)!!
+    get() = requireArguments().getParcelableCompat(ARG_BADGE, Badge::class.java)!!
 
   override fun bindAdapter(adapter: DSLSettingsAdapter) {
     ExpiredGiftSheetConfiguration.register(adapter)

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

@@ -58,7 +58,7 @@ class GiftMessageView @JvmOverloads constructor(
 
     if (isOutgoing) {
       actionView.setText(R.string.GiftMessageView__view)
-      titleView.text = context.getString(R.string.GiftMessageView__donation_to_s, recipient.getDisplayName(context))
+      titleView.text = context.getString(R.string.GiftMessageView__donation_on_behalf_of_s, recipient.getDisplayName(context))
     } else {
       titleView.text = context.getString(R.string.GiftMessageView__s_donated_to_signal_on, recipient.getShortDisplayName(context))
       when (giftBadge.redemptionState) {

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

@@ -9,6 +9,7 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
 import androidx.navigation.fragment.findNavController
+import org.signal.core.util.getParcelableArrayListCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchConfiguration
 import org.thoughtcrime.securesms.contacts.paged.ContactSearchKey
@@ -79,7 +80,7 @@ class GiftFlowRecipientSelectionFragment : Fragment(R.layout.gift_flow_recipient
   override fun onSearchInputFocused() = Unit
 
   override fun setResult(bundle: Bundle) {
-    val contacts: List<ContactSearchKey.RecipientSearchKey> = bundle.getParcelableArrayList(MultiselectForwardFragment.RESULT_SELECTION)!!
+    val contacts: List<ContactSearchKey.RecipientSearchKey> = bundle.getParcelableArrayListCompat(MultiselectForwardFragment.RESULT_SELECTION, ContactSearchKey.RecipientSearchKey::class.java)!!
 
     if (contacts.isNotEmpty()) {
       viewModel.setSelectedContact(contacts.first())

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

@@ -18,6 +18,7 @@ import org.thoughtcrime.securesms.util.LifecycleDisposable
 import org.thoughtcrime.securesms.util.ViewUtil
 import org.thoughtcrime.securesms.util.adapter.mapping.MappingAdapter
 import org.thoughtcrime.securesms.util.navigation.safeNavigate
+import java.util.concurrent.TimeUnit
 
 /**
  * Landing fragment for sending gifts.
@@ -78,8 +79,9 @@ class GiftFlowStartFragment : DSLSettingsFragment(
 
       space(DimensionUnit.DP.toPixels(16f).toInt())
 
+      val days = state.giftBadge?.duration?.let { TimeUnit.MILLISECONDS.toDays(it) } ?: 60L
       noPadTextPref(
-        title = DSLSettingsText.from(resources.getQuantityString(R.plurals.GiftFlowStartFragment__support_signal_by, 30, 30), DSLSettingsText.CenterModifier)
+        title = DSLSettingsText.from(resources.getQuantityString(R.plurals.GiftFlowStartFragment__support_signal_by, days.toInt(), days), DSLSettingsText.CenterModifier)
       )
 
       space(DimensionUnit.DP.toPixels(16f).toInt())

app/src/main/java/org/thoughtcrime/securesms/badges/gifts/thanks/GiftThanksSheet.kt

@@ -4,6 +4,7 @@ import android.os.Bundle
 import androidx.fragment.app.FragmentManager
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import org.signal.core.util.DimensionUnit
+import org.signal.core.util.getParcelableCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.badges.models.BadgePreview
@@ -41,10 +42,10 @@ class GiftThanksSheet : DSLSettingsBottomSheetFragment() {
   private val lifecycleDisposable = LifecycleDisposable()
 
   private val recipientId: RecipientId
-    get() = requireArguments().getParcelable(ARGS_RECIPIENT_ID)!!
+    get() = requireArguments().getParcelableCompat(ARGS_RECIPIENT_ID, RecipientId::class.java)!!
 
   private val badge: Badge
-    get() = requireArguments().getParcelable(ARGS_BADGE)!!
+    get() = requireArguments().getParcelableCompat(ARGS_BADGE, Badge::class.java)!!
 
   override fun bindAdapter(adapter: DSLSettingsAdapter) {
     BadgePreview.register(adapter)

app/src/main/java/org/thoughtcrime/securesms/badges/gifts/viewgift/received/ViewReceivedGiftBottomSheet.kt

@@ -11,6 +11,7 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.kotlin.subscribeBy
 import org.signal.core.util.DimensionUnit
+import org.signal.core.util.getParcelableCompat
 import org.signal.core.util.logging.Log
 import org.signal.libsignal.zkgroup.InvalidInputException
 import org.signal.libsignal.zkgroup.receipts.ReceiptCredentialPresentation
@@ -73,7 +74,7 @@ class ViewReceivedGiftBottomSheet : DSLSettingsBottomSheetFragment() {
   private val lifecycleDisposable = LifecycleDisposable()
 
   private val sentFrom: RecipientId
-    get() = requireArguments().getParcelable(ARG_SENT_FROM)!!
+    get() = requireArguments().getParcelableCompat(ARG_SENT_FROM, RecipientId::class.java)!!
 
   private val messageId: Long
     get() = requireArguments().getLong(ARG_MESSAGE_ID)

app/src/main/java/org/thoughtcrime/securesms/badges/gifts/viewgift/sent/ViewSentGiftBottomSheet.kt

@@ -5,6 +5,7 @@ import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import org.signal.core.util.DimensionUnit
+import org.signal.core.util.getParcelableCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.badges.gifts.viewgift.ViewGiftRepository
 import org.thoughtcrime.securesms.badges.models.BadgeDisplay112
@@ -41,7 +42,7 @@ class ViewSentGiftBottomSheet : DSLSettingsBottomSheetFragment() {
   }
 
   private val sentTo: RecipientId
-    get() = requireArguments().getParcelable(ARG_SENT_TO)!!
+    get() = requireArguments().getParcelableCompat(ARG_SENT_TO, RecipientId::class.java)!!
 
   private val giftBadge: GiftBadge
     get() = GiftBadge.parseFrom(requireArguments().getByteArray(ARG_GIFT_BADGE))

app/src/main/java/org/thoughtcrime/securesms/badges/view/ViewBadgeBottomSheetDialogFragment.kt

@@ -11,6 +11,7 @@ import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
 import androidx.viewpager2.widget.ViewPager2
 import com.google.android.material.tabs.TabLayoutMediator
+import org.signal.core.util.getParcelableCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.badges.BadgeRepository
 import org.thoughtcrime.securesms.badges.models.Badge
@@ -122,9 +123,9 @@ class ViewBadgeBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFr
     }
   }
 
-  private fun getStartBadge(): Badge? = requireArguments().getParcelable(ARG_START_BADGE)
+  private fun getStartBadge(): Badge? = requireArguments().getParcelableCompat(ARG_START_BADGE, Badge::class.java)
 
-  private fun getRecipientId(): RecipientId = requireNotNull(requireArguments().getParcelable(ARG_RECIPIENT_ID))
+  private fun getRecipientId(): RecipientId = requireNotNull(requireArguments().getParcelableCompat(ARG_RECIPIENT_ID, RecipientId::class.java))
 
   companion object {
 

app/src/main/java/org/thoughtcrime/securesms/blocked/BlockedUsersActivity.java

@@ -97,7 +97,7 @@ public class BlockedUsersActivity extends PassphraseRequiredActivity implements
   }
 
   @Override
-  public void onBeforeContactSelected(@NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
+  public void onBeforeContactSelected(boolean isFromUnknownSearchKey, @NonNull Optional<RecipientId> recipientId, String number, @NonNull Consumer<Boolean> callback) {
     final String displayName = recipientId.map(id -> Recipient.resolved(id).getDisplayName(this)).orElse(number);
 
     AlertDialog confirmationDialog = new MaterialAlertDialogBuilder(this)

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

@@ -0,0 +1,242 @@
+package org.thoughtcrime.securesms.calls.links
+
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.widget.Toast
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+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.layout.width
+import androidx.compose.foundation.layout.wrapContentSize
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Alignment.Companion.CenterHorizontally
+import androidx.compose.ui.Alignment.Companion.CenterVertically
+import androidx.compose.ui.Alignment.Companion.End
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.dimensionResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.core.app.ShareCompat
+import androidx.fragment.app.viewModels
+import org.signal.core.ui.Buttons
+import org.signal.core.ui.Dividers
+import org.signal.core.ui.Rows
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.compose.ComposeBottomSheetDialogFragment
+import org.thoughtcrime.securesms.conversation.mutiselect.forward.MultiselectForwardFragment
+import org.thoughtcrime.securesms.conversation.mutiselect.forward.MultiselectForwardFragmentArgs
+import org.thoughtcrime.securesms.sharing.MultiShareArgs
+import org.thoughtcrime.securesms.util.Util
+
+/**
+ * Bottom sheet for creating call links
+ */
+class CreateCallLinkBottomSheetDialogFragment : ComposeBottomSheetDialogFragment() {
+
+  private val viewModel: CreateCallLinkViewModel by viewModels()
+
+  override val peekHeightPercentage: Float = 1f
+
+  @Composable
+  override fun SheetContent() {
+    Column(
+      modifier = Modifier
+        .fillMaxWidth()
+        .wrapContentSize(Alignment.Center)
+    ) {
+      val callName: String by viewModel.callName
+      val callLink: String by viewModel.callLink
+      val approveAllMembers: Boolean by viewModel.approveAllMembers
+
+      Handle(modifier = Modifier.align(CenterHorizontally))
+
+      Spacer(modifier = Modifier.height(20.dp))
+
+      Text(
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__create_call_link),
+        style = MaterialTheme.typography.titleLarge,
+        textAlign = TextAlign.Center,
+        modifier = Modifier.fillMaxWidth()
+      )
+
+      Spacer(modifier = Modifier.height(24.dp))
+
+      SignalCallRow(
+        callName = callName,
+        callLink = callLink,
+        onJoinClicked = this@CreateCallLinkBottomSheetDialogFragment::onJoinClicked
+      )
+
+      Spacer(modifier = Modifier.height(12.dp))
+
+      Rows.TextRow(
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__add_call_name),
+        modifier = Modifier.clickable(onClick = this@CreateCallLinkBottomSheetDialogFragment::onAddACallNameClicked)
+      )
+
+      Rows.ToggleRow(
+        checked = approveAllMembers,
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__approve_all_members),
+        onCheckChanged = viewModel::setApproveAllMembers,
+        modifier = Modifier.clickable(onClick = viewModel::toggleApproveAllMembers)
+      )
+
+      Dividers.Default()
+
+      Rows.TextRow(
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__share_link_via_signal),
+        icon = ImageVector.vectorResource(id = R.drawable.symbol_forward_24),
+        modifier = Modifier.clickable(onClick = this@CreateCallLinkBottomSheetDialogFragment::onShareViaSignalClicked)
+      )
+
+      Rows.TextRow(
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__copy_link),
+        icon = ImageVector.vectorResource(id = R.drawable.symbol_copy_android_24),
+        modifier = Modifier.clickable(onClick = this@CreateCallLinkBottomSheetDialogFragment::onCopyLinkClicked)
+      )
+
+      Rows.TextRow(
+        text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__share_link),
+        icon = ImageVector.vectorResource(id = R.drawable.symbol_share_android_24),
+        modifier = Modifier.clickable(onClick = this@CreateCallLinkBottomSheetDialogFragment::onShareLinkClicked)
+      )
+
+      Buttons.MediumTonal(
+        onClick = this@CreateCallLinkBottomSheetDialogFragment::onDoneClicked,
+        modifier = Modifier
+          .padding(end = dimensionResource(id = R.dimen.core_ui__gutter))
+          .align(End)
+      ) {
+        Text(text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__done))
+      }
+
+      Spacer(modifier = Modifier.size(16.dp))
+    }
+  }
+
+  private fun onAddACallNameClicked() {
+    EditCallLinkNameDialogFragment().show(childFragmentManager, null)
+  }
+
+  private fun onJoinClicked() {
+  }
+
+  private fun onDoneClicked() {
+  }
+
+  private fun onShareViaSignalClicked() {
+    val snapshot = viewModel.callLink.value
+
+    MultiselectForwardFragment.showFullScreen(
+      childFragmentManager,
+      MultiselectForwardFragmentArgs(
+        canSendToNonPush = false,
+        multiShareArgs = listOf(
+          MultiShareArgs.Builder()
+            .withDraftText(snapshot)
+            .build()
+        )
+      )
+    )
+  }
+
+  private fun onCopyLinkClicked() {
+    val snapshot = viewModel.callLink.value
+    Util.copyToClipboard(requireContext(), snapshot)
+    Toast.makeText(requireContext(), R.string.CreateCallLinkBottomSheetDialogFragment__copied_to_clipboard, Toast.LENGTH_LONG).show()
+  }
+
+  private fun onShareLinkClicked() {
+    val snapshot = viewModel.callLink.value
+    val mimeType = Intent.normalizeMimeType("text/plain")
+    val shareIntent = ShareCompat.IntentBuilder(requireContext())
+      .setText(snapshot)
+      .setType(mimeType)
+      .createChooserIntent()
+      .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+
+    try {
+      startActivity(shareIntent)
+    } catch (e: ActivityNotFoundException) {
+      Toast.makeText(requireContext(), R.string.CreateCallLinkBottomSheetDialogFragment__failed_to_open_share_sheet, Toast.LENGTH_LONG).show()
+    }
+  }
+}
+
+@Composable
+private fun SignalCallRow(
+  callName: String,
+  callLink: String,
+  onJoinClicked: () -> Unit
+) {
+  Row(
+    modifier = Modifier
+      .fillMaxWidth()
+      .padding(horizontal = dimensionResource(id = R.dimen.core_ui__gutter))
+      .border(
+        width = 1.25.dp,
+        color = MaterialTheme.colorScheme.outline,
+        shape = RoundedCornerShape(18.dp)
+      )
+      .padding(16.dp)
+  ) {
+    Image(
+      imageVector = ImageVector.vectorResource(id = R.drawable.symbol_video_display_bold_40),
+      contentScale = ContentScale.Inside,
+      contentDescription = null,
+      colorFilter = ColorFilter.tint(Color(0xFF5151F6)),
+      modifier = Modifier
+        .size(64.dp)
+        .background(
+          color = Color(0xFFE5E5FE),
+          shape = CircleShape
+        )
+    )
+
+    Spacer(modifier = Modifier.width(10.dp))
+
+    Column(
+      modifier = Modifier
+        .weight(1f)
+        .align(CenterVertically)
+    ) {
+      Text(
+        text = callName.ifEmpty { stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__signal_call) }
+      )
+      Text(
+        text = callLink,
+        style = MaterialTheme.typography.bodyMedium,
+        color = MaterialTheme.colorScheme.onSurfaceVariant
+      )
+    }
+
+    Spacer(modifier = Modifier.width(10.dp))
+
+    Buttons.Small(
+      onClick = onJoinClicked,
+      modifier = Modifier.align(CenterVertically)
+    ) {
+      Text(text = stringResource(id = R.string.CreateCallLinkBottomSheetDialogFragment__join))
+    }
+  }
+}

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

@@ -0,0 +1,32 @@
+package org.thoughtcrime.securesms.calls.links
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.lifecycle.ViewModel
+
+class CreateCallLinkViewModel : ViewModel() {
+  private val _callName: MutableState<String> = mutableStateOf("")
+  private val _callLink: MutableState<String> = mutableStateOf("")
+  private val _approveAllMembers: MutableState<Boolean> = mutableStateOf(false)
+
+  val callName: State<String> = _callName
+  val callLink: State<String> = _callLink
+  val approveAllMembers: State<Boolean> = _approveAllMembers
+
+  fun setApproveAllMembers(approveAllMembers: Boolean) {
+    _approveAllMembers.value = approveAllMembers
+  }
+
+  fun toggleApproveAllMembers() {
+    _approveAllMembers.value = !_approveAllMembers.value
+  }
+
+  fun setCallName(callName: String) {
+    _callName.value = callName
+  }
+
+  fun setCallLink(callLink: String) {
+    _callLink.value = callLink
+  }
+}

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

@@ -0,0 +1,114 @@
+package org.thoughtcrime.securesms.calls.links
+
+import android.app.Dialog
+import android.os.Bundle
+import android.view.WindowManager
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment.Companion.End
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.res.dimensionResource
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextRange
+import androidx.compose.ui.text.input.TextFieldValue
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.fragment.app.viewModels
+import org.signal.core.ui.Buttons
+import org.signal.core.ui.Scaffolds
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.compose.ComposeDialogFragment
+
+class EditCallLinkNameDialogFragment : ComposeDialogFragment() {
+
+  private val viewModel: CreateCallLinkViewModel by viewModels(
+    ownerProducer = { requireParentFragment() }
+  )
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    setStyle(STYLE_NO_FRAME, R.style.Signal_DayNight_Dialog_FullScreen)
+  }
+
+  override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+    val dialog = super.onCreateDialog(savedInstanceState)
+    dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
+    return dialog
+  }
+
+  @OptIn(ExperimentalMaterial3Api::class)
+  @Preview
+  @Composable
+  override fun DialogContent() {
+    val viewModelCallName by viewModel.callName
+    var callName by remember {
+      mutableStateOf(
+        TextFieldValue(
+          text = viewModelCallName,
+          selection = TextRange(viewModelCallName.length)
+        )
+      )
+    }
+
+    Scaffolds.Settings(
+      title = stringResource(id = R.string.EditCallLinkNameDialogFragment__edit_call_name),
+      onNavigationClick = this::dismiss,
+      navigationIconPainter = painterResource(id = R.drawable.ic_arrow_left_24),
+      navigationContentDescription = stringResource(id = R.string.Material3SearchToolbar__close)
+    ) { paddingValues ->
+      val focusRequester = remember { FocusRequester() }
+
+      Surface(modifier = Modifier.padding(paddingValues)) {
+        Column(
+          modifier = Modifier
+            .padding(
+              horizontal = dimensionResource(id = org.signal.core.ui.R.dimen.core_ui__gutter)
+            )
+            .padding(top = 20.dp, bottom = 16.dp)
+        ) {
+          TextField(
+            value = callName,
+            label = {
+              Text(text = stringResource(id = R.string.EditCallLinkNameDialogFragment__call_name))
+            },
+            onValueChange = { callName = it },
+            singleLine = true,
+            modifier = Modifier
+              .fillMaxWidth()
+              .focusRequester(focusRequester)
+          )
+          Spacer(modifier = Modifier.weight(1f))
+          Buttons.MediumTonal(
+            onClick = {
+              viewModel.setCallName(callName.text)
+              dismiss()
+            },
+            modifier = Modifier.align(End)
+          ) {
+            Text(text = stringResource(id = R.string.EditCallLinkNameDialogFragment__save))
+          }
+        }
+      }
+
+      LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+      }
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogActionMode.kt

@@ -0,0 +1,74 @@
+package org.thoughtcrime.securesms.calls.log
+
+import android.content.res.Resources
+import android.view.Menu
+import android.view.MenuItem
+import androidx.appcompat.view.ActionMode
+import org.thoughtcrime.securesms.R
+
+class CallLogActionMode(
+  private val callback: Callback
+) : ActionMode.Callback {
+
+  private var actionMode: ActionMode? = null
+  private var count: Int = 0
+
+  override fun onCreateActionMode(mode: ActionMode?, menu: Menu?): Boolean {
+    mode?.title = getTitle(1)
+    return true
+  }
+
+  override fun onPrepareActionMode(mode: ActionMode?, menu: Menu?): Boolean {
+    return false
+  }
+
+  override fun onActionItemClicked(mode: ActionMode?, item: MenuItem?): Boolean {
+    return true
+  }
+
+  override fun onDestroyActionMode(mode: ActionMode?) {
+    callback.onResetSelectionState()
+    endIfActive()
+  }
+
+  fun isInActionMode(): Boolean {
+    return actionMode != null
+  }
+
+  fun getCount(): Int {
+    return if (actionMode != null) count else 0
+  }
+
+  fun setCount(count: Int) {
+    this.count = count
+    actionMode?.title = getTitle(count)
+  }
+
+  fun start() {
+    actionMode = callback.startActionMode(this)
+  }
+
+  fun end() {
+    callback.onActionModeWillEnd()
+    actionMode?.finish()
+    count = 0
+    actionMode = null
+  }
+
+  private fun getTitle(callLogsSelected: Int): String {
+    return callback.getResources().getQuantityString(R.plurals.ConversationListFragment_s_selected, callLogsSelected, callLogsSelected)
+  }
+
+  private fun endIfActive() {
+    if (actionMode != null) {
+      end()
+    }
+  }
+
+  interface Callback {
+    fun startActionMode(callback: ActionMode.Callback): ActionMode?
+    fun onActionModeWillEnd()
+    fun getResources(): Resources
+    fun onResetSelectionState()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogAdapter.kt

@@ -0,0 +1,330 @@
+package org.thoughtcrime.securesms.calls.log
+
+import android.content.res.ColorStateList
+import android.view.View
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
+import androidx.core.content.ContextCompat
+import androidx.core.widget.TextViewCompat
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.database.CallTable
+import org.thoughtcrime.securesms.database.MessageTypes
+import org.thoughtcrime.securesms.databinding.CallLogAdapterItemBinding
+import org.thoughtcrime.securesms.databinding.CallLogCreateCallLinkItemBinding
+import org.thoughtcrime.securesms.databinding.ConversationListItemClearFilterBinding
+import org.thoughtcrime.securesms.mms.GlideApp
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.util.DateUtils
+import org.thoughtcrime.securesms.util.adapter.mapping.BindingFactory
+import org.thoughtcrime.securesms.util.adapter.mapping.BindingViewHolder
+import org.thoughtcrime.securesms.util.adapter.mapping.MappingModel
+import org.thoughtcrime.securesms.util.adapter.mapping.PagingMappingAdapter
+import org.thoughtcrime.securesms.util.setRelativeDrawables
+import org.thoughtcrime.securesms.util.visible
+import java.util.Locale
+
+/**
+ * RecyclerView Adapter for the Call Log screen
+ */
+class CallLogAdapter(
+  callbacks: Callbacks
+) : PagingMappingAdapter<CallLogRow.Id>() {
+
+  init {
+    registerFactory(
+      CallModel::class.java,
+      BindingFactory(
+        creator = {
+          CallModelViewHolder(
+            it,
+            callbacks::onCallClicked,
+            callbacks::onCallLongClicked,
+            callbacks::onStartAudioCallClicked,
+            callbacks::onStartVideoCallClicked
+          )
+        },
+        inflater = CallLogAdapterItemBinding::inflate
+      )
+    )
+    registerFactory(
+      ClearFilterModel::class.java,
+      BindingFactory(
+        creator = { ClearFilterViewHolder(it, callbacks::onClearFilterClicked) },
+        inflater = ConversationListItemClearFilterBinding::inflate
+      )
+    )
+    registerFactory(
+      CreateCallLinkModel::class.java,
+      BindingFactory(
+        creator = { CreateCallLinkViewHolder(it, callbacks::onCreateACallLinkClicked) },
+        inflater = CallLogCreateCallLinkItemBinding::inflate
+      )
+    )
+  }
+
+  fun submitCallRows(
+    rows: List<CallLogRow?>,
+    selectionState: CallLogSelectionState,
+    stagedDeletion: CallLogStagedDeletion?
+  ): Int {
+    val filteredRows = rows
+      .filterNotNull()
+      .filterNot { stagedDeletion?.isStagedForDeletion(it.id) == true }
+      .map {
+        when (it) {
+          is CallLogRow.Call -> CallModel(it, selectionState, itemCount)
+          is CallLogRow.ClearFilter -> ClearFilterModel()
+          is CallLogRow.CreateCallLink -> CreateCallLinkModel()
+        }
+      }
+
+    submitList(filteredRows)
+
+    return filteredRows.size
+  }
+
+  private class CallModel(
+    val call: CallLogRow.Call,
+    val selectionState: CallLogSelectionState,
+    val itemCount: Int
+  ) : MappingModel<CallModel> {
+    companion object {
+      const val PAYLOAD_SELECTION_STATE = "PAYLOAD_SELECTION_STATE"
+    }
+
+    override fun areItemsTheSame(newItem: CallModel): Boolean = call.id == newItem.call.id
+    override fun areContentsTheSame(newItem: CallModel): Boolean {
+      return call == newItem.call &&
+        isSelectionStateTheSame(newItem) &&
+        isItemCountTheSame(newItem)
+    }
+
+    override fun getChangePayload(newItem: CallModel): Any? {
+      return if (call == newItem.call && (!isSelectionStateTheSame(newItem) || !isItemCountTheSame(newItem))) {
+        PAYLOAD_SELECTION_STATE
+      } else {
+        null
+      }
+    }
+
+    private fun isSelectionStateTheSame(newItem: CallModel): Boolean {
+      return selectionState.contains(call.id) == newItem.selectionState.contains(newItem.call.id) &&
+        selectionState.isNotEmpty(itemCount) == newItem.selectionState.isNotEmpty(newItem.itemCount)
+    }
+
+    private fun isItemCountTheSame(newItem: CallModel): Boolean {
+      return itemCount == newItem.itemCount
+    }
+  }
+
+  private class ClearFilterModel : MappingModel<ClearFilterModel> {
+    override fun areItemsTheSame(newItem: ClearFilterModel): Boolean = true
+    override fun areContentsTheSame(newItem: ClearFilterModel): Boolean = true
+  }
+
+  private class CreateCallLinkModel : MappingModel<CreateCallLinkModel> {
+    override fun areItemsTheSame(newItem: CreateCallLinkModel): Boolean = true
+
+    override fun areContentsTheSame(newItem: CreateCallLinkModel): Boolean = true
+  }
+
+  private class CallModelViewHolder(
+    binding: CallLogAdapterItemBinding,
+    private val onCallClicked: (CallLogRow.Call) -> Unit,
+    private val onCallLongClicked: (View, CallLogRow.Call) -> Boolean,
+    private val onStartAudioCallClicked: (Recipient) -> Unit,
+    private val onStartVideoCallClicked: (Recipient) -> Unit
+  ) : BindingViewHolder<CallModel, CallLogAdapterItemBinding>(binding) {
+    override fun bind(model: CallModel) {
+      itemView.setOnClickListener {
+        onCallClicked(model.call)
+      }
+
+      itemView.setOnLongClickListener {
+        onCallLongClicked(itemView, model.call)
+      }
+
+      itemView.isSelected = model.selectionState.contains(model.call.id)
+      binding.callSelected.isChecked = model.selectionState.contains(model.call.id)
+      binding.callSelected.visible = model.selectionState.isNotEmpty(model.itemCount)
+
+      if (payload.contains(CallModel.PAYLOAD_SELECTION_STATE)) {
+        return
+      }
+
+      binding.callRecipientAvatar.setAvatar(GlideApp.with(binding.callRecipientAvatar), model.call.peer, true)
+      binding.callRecipientBadge.setBadgeFromRecipient(model.call.peer)
+      binding.callRecipientName.text = model.call.peer.getDisplayName(context)
+      presentCallInfo(model.call, model.call.date)
+      presentCallType(model)
+    }
+
+    private fun presentCallInfo(call: CallLogRow.Call, date: Long) {
+      val callState = context.getString(getCallStateStringRes(call.record))
+      binding.callInfo.text = context.getString(
+        R.string.CallLogAdapter__s_dot_s,
+        if (call.children.size > 1) {
+          context.getString(R.string.CallLogAdapter__d_s, call.children.size, callState)
+        } else {
+          callState
+        },
+        DateUtils.getBriefRelativeTimeSpanString(context, Locale.getDefault(), date)
+      )
+
+      binding.callInfo.setRelativeDrawables(
+        start = getCallStateDrawableRes(call.record)
+      )
+
+      val color = ContextCompat.getColor(
+        context,
+        if (call.record.event == CallTable.Event.MISSED) {
+          R.color.signal_colorError
+        } else {
+          R.color.signal_colorOnSurface
+        }
+      )
+
+      TextViewCompat.setCompoundDrawableTintList(
+        binding.callInfo,
+        ColorStateList.valueOf(color)
+      )
+
+      binding.callInfo.setTextColor(color)
+    }
+
+    private fun presentCallType(model: CallModel) {
+      when (model.call.record.type) {
+        CallTable.Type.AUDIO_CALL -> {
+          binding.callType.setImageResource(R.drawable.symbol_phone_24)
+          binding.callType.setOnClickListener { onStartAudioCallClicked(model.call.peer) }
+          binding.callType.visible = true
+          binding.groupCallButton.visible = false
+        }
+
+        CallTable.Type.VIDEO_CALL -> {
+          binding.callType.setImageResource(R.drawable.symbol_video_24)
+          binding.callType.setOnClickListener { onStartVideoCallClicked(model.call.peer) }
+          binding.callType.visible = true
+          binding.groupCallButton.visible = false
+        }
+
+        CallTable.Type.GROUP_CALL, CallTable.Type.AD_HOC_CALL -> {
+          binding.callType.setImageResource(R.drawable.symbol_video_24)
+          binding.callType.setOnClickListener { onStartVideoCallClicked(model.call.peer) }
+          binding.groupCallButton.setOnClickListener { onStartVideoCallClicked(model.call.peer) }
+
+          when (model.call.groupCallState) {
+            CallLogRow.GroupCallState.NONE, CallLogRow.GroupCallState.FULL -> {
+              binding.callType.visible = true
+              binding.groupCallButton.visible = false
+            }
+            CallLogRow.GroupCallState.ACTIVE, CallLogRow.GroupCallState.LOCAL_USER_JOINED -> {
+              binding.callType.visible = false
+              binding.groupCallButton.visible = true
+
+              binding.groupCallButton.setText(
+                if (model.call.groupCallState == CallLogRow.GroupCallState.LOCAL_USER_JOINED) {
+                  R.string.CallLogAdapter__return
+                } else {
+                  R.string.CallLogAdapter__join
+                }
+              )
+            }
+          }
+        }
+      }
+    }
+
+    @DrawableRes
+    private fun getCallStateDrawableRes(call: CallTable.Call): Int {
+      return when (call.messageType) {
+        MessageTypes.MISSED_VIDEO_CALL_TYPE, MessageTypes.MISSED_AUDIO_CALL_TYPE -> R.drawable.symbol_missed_incoming_compact_16
+        MessageTypes.INCOMING_AUDIO_CALL_TYPE, MessageTypes.INCOMING_VIDEO_CALL_TYPE -> R.drawable.symbol_arrow_downleft_compact_16
+        MessageTypes.OUTGOING_AUDIO_CALL_TYPE, MessageTypes.OUTGOING_VIDEO_CALL_TYPE -> R.drawable.symbol_arrow_upright_compact_16
+        MessageTypes.GROUP_CALL_TYPE -> when {
+          call.event == CallTable.Event.MISSED -> R.drawable.symbol_missed_incoming_24
+          call.event == CallTable.Event.GENERIC_GROUP_CALL || call.event == CallTable.Event.JOINED -> R.drawable.symbol_group_compact_16
+          call.direction == CallTable.Direction.INCOMING -> R.drawable.symbol_arrow_downleft_compact_16
+          call.direction == CallTable.Direction.OUTGOING -> R.drawable.symbol_arrow_upright_compact_16
+          else -> throw AssertionError()
+        }
+        else -> error("Unexpected type ${call.type}")
+      }
+    }
+
+    @StringRes
+    private fun getCallStateStringRes(call: CallTable.Call): Int {
+      return when (call.messageType) {
+        MessageTypes.MISSED_VIDEO_CALL_TYPE -> R.string.CallLogAdapter__missed
+        MessageTypes.MISSED_AUDIO_CALL_TYPE -> R.string.CallLogAdapter__missed
+        MessageTypes.INCOMING_AUDIO_CALL_TYPE -> R.string.CallLogAdapter__incoming
+        MessageTypes.INCOMING_VIDEO_CALL_TYPE -> R.string.CallLogAdapter__incoming
+        MessageTypes.OUTGOING_AUDIO_CALL_TYPE -> R.string.CallLogAdapter__outgoing
+        MessageTypes.OUTGOING_VIDEO_CALL_TYPE -> R.string.CallLogAdapter__outgoing
+        MessageTypes.GROUP_CALL_TYPE -> when {
+          call.event == CallTable.Event.MISSED -> R.string.CallPreference__missed_group_call
+          call.event == CallTable.Event.GENERIC_GROUP_CALL || call.event == CallTable.Event.JOINED -> R.string.CallPreference__group_call
+          call.direction == CallTable.Direction.INCOMING -> R.string.CallLogAdapter__incoming
+          call.direction == CallTable.Direction.OUTGOING -> R.string.CallLogAdapter__outgoing
+          else -> throw AssertionError()
+        }
+        else -> error("Unexpected type ${call.messageType}")
+      }
+    }
+  }
+
+  private class ClearFilterViewHolder(
+    binding: ConversationListItemClearFilterBinding,
+    onClearFilterClicked: () -> Unit
+  ) : BindingViewHolder<ClearFilterModel, ConversationListItemClearFilterBinding>(binding) {
+
+    init {
+      binding.clearFilter.setOnClickListener { onClearFilterClicked() }
+    }
+
+    override fun bind(model: ClearFilterModel) = Unit
+  }
+
+  private class CreateCallLinkViewHolder(
+    binding: CallLogCreateCallLinkItemBinding,
+    onClick: () -> Unit
+  ) : BindingViewHolder<CreateCallLinkModel, CallLogCreateCallLinkItemBinding>(binding) {
+    init {
+      binding.root.setOnClickListener { onClick() }
+    }
+
+    override fun bind(model: CreateCallLinkModel) = Unit
+  }
+
+  interface Callbacks {
+    /**
+     * Invoked when 'Create a call link' is clicked
+     */
+    fun onCreateACallLinkClicked()
+
+    /**
+     * Invoked when a call row is clicked
+     */
+    fun onCallClicked(callLogRow: CallLogRow.Call)
+
+    /**
+     * Invoked when a call row is long-clicked
+     */
+    fun onCallLongClicked(itemView: View, callLogRow: CallLogRow.Call): Boolean
+
+    /**
+     * Invoked when the clear filter button is pressed
+     */
+    fun onClearFilterClicked()
+
+    /**
+     * Invoked when user presses the audio icon
+     */
+    fun onStartAudioCallClicked(peer: Recipient)
+
+    /**
+     * Invoked when user presses the video icon
+     */
+    fun onStartVideoCallClicked(peer: Recipient)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogContextMenu.kt

@@ -0,0 +1,106 @@
+package org.thoughtcrime.securesms.calls.log
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.menu.ActionItem
+import org.thoughtcrime.securesms.components.menu.SignalContextMenu
+import org.thoughtcrime.securesms.components.settings.conversation.ConversationSettingsActivity
+import org.thoughtcrime.securesms.conversation.ConversationIntents
+import org.thoughtcrime.securesms.database.CallTable
+import org.thoughtcrime.securesms.util.CommunicationActions
+
+/**
+ * Context menu for row items on the Call Log screen.
+ */
+class CallLogContextMenu(
+  private val fragment: Fragment,
+  private val callbacks: Callbacks
+) {
+  fun show(anchor: View, call: CallLogRow.Call) {
+    anchor.isSelected = true
+    SignalContextMenu.Builder(anchor, anchor.parent as ViewGroup)
+      .preferredVerticalPosition(SignalContextMenu.VerticalPosition.BELOW)
+      .onDismiss { anchor.isSelected = false }
+      .show(
+        listOfNotNull(
+          getVideoCallActionItem(call),
+          getAudioCallActionItem(call),
+          getGoToChatActionItem(call),
+          getInfoActionItem(call),
+          getSelectActionItem(call),
+          getDeleteActionItem(call)
+        )
+      )
+  }
+
+  private fun getVideoCallActionItem(call: CallLogRow.Call): ActionItem {
+    // TODO [alex] -- Need group calling disposition to make this correct
+    return ActionItem(
+      iconRes = R.drawable.symbol_video_24,
+      title = fragment.getString(R.string.CallContextMenu__video_call)
+    ) {
+      CommunicationActions.startVideoCall(fragment, call.peer)
+    }
+  }
+
+  private fun getAudioCallActionItem(call: CallLogRow.Call): ActionItem? {
+    if (call.peer.isGroup) {
+      return null
+    }
+
+    return ActionItem(
+      iconRes = R.drawable.symbol_phone_24,
+      title = fragment.getString(R.string.CallContextMenu__audio_call)
+    ) {
+      CommunicationActions.startVoiceCall(fragment, call.peer)
+    }
+  }
+
+  private fun getGoToChatActionItem(call: CallLogRow.Call): ActionItem {
+    return ActionItem(
+      iconRes = R.drawable.symbol_open_24,
+      title = fragment.getString(R.string.CallContextMenu__go_to_chat)
+    ) {
+      fragment.startActivity(ConversationIntents.createBuilder(fragment.requireContext(), call.peer.id, -1L).build())
+    }
+  }
+
+  private fun getInfoActionItem(call: CallLogRow.Call): ActionItem {
+    return ActionItem(
+      iconRes = R.drawable.symbol_info_24,
+      title = fragment.getString(R.string.CallContextMenu__info)
+    ) {
+      val intent = ConversationSettingsActivity.forCall(fragment.requireContext(), call.peer, longArrayOf(call.record.messageId!!))
+      fragment.startActivity(intent)
+    }
+  }
+
+  private fun getSelectActionItem(call: CallLogRow.Call): ActionItem {
+    return ActionItem(
+      iconRes = R.drawable.symbol_check_circle_24,
+      title = fragment.getString(R.string.CallContextMenu__select)
+    ) {
+      callbacks.startSelection(call)
+    }
+  }
+
+  private fun getDeleteActionItem(call: CallLogRow.Call): ActionItem? {
+    if (call.record.event == CallTable.Event.ONGOING) {
+      return null
+    }
+
+    return ActionItem(
+      iconRes = R.drawable.symbol_trash_24,
+      title = fragment.getString(R.string.CallContextMenu__delete)
+    ) {
+      callbacks.deleteCall(call)
+    }
+  }
+
+  interface Callbacks {
+    fun startSelection(call: CallLogRow.Call)
+    fun deleteCall(call: CallLogRow.Call)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogFilter.kt

@@ -0,0 +1,16 @@
+package org.thoughtcrime.securesms.calls.log
+
+/**
+ * Allows user to only display certain classes of calls.
+ */
+enum class CallLogFilter {
+  /**
+   * All call logs will be displayed
+   */
+  ALL,
+
+  /**
+   * Only missed calls will be displayed
+   */
+  MISSED
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogFragment.kt

@@ -0,0 +1,385 @@
+package org.thoughtcrime.securesms.calls.log
+
+import android.annotation.SuppressLint
+import android.content.res.Resources
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import androidx.activity.OnBackPressedCallback
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.view.ActionMode
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.MenuProvider
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.viewModels
+import androidx.navigation.fragment.findNavController
+import androidx.recyclerview.widget.LinearLayoutManager
+import com.google.android.material.appbar.AppBarLayout
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.snackbar.Snackbar
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.kotlin.Flowables
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import org.signal.core.util.DimensionUnit
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.calls.new.NewCallActivity
+import org.thoughtcrime.securesms.components.Material3SearchToolbar
+import org.thoughtcrime.securesms.components.ViewBinderDelegate
+import org.thoughtcrime.securesms.components.menu.ActionItem
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+import org.thoughtcrime.securesms.components.settings.app.notifications.manual.NotificationProfileSelectionFragment
+import org.thoughtcrime.securesms.components.settings.conversation.ConversationSettingsActivity
+import org.thoughtcrime.securesms.conversation.SignalBottomActionBarController
+import org.thoughtcrime.securesms.conversationlist.ConversationFilterBehavior
+import org.thoughtcrime.securesms.conversationlist.chatfilter.ConversationFilterSource
+import org.thoughtcrime.securesms.conversationlist.chatfilter.ConversationListFilterPullView.OnCloseClicked
+import org.thoughtcrime.securesms.conversationlist.chatfilter.ConversationListFilterPullView.OnFilterStateChanged
+import org.thoughtcrime.securesms.conversationlist.chatfilter.FilterLerp
+import org.thoughtcrime.securesms.conversationlist.chatfilter.FilterPullState
+import org.thoughtcrime.securesms.databinding.CallLogFragmentBinding
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.main.Material3OnScrollHelperBinder
+import org.thoughtcrime.securesms.main.SearchBinder
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.stories.tabs.ConversationListTab
+import org.thoughtcrime.securesms.stories.tabs.ConversationListTabsViewModel
+import org.thoughtcrime.securesms.util.CommunicationActions
+import org.thoughtcrime.securesms.util.LifecycleDisposable
+import org.thoughtcrime.securesms.util.ViewUtil
+import org.thoughtcrime.securesms.util.fragments.requireListener
+import org.thoughtcrime.securesms.util.visible
+import java.util.Objects
+
+/**
+ * Call Log tab.
+ */
+@SuppressLint("DiscouragedApi")
+class CallLogFragment : Fragment(R.layout.call_log_fragment), CallLogAdapter.Callbacks, CallLogContextMenu.Callbacks {
+
+  companion object {
+    private const val LIST_SMOOTH_SCROLL_TO_TOP_THRESHOLD = 25
+  }
+
+  private val viewModel: CallLogViewModel by viewModels()
+  private val binding: CallLogFragmentBinding by ViewBinderDelegate(CallLogFragmentBinding::bind)
+  private val disposables = LifecycleDisposable()
+  private val callLogContextMenu = CallLogContextMenu(this, this)
+  private val callLogActionMode = CallLogActionMode(CallLogActionModeCallback())
+
+  private lateinit var signalBottomActionBarController: SignalBottomActionBarController
+
+  private val tabsViewModel: ConversationListTabsViewModel by viewModels(ownerProducer = { requireActivity() })
+
+  private val menuProvider = object : MenuProvider {
+    override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+      menuInflater.inflate(R.menu.calls_tab_menu, menu)
+    }
+
+    override fun onPrepareMenu(menu: Menu) {
+      val isFiltered = viewModel.filterSnapshot == CallLogFilter.MISSED
+      menu.findItem(R.id.action_clear_missed_call_filter).isVisible = isFiltered
+      menu.findItem(R.id.action_filter_missed_calls).isVisible = !isFiltered
+    }
+
+    override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+      when (menuItem.itemId) {
+        R.id.action_settings -> startActivity(AppSettingsActivity.home(requireContext()))
+        R.id.action_notification_profile -> NotificationProfileSelectionFragment.show(parentFragmentManager)
+        R.id.action_filter_missed_calls -> filterMissedCalls()
+        R.id.action_clear_missed_call_filter -> onClearFilterClicked()
+      }
+
+      return true
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    requireActivity().addMenuProvider(menuProvider, viewLifecycleOwner)
+
+    val adapter = CallLogAdapter(this)
+    disposables.bindTo(viewLifecycleOwner)
+    adapter.setPagingController(viewModel.controller)
+
+    disposables += Flowables.combineLatest(viewModel.data, viewModel.selectedAndStagedDeletion)
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { (data, selected) ->
+        val filteredCount = adapter.submitCallRows(data, selected.first, selected.second)
+        binding.emptyState.visible = filteredCount == 0
+      }
+
+    disposables += Flowables.combineLatest(viewModel.selectedAndStagedDeletion, viewModel.totalCount)
+      .distinctUntilChanged()
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe { (selected, totalCount) ->
+        if (selected.first.isNotEmpty(totalCount)) {
+          callLogActionMode.setCount(selected.first.count(totalCount))
+        } else {
+          callLogActionMode.end()
+        }
+      }
+
+    binding.recycler.adapter = adapter
+
+    requireListener<Material3OnScrollHelperBinder>().bindScrollHelper(binding.recycler)
+    binding.fab.setOnClickListener {
+      startActivity(NewCallActivity.createIntent(requireContext()))
+    }
+
+    binding.pullView.setPillText(R.string.CallLogFragment__filtered_by_missed)
+
+    binding.bottomActionBar.setItems(
+      listOf(
+        ActionItem(
+          iconRes = R.drawable.symbol_check_circle_24,
+          title = getString(R.string.CallLogFragment__select_all)
+        ) {
+          viewModel.selectAll()
+        },
+        ActionItem(
+          iconRes = R.drawable.symbol_trash_24,
+          title = getString(R.string.CallLogFragment__delete),
+          action = this::handleDeleteSelectedRows
+        )
+      )
+    )
+
+    initializePullToFilter()
+    initializeTapToScrollToTop()
+
+    requireActivity().onBackPressedDispatcher.addCallback(
+      viewLifecycleOwner,
+      object : OnBackPressedCallback(true) {
+        override fun handleOnBackPressed() {
+          if (!closeSearchIfOpen()) {
+            tabsViewModel.onChatsSelected()
+          }
+        }
+      }
+    )
+
+    signalBottomActionBarController = SignalBottomActionBarController(
+      binding.bottomActionBar,
+      binding.recycler,
+      BottomActionBarControllerCallback()
+    )
+  }
+
+  override fun onResume() {
+    super.onResume()
+    initializeSearchAction()
+    ApplicationDependencies.getDeletedCallEventManager().scheduleIfNecessary()
+  }
+
+  private fun initializeTapToScrollToTop() {
+    disposables += tabsViewModel.tabClickEvents
+      .filter { it == ConversationListTab.CALLS }
+      .subscribeBy(onNext = {
+        val layoutManager = binding.recycler.layoutManager as? LinearLayoutManager ?: return@subscribeBy
+        if (layoutManager.findFirstVisibleItemPosition() <= LIST_SMOOTH_SCROLL_TO_TOP_THRESHOLD) {
+          binding.recycler.smoothScrollToPosition(0)
+        } else {
+          binding.recycler.scrollToPosition(0)
+        }
+      })
+  }
+
+  private fun handleDeleteSelectedRows() {
+    val count = callLogActionMode.getCount()
+    MaterialAlertDialogBuilder(requireContext())
+      .setTitle(resources.getQuantityString(R.plurals.CallLogFragment__delete_d_calls, count, count))
+      .setPositiveButton(R.string.CallLogFragment__delete_for_me) { _, _ ->
+        viewModel.stageSelectionDeletion()
+        callLogActionMode.end()
+        Snackbar
+          .make(
+            binding.root,
+            resources.getQuantityString(R.plurals.CallLogFragment__d_calls_deleted, count, count),
+            Snackbar.LENGTH_SHORT
+          )
+          .addCallback(SnackbarDeletionCallback())
+          .setAction(R.string.CallLogFragment__undo) {
+            viewModel.cancelStagedDeletion()
+          }
+          .show()
+      }
+      .setNegativeButton(android.R.string.cancel) { _, _ -> }
+      .show()
+  }
+
+  private fun initializeSearchAction() {
+    val searchBinder = requireListener<SearchBinder>()
+    searchBinder.getSearchAction().setOnClickListener {
+      searchBinder.onSearchOpened()
+      searchBinder.getSearchToolbar().get().setSearchInputHint(R.string.SearchToolbar_search)
+
+      searchBinder.getSearchToolbar().get().listener = object : Material3SearchToolbar.Listener {
+        override fun onSearchTextChange(text: String) {
+          viewModel.setSearchQuery(text.trim())
+        }
+
+        override fun onSearchClosed() {
+          viewModel.setSearchQuery("")
+          searchBinder.onSearchClosed()
+        }
+      }
+    }
+  }
+
+  private fun initializePullToFilter() {
+    val collapsingToolbarLayout = binding.collapsingToolbar
+    val openHeight = DimensionUnit.DP.toPixels(FilterLerp.FILTER_OPEN_HEIGHT).toInt()
+
+    binding.pullView.onFilterStateChanged = OnFilterStateChanged { state: FilterPullState?, source: ConversationFilterSource ->
+      when (state) {
+        FilterPullState.CLOSING -> viewModel.setFilter(CallLogFilter.ALL)
+        FilterPullState.OPENING -> {
+          ViewUtil.setMinimumHeight(collapsingToolbarLayout, openHeight)
+          viewModel.setFilter(CallLogFilter.MISSED)
+        }
+
+        FilterPullState.OPEN_APEX -> if (source === ConversationFilterSource.DRAG) {
+          // TODO[alex] -- hint here? SignalStore.uiHints().incrementNeverDisplayPullToFilterTip()
+        }
+
+        FilterPullState.CLOSE_APEX -> ViewUtil.setMinimumHeight(collapsingToolbarLayout, 0)
+        else -> Unit
+      }
+    }
+
+    binding.pullView.onCloseClicked = OnCloseClicked {
+      onClearFilterClicked()
+    }
+
+    val conversationFilterBehavior = Objects.requireNonNull<ConversationFilterBehavior?>((binding.recyclerCoordinatorAppBar.layoutParams as CoordinatorLayout.LayoutParams).behavior as ConversationFilterBehavior?)
+    conversationFilterBehavior.callback = object : ConversationFilterBehavior.Callback {
+      override fun onStopNestedScroll() {
+        binding.pullView.onUserDragFinished()
+      }
+
+      override fun canStartNestedScroll(): Boolean {
+        return !callLogActionMode.isInActionMode() || !isSearchOpen() || binding.pullView.isCloseable()
+      }
+    }
+
+    binding.recyclerCoordinatorAppBar.addOnOffsetChangedListener { layout: AppBarLayout, verticalOffset: Int ->
+      val progress = 1 - verticalOffset.toFloat() / -layout.height
+      binding.pullView.onUserDrag(progress)
+    }
+  }
+
+  override fun onCreateACallLinkClicked() {
+    findNavController().navigate(R.id.createCallLinkBottomSheet)
+  }
+
+  override fun onCallClicked(callLogRow: CallLogRow.Call) {
+    if (viewModel.selectionStateSnapshot.isNotEmpty(binding.recycler.adapter!!.itemCount)) {
+      viewModel.toggleSelected(callLogRow.id)
+    } else {
+      val intent = ConversationSettingsActivity.forCall(requireContext(), callLogRow.peer, (callLogRow.id as CallLogRow.Id.Call).children.toLongArray())
+      startActivity(intent)
+    }
+  }
+
+  override fun onCallLongClicked(itemView: View, callLogRow: CallLogRow.Call): Boolean {
+    callLogContextMenu.show(itemView, callLogRow)
+    return true
+  }
+
+  override fun onClearFilterClicked() {
+    binding.pullView.toggle()
+    binding.recyclerCoordinatorAppBar.setExpanded(false, true)
+  }
+
+  override fun onStartAudioCallClicked(peer: Recipient) {
+    CommunicationActions.startVoiceCall(this, peer)
+  }
+
+  override fun onStartVideoCallClicked(peer: Recipient) {
+    CommunicationActions.startVideoCall(this, peer)
+  }
+
+  override fun startSelection(call: CallLogRow.Call) {
+    callLogActionMode.start()
+    viewModel.toggleSelected(call.id)
+  }
+
+  override fun deleteCall(call: CallLogRow.Call) {
+    MaterialAlertDialogBuilder(requireContext())
+      .setTitle(resources.getQuantityString(R.plurals.CallLogFragment__delete_d_calls, 1, 1))
+      .setPositiveButton(R.string.CallLogFragment__delete_for_me) { _, _ ->
+        viewModel.stageCallDeletion(call)
+        Snackbar
+          .make(
+            binding.root,
+            resources.getQuantityString(R.plurals.CallLogFragment__d_calls_deleted, 1, 1),
+            Snackbar.LENGTH_SHORT
+          )
+          .addCallback(SnackbarDeletionCallback())
+          .setAction(R.string.CallLogFragment__undo) {
+            viewModel.cancelStagedDeletion()
+          }
+          .show()
+      }
+      .setNegativeButton(android.R.string.cancel) { _, _ -> }
+      .show()
+  }
+
+  private fun filterMissedCalls() {
+    binding.pullView.toggle()
+    binding.recyclerCoordinatorAppBar.setExpanded(false, true)
+  }
+
+  private fun isSearchOpen(): Boolean {
+    return isSearchVisible() || viewModel.hasSearchQuery
+  }
+
+  private fun closeSearchIfOpen(): Boolean {
+    if (isSearchOpen()) {
+      requireListener<SearchBinder>().getSearchToolbar().get().collapse()
+      requireListener<SearchBinder>().onSearchClosed()
+      return true
+    }
+    return false
+  }
+
+  private fun isSearchVisible(): Boolean {
+    return requireListener<SearchBinder>().getSearchToolbar().resolved() &&
+      requireListener<SearchBinder>().getSearchToolbar().get().getVisibility() == View.VISIBLE
+  }
+
+  private inner class BottomActionBarControllerCallback : SignalBottomActionBarController.Callback {
+    override fun onBottomActionBarVisibilityChanged(visibility: Int) = Unit
+  }
+
+  private inner class CallLogActionModeCallback : CallLogActionMode.Callback {
+    override fun startActionMode(callback: ActionMode.Callback): ActionMode? {
+      val actionMode = (requireActivity() as AppCompatActivity).startSupportActionMode(callback)
+      requireListener<Callback>().onMultiSelectStarted()
+      signalBottomActionBarController.setVisibility(true)
+      return actionMode
+    }
+
+    override fun onActionModeWillEnd() {
+      requireListener<Callback>().onMultiSelectFinished()
+      signalBottomActionBarController.setVisibility(false)
+    }
+
+    override fun getResources(): Resources = resources
+    override fun onResetSelectionState() {
+      viewModel.clearSelected()
+    }
+  }
+
+  private inner class SnackbarDeletionCallback : Snackbar.Callback() {
+    override fun onDismissed(transientBottomBar: Snackbar?, event: Int) {
+      viewModel.commitStagedDeletion()
+    }
+  }
+
+  interface Callback {
+    fun onMultiSelectStarted()
+    fun onMultiSelectFinished()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogPagedDataSource.kt

@@ -0,0 +1,51 @@
+package org.thoughtcrime.securesms.calls.log
+
+import org.signal.paging.PagedDataSource
+import org.thoughtcrime.securesms.util.FeatureFlags
+
+class CallLogPagedDataSource(
+  private val query: String?,
+  private val filter: CallLogFilter,
+  private val repository: CallRepository
+) : PagedDataSource<CallLogRow.Id, CallLogRow> {
+
+  private val hasFilter = filter == CallLogFilter.MISSED
+  private val hasCallLinkRow = FeatureFlags.adHocCalling() && filter == CallLogFilter.ALL && query.isNullOrEmpty()
+
+  private var callsCount = 0
+
+  override fun size(): Int {
+    callsCount = repository.getCallsCount(query, filter)
+    return callsCount + hasFilter.toInt() + hasCallLinkRow.toInt()
+  }
+
+  override fun load(start: Int, length: Int, cancellationSignal: PagedDataSource.CancellationSignal): MutableList<CallLogRow> {
+    val calls = mutableListOf<CallLogRow>()
+    val callLimit = length - hasCallLinkRow.toInt()
+
+    if (start == 0 && length >= 1 && hasCallLinkRow) {
+      calls.add(CallLogRow.CreateCallLink)
+    }
+
+    calls.addAll(repository.getCalls(query, filter, start, callLimit).toMutableList())
+
+    if (calls.size < length && hasFilter) {
+      calls.add(CallLogRow.ClearFilter)
+    }
+
+    return calls
+  }
+
+  override fun getKey(data: CallLogRow): CallLogRow.Id = data.id
+
+  override fun load(key: CallLogRow.Id?): CallLogRow = error("Not supported")
+
+  private fun Boolean.toInt(): Int {
+    return if (this) 1 else 0
+  }
+
+  interface CallRepository {
+    fun getCallsCount(query: String?, filter: CallLogFilter): Int
+    fun getCalls(query: String?, filter: CallLogFilter, start: Int, length: Int): List<CallLogRow>
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogRepository.kt

@@ -0,0 +1,53 @@
+package org.thoughtcrime.securesms.calls.log
+
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import org.thoughtcrime.securesms.database.DatabaseObserver
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+
+class CallLogRepository : CallLogPagedDataSource.CallRepository {
+  override fun getCallsCount(query: String?, filter: CallLogFilter): Int {
+    return SignalDatabase.calls.getCallsCount(query, filter)
+  }
+
+  override fun getCalls(query: String?, filter: CallLogFilter, start: Int, length: Int): List<CallLogRow> {
+    return SignalDatabase.calls.getCalls(start, length, query, filter)
+  }
+
+  fun listenForChanges(): Observable<Unit> {
+    return Observable.create { emitter ->
+      fun refresh() {
+        emitter.onNext(Unit)
+      }
+
+      val databaseObserver = DatabaseObserver.Observer {
+        refresh()
+      }
+
+      ApplicationDependencies.getDatabaseObserver().registerConversationListObserver(databaseObserver)
+      ApplicationDependencies.getDatabaseObserver().registerCallUpdateObserver(databaseObserver)
+
+      emitter.setCancellable {
+        ApplicationDependencies.getDatabaseObserver().unregisterObserver(databaseObserver)
+      }
+    }
+  }
+
+  fun deleteSelectedCallLogs(
+    selectedCallRowIds: Set<Long>
+  ): Completable {
+    return Completable.fromAction {
+      SignalDatabase.calls.deleteCallEvents(selectedCallRowIds)
+    }.observeOn(Schedulers.io())
+  }
+
+  fun deleteAllCallLogsExcept(
+    selectedCallRowIds: Set<Long>
+  ): Completable {
+    return Completable.fromAction {
+      SignalDatabase.calls.deleteAllCallEventsExcept(selectedCallRowIds)
+    }.observeOn(Schedulers.io())
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogRow.kt

@@ -0,0 +1,86 @@
+package org.thoughtcrime.securesms.calls.log
+
+import org.thoughtcrime.securesms.database.CallTable
+import org.thoughtcrime.securesms.database.model.databaseprotos.GroupCallUpdateDetails
+import org.thoughtcrime.securesms.recipients.Recipient
+
+/**
+ * A row to be displayed in the call log
+ */
+sealed class CallLogRow {
+
+  abstract val id: Id
+
+  /**
+   * An incoming, outgoing, or missed call.
+   */
+  data class Call(
+    val record: CallTable.Call,
+    val peer: Recipient,
+    val date: Long,
+    val groupCallState: GroupCallState,
+    val children: Set<Long>,
+    override val id: Id = Id.Call(children)
+  ) : CallLogRow()
+
+  /**
+   * A row which can be used to clear the current filter.
+   */
+  object ClearFilter : CallLogRow() {
+    override val id: Id = Id.ClearFilter
+  }
+
+  object CreateCallLink : CallLogRow() {
+    override val id: Id = Id.CreateCallLink
+  }
+
+  sealed class Id {
+    data class Call(val children: Set<Long>) : Id()
+    object ClearFilter : Id()
+    object CreateCallLink : Id()
+  }
+
+  enum class GroupCallState {
+    /**
+     * No group call available.
+     */
+    NONE,
+
+    /**
+     * Active, but the local user is not in the call.
+     */
+    ACTIVE,
+
+    /**
+     * Active and the local user is in the call
+     */
+    LOCAL_USER_JOINED,
+
+    /**
+     * Active but the call is full.
+     */
+    FULL;
+
+    companion object {
+      fun fromDetails(groupCallUpdateDetails: GroupCallUpdateDetails?): GroupCallState {
+        if (groupCallUpdateDetails == null) {
+          return NONE
+        }
+
+        if (groupCallUpdateDetails.isCallFull) {
+          return FULL
+        }
+
+        if (groupCallUpdateDetails.inCallUuidsList.contains(Recipient.self().requireServiceId().uuid().toString())) {
+          return LOCAL_USER_JOINED
+        }
+
+        return if (groupCallUpdateDetails.inCallUuidsCount > 0) {
+          ACTIVE
+        } else {
+          NONE
+        }
+      }
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogSelectionState.kt

@@ -0,0 +1,81 @@
+package org.thoughtcrime.securesms.calls.log
+
+/**
+ * Selection state object for call logs.
+ */
+sealed class CallLogSelectionState {
+  abstract fun contains(callId: CallLogRow.Id): Boolean
+  abstract fun isNotEmpty(totalCount: Int): Boolean
+
+  abstract fun count(totalCount: Int): Int
+
+  abstract fun selected(): Set<CallLogRow.Id>
+  fun isExclusionary(): Boolean = this is Excludes
+
+  protected abstract fun select(callId: CallLogRow.Id): CallLogSelectionState
+  protected abstract fun deselect(callId: CallLogRow.Id): CallLogSelectionState
+
+  fun toggle(callId: CallLogRow.Id): CallLogSelectionState {
+    return if (contains(callId)) {
+      deselect(callId)
+    } else {
+      select(callId)
+    }
+  }
+
+  /**
+   * Includes contains an opt-in list of call logs.
+   */
+  data class Includes(private val includes: Set<CallLogRow.Id>) : CallLogSelectionState() {
+    override fun contains(callId: CallLogRow.Id): Boolean {
+      return includes.contains(callId)
+    }
+
+    override fun isNotEmpty(totalCount: Int): Boolean {
+      return includes.isNotEmpty()
+    }
+
+    override fun count(totalCount: Int): Int {
+      return includes.size
+    }
+
+    override fun select(callId: CallLogRow.Id): CallLogSelectionState {
+      return Includes(includes + callId)
+    }
+
+    override fun deselect(callId: CallLogRow.Id): CallLogSelectionState {
+      return Includes(includes - callId)
+    }
+
+    override fun selected(): Set<CallLogRow.Id> {
+      return includes
+    }
+  }
+
+  /**
+   * Excludes contains an opt-out list of call logs.
+   */
+  data class Excludes(private val excluded: Set<CallLogRow.Id>) : CallLogSelectionState() {
+    override fun contains(callId: CallLogRow.Id): Boolean = !excluded.contains(callId)
+    override fun isNotEmpty(totalCount: Int): Boolean = excluded.size < totalCount
+
+    override fun count(totalCount: Int): Int {
+      return totalCount - excluded.size
+    }
+
+    override fun select(callId: CallLogRow.Id): CallLogSelectionState {
+      return Excludes(excluded - callId)
+    }
+
+    override fun deselect(callId: CallLogRow.Id): CallLogSelectionState {
+      return Excludes(excluded + callId)
+    }
+
+    override fun selected(): Set<CallLogRow.Id> = excluded
+  }
+
+  companion object {
+    fun empty(): CallLogSelectionState = Includes(emptySet())
+    fun selectAll(): CallLogSelectionState = Excludes(emptySet())
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogStagedDeletion.kt

@@ -0,0 +1,43 @@
+package org.thoughtcrime.securesms.calls.log
+
+import androidx.annotation.MainThread
+
+/**
+ * Encapsulates a single deletion action
+ */
+class CallLogStagedDeletion(
+  private val stateSnapshot: CallLogSelectionState,
+  private val repository: CallLogRepository
+) {
+
+  private var isCommitted = false
+
+  fun isStagedForDeletion(id: CallLogRow.Id): Boolean {
+    return stateSnapshot.contains(id)
+  }
+
+  @MainThread
+  fun cancel() {
+    isCommitted = true
+  }
+
+  @MainThread
+  fun commit() {
+    if (isCommitted) {
+      return
+    }
+
+    isCommitted = true
+    val callRowIds = stateSnapshot.selected()
+      .filterIsInstance<CallLogRow.Id.Call>()
+      .map { it.children }
+      .flatten()
+      .toSet()
+
+    if (stateSnapshot.isExclusionary()) {
+      repository.deleteAllCallLogsExcept(callRowIds).subscribe()
+    } else {
+      repository.deleteSelectedCallLogs(callRowIds).subscribe()
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/calls/log/CallLogViewModel.kt

@@ -0,0 +1,158 @@
+package org.thoughtcrime.securesms.calls.log
+
+import androidx.annotation.MainThread
+import androidx.lifecycle.ViewModel
+import io.reactivex.rxjava3.core.BackpressureStrategy
+import io.reactivex.rxjava3.core.Flowable
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.processors.BehaviorProcessor
+import org.signal.paging.ObservablePagedData
+import org.signal.paging.PagedData
+import org.signal.paging.PagingConfig
+import org.signal.paging.ProxyPagingController
+import org.thoughtcrime.securesms.util.rx.RxStore
+
+/**
+ * ViewModel for call log management.
+ */
+class CallLogViewModel(
+  private val callLogRepository: CallLogRepository = CallLogRepository()
+) : ViewModel() {
+  private val callLogStore = RxStore(CallLogState())
+
+  private val disposables = CompositeDisposable()
+  private val pagedData: BehaviorProcessor<ObservablePagedData<CallLogRow.Id, CallLogRow>> = BehaviorProcessor.create()
+
+  private val distinctQueryFilterPairs = callLogStore
+    .stateFlowable
+    .map { (query, filter) -> Pair(query, filter) }
+    .distinctUntilChanged()
+
+  val controller = ProxyPagingController<CallLogRow.Id>()
+  val data: Flowable<MutableList<CallLogRow?>> = pagedData.switchMap { it.data.toFlowable(BackpressureStrategy.LATEST) }
+  val selectedAndStagedDeletion: Flowable<Pair<CallLogSelectionState, CallLogStagedDeletion?>> = callLogStore
+    .stateFlowable
+    .map { it.selectionState to it.stagedDeletion }
+
+  val totalCount: Flowable<Int> = Flowable.combineLatest(distinctQueryFilterPairs, data) { a, _ -> a }
+    .map { (query, filter) -> callLogRepository.getCallsCount(query, filter) }
+
+  val selectionStateSnapshot: CallLogSelectionState
+    get() = callLogStore.state.selectionState
+  val filterSnapshot: CallLogFilter
+    get() = callLogStore.state.filter
+
+  val hasSearchQuery: Boolean
+    get() = !callLogStore.state.query.isNullOrBlank()
+
+  private val pagingConfig = PagingConfig.Builder()
+    .setBufferPages(1)
+    .setPageSize(20)
+    .setStartIndex(0)
+    .build()
+
+  init {
+    disposables.add(callLogStore)
+    disposables += distinctQueryFilterPairs.subscribe { (query, filter) ->
+      pagedData.onNext(
+        PagedData.createForObservable(
+          CallLogPagedDataSource(query, filter, callLogRepository),
+          pagingConfig
+        )
+      )
+    }
+
+    disposables += pagedData.map { it.controller }.subscribe {
+      controller.set(it)
+    }
+
+    disposables += callLogRepository.listenForChanges().subscribe {
+      controller.onDataInvalidated()
+    }
+  }
+
+  override fun onCleared() {
+    commitStagedDeletion()
+    disposables.dispose()
+  }
+
+  fun selectAll() {
+    callLogStore.update {
+      val selectionState = CallLogSelectionState.selectAll()
+      it.copy(selectionState = selectionState)
+    }
+  }
+
+  fun toggleSelected(callId: CallLogRow.Id) {
+    callLogStore.update {
+      val selectionState = it.selectionState.toggle(callId)
+      it.copy(selectionState = selectionState)
+    }
+  }
+
+  @MainThread
+  fun stageCallDeletion(call: CallLogRow.Call) {
+    callLogStore.state.stagedDeletion?.commit()
+    callLogStore.update {
+      it.copy(
+        stagedDeletion = CallLogStagedDeletion(
+          CallLogSelectionState.empty().toggle(call.id),
+          callLogRepository
+        )
+      )
+    }
+  }
+
+  @MainThread
+  fun stageSelectionDeletion() {
+    callLogStore.state.stagedDeletion?.commit()
+    callLogStore.update {
+      it.copy(
+        stagedDeletion = CallLogStagedDeletion(
+          it.selectionState,
+          callLogRepository
+        )
+      )
+    }
+  }
+
+  fun commitStagedDeletion() {
+    callLogStore.state.stagedDeletion?.commit()
+    callLogStore.update {
+      it.copy(
+        stagedDeletion = null
+      )
+    }
+  }
+
+  fun cancelStagedDeletion() {
+    callLogStore.state.stagedDeletion?.cancel()
+    callLogStore.update {
+      it.copy(
+        stagedDeletion = null
+      )
+    }
+  }
+
+  fun clearSelected() {
+    callLogStore.update {
+      it.copy(selectionState = CallLogSelectionState.empty())
+    }
+  }
+
+  fun setSearchQuery(query: String) {
+    callLogStore.update { it.copy(query = query) }
+  }
+
+  fun setFilter(filter: CallLogFilter) {
+    callLogStore.update { it.copy(filter = filter) }
+  }
+
+  private data class CallLogState(
+    val query: String? = null,
+    val filter: CallLogFilter = CallLogFilter.ALL,
+    val selectionState: CallLogSelectionState = CallLogSelectionState.empty(),
+    val stagedDeletion: CallLogStagedDeletion? = null
+  )
+}

app/src/main/java/org/thoughtcrime/securesms/calls/new/NewCallActivity.kt

@@ -0,0 +1,127 @@
+package org.thoughtcrime.securesms.calls.new
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import androidx.core.app.ActivityCompat
+import androidx.core.view.MenuProvider
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.signal.core.util.concurrent.SimpleTask
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.ContactSelectionActivity
+import org.thoughtcrime.securesms.ContactSelectionListFragment
+import org.thoughtcrime.securesms.InviteActivity
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.contacts.ContactSelectionDisplayMode
+import org.thoughtcrime.securesms.contacts.sync.ContactDiscovery.refresh
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.util.CommunicationActions
+import org.thoughtcrime.securesms.util.views.SimpleProgressDialog
+import java.io.IOException
+import java.util.Optional
+import java.util.function.Consumer
+
+class NewCallActivity : ContactSelectionActivity(), ContactSelectionListFragment.NewCallCallback {
+
+  override fun onCreate(icicle: Bundle?, ready: Boolean) {
+    super.onCreate(icicle, ready)
+    requireNotNull(supportActionBar)
+    supportActionBar?.setTitle(R.string.NewCallActivity__new_call)
+    supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    addMenuProvider(NewCallMenuProvider())
+  }
+
+  override fun onSelectionChanged() = Unit
+
+  override fun onBeforeContactSelected(isFromUnknownSearchKey: Boolean, recipientId: Optional<RecipientId?>, number: String?, callback: Consumer<Boolean?>) {
+    if (isFromUnknownSearchKey) {
+      Log.i(TAG, "[onContactSelected] Maybe creating a new recipient.")
+      if (SignalStore.account().isRegistered) {
+        Log.i(TAG, "[onContactSelected] Doing contact refresh.")
+        val progress = SimpleProgressDialog.show(this)
+        SimpleTask.run<Recipient>(lifecycle, {
+          var resolved = Recipient.external(this, number!!)
+          if (!resolved.isRegistered || !resolved.hasServiceId()) {
+            Log.i(TAG, "[onContactSelected] Not registered or no UUID. Doing a directory refresh.")
+            resolved = try {
+              refresh(this, resolved, false)
+              Recipient.resolved(resolved.id)
+            } catch (e: IOException) {
+              Log.w(TAG, "[onContactSelected] Failed to refresh directory for new contact.")
+              return@run null
+            }
+          }
+          resolved
+        }) { resolved: Recipient? ->
+          progress.dismiss()
+          if (resolved != null) {
+            if (resolved.isRegistered && resolved.hasServiceId()) {
+              launch(resolved)
+            } else {
+              MaterialAlertDialogBuilder(this)
+                .setMessage(getString(R.string.NewConversationActivity__s_is_not_a_signal_user, resolved.getDisplayName(this)))
+                .setPositiveButton(android.R.string.ok, null)
+                .show()
+            }
+          } else {
+            MaterialAlertDialogBuilder(this)
+              .setMessage(R.string.NetworkFailure__network_error_check_your_connection_and_try_again)
+              .setPositiveButton(android.R.string.ok, null)
+              .show()
+          }
+        }
+      }
+    }
+    callback.accept(true)
+  }
+
+  private fun launch(recipient: Recipient) {
+    if (recipient.isGroup) {
+      CommunicationActions.startVideoCall(this, recipient)
+    } else {
+      CommunicationActions.startVoiceCall(this, recipient)
+    }
+  }
+
+  companion object {
+
+    private val TAG = Log.tag(NewCallActivity::class.java)
+
+    fun createIntent(context: Context): Intent {
+      return Intent(context, NewCallActivity::class.java)
+        .putExtra(
+          ContactSelectionListFragment.DISPLAY_MODE,
+          ContactSelectionDisplayMode.none()
+            .withPush()
+            .withActiveGroups()
+            .withGroupMembers()
+            .build()
+        )
+    }
+  }
+
+  override fun onInvite() {
+    startActivity(Intent(this, InviteActivity::class.java))
+  }
+
+  private inner class NewCallMenuProvider : MenuProvider {
+    override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+      menuInflater.inflate(R.menu.new_call_menu, menu)
+    }
+
+    override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+      when (menuItem.itemId) {
+        android.R.id.home -> ActivityCompat.finishAfterTransition(this@NewCallActivity)
+        R.id.menu_refresh -> onRefresh()
+        R.id.menu_invite -> startActivity(Intent(this@NewCallActivity, InviteActivity::class.java))
+      }
+
+      return true
+    }
+  }
+}

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

@@ -28,7 +28,6 @@ public class AlertView extends LinearLayout {
     initialize(attrs);
   }
 
-  @TargetApi(VERSION_CODES.HONEYCOMB)
   public AlertView(final Context context, AttributeSet attrs, int defStyle) {
     super(context, attrs, defStyle);
     initialize(attrs);

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

@@ -64,8 +64,10 @@ public class AnimatingToggle extends FrameLayout {
   public void displayQuick(@Nullable View view) {
     if (view == current && current.getVisibility() == View.VISIBLE) return;
     if (current != null) current.setVisibility(View.GONE);
-    if (view != null)    view.setVisibility(View.VISIBLE);
-
+    if (view != null) {
+      view.setVisibility(View.VISIBLE);
+      view.clearAnimation();
+    }
     current = view;
   }
 }

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

@@ -6,8 +6,8 @@ import android.graphics.Path
 import android.graphics.Rect
 import android.graphics.RectF
 import android.util.AttributeSet
-import androidx.cardview.widget.CardView
 import androidx.core.graphics.withClip
+import com.google.android.material.card.MaterialCardView
 
 /**
  * Adds manual clipping around the card. This ensures that software rendering
@@ -16,7 +16,7 @@ import androidx.core.graphics.withClip
 class ClippedCardView @JvmOverloads constructor(
   context: Context,
   attrs: AttributeSet? = null
-) : CardView(context, attrs) {
+) : MaterialCardView(context, attrs) {
 
   private val bounds = Rect()
   private val boundsF = RectF()

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

@@ -3,7 +3,6 @@ package org.thoughtcrime.securesms.components;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Canvas;
-import android.graphics.Typeface;
 import android.os.Build;
 import android.os.Bundle;
 import android.text.Annotation;
@@ -15,11 +14,7 @@ import android.text.SpannableStringBuilder;
 import android.text.Spanned;
 import android.text.TextUtils;
 import android.text.TextUtils.TruncateAt;
-import android.text.style.CharacterStyle;
 import android.text.style.RelativeSizeSpan;
-import android.text.style.StrikethroughSpan;
-import android.text.style.StyleSpan;
-import android.text.style.TypefaceSpan;
 import android.util.AttributeSet;
 import android.view.ActionMode;
 import android.view.Menu;
@@ -42,6 +37,7 @@ import org.thoughtcrime.securesms.components.mention.MentionAnnotation;
 import org.thoughtcrime.securesms.components.mention.MentionDeleter;
 import org.thoughtcrime.securesms.components.mention.MentionRendererDelegate;
 import org.thoughtcrime.securesms.components.mention.MentionValidatorWatcher;
+import org.thoughtcrime.securesms.components.spoiler.SpoilerRendererDelegate;
 import org.thoughtcrime.securesms.conversation.MessageSendType;
 import org.thoughtcrime.securesms.conversation.MessageStyler;
 import org.thoughtcrime.securesms.conversation.ui.inlinequery.InlineQuery;
@@ -63,26 +59,19 @@ import static org.thoughtcrime.securesms.database.MentionUtil.MENTION_STARTER;
 public class ComposeText extends EmojiEditText {
 
   private static final char EMOJI_STARTER       = ':';
-  private static final long EMOJI_KEYWORD_DELAY = 1500;
 
   private static final Pattern TIME_PATTERN = Pattern.compile("^[0-9]{1,2}:[0-9]{1,2}$");
 
   private CharSequence            hint;
   private SpannableString         subHint;
   private MentionRendererDelegate mentionRendererDelegate;
+  private SpoilerRendererDelegate spoilerRendererDelegate;
   private MentionValidatorWatcher mentionValidatorWatcher;
 
   @Nullable private InputPanel.MediaListener      mediaListener;
   @Nullable private CursorPositionChangedListener cursorPositionChangedListener;
   @Nullable private InlineQueryChangedListener    inlineQueryChangedListener;
 
-  private final Runnable keywordSearchRunnable = () -> {
-    Editable text = getText();
-    if (text != null && enoughToFilter(text, true)) {
-      performFiltering(text, true);
-    }
-  };
-
   public ComposeText(Context context) {
     super(context);
     initialize();
@@ -164,6 +153,9 @@ public class ComposeText extends EmojiEditText {
 
       try {
         mentionRendererDelegate.draw(canvas, getText(), getLayout());
+        if (spoilerRendererDelegate != null) {
+          spoilerRendererDelegate.draw(canvas, getText(), getLayout());
+        }
       } finally {
         canvas.restoreToCount(checkpoint);
       }
@@ -310,6 +302,12 @@ public class ComposeText extends EmojiEditText {
     addTextChangedListener(mentionValidatorWatcher);
 
     if (FeatureFlags.textFormatting()) {
+      if (FeatureFlags.textFormattingSpoilerSend()) {
+        spoilerRendererDelegate = new SpoilerRendererDelegate(this, true);
+      }
+
+      addTextChangedListener(new ComposeTextStyleWatcher());
+
       setCustomSelectionActionModeCallback(new ActionMode.Callback() {
         @Override
         public boolean onCreateActionMode(ActionMode mode, Menu menu) {
@@ -326,6 +324,10 @@ public class ComposeText extends EmojiEditText {
           menu.add(0, R.id.edittext_strikethrough, largestOrder, getContext().getString(R.string.TextFormatting_strikethrough));
           menu.add(0, R.id.edittext_monospace, largestOrder, getContext().getString(R.string.TextFormatting_monospace));
 
+          if (FeatureFlags.textFormattingSpoilerSend()) {
+            menu.add(0, R.id.edittext_spoiler, largestOrder, getContext().getString(R.string.TextFormatting_spoiler));
+          }
+
           return true;
         }
 
@@ -340,7 +342,8 @@ public class ComposeText extends EmojiEditText {
           if (item.getItemId() != R.id.edittext_bold &&
               item.getItemId() != R.id.edittext_italic &&
               item.getItemId() != R.id.edittext_strikethrough &&
-              item.getItemId() != R.id.edittext_monospace) {
+              item.getItemId() != R.id.edittext_monospace &&
+              item.getItemId() != R.id.edittext_spoiler) {
             return false;
           }
 
@@ -349,7 +352,7 @@ public class ComposeText extends EmojiEditText {
 
           CharSequence    charSequence = text.subSequence(start, end);
           SpannableString replacement  = new SpannableString(charSequence);
-          CharacterStyle  style        = null;
+          Object          style        = null;
 
           if (item.getItemId() == R.id.edittext_bold) {
             style = MessageStyler.boldStyle();
@@ -359,10 +362,12 @@ public class ComposeText extends EmojiEditText {
             style = MessageStyler.strikethroughStyle();
           } else if (item.getItemId() == R.id.edittext_monospace) {
             style = MessageStyler.monoStyle();
+          } else if (item.getItemId() == R.id.edittext_spoiler) {
+            style = MessageStyler.spoilerStyle(MessageStyler.COMPOSE_ID, start, charSequence.length());
           }
 
           if (style != null) {
-            replacement.setSpan(style, 0, charSequence.length(), Spannable.SPAN_EXCLUSIVE_INCLUSIVE);
+            replacement.setSpan(style, 0, charSequence.length(), MessageStyler.SPAN_FLAGS);
           }
 
           clearComposingText();
@@ -532,6 +537,11 @@ public class ComposeText extends EmojiEditText {
     return -1;
   }
 
+  @Override
+  protected boolean shouldPersistSignalStylingWhenPasting() {
+    return true;
+  }
+
   /**
    * Return true if we think the user may be inputting a time.
    */

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

@@ -0,0 +1,92 @@
+package org.thoughtcrime.securesms.components
+
+import android.text.Annotation
+import android.text.Editable
+import android.text.Spannable
+import android.text.Spanned
+import android.text.TextUtils
+import android.text.TextWatcher
+import org.signal.core.util.StringUtil
+import org.thoughtcrime.securesms.conversation.MessageStyler
+import org.thoughtcrime.securesms.conversation.MessageStyler.isSupportedStyle
+
+/**
+ * Formatting should only grow when appending until a white space character is entered/pasted.
+ *
+ * This watcher observes changes to the text and will shrink supported style ranges as necessary
+ * to provide the desired behavior.
+ */
+class ComposeTextStyleWatcher : TextWatcher {
+  private val markerAnnotation = Annotation("text-formatting", "marker")
+  private var textSnapshotPriorToChange: CharSequence? = null
+
+  override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
+    if (s is Spannable) {
+      s.removeSpan(markerAnnotation)
+    }
+
+    textSnapshotPriorToChange = s.subSequence(start, start + count)
+  }
+
+  override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+    if (s is Spannable) {
+      s.removeSpan(markerAnnotation)
+
+      if (count > 0) {
+        s.setSpan(markerAnnotation, start, start + count, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+      }
+    }
+  }
+
+  override fun afterTextChanged(s: Editable) {
+    val editStart = s.getSpanStart(markerAnnotation)
+    val editEnd = s.getSpanEnd(markerAnnotation)
+
+    s.removeSpan(markerAnnotation)
+
+    try {
+      if (editStart < 0 || editEnd < 0 || editStart >= editEnd || (editStart == 0 && editEnd == s.length)) {
+        return
+      }
+
+      val change = s.subSequence(editStart, editEnd)
+      if (change.isEmpty() || textSnapshotPriorToChange == null || (editEnd - editStart == 1 && !StringUtil.isVisuallyEmpty(change[0])) || TextUtils.equals(textSnapshotPriorToChange, change)) {
+        textSnapshotPriorToChange = null
+        return
+      }
+      textSnapshotPriorToChange = null
+
+      var newEnd = editStart
+      for (i in change.indices) {
+        if (StringUtil.isVisuallyEmpty(change[i])) {
+          newEnd = editStart + i
+          break
+        }
+      }
+
+      s.getSpans(editStart, editEnd, Object::class.java)
+        .filter { it.isSupportedStyle() }
+        .forEach { style ->
+          val styleStart = s.getSpanStart(style)
+          val styleEnd = s.getSpanEnd(style)
+
+          if (styleEnd == editEnd && styleStart < styleEnd) {
+            s.removeSpan(style)
+            s.setSpan(style, styleStart, newEnd, MessageStyler.SPAN_FLAGS)
+          } else if (styleStart >= styleEnd) {
+            s.removeSpan(style)
+          }
+        }
+    } finally {
+      s.getSpans(editStart, editEnd, Object::class.java)
+        .filter { it.isSupportedStyle() }
+        .forEach { style ->
+          val styleStart = s.getSpanStart(style)
+          val styleEnd = s.getSpanEnd(style)
+          if (styleEnd == styleStart || styleStart > styleEnd) {
+            s.removeSpan(style)
+          }
+        }
+    }
+  }
+}

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

@@ -12,6 +12,7 @@ import androidx.annotation.Px
 import androidx.annotation.UiThread
 import androidx.core.os.bundleOf
 import org.signal.core.util.dp
+import org.signal.core.util.getParcelableCompat
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.mms.GlideRequests
 import org.thoughtcrime.securesms.mms.Slide
@@ -95,8 +96,8 @@ class ConversationItemThumbnail @JvmOverloads constructor(
 
   override fun onRestoreInstanceState(state: Parcelable) {
     if (state is Bundle && state.containsKey(STATE_STATE)) {
-      val root = state.getParcelable<Parcelable>(STATE_ROOT)
-      this.state = state.getParcelable(STATE_STATE)!!
+      val root: Parcelable? = state.getParcelableCompat(STATE_ROOT, Parcelable::class.java)
+      this.state = state.getParcelableCompat(STATE_STATE, ConversationItemThumbnailState::class.java)!!
       super.onRestoreInstanceState(root)
     } else {
       super.onRestoreInstanceState(state)

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

@@ -22,7 +22,6 @@ public class HidingLinearLayout extends LinearLayout {
     super(context, attrs);
   }
 
-  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   public HidingLinearLayout(Context context, AttributeSet attrs, int defStyleAttr) {
     super(context, attrs, defStyleAttr);
   }

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

@@ -31,7 +31,6 @@ public class InsetAwareConstraintLayout extends ConstraintLayout {
   }
 
   @Override
-  @TargetApi(20)
   public WindowInsets onApplyWindowInsets(WindowInsets insets) {
     if (Build.VERSION.SDK_INT < 30) {
       return super.onApplyWindowInsets(insets);

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

@@ -22,6 +22,7 @@ class NumericKeyboardView @JvmOverloads constructor(
   var listener: Listener? = null
 
   init {
+    layoutDirection = LAYOUT_DIRECTION_LTR
     inflate(context, R.layout.numeric_keyboard_view, this)
 
     findViewById<TextView>(R.id.numeric_keyboard_1).setOnClickListener {

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

@@ -5,6 +5,7 @@ import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Canvas;
 import android.os.Build;
+import android.text.Spannable;
 import android.text.TextUtils;
 import android.util.AttributeSet;
 import android.view.View;
@@ -27,8 +28,10 @@ import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.attachments.Attachment;
 import org.thoughtcrime.securesms.components.emoji.EmojiImageView;
+import org.thoughtcrime.securesms.components.emoji.EmojiTextView;
 import org.thoughtcrime.securesms.components.mention.MentionAnnotation;
 import org.thoughtcrime.securesms.components.quotes.QuoteViewColorTheme;
+import org.thoughtcrime.securesms.components.spoiler.SpoilerAnnotation;
 import org.thoughtcrime.securesms.conversation.MessageStyler;
 import org.thoughtcrime.securesms.database.model.Mention;
 import org.thoughtcrime.securesms.database.model.databaseprotos.BodyRangeList;
@@ -82,7 +85,7 @@ public class QuoteView extends FrameLayout implements RecipientForeverObserver {
   private ViewGroup          mainView;
   private ViewGroup          footerView;
   private TextView           authorView;
-  private TextView           bodyView;
+  private EmojiTextView      bodyView;
   private View               quoteBarView;
   private ShapeableImageView thumbnailView;
   private View               attachmentVideoOverlayView;
@@ -163,6 +166,7 @@ public class QuoteView extends FrameLayout implements RecipientForeverObserver {
 
     setMessageType(messageType);
 
+    bodyView.enableSpoilerFiltering();
     dismissView.setOnClickListener(view -> setVisibility(GONE));
   }
 

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

@@ -133,14 +133,12 @@ public class RecentPhotoViewRail extends FrameLayout implements LoaderManager.Lo
 
     }
 
-    @TargetApi(16)
     @SuppressWarnings("SuspiciousNameCombination")
     private String getWidthColumn(int orientation) {
       if (orientation == 0 || orientation == 180) return MediaStore.Images.ImageColumns.WIDTH;
       else                                        return MediaStore.Images.ImageColumns.HEIGHT;
     }
 
-    @TargetApi(16)
     @SuppressWarnings("SuspiciousNameCombination")
     private String getHeightColumn(int orientation) {
       if (orientation == 0 || orientation == 180) return MediaStore.Images.ImageColumns.HEIGHT;

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

@@ -28,7 +28,7 @@ import kotlin.jvm.functions.Function2;
  * fill the bounds with a gradient.
  *
  * If you wish to apply clipping to this drawable, it is recommended to either use it with
- * a CardView or utilize {@link org.thoughtcrime.securesms.util.CustomDrawWrapperKt#customizeOnDraw(Drawable, Function2)}
+ * a MaterialCardView or utilize {@link org.thoughtcrime.securesms.util.CustomDrawWrapperKt#customizeOnDraw(Drawable, Function2)}
  */
 public final class RotatableGradientDrawable extends Drawable {
 

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

@@ -23,7 +23,7 @@ public class SquareFrameLayout extends FrameLayout {
     this(context, attrs, 0);
   }
 
-  @TargetApi(VERSION_CODES.HONEYCOMB) @SuppressWarnings("unused")
+  @SuppressWarnings("unused")
   public SquareFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
     super(context, attrs, defStyleAttr);
 

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

@@ -1,53 +0,0 @@
-package org.thoughtcrime.securesms.components;
-
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.os.Build;
-import android.util.AttributeSet;
-
-import androidx.preference.CheckBoxPreference;
-import androidx.preference.Preference;
-
-import org.thoughtcrime.securesms.R;
-
-public class SwitchPreferenceCompat extends CheckBoxPreference {
-
-    private Preference.OnPreferenceClickListener listener;
-
-    public SwitchPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-        setLayoutRes();
-    }
-
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-    public SwitchPreferenceCompat(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
-        super(context, attrs, defStyleAttr, defStyleRes);
-        setLayoutRes();
-    }
-
-    public SwitchPreferenceCompat(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        setLayoutRes();
-    }
-
-    public SwitchPreferenceCompat(Context context) {
-        super(context);
-        setLayoutRes();
-    }
-
-    private void setLayoutRes() {
-        setWidgetLayoutResource(R.layout.switch_compat_preference);
-    }
-
-    @Override
-    public void setOnPreferenceClickListener(Preference.OnPreferenceClickListener listener) {
-        this.listener = listener;
-    }
-
-    @Override
-    protected void onClick() {
-        if (listener == null || !listener.onPreferenceClick(this)) {
-            super.onClick();
-        }
-    }
-}

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

@@ -62,12 +62,12 @@ public class TypingStatusRepository {
       ThreadUtil.cancelRunnableOnMain(timer);
     }
 
-    timer = () -> onTypingStopped(context, threadId, author, device, false);
+    timer = () -> onTypingStopped(threadId, author, device, false);
     ThreadUtil.runOnMainDelayed(timer, RECIPIENT_TYPING_TIMEOUT);
     timers.put(typist, timer);
   }
 
-  public synchronized void onTypingStopped(@NonNull Context context, long threadId, @NonNull Recipient author, int device, boolean isReplacedByIncomingMessage) {
+  public synchronized void onTypingStopped(long threadId, @NonNull Recipient author, int device, boolean isReplacedByIncomingMessage) {
     if (author.isSelf()) {
       return;
     }

app/src/main/java/org/thoughtcrime/securesms/components/emoji/EmojiEditText.java

@@ -1,9 +1,13 @@
 package org.thoughtcrime.securesms.components.emoji;
 
+import android.content.ClipData;
+import android.content.ClipboardManager;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.drawable.Drawable;
+import android.os.Build;
 import android.text.InputFilter;
+import android.text.TextUtils;
 import android.util.AttributeSet;
 
 import androidx.annotation.NonNull;
@@ -14,7 +18,9 @@ import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.components.emoji.EmojiProvider.EmojiDrawable;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.util.EditTextExtensionsKt;
+import org.thoughtcrime.securesms.util.ServiceUtil;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
+import org.thoughtcrime.securesms.util.Util;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -35,9 +41,9 @@ public class EmojiEditText extends AppCompatEditText {
   public EmojiEditText(Context context, AttributeSet attrs, int defStyleAttr) {
     super(context, attrs, defStyleAttr);
 
-    TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.EmojiTextView, 0, 0);
-    boolean forceCustom = a.getBoolean(R.styleable.EmojiTextView_emoji_forceCustom, false);
-    boolean jumboEmoji = a.getBoolean(R.styleable.EmojiTextView_emoji_forceJumbo, false);
+    TypedArray a           = context.getTheme().obtainStyledAttributes(attrs, R.styleable.EmojiTextView, 0, 0);
+    boolean    forceCustom = a.getBoolean(R.styleable.EmojiTextView_emoji_forceCustom, false);
+    boolean    jumboEmoji  = a.getBoolean(R.styleable.EmojiTextView_emoji_forceJumbo, false);
     a.recycle();
 
     if (!isInEditMode() && (forceCustom || !SignalStore.settings().isPreferSystemEmoji())) {
@@ -57,8 +63,8 @@ public class EmojiEditText extends AppCompatEditText {
   }
 
   public void insertEmoji(String emoji) {
-    final int          start = getSelectionStart();
-    final int          end   = getSelectionEnd();
+    final int start = getSelectionStart();
+    final int end   = getSelectionEnd();
 
     getText().replace(Math.min(start, end), Math.max(start, end), emoji);
     setSelection(start + emoji.length());
@@ -66,8 +72,11 @@ public class EmojiEditText extends AppCompatEditText {
 
   @Override
   public void invalidateDrawable(@NonNull Drawable drawable) {
-    if (drawable instanceof EmojiDrawable) invalidate();
-    else                                   super.invalidateDrawable(drawable);
+    if (drawable instanceof EmojiDrawable) {
+      invalidate();
+    } else {
+      super.invalidateDrawable(drawable);
+    }
   }
 
   @Override
@@ -95,4 +104,50 @@ public class EmojiEditText extends AppCompatEditText {
 
     return result;
   }
+
+  @Override
+  public boolean onTextContextMenuItem(int id) {
+    if (id == android.R.id.paste) {
+      ClipData clipData = ServiceUtil.getClipboardManager(getContext()).getPrimaryClip();
+
+      if (clipData != null) {
+        CharSequence label        = clipData.getDescription().getLabel();
+        CharSequence pendingPaste = getTextFromClipData(clipData);
+
+        if (TextUtils.equals(Util.COPY_LABEL, label) && shouldPersistSignalStylingWhenPasting()) {
+          return super.onTextContextMenuItem(id);
+        } else if (Build.VERSION.SDK_INT >= 23) {
+          return super.onTextContextMenuItem(android.R.id.pasteAsPlainText);
+        } else if (pendingPaste != null) {
+          Util.copyToClipboard(getContext(), pendingPaste.toString());
+          return super.onTextContextMenuItem(id);
+        }
+      }
+    } else if (id == android.R.id.copy || id == android.R.id.cut) {
+      boolean          originalResult   = super.onTextContextMenuItem(id);
+      ClipboardManager clipboardManager = ServiceUtil.getClipboardManager(getContext());
+      CharSequence     clipText         = getTextFromClipData(clipboardManager.getPrimaryClip());
+
+      if (clipText != null) {
+        Util.copyToClipboard(getContext(), clipText);
+        return true;
+      }
+
+      return originalResult;
+    }
+
+    return super.onTextContextMenuItem(id);
+  }
+
+  private @Nullable CharSequence getTextFromClipData(@Nullable ClipData data) {
+    if (data != null && data.getItemCount() > 0) {
+      return data.getItemAt(0).coerceToText(getContext());
+    } else {
+      return null;
+    }
+  }
+
+  protected boolean shouldPersistSignalStylingWhenPasting() {
+    return false;
+  }
 }

app/src/main/java/org/thoughtcrime/securesms/components/emoji/EmojiStrings.java

@@ -10,4 +10,5 @@ public final class EmojiStrings {
   public static final String STICKER            = "\u2B50";
   public static final String GIFT               = "\uD83C\uDF81";
   public static final String CARD               = "\uD83D\uDCB3";
+  public static final String FAILED_STORY       = "\u2757";
 }