Bump version to 5.26.8

Fixes #11729

.github/ISSUE_TEMPLATE/bug_report.md

@@ -50,5 +50,5 @@ Describe here the issue that you are experiencing.
 **Signal version:** 0.0.0
 
 ### Link to debug log
-<!-- immediately after the bug has happened capture a debug log via Signal's advanced settings and paste the link below -->
+<!-- immediately after the bug has happened capture a debug log via Signal's settings (Help -> Debug log) and paste the link below -->
 

app/build.gradle

@@ -9,6 +9,7 @@ apply from: 'translations.gradle'
 apply from: 'witness-verifications.gradle'
 apply plugin: 'org.jetbrains.kotlin.android'
 apply plugin: 'app.cash.exhaustive'
+apply plugin: 'kotlin-parcelize'
 
 repositories {
     maven {
@@ -53,7 +54,7 @@ repositories {
 
 protobuf {
     protoc {
-        artifact = 'com.google.protobuf:protoc:3.10.0'
+        artifact = 'com.google.protobuf:protoc:3.11.4'
     }
     generateProtoTasks {
         all().each { task ->
@@ -66,8 +67,8 @@ protobuf {
     }
 }
 
-def canonicalVersionCode = 930
-def canonicalVersionName = "5.24.10"
+def canonicalVersionCode = 955
+def canonicalVersionName = "5.26.8"
 
 def postFixSize = 100
 def abiPostFix = ['universal'   : 0,
@@ -161,12 +162,12 @@ android {
         buildConfigField "String", "CDSH_PUBLIC_KEY", "\"2fe57da347cd62431528daac5fbb290730fff684afc4cfc2ed90995f58cb3b74\""
         buildConfigField "String", "CDSH_CODE_HASH", "\"ec31a51880d19a5e9e0fed404740c1a3ff53a553125564b745acce475f0fded8\""
         buildConfigField "String", "CDS_MRENCLAVE", "\"c98e00a4e3ff977a56afefe7362a27e4961e4f19e211febfbb19b897e6b80b15\""
-        buildConfigField "KbsEnclave", "KBS_ENCLAVE", "new KbsEnclave(\"fe7c1bfae98f9b073d220366ea31163ee82f6d04bead774f71ca8e5c40847bfe\"," +
-                                                                     "\"fe7c1bfae98f9b073d220366ea31163ee82f6d04bead774f71ca8e5c40847bfe\", " +
-                                                                     "\"a3baab19ef6ce6f34ab9ebb25ba722725ae44a8872dc0ff08ad6d83a9489de87\")";
-        buildConfigField "KbsEnclave[]", "KBS_FALLBACKS", "new KbsEnclave[0]"
+        buildConfigField "org.thoughtcrime.securesms.KbsEnclave", "KBS_ENCLAVE", "new org.thoughtcrime.securesms.KbsEnclave(\"fe7c1bfae98f9b073d220366ea31163ee82f6d04bead774f71ca8e5c40847bfe\"," +
+                                                                                                "\"fe7c1bfae98f9b073d220366ea31163ee82f6d04bead774f71ca8e5c40847bfe\", " +
+                                                                                                "\"a3baab19ef6ce6f34ab9ebb25ba722725ae44a8872dc0ff08ad6d83a9489de87\")";
+        buildConfigField "org.thoughtcrime.securesms.KbsEnclave[]", "KBS_FALLBACKS", "new org.thoughtcrime.securesms.KbsEnclave[0]"
         buildConfigField "String", "UNIDENTIFIED_SENDER_TRUST_ROOT", "\"BXu6QIKVz5MA8gstzfOgRQGqyLqOwNKHL6INkv3IHWMF\""
-        buildConfigField "String", "ZKGROUP_SERVER_PUBLIC_PARAMS", "\"AMhf5ywVwITZMsff/eCyudZx9JDmkkkbV6PInzG4p8x3VqVJSFiMvnvlEKWuRob/1eaIetR31IYeAbm0NdOuHH8Qi+Rexi1wLlpzIo1gstHWBfZzy1+qHRV5A4TqPp15YzBPm0WSggW6PbSn+F4lf57VCnHF7p8SvzAA2ZZJPYJURt8X7bbg+H3i+PEjH9DXItNEqs2sNcug37xZQDLm7X0=\""
+        buildConfigField "String", "ZKGROUP_SERVER_PUBLIC_PARAMS", "\"AMhf5ywVwITZMsff/eCyudZx9JDmkkkbV6PInzG4p8x3VqVJSFiMvnvlEKWuRob/1eaIetR31IYeAbm0NdOuHH8Qi+Rexi1wLlpzIo1gstHWBfZzy1+qHRV5A4TqPp15YzBPm0WSggW6PbSn+F4lf57VCnHF7p8SvzAA2ZZJPYJURt8X7bbg+H3i+PEjH9DXItNEqs2sNcug37xZQDLm7X36nOoGPs54XsEGzPdEV+itQNGUFEjY6X9Uv+Acuks7NpyGvCoKxGwgKgE5XyJ+nNKlyHHOLb6N1NuHyBrZrgtY\""
         buildConfigField "String[]", "LANGUAGES", "new String[]{\"" + autoResConfig().collect { s -> s.replace('-r', '_') }.join('", "') + '"}'
         buildConfigField "int", "CANONICAL_VERSION_CODE", "$canonicalVersionCode"
         buildConfigField "String", "DEFAULT_CURRENCIES", "\"EUR,AUD,GBP,CAD,CNY\""
@@ -177,6 +178,8 @@ android {
         buildConfigField "String", "BUILD_DISTRIBUTION_TYPE", "\"unset\""
         buildConfigField "String", "BUILD_ENVIRONMENT_TYPE", "\"unset\""
         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\""
 
         ndk {
             abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
@@ -194,6 +197,11 @@ android {
         }
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunnerArguments clearPackageData: 'true'
+    }
+
+    testOptions {
+        execution 'ANDROIDX_TEST_ORCHESTRATOR'
     }
 
     compileOptions {
@@ -339,16 +347,17 @@ android {
             buildConfigField "String", "SIGNAL_CONTACT_DISCOVERY_URL", "\"https://api-staging.directory.signal.org\""
             buildConfigField "String", "SIGNAL_KEY_BACKUP_URL", "\"https://api-staging.backup.signal.org\""
             buildConfigField "String", "CDS_MRENCLAVE", "\"c98e00a4e3ff977a56afefe7362a27e4961e4f19e211febfbb19b897e6b80b15\""
-            buildConfigField "KbsEnclave", "KBS_ENCLAVE", "new KbsEnclave(\"823a3b2c037ff0cbe305cc48928cfcc97c9ed4a8ca6d49af6f7d6981fb60a4e9\", " +
-                                                                         "\"16b94ac6d2b7f7b9d72928f36d798dbb35ed32e7bb14c42b4301ad0344b46f29\", " +
-                                                                         "\"a3baab19ef6ce6f34ab9ebb25ba722725ae44a8872dc0ff08ad6d83a9489de87\")"
-            buildConfigField "KbsEnclave[]", "KBS_FALLBACKS", "new KbsEnclave[0]"
+            buildConfigField "org.thoughtcrime.securesms.KbsEnclave", "KBS_ENCLAVE", "new org.thoughtcrime.securesms.KbsEnclave(\"823a3b2c037ff0cbe305cc48928cfcc97c9ed4a8ca6d49af6f7d6981fb60a4e9\", " +
+                                                                                                    "\"16b94ac6d2b7f7b9d72928f36d798dbb35ed32e7bb14c42b4301ad0344b46f29\", " +
+                                                                                                    "\"a3baab19ef6ce6f34ab9ebb25ba722725ae44a8872dc0ff08ad6d83a9489de87\")"
+            buildConfigField "org.thoughtcrime.securesms.KbsEnclave[]", "KBS_FALLBACKS", "new org.thoughtcrime.securesms.KbsEnclave[0]"
             buildConfigField "String", "UNIDENTIFIED_SENDER_TRUST_ROOT", "\"BbqY1DzohE4NUZoVF+L18oUPrK3kILllLEJh2UnPSsEx\""
-            buildConfigField "String", "ZKGROUP_SERVER_PUBLIC_PARAMS", "\"ABSY21VckQcbSXVNCGRYJcfWHiAMZmpTtTELcDmxgdFbtp/bWsSxZdMKzfCp8rvIs8ocCU3B37fT3r4Mi5qAemeGeR2X+/YmOGR5ofui7tD5mDQfstAI9i+4WpMtIe8KC3wU5w3Inq3uNWVmoGtpKndsNfwJrCg0Hd9zmObhypUnSkfYn2ooMOOnBpfdanRtrvetZUayDMSC5iSRcXKpdls=\""
+            buildConfigField "String", "ZKGROUP_SERVER_PUBLIC_PARAMS", "\"ABSY21VckQcbSXVNCGRYJcfWHiAMZmpTtTELcDmxgdFbtp/bWsSxZdMKzfCp8rvIs8ocCU3B37fT3r4Mi5qAemeGeR2X+/YmOGR5ofui7tD5mDQfstAI9i+4WpMtIe8KC3wU5w3Inq3uNWVmoGtpKndsNfwJrCg0Hd9zmObhypUnSkfYn2ooMOOnBpfdanRtrvetZUayDMSC5iSRcXKpdlukrpzzsCIvEwjwQlJYVPOQPj4V0F4UXXBdHSLK05uoPBCQG8G9rYIGedYsClJXnbrgGYG3eMTG5hnx4X4ntARB\""
             buildConfigField "String", "MOBILE_COIN_ENVIRONMENT", "\"testnet\""
             buildConfigField "String", "RECAPTCHA_PROOF_URL", "\"https://signalcaptchas.org/staging/challenge/generate.html\""
 
             buildConfigField "String", "BUILD_ENVIRONMENT_TYPE", "\"Staging\""
+            buildConfigField "String", "STRIPE_PUBLISHABLE_KEY", "\"pk_test_sngOd8FnXNkpce9nPXawKrJD00kIDngZkD\""
         }
     }
 
@@ -454,6 +463,7 @@ dependencies {
     implementation project(':video')
     implementation project(':device-transfer')
     implementation project(':image-editor')
+    implementation project(':donations')
 
     implementation libs.signal.zkgroup.android
     implementation libs.signal.client.android
@@ -523,6 +533,7 @@ dependencies {
 
     flipperImplementation libs.facebook.flipper
     flipperImplementation libs.facebook.soloader
+    flipperImplementation libs.square.leakcanary
 
     testImplementation testLibs.junit.junit
     testImplementation testLibs.assertj.core
@@ -544,12 +555,16 @@ dependencies {
     androidTestImplementation testLibs.androidx.test.ext.junit
     androidTestImplementation testLibs.espresso.core
 
+    testImplementation testLibs.espresso.core
+
     implementation libs.kotlin.stdlib.jdk8
     implementation libs.kotlin.reflect
     implementation libs.jackson.module.kotlin
 
     implementation libs.rxjava3.rxandroid
     implementation libs.rxjava3.rxkotlin
+
+    androidTestUtil 'androidx.test:orchestrator:1.4.0'
 }
 
 dependencyVerification {

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

@@ -0,0 +1,367 @@
+package org.thoughtcrime.securesms.database
+
+import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.whispersystems.libsignal.util.guava.Optional
+import org.whispersystems.signalservice.api.push.ACI
+import java.lang.IllegalArgumentException
+import java.util.UUID
+
+@RunWith(AndroidJUnit4::class)
+class RecipientDatabaseTest {
+
+  private lateinit var recipientDatabase: RecipientDatabase
+
+  @Before
+  fun setup() {
+    recipientDatabase = DatabaseFactory.getRecipientDatabase(context)
+    ensureDbEmpty()
+  }
+
+  // ==============================================================
+  // If both the ACI and E164 map to no one
+  // ==============================================================
+
+  /** If all you have is an ACI, you can just store that, regardless of trust level. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_aciOnly_highTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, null, true)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(ACI_A, recipient.requireAci())
+    assertFalse(recipient.hasE164())
+  }
+
+  /** If all you have is an ACI, you can just store that, regardless of trust level. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_aciOnly_lowTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, null, false)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(ACI_A, recipient.requireAci())
+    assertFalse(recipient.hasE164())
+  }
+
+  /** If all you have is an E164, you can just store that, regardless of trust level. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_e164Only_highTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(null, E164_A, true)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(E164_A, recipient.requireE164())
+    assertFalse(recipient.hasAci())
+  }
+
+  /** If all you have is an E164, you can just store that, regardless of trust level. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_e164Only_lowTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(null, E164_A, false)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(E164_A, recipient.requireE164())
+    assertFalse(recipient.hasAci())
+  }
+
+  /** With high trust, you can associate an ACI-e164 pair. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_aciAndE164_highTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(ACI_A, recipient.requireAci())
+    assertEquals(E164_A, recipient.requireE164())
+  }
+
+  /** With low trust, you cannot associate an ACI-e164 pair, and therefore can only store the ACI. */
+  @Test
+  fun getAndPossiblyMerge_aciAndE164MapToNoOne_aciAndE164_lowTrust() {
+    val recipientId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, false)
+
+    val recipient = Recipient.resolved(recipientId)
+    assertEquals(ACI_A, recipient.requireAci())
+    assertFalse(recipient.hasE164())
+  }
+
+  // ==============================================================
+  // If the ACI maps to an existing user, but the E164 doesn't
+  // ==============================================================
+
+  /** With high trust, you can associate an e164 with an existing ACI. */
+  @Test
+  fun getAndPossiblyMerge_aciMapsToExistingUserButE164DoesNot_aciAndE164_highTrust() {
+    val existingId: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+  }
+
+  /** With low trust, you cannot associate an ACI-e164 pair, and therefore cannot store the e164. */
+  @Test
+  fun getAndPossiblyMerge_aciMapsToExistingUserButE164DoesNot_aciAndE164_lowTrust() {
+    val existingId: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, false)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertFalse(retrievedRecipient.hasE164())
+  }
+
+  /** Basically the ‘change number’ case. High trust lets you update the existing user. */
+  @Test
+  fun getAndPossiblyMerge_aciMapsToExistingUserButE164DoesNot_aciAndE164_2_highTrust() {
+    val existingId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_B, true)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_B, retrievedRecipient.requireE164())
+  }
+
+  /** Low trust means you can’t update the underlying data, but you also don’t need to create any new rows. */
+  @Test
+  fun getAndPossiblyMerge_aciMapsToExistingUserButE164DoesNot_aciAndE164_2_lowTrust() {
+    val existingId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_B, false)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+  }
+
+  // ==============================================================
+  // If the E164 maps to an existing user, but the ACI doesn't
+  // ==============================================================
+
+  /** With high trust, you can associate an e164 with an existing ACI. */
+  @Test
+  fun getAndPossiblyMerge_e164MapsToExistingUserButAciDoesNot_aciAndE164_highTrust() {
+    val existingId: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+  }
+
+  /** With low trust, you cannot associate an ACI-e164 pair, and therefore need to create a new person with just the ACI. */
+  @Test
+  fun getAndPossiblyMerge_e164MapsToExistingUserButAciDoesNot_aciAndE164_lowTrust() {
+    val existingId: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, false)
+    assertNotEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertFalse(retrievedRecipient.hasE164())
+
+    val existingRecipient = Recipient.resolved(existingId)
+    assertEquals(E164_A, existingRecipient.requireE164())
+    assertFalse(existingRecipient.hasAci())
+  }
+
+  /** We never change the ACI of an existing row. New ACI = new person, regardless of trust. But high trust lets us take the e164 from the current holder. */
+  @Test
+  fun getAndPossiblyMerge_e164MapsToExistingUserButAciDoesNot_aciAndE164_2_highTrust() {
+    val existingId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_B, E164_A, true)
+    assertNotEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_B, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+
+    val existingRecipient = Recipient.resolved(existingId)
+    assertEquals(ACI_A, existingRecipient.requireAci())
+    assertFalse(existingRecipient.hasE164())
+  }
+
+  /** We never change the ACI of an existing row. New ACI = new person, regardless of trust. And low trust means we can’t take the e164. */
+  @Test
+  fun getAndPossiblyMerge_e164MapsToExistingUserButAciDoesNot_aciAndE164_2_lowTrust() {
+    val existingId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_B, E164_A, false)
+    assertNotEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_B, retrievedRecipient.requireAci())
+    assertFalse(retrievedRecipient.hasE164())
+
+    val existingRecipient = Recipient.resolved(existingId)
+    assertEquals(ACI_A, existingRecipient.requireAci())
+    assertEquals(E164_A, existingRecipient.requireE164())
+  }
+
+  // ==============================================================
+  // If both the ACI and E164 map to an existing user
+  // ==============================================================
+
+  /** Regardless of trust, if your ACI and e164 match, you’re good. */
+  @Test
+  fun getAndPossiblyMerge_bothAciAndE164MapToExistingUser_aciAndE164_highTrust() {
+    val existingId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    assertEquals(existingId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+  }
+
+  /** High trust lets you merge two different users into one. You should prefer the ACI user. Not shown: merging threads, dropping e164 sessions, etc. */
+  @Test
+  fun getAndPossiblyMerge_bothAciAndE164MapToExistingUser_aciAndE164_merge_highTrust() {
+    val existingAciId: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+    val existingE164Id: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    assertEquals(existingAciId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+
+    val existingE164Recipient = Recipient.resolved(existingE164Id)
+    assertEquals(retrievedId, existingE164Recipient.id)
+  }
+
+  /** Low trust means you can’t merge. If you’re retrieving a user from the table with this data, prefer the ACI one. */
+  @Test
+  fun getAndPossiblyMerge_bothAciAndE164MapToExistingUser_aciAndE164_lowTrust() {
+    val existingAciId: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+    val existingE164Id: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, false)
+    assertEquals(existingAciId, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertFalse(retrievedRecipient.hasE164())
+
+    val existingE164Recipient = Recipient.resolved(existingE164Id)
+    assertEquals(E164_A, existingE164Recipient.requireE164())
+    assertFalse(existingE164Recipient.hasAci())
+  }
+
+  /** Another high trust case. No new rules here, just a more complex scenario to show how different rules interact. */
+  @Test
+  fun getAndPossiblyMerge_bothAciAndE164MapToExistingUser_aciAndE164_complex_highTrust() {
+    val existingId1: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_B, true)
+    val existingId2: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_B, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    assertEquals(existingId1, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+
+    val existingRecipient2 = Recipient.resolved(existingId2)
+    assertEquals(ACI_B, existingRecipient2.requireAci())
+    assertFalse(existingRecipient2.hasE164())
+  }
+
+  /** Another low trust case. No new rules here, just a more complex scenario to show how different rules interact. */
+  @Test
+  fun getAndPossiblyMerge_bothAciAndE164MapToExistingUser_aciAndE164_complex_lowTrust() {
+    val existingId1: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_B, true)
+    val existingId2: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_B, E164_A, true)
+
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, false)
+    assertEquals(existingId1, retrievedId)
+
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_B, retrievedRecipient.requireE164())
+
+    val existingRecipient2 = Recipient.resolved(existingId2)
+    assertEquals(ACI_B, existingRecipient2.requireAci())
+    assertEquals(E164_A, existingRecipient2.requireE164())
+  }
+
+  // ==============================================================
+  // Misc
+  // ==============================================================
+
+  @Test
+  fun createByE164SanityCheck() {
+    // GIVEN one recipient
+    val recipientId: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    // WHEN I retrieve one by E164
+    val possible: Optional<RecipientId> = recipientDatabase.getByE164(E164_A)
+
+    // THEN I get it back, and it has the properties I expect
+    assertTrue(possible.isPresent)
+    assertEquals(recipientId, possible.get())
+
+    val recipient = Recipient.resolved(recipientId)
+    assertTrue(recipient.e164.isPresent)
+    assertEquals(E164_A, recipient.e164.get())
+  }
+
+  @Test
+  fun createByUuidSanityCheck() {
+    // GIVEN one recipient
+    val recipientId: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+
+    // WHEN I retrieve one by UUID
+    val possible: Optional<RecipientId> = recipientDatabase.getByAci(ACI_A)
+
+    // THEN I get it back, and it has the properties I expect
+    assertTrue(possible.isPresent)
+    assertEquals(recipientId, possible.get())
+
+    val recipient = Recipient.resolved(recipientId)
+    assertTrue(recipient.aci.isPresent)
+    assertEquals(ACI_A, recipient.aci.get())
+  }
+
+  @Test(expected = IllegalArgumentException::class)
+  fun getAndPossiblyMerge_noArgs_invalid() {
+    recipientDatabase.getAndPossiblyMerge(null, null, true)
+  }
+
+  private val context: Application
+    get() = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
+
+  private fun ensureDbEmpty() {
+    DatabaseFactory.getInstance(context).rawDatabase.rawQuery("SELECT COUNT(*) FROM ${RecipientDatabase.TABLE_NAME}", null).use { cursor ->
+      assertTrue(cursor.moveToFirst())
+      assertEquals(0, cursor.getLong(0))
+    }
+  }
+
+  companion object {
+    val ACI_A = ACI.from(UUID.fromString("3436efbe-5a76-47fa-a98a-7e72c948a82e"))
+    val ACI_B = ACI.from(UUID.fromString("8de7f691-0b60-4a68-9cd9-ed2f8453f9ed"))
+
+    val E164_A = "+12221234567"
+    val E164_B = "+13331234567"
+  }
+}

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

@@ -0,0 +1,221 @@
+package org.thoughtcrime.securesms.database
+
+import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import net.zetetic.database.sqlcipher.SQLiteDatabase
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.signal.storageservice.protos.groups.local.DecryptedGroup
+import org.signal.storageservice.protos.groups.local.DecryptedMember
+import org.signal.zkgroup.groups.GroupMasterKey
+import org.thoughtcrime.securesms.database.model.Mention
+import org.thoughtcrime.securesms.database.model.MessageRecord
+import org.thoughtcrime.securesms.groups.GroupId
+import org.thoughtcrime.securesms.mms.IncomingMediaMessage
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.sms.IncomingTextMessage
+import org.thoughtcrime.securesms.util.CursorUtil
+import org.whispersystems.libsignal.IdentityKey
+import org.whispersystems.libsignal.SignalProtocolAddress
+import org.whispersystems.libsignal.state.SessionRecord
+import org.whispersystems.libsignal.util.guava.Optional
+import org.whispersystems.signalservice.api.push.ACI
+import org.whispersystems.signalservice.api.util.UuidUtil
+import java.util.UUID
+
+@RunWith(AndroidJUnit4::class)
+class RecipientDatabaseTest_merges {
+
+  private lateinit var recipientDatabase: RecipientDatabase
+  private lateinit var identityDatabase: IdentityDatabase
+  private lateinit var groupReceiptDatabase: GroupReceiptDatabase
+  private lateinit var groupDatabase: GroupDatabase
+  private lateinit var threadDatabase: ThreadDatabase
+  private lateinit var smsDatabase: MessageDatabase
+  private lateinit var mmsDatabase: MessageDatabase
+  private lateinit var sessionDatabase: SessionDatabase
+  private lateinit var mentionDatabase: MentionDatabase
+
+  @Before
+  fun setup() {
+    recipientDatabase = DatabaseFactory.getRecipientDatabase(context)
+    identityDatabase = DatabaseFactory.getIdentityDatabase(context)
+    groupReceiptDatabase = DatabaseFactory.getGroupReceiptDatabase(context)
+    groupDatabase = DatabaseFactory.getGroupDatabase(context)
+    threadDatabase = DatabaseFactory.getThreadDatabase(context)
+    smsDatabase = DatabaseFactory.getSmsDatabase(context)
+    mmsDatabase = DatabaseFactory.getMmsDatabase(context)
+    sessionDatabase = DatabaseFactory.getSessionDatabase(context)
+    mentionDatabase = DatabaseFactory.getMentionDatabase(context)
+
+    ensureDbEmpty()
+  }
+
+  /** High trust lets you merge two different users into one. You should prefer the ACI user. Not shown: merging threads, dropping e164 sessions, etc. */
+  @Test
+  fun getAndPossiblyMerge_general() {
+    // Setup
+    val recipientIdAci: RecipientId = recipientDatabase.getOrInsertFromAci(ACI_A)
+    val recipientIdE164: RecipientId = recipientDatabase.getOrInsertFromE164(E164_A)
+
+    val smsId1: Long = smsDatabase.insertMessageInbox(smsMessage(sender = recipientIdAci, time = 0, body = "0")).get().messageId
+    val smsId2: Long = smsDatabase.insertMessageInbox(smsMessage(sender = recipientIdE164, time = 1, body = "1")).get().messageId
+    val smsId3: Long = smsDatabase.insertMessageInbox(smsMessage(sender = recipientIdAci, time = 2, body = "2")).get().messageId
+
+    val mmsId1: Long = mmsDatabase.insertSecureDecryptedMessageInbox(mmsMessage(sender = recipientIdAci, time = 3, body = "3"), -1).get().messageId
+    val mmsId2: Long = mmsDatabase.insertSecureDecryptedMessageInbox(mmsMessage(sender = recipientIdE164, time = 4, body = "4"), -1).get().messageId
+    val mmsId3: Long = mmsDatabase.insertSecureDecryptedMessageInbox(mmsMessage(sender = recipientIdAci, time = 5, body = "5"), -1).get().messageId
+
+    val threadIdAci: Long = threadDatabase.getThreadIdFor(recipientIdAci)!!
+    val threadIdE164: Long = threadDatabase.getThreadIdFor(recipientIdE164)!!
+    assertNotEquals(threadIdAci, threadIdE164)
+
+    mentionDatabase.insert(threadIdAci, mmsId1, listOf(Mention(recipientIdE164, 0, 1)))
+    mentionDatabase.insert(threadIdE164, mmsId2, listOf(Mention(recipientIdAci, 0, 1)))
+
+    groupReceiptDatabase.insert(listOf(recipientIdAci, recipientIdE164), mmsId1, 0, 3)
+
+    val identityKeyAci: IdentityKey = identityKey(1)
+    val identityKeyE164: IdentityKey = identityKey(2)
+
+    identityDatabase.saveIdentity(ACI_A.toString(), recipientIdAci, identityKeyAci, IdentityDatabase.VerifiedStatus.VERIFIED, false, 0, false)
+    identityDatabase.saveIdentity(E164_A, recipientIdE164, identityKeyE164, IdentityDatabase.VerifiedStatus.VERIFIED, false, 0, false)
+
+    sessionDatabase.store(SignalProtocolAddress(ACI_A.toString(), 1), SessionRecord())
+
+    // Merge
+    val retrievedId: RecipientId = recipientDatabase.getAndPossiblyMerge(ACI_A, E164_A, true)
+    val retrievedThreadId: Long = threadDatabase.getThreadIdFor(retrievedId)!!
+    assertEquals(recipientIdAci, retrievedId)
+
+    // Recipient validation
+    val retrievedRecipient = Recipient.resolved(retrievedId)
+    assertEquals(ACI_A, retrievedRecipient.requireAci())
+    assertEquals(E164_A, retrievedRecipient.requireE164())
+
+    val existingE164Recipient = Recipient.resolved(recipientIdE164)
+    assertEquals(retrievedId, existingE164Recipient.id)
+
+    // Thread validation
+    assertEquals(threadIdAci, retrievedThreadId)
+    assertNull(threadDatabase.getThreadIdFor(recipientIdE164))
+    assertNull(threadDatabase.getThreadRecord(threadIdE164))
+
+    // SMS validation
+    val sms1: MessageRecord = smsDatabase.getMessageRecord(smsId1)!!
+    val sms2: MessageRecord = smsDatabase.getMessageRecord(smsId2)!!
+    val sms3: MessageRecord = smsDatabase.getMessageRecord(smsId3)!!
+
+    assertEquals(retrievedId, sms1.recipient.id)
+    assertEquals(retrievedId, sms2.recipient.id)
+    assertEquals(retrievedId, sms3.recipient.id)
+
+    assertEquals(retrievedThreadId, sms1.threadId)
+    assertEquals(retrievedThreadId, sms2.threadId)
+    assertEquals(retrievedThreadId, sms3.threadId)
+
+    // MMS validation
+    val mms1: MessageRecord = mmsDatabase.getMessageRecord(mmsId1)!!
+    val mms2: MessageRecord = mmsDatabase.getMessageRecord(mmsId2)!!
+    val mms3: MessageRecord = mmsDatabase.getMessageRecord(mmsId3)!!
+
+    assertEquals(retrievedId, mms1.recipient.id)
+    assertEquals(retrievedId, mms2.recipient.id)
+    assertEquals(retrievedId, mms3.recipient.id)
+
+    assertEquals(retrievedThreadId, mms1.threadId)
+    assertEquals(retrievedThreadId, mms2.threadId)
+    assertEquals(retrievedThreadId, mms3.threadId)
+
+    // Mention validation
+    val mention1: MentionModel = getMention(mmsId1)
+    assertEquals(retrievedId, mention1.recipientId)
+    assertEquals(retrievedThreadId, mention1.threadId)
+
+    val mention2: MentionModel = getMention(mmsId2)
+    assertEquals(retrievedId, mention2.recipientId)
+    assertEquals(retrievedThreadId, mention2.threadId)
+
+    // Group receipt validation
+    val groupReceipts: List<GroupReceiptDatabase.GroupReceiptInfo> = groupReceiptDatabase.getGroupReceiptInfo(mmsId1)
+    assertEquals(retrievedId, groupReceipts[0].recipientId)
+    assertEquals(retrievedId, groupReceipts[1].recipientId)
+
+    // Identity validation
+    assertEquals(identityKeyAci, identityDatabase.getIdentityStoreRecord(ACI_A.toString())!!.identityKey)
+    assertNull(identityDatabase.getIdentityStoreRecord(E164_A))
+
+    // Session validation
+    assertNotNull(sessionDatabase.load(SignalProtocolAddress(ACI_A.toString(), 1)))
+  }
+
+  private val context: Application
+    get() = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
+
+  private fun ensureDbEmpty() {
+    DatabaseFactory.getInstance(context).rawDatabase.rawQuery("SELECT COUNT(*) FROM ${RecipientDatabase.TABLE_NAME}", null).use { cursor ->
+      assertTrue(cursor.moveToFirst())
+      assertEquals(0, cursor.getLong(0))
+    }
+  }
+
+  private fun smsMessage(sender: RecipientId, time: Long = 0, body: String = "", groupId: Optional<GroupId> = Optional.absent()): IncomingTextMessage {
+    return IncomingTextMessage(sender, 1, time, time, time, body, groupId, 0, true, null)
+  }
+
+  private fun mmsMessage(sender: RecipientId, time: Long = 0, body: String = "", groupId: Optional<GroupId> = Optional.absent()): IncomingMediaMessage {
+    return IncomingMediaMessage(sender, groupId, body, time, time, time, emptyList(), 0, 0, false, false, true, Optional.absent())
+  }
+
+  private fun identityKey(value: Byte): IdentityKey {
+    val bytes = ByteArray(33)
+    bytes[0] = 0x05
+    bytes[1] = value
+    return IdentityKey(bytes)
+  }
+
+  private fun groupMasterKey(value: Byte): GroupMasterKey {
+    val bytes = ByteArray(32)
+    bytes[0] = value
+    return GroupMasterKey(bytes)
+  }
+
+  private fun decryptedGroup(members: Collection<UUID>): DecryptedGroup {
+    return DecryptedGroup.newBuilder()
+      .addAllMembers(members.map { DecryptedMember.newBuilder().setUuid(UuidUtil.toByteString(it)).build() })
+      .build()
+  }
+
+  private fun getMention(messageId: Long): MentionModel {
+    val db: SQLiteDatabase = DatabaseFactory.getInstance(context).rawDatabase
+    db.rawQuery("SELECT * FROM ${MentionDatabase.TABLE_NAME}").use { cursor ->
+      cursor.moveToFirst()
+      return MentionModel(
+        recipientId = RecipientId.from(CursorUtil.requireLong(cursor, MentionDatabase.RECIPIENT_ID)),
+        threadId = CursorUtil.requireLong(cursor, MentionDatabase.THREAD_ID)
+      )
+    }
+  }
+
+  /** The normal mention model doesn't have a threadId, so we need to do it ourselves for the test */
+  data class MentionModel(
+    val recipientId: RecipientId,
+    val threadId: Long
+  )
+
+  companion object {
+    val ACI_A = ACI.from(UUID.fromString("3436efbe-5a76-47fa-a98a-7e72c948a82e"))
+    val ACI_B = ACI.from(UUID.fromString("8de7f691-0b60-4a68-9cd9-ed2f8453f9ed"))
+
+    val E164_A = "+12221234567"
+    val E164_B = "+13331234567"
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/lock/PinHashing_hashPin_Test.java

@@ -1,6 +1,9 @@
 package org.thoughtcrime.securesms.lock;
 
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.thoughtcrime.securesms.util.Hex;
 import org.whispersystems.signalservice.api.kbs.HashedPin;
 import org.whispersystems.signalservice.api.kbs.KbsData;
@@ -12,6 +15,7 @@ import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
+@RunWith(AndroidJUnit4.class)
 public final class PinHashing_hashPin_Test {
 
   @Test

app/src/flipper/java/org/thoughtcrime/securesms/FlipperApplicationContext.java

@@ -1,27 +0,0 @@
-package org.thoughtcrime.securesms;
-
-import com.facebook.flipper.android.AndroidFlipperClient;
-import com.facebook.flipper.core.FlipperClient;
-import com.facebook.flipper.plugins.databases.DatabasesFlipperPlugin;
-import com.facebook.flipper.plugins.inspector.DescriptorMapping;
-import com.facebook.flipper.plugins.inspector.InspectorFlipperPlugin;
-import com.facebook.flipper.plugins.sharedpreferences.SharedPreferencesFlipperPlugin;
-import com.facebook.soloader.SoLoader;
-
-import org.thoughtcrime.securesms.database.FlipperSqlCipherAdapter;
-
-public class FlipperApplicationContext extends ApplicationContext {
-
-  @Override
-  public void onCreate() {
-    super.onCreate();
-
-    SoLoader.init(this, false);
-
-    FlipperClient client = AndroidFlipperClient.getInstance(this);
-    client.addPlugin(new InspectorFlipperPlugin(this, DescriptorMapping.withDefaults()));
-    client.addPlugin(new DatabasesFlipperPlugin(new FlipperSqlCipherAdapter(this)));
-    client.addPlugin(new SharedPreferencesFlipperPlugin(this));
-    client.start();
-  }
-}

app/src/flipper/java/org/thoughtcrime/securesms/FlipperApplicationContext.kt

@@ -0,0 +1,46 @@
+package org.thoughtcrime.securesms
+
+import com.facebook.flipper.android.AndroidFlipperClient
+import com.facebook.flipper.plugins.databases.DatabasesFlipperPlugin
+import com.facebook.flipper.plugins.inspector.DescriptorMapping
+import com.facebook.flipper.plugins.inspector.InspectorFlipperPlugin
+import com.facebook.flipper.plugins.sharedpreferences.SharedPreferencesFlipperPlugin
+import com.facebook.soloader.SoLoader
+import leakcanary.LeakCanary
+import org.thoughtcrime.securesms.database.FlipperSqlCipherAdapter
+import shark.AndroidReferenceMatchers
+
+class FlipperApplicationContext : ApplicationContext() {
+  override fun onCreate() {
+    super.onCreate()
+    SoLoader.init(this, false)
+
+    val client = AndroidFlipperClient.getInstance(this)
+    client.addPlugin(InspectorFlipperPlugin(this, DescriptorMapping.withDefaults()))
+    client.addPlugin(DatabasesFlipperPlugin(FlipperSqlCipherAdapter(this)))
+    client.addPlugin(SharedPreferencesFlipperPlugin(this))
+    client.start()
+
+    LeakCanary.config = LeakCanary.config.copy(
+      referenceMatchers = AndroidReferenceMatchers.appDefaults +
+        AndroidReferenceMatchers.instanceFieldLeak(
+          className = "android.service.media.MediaBrowserService\$ServiceBinder",
+          fieldName = "this\$0",
+          description = "Framework bug",
+          patternApplies = { true }
+        ) +
+        AndroidReferenceMatchers.instanceFieldLeak(
+          className = "androidx.media.MediaBrowserServiceCompat\$MediaBrowserServiceImplApi26\$MediaBrowserServiceApi26",
+          fieldName = "mBase",
+          description = "Framework bug",
+          patternApplies = { true }
+        ) +
+        AndroidReferenceMatchers.instanceFieldLeak(
+          className = "org.thoughtcrime.securesms.components.voice.VoiceNotePlaybackService",
+          fieldName = "mApplication",
+          description = "Framework bug",
+          patternApplies = { true }
+        )
+    )
+  }
+}

app/src/main/AndroidManifest.xml

@@ -101,6 +101,10 @@
                  android:theme="@style/TextSecure.LightTheme"
                  android:largeHeap="true">
 
+    <meta-data
+            android:name="com.google.android.gms.wallet.api.enabled"
+            android:value="true" />
+
     <meta-data
             android:name="com.google.android.geo.API_KEY"
             android:value="AIzaSyCSx9xea86GwDKGznCAULE9Y5a8b-TfN9U"/>
@@ -395,7 +399,7 @@
             android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"/>
 
         <activity android:name=".components.settings.conversation.ConversationSettingsActivity"
-            android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"
+            android:configChanges="touchscreen|keyboard|keyboardHidden|screenLayout|screenSize"
             android:theme="@style/Signal.DayNight.ConversationSettings"
             android:windowSoftInputMode="stateAlwaysHidden">
         </activity>

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

@@ -54,6 +54,7 @@ import org.thoughtcrime.securesms.jobs.MultiDeviceContactUpdateJob;
 import org.thoughtcrime.securesms.jobs.PushNotificationReceiveJob;
 import org.thoughtcrime.securesms.jobs.RefreshPreKeysJob;
 import org.thoughtcrime.securesms.jobs.RetrieveProfileJob;
+import org.thoughtcrime.securesms.jobs.SubscriptionKeepAliveJob;
 import org.thoughtcrime.securesms.keyvalue.SignalStore;
 import org.thoughtcrime.securesms.logging.CustomSignalProtocolLogger;
 import org.thoughtcrime.securesms.logging.PersistentLogger;
@@ -61,7 +62,6 @@ import org.thoughtcrime.securesms.messageprocessingalarm.MessageProcessReceiver;
 import org.thoughtcrime.securesms.migrations.ApplicationMigrations;
 import org.thoughtcrime.securesms.notifications.NotificationChannels;
 import org.thoughtcrime.securesms.providers.BlobProvider;
-import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
 import org.thoughtcrime.securesms.ratelimit.RateLimitUtil;
 import org.thoughtcrime.securesms.registration.RegistrationUtil;
 import org.thoughtcrime.securesms.ringrtc.RingRtcLogger;
@@ -82,8 +82,6 @@ import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.thoughtcrime.securesms.util.Util;
 import org.thoughtcrime.securesms.util.VersionTracker;
 import org.thoughtcrime.securesms.util.dynamiclanguage.DynamicLanguageContextWrapper;
-import org.webrtc.voiceengine.WebRtcAudioManager;
-import org.webrtc.voiceengine.WebRtcAudioUtils;
 import org.whispersystems.libsignal.logging.SignalProtocolLoggerProvider;
 
 import java.security.Security;
@@ -191,8 +189,10 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
     long startTime = System.currentTimeMillis();
     Log.i(TAG, "App is now visible.");
 
-    ApplicationDependencies.getFrameRateTracker().begin();
+    ApplicationDependencies.getFrameRateTracker().start();
     ApplicationDependencies.getMegaphoneRepository().onAppForegrounded();
+    ApplicationDependencies.getDeadlockDetector().start();
+    SubscriptionKeepAliveJob.launchSubscriberIdKeepAliveJobIfNecessary();
 
     SignalExecutors.BOUNDED.execute(() -> {
       FeatureFlags.refreshIfNecessary();
@@ -213,8 +213,9 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
     Log.i(TAG, "App is no longer visible.");
     KeyCachingService.onAppBackgrounded(this);
     ApplicationDependencies.getMessageNotifier().clearVisibleThread();
-    ApplicationDependencies.getFrameRateTracker().end();
+    ApplicationDependencies.getFrameRateTracker().stop();
     ApplicationDependencies.getShakeToReport().disable();
+    ApplicationDependencies.getDeadlockDetector().stop();
   }
 
   public PersistentLogger getPersistentLogger() {
@@ -258,7 +259,10 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
 
     SignalProtocolLoggerProvider.setProvider(new CustomSignalProtocolLogger());
 
-    SignalExecutors.UNBOUNDED.execute(() -> LogDatabase.getInstance(this).trimToSize());
+    SignalExecutors.UNBOUNDED.execute(() -> {
+      Log.blockUntilAllWritesFinished();
+      LogDatabase.getInstance(this).trimToSize();
+    });
   }
 
   private void initializeCrashHandling() {
@@ -338,14 +342,6 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
 
   private void initializeRingRtc() {
     try {
-      if (RtcDeviceLists.hardwareAECBlocked()) {
-        WebRtcAudioUtils.setWebRtcBasedAcousticEchoCanceler(true);
-      }
-
-      if (!RtcDeviceLists.openSLESAllowed()) {
-        WebRtcAudioManager.setBlacklistDeviceForOpenSLESUsage(true);
-      }
-
       CallManager.initialize(this, new RingRtcLogger());
     } catch (UnsatisfiedLinkError e) {
       throw new AssertionError("Unable to load ringrtc library", e);
@@ -354,7 +350,7 @@ public class ApplicationContext extends MultiDexApplication implements AppForegr
 
   @WorkerThread
   private void initializeCircumvention() {
-    if (new SignalServiceNetworkAccess(ApplicationContext.this).isCensored(ApplicationContext.this)) {
+    if (ApplicationDependencies.getSignalServiceNetworkAccess().isCensored(ApplicationContext.this)) {
       try {
         ProviderInstaller.installIfNeeded(ApplicationContext.this);
       } catch (Throwable t) {

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

@@ -56,6 +56,10 @@ public interface BindableConversationItem extends Unbindable, GiphyMp4Playable,
     // Intentionally Blank.
   }
 
+  default void updateContactNameColor() {
+    // Intentionally Blank.
+  }
+
   interface EventListener {
     void onQuoteClicked(MmsMessageRecord messageRecord);
     void onLinkPreviewClicked(@NonNull LinkPreview linkPreview);

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

@@ -26,7 +26,6 @@ import android.database.Cursor;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.text.TextUtils;
-import android.util.AttributeSet;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -572,7 +571,7 @@ public final class ContactSelectionListFragment extends LoggingFragment
           AlertDialog loadingDialog = SimpleProgressDialog.show(requireContext());
 
           SimpleTask.run(getViewLifecycleOwner().getLifecycle(), () -> {
-            return UsernameUtil.fetchUuidForUsername(requireContext(), contact.getNumber());
+            return UsernameUtil.fetchAciForUsername(requireContext(), contact.getNumber());
           }, uuid -> {
             loadingDialog.dismiss();
             if (uuid.isPresent()) {

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

@@ -33,22 +33,19 @@ public class MuteDialog extends AlertDialog {
   public static void show(final Context context, final @NonNull MuteSelectionListener listener, @Nullable Runnable cancelListener) {
     AlertDialog.Builder builder = new MaterialAlertDialogBuilder(context);
     builder.setTitle(R.string.MuteDialog_mute_notifications);
-    builder.setItems(R.array.mute_durations, new DialogInterface.OnClickListener() {
-      @Override
-      public void onClick(DialogInterface dialog, final int which) {
-        final long muteUntil;
+    builder.setItems(R.array.mute_durations, (dialog, which) -> {
+      final long muteUntil;
 
-        switch (which) {
-          case 0:  muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);  break;
-          case 1:  muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(8);  break;
-          case 2:  muteUntil = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1);   break;
-          case 3:  muteUntil = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(7);   break;
-          case 4:  muteUntil = Long.MAX_VALUE;                                           break;
-          default: muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);  break;
-        }
-
-        listener.onMuted(muteUntil);
+      switch (which) {
+        case 0:  muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);  break;
+        case 1:  muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(8);  break;
+        case 2:  muteUntil = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(1);   break;
+        case 3:  muteUntil = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(7);   break;
+        case 4:  muteUntil = Long.MAX_VALUE;                                           break;
+        default: muteUntil = System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1);  break;
       }
+
+      listener.onMuted(muteUntil);
     });
 
     if (cancelListener != null) {

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

@@ -75,7 +75,7 @@ public class NewConversationActivity extends ContactSelectionActivity
         SimpleTask.run(getLifecycle(), () -> {
           Recipient resolved = Recipient.external(this, number);
 
-          if (!resolved.isRegistered() || !resolved.hasUuid()) {
+          if (!resolved.isRegistered() || !resolved.hasAci()) {
             Log.i(TAG, "[onContactSelected] Not registered or no UUID. Doing a directory refresh.");
             try {
               DirectoryHelper.refreshDirectoryFor(this, resolved, false);

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

@@ -0,0 +1,40 @@
+package org.thoughtcrime.securesms
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import androidx.annotation.ColorInt
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation
+import java.security.MessageDigest
+
+/**
+ * BitmapTransformation which overlays the given bitmap with the given color.
+ */
+class OverlayTransformation(
+  @ColorInt private val color: Int
+) : BitmapTransformation() {
+
+  private val id = "${OverlayTransformation::class.java.name}$color"
+
+  override fun updateDiskCacheKey(messageDigest: MessageDigest) {
+    messageDigest.update(id.toByteArray(CHARSET))
+  }
+
+  override fun transform(pool: BitmapPool, toTransform: Bitmap, outWidth: Int, outHeight: Int): Bitmap {
+    val outBitmap = pool.get(outWidth, outHeight, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(outBitmap)
+
+    canvas.drawBitmap(toTransform, 0f, 0f, null)
+    canvas.drawColor(color)
+
+    return outBitmap
+  }
+
+  override fun equals(other: Any?): Boolean {
+    return (other as? OverlayTransformation)?.color == color
+  }
+
+  override fun hashCode(): Int {
+    return id.hashCode()
+  }
+}

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

@@ -60,7 +60,7 @@ public abstract class PassphraseRequiredActivity extends BaseActivity implements
   protected final void onCreate(Bundle savedInstanceState) {
     Tracer.getInstance().start(Log.tag(getClass()) + "#onCreate()");
     AppStartup.getInstance().onCriticalRenderEventStart();
-    this.networkAccess = new SignalServiceNetworkAccess(this);
+    this.networkAccess = ApplicationDependencies.getSignalServiceNetworkAccess();
     onPreCreate();
 
     final boolean locked = KeyCachingService.isLocked(this);

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

@@ -1,48 +0,0 @@
-package org.thoughtcrime.securesms;
-
-import android.os.Build;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Device hardware capability lists.
- * <p>
- * Moved outside of ApplicationContext as the indirection was important for API19 support with desugaring: https://issuetracker.google.com/issues/183419297
- */
-final class RtcDeviceLists {
-
-  private RtcDeviceLists() {}
-
-  static Set<String> hardwareAECBlockList() {
-    return new HashSet<String>() {{
-      add("Pixel");
-      add("Pixel XL");
-      add("Moto G5");
-      add("Moto G (5S) Plus");
-      add("Moto G4");
-      add("TA-1053");
-      add("Mi A1");
-      add("Mi A2");
-      add("E5823"); // Sony z5 compact
-      add("Redmi Note 5");
-      add("FP2"); // Fairphone FP2
-      add("MI 5");
-    }};
-  }
-
-  static Set<String> openSlEsAllowList() {
-    return new HashSet<String>() {{
-      add("Pixel");
-      add("Pixel XL");
-    }};
-  }
-
-  static boolean hardwareAECBlocked() {
-    return hardwareAECBlockList().contains(Build.MODEL);
-  }
-
-  static boolean openSLESAllowed() {
-    return openSlEsAllowList().contains(Build.MODEL);
-  }
-}

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

@@ -56,7 +56,6 @@ import android.widget.Toast;
 
 import androidx.annotation.DrawableRes;
 import androidx.annotation.NonNull;
-import androidx.appcompat.app.AlertDialog;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.appcompat.widget.Toolbar;
 import androidx.core.view.OneShotPreDrawListener;
@@ -64,6 +63,8 @@ import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentTransaction;
 import androidx.interpolator.view.animation.FastOutSlowInInterpolator;
 
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
+
 import org.signal.core.util.ThreadUtil;
 import org.signal.core.util.concurrent.SignalExecutors;
 import org.signal.core.util.logging.Log;
@@ -322,23 +323,26 @@ public class VerifyIdentityActivity extends PassphraseRequiredActivity implement
       //noinspection WrongThread
       Recipient resolved = recipient.resolve();
 
-      if (FeatureFlags.verifyV2() && resolved.getUuid().isPresent()) {
+      if (FeatureFlags.verifyV2() && resolved.getAci().isPresent()) {
         Log.i(TAG, "Using UUID (version 2).");
         version  = 2;
-        localId  = UuidUtil.toByteArray(TextSecurePreferences.getLocalUuid(requireContext()));
-        remoteId = UuidUtil.toByteArray(resolved.getUuid().get());
+        localId  = TextSecurePreferences.getLocalAci(requireContext()).toByteArray();
+        remoteId = resolved.requireAci().toByteArray();
       } else if (!FeatureFlags.verifyV2() && resolved.getE164().isPresent()) {
         Log.i(TAG, "Using E164 (version 1).");
         version  = 1;
         localId  = TextSecurePreferences.getLocalNumber(requireContext()).getBytes();
         remoteId = resolved.requireE164().getBytes();
       } else {
-        Log.w(TAG, String.format(Locale.ENGLISH, "Could not show proper verification! verifyV2: %s, hasUuid: %s, hasE164: %s", FeatureFlags.verifyV2(), resolved.getUuid().isPresent(), resolved.getE164().isPresent()));
-        new AlertDialog.Builder(requireContext())
-                       .setMessage(getString(R.string.VerifyIdentityActivity_you_must_first_exchange_messages_in_order_to_view, resolved.getDisplayName(requireContext())))
-                       .setPositiveButton(android.R.string.ok, (dialog, which) -> requireActivity().finish())
-                       .setOnDismissListener(dialog -> requireActivity().finish())
-                       .show();
+        Log.w(TAG, String.format(Locale.ENGLISH, "Could not show proper verification! verifyV2: %s, hasUuid: %s, hasE164: %s", FeatureFlags.verifyV2(), resolved.getAci().isPresent(), resolved.getE164().isPresent()));
+        new MaterialAlertDialogBuilder(requireContext())
+            .setMessage(getString(R.string.VerifyIdentityActivity_you_must_first_exchange_messages_in_order_to_view, resolved.getDisplayName(requireContext())))
+            .setPositiveButton(android.R.string.ok, (dialog, which) -> requireActivity().finish())
+            .setOnDismissListener(dialog -> {
+              requireActivity().finish();
+              dialog.dismiss();
+            })
+            .show();
         return;
       }
 

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

@@ -484,6 +484,12 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
     delayedFinish();
   }
 
+  private void handleGlare(@NonNull Recipient recipient) {
+    Log.i(TAG, "handleGlare: " + recipient.getId());
+
+    callScreen.setStatus("");
+  }
+
   private void handleCallRinging() {
     callScreen.setStatus(getString(R.string.RedPhone_ringing));
   }
@@ -629,6 +635,8 @@ public class WebRtcCallActivity extends BaseActivity implements SafetyNumberChan
         handleCallRinging(); break;
       case CALL_DISCONNECTED:
         handleTerminate(event.getRecipient(), HangupMessage.Type.NORMAL); break;
+      case CALL_DISCONNECTED_GLARE:
+        handleGlare(event.getRecipient()); break;
       case CALL_ACCEPTED_ELSEWHERE:
         handleTerminate(event.getRecipient(), HangupMessage.Type.ACCEPTED); break;
       case CALL_DECLINED_ELSEWHERE:

app/src/main/java/org/thoughtcrime/securesms/badges/BadgeImageView.kt

@@ -1,75 +1,94 @@
 package org.thoughtcrime.securesms.badges
 
 import android.content.Context
-import android.graphics.Color
-import android.graphics.drawable.Drawable
 import android.util.AttributeSet
-import androidx.annotation.ColorInt
-import androidx.annotation.Px
 import androidx.appcompat.widget.AppCompatImageView
 import androidx.core.content.res.use
-import androidx.lifecycle.Lifecycle
-import org.signal.core.util.logging.Log
+import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.badges.Badges.insetWithOutline
+import org.thoughtcrime.securesms.badges.glide.BadgeSpriteTransformation
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.mms.GlideApp
+import org.thoughtcrime.securesms.mms.GlideRequests
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.util.ViewUtil
-import org.thoughtcrime.securesms.util.visible
-
-private val TAG = Log.tag(BadgeImageView::class.java)
+import org.thoughtcrime.securesms.util.ThemeUtil
+import java.lang.IllegalArgumentException
 
 class BadgeImageView @JvmOverloads constructor(
   context: Context,
   attrs: AttributeSet? = null
 ) : AppCompatImageView(context, attrs) {
 
-  @Px
-  private var outlineWidth: Float = 0f
-
-  @ColorInt
-  private var outlineColor: Int = Color.BLACK
+  private var badgeSize: Int = 0
 
   init {
     context.obtainStyledAttributes(attrs, R.styleable.BadgeImageView).use {
-      outlineWidth = it.getDimension(R.styleable.BadgeImageView_badge_outline_width, 0f)
-      outlineColor = it.getColor(R.styleable.BadgeImageView_badge_outline_color, Color.BLACK)
+      badgeSize = it.getInt(R.styleable.BadgeImageView_badge_size, 0)
     }
+
+    isClickable = false
+  }
+
+  override fun setOnClickListener(l: OnClickListener?) {
+    val wasClickable = isClickable
+    super.setOnClickListener(l)
+    this.isClickable = wasClickable
   }
 
   fun setBadgeFromRecipient(recipient: Recipient?) {
+    getGlideRequests()?.let {
+      setBadgeFromRecipient(recipient, it)
+    } ?: clearDrawable()
+  }
+
+  fun setBadgeFromRecipient(recipient: Recipient?, glideRequests: GlideRequests) {
     if (recipient == null || recipient.badges.isEmpty()) {
-      setBadge(null)
+      setBadge(null, glideRequests)
+    } else if (recipient.isSelf) {
+      val badge = recipient.featuredBadge
+      if (badge == null || !badge.visible || badge.isExpired()) {
+        setBadge(null, glideRequests)
+      } else {
+        setBadge(badge, glideRequests)
+      }
     } else {
-      setBadge(recipient.badges[0])
+      setBadge(recipient.featuredBadge, glideRequests)
     }
   }
 
   fun setBadge(badge: Badge?) {
-    visible = badge != null
-
-    val lifecycle = ViewUtil.getActivityLifecycle(this)
-    if (lifecycle?.currentState == Lifecycle.State.DESTROYED) {
-      Log.w(TAG, "Ignoring setBadge call for destroyed activity.")
-      return
-    }
-
-    GlideApp
-      .with(this)
-      .load(badge)
-      .into(this)
+    getGlideRequests()?.let {
+      setBadge(badge, it)
+    } ?: clearDrawable()
   }
 
-  override fun setImageDrawable(drawable: Drawable?) {
-    if (drawable == null || outlineWidth == 0f) {
-      super.setImageDrawable(drawable)
+  fun setBadge(badge: Badge?, glideRequests: GlideRequests) {
+    if (badge != null) {
+      glideRequests
+        .load(badge)
+        .downsample(DownsampleStrategy.NONE)
+        .transform(BadgeSpriteTransformation(BadgeSpriteTransformation.Size.fromInteger(badgeSize), badge.imageDensity, ThemeUtil.isDarkTheme(context)))
+        .into(this)
+
+      isClickable = true
     } else {
-      super.setImageDrawable(
-        drawable.insetWithOutline(
-          outlineWidth, outlineColor
-        )
-      )
+      glideRequests
+        .clear(this)
+      clearDrawable()
+    }
+  }
+
+  private fun clearDrawable() {
+    setImageDrawable(null)
+    isClickable = false
+  }
+
+  private fun getGlideRequests(): GlideRequests? {
+    return try {
+      GlideApp.with(this)
+    } catch (e: IllegalArgumentException) {
+      // View not attached to an activity or activity destroyed
+      null
     }
   }
 }

app/src/main/java/org/thoughtcrime/securesms/badges/BadgeRepository.kt

@@ -6,24 +6,35 @@ import io.reactivex.rxjava3.schedulers.Schedulers
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.database.DatabaseFactory
 import org.thoughtcrime.securesms.database.RecipientDatabase
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.storage.StorageSyncHelper
 import org.thoughtcrime.securesms.util.ProfileUtil
 
 class BadgeRepository(context: Context) {
 
   private val context = context.applicationContext
 
-  fun setVisibilityForAllBadges(displayBadgesOnProfile: Boolean): Completable = Completable.fromAction {
-    val badges = Recipient.self().badges.map { it.copy(visible = displayBadgesOnProfile) }
+  fun setVisibilityForAllBadges(
+    displayBadgesOnProfile: Boolean,
+    selfBadges: List<Badge> = Recipient.self().badges
+  ): Completable = Completable.fromAction {
+    val recipientDatabase: RecipientDatabase = DatabaseFactory.getRecipientDatabase(context)
+
+    SignalStore.donationsValues().setDisplayBadgesOnProfile(displayBadgesOnProfile)
+
+    recipientDatabase.markNeedsSync(Recipient.self().id)
+    StorageSyncHelper.scheduleSyncForDataChange()
+
+    val badges = selfBadges.map { it.copy(visible = displayBadgesOnProfile) }
     ProfileUtil.uploadProfileWithBadges(context, badges)
 
-    val recipientDatabase: RecipientDatabase = DatabaseFactory.getRecipientDatabase(context)
     recipientDatabase.setBadges(Recipient.self().id, badges)
   }.subscribeOn(Schedulers.io())
 
   fun setFeaturedBadge(featuredBadge: Badge): Completable = Completable.fromAction {
     val badges = Recipient.self().badges
-    val reOrderedBadges = listOf(featuredBadge) + (badges - featuredBadge)
+    val reOrderedBadges = listOf(featuredBadge.copy(visible = true)) + (badges.filterNot { it.id == featuredBadge.id })
     ProfileUtil.uploadProfileWithBadges(context, reOrderedBadges)
 
     val recipientDatabase: RecipientDatabase = DatabaseFactory.getRecipientDatabase(context)

app/src/main/java/org/thoughtcrime/securesms/badges/Badges.kt

@@ -1,82 +1,51 @@
 package org.thoughtcrime.securesms.badges
 
 import android.content.Context
-import android.graphics.drawable.Drawable
-import androidx.annotation.ColorInt
-import androidx.annotation.Px
-import androidx.core.graphics.withScale
+import android.net.Uri
 import androidx.recyclerview.widget.RecyclerView
-import com.airbnb.lottie.SimpleColorFilter
 import com.google.android.flexbox.AlignItems
 import com.google.android.flexbox.FlexDirection
 import com.google.android.flexbox.FlexboxLayoutManager
 import com.google.android.flexbox.JustifyContent
+import org.signal.core.util.DimensionUnit
+import org.thoughtcrime.securesms.BuildConfig
+import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.badges.models.Badge
-import org.thoughtcrime.securesms.badges.models.BadgeAnimator
+import org.thoughtcrime.securesms.badges.models.Badge.Category.Companion.fromCode
 import org.thoughtcrime.securesms.components.settings.DSLConfiguration
-import org.thoughtcrime.securesms.util.customizeOnDraw
+import org.thoughtcrime.securesms.database.model.databaseprotos.BadgeList
+import org.thoughtcrime.securesms.util.ScreenDensity
+import org.whispersystems.libsignal.util.Pair
+import org.whispersystems.signalservice.api.profiles.SignalServiceProfile
+import java.math.BigDecimal
+import java.sql.Timestamp
 
 object Badges {
-  fun Drawable.insetWithOutline(
-    @Px outlineWidth: Float,
-    @ColorInt outlineColor: Int
-  ): Drawable {
-    val clone = mutate().constantState?.newDrawable()?.mutate()
-    clone?.colorFilter = SimpleColorFilter(outlineColor)
-
-    return customizeOnDraw { wrapped, canvas ->
-      clone?.bounds = wrapped.bounds
-      clone?.draw(canvas)
-
-      val scale = 1 - ((outlineWidth * 2) / canvas.width)
-
-      canvas.withScale(x = scale, y = scale, canvas.width / 2f, canvas.height / 2f) {
-        wrapped.draw(canvas)
-      }
-    }
-  }
-
-  fun Drawable.selectable(
-    @Px outlineWidth: Float,
-    @ColorInt outlineColor: Int,
-    @ColorInt gapColor: Int,
-    animator: BadgeAnimator
-  ): Drawable {
-    val outline = mutate().constantState?.newDrawable()?.mutate()
-    outline?.colorFilter = SimpleColorFilter(outlineColor)
-
-    val gap = mutate().constantState?.newDrawable()?.mutate()
-    gap?.colorFilter = SimpleColorFilter(gapColor)
-
-    return customizeOnDraw { wrapped, canvas ->
-      outline?.bounds = wrapped.bounds
-      gap?.bounds = wrapped.bounds
-
-      outline?.draw(canvas)
-
-      val scale = 1 - ((outlineWidth * 2) / wrapped.bounds.width())
-      val interpolatedScale = scale + (1f - scale) * animator.getFraction()
-
-      canvas.withScale(x = interpolatedScale, y = interpolatedScale, wrapped.bounds.width() / 2f, wrapped.bounds.height() / 2f) {
-        gap?.draw(canvas)
-
-        canvas.withScale(x = interpolatedScale, y = interpolatedScale, wrapped.bounds.width() / 2f, wrapped.bounds.height() / 2f) {
-          wrapped.draw(canvas)
-        }
-      }
-
-      if (animator.shouldInvalidate()) {
-        invalidateSelf()
-      }
-    }
-  }
-
-  fun DSLConfiguration.displayBadges(badges: List<Badge>, selectedBadge: Badge? = null) {
+  fun DSLConfiguration.displayBadges(
+    context: Context,
+    badges: List<Badge>,
+    selectedBadge: Badge? = null,
+    fadedBadgeId: String? = null
+  ) {
     badges
-      .map { Badge.Model(it, it == selectedBadge) }
+      .map {
+        Badge.Model(
+          badge = it,
+          isSelected = it == selectedBadge,
+          isFaded = it.id == fadedBadgeId
+        )
+      }
       .forEach { customPref(it) }
 
-    val empties = (4 - (badges.size % 4)) % 4
+    val gutter = context.resources.getDimensionPixelSize(R.dimen.dsl_settings_gutter)
+    val buffer = DimensionUnit.DP.toPixels(12f)
+    val gutterExtra = gutter - buffer
+    val badgeSize = DimensionUnit.DP.toPixels(88f)
+    val windowWidth = context.resources.displayMetrics.widthPixels
+    val availableWidth = windowWidth - gutterExtra
+    val perRow = (availableWidth / badgeSize).toInt()
+
+    val empties = ((perRow - (badges.size % perRow)) % perRow)
     repeat(empties) {
       customPref(Badge.EmptyModel())
     }
@@ -91,4 +60,68 @@ object Badges {
 
     return layoutManager
   }
+
+  private fun getBadgeImageUri(densityPath: String): Uri {
+    return Uri.parse(BuildConfig.BADGE_STATIC_ROOT).buildUpon()
+      .appendPath(densityPath)
+      .build()
+  }
+
+  private fun getBestBadgeImageUriForDevice(serviceBadge: SignalServiceProfile.Badge): Pair<Uri, String> {
+    return when (ScreenDensity.getBestDensityBucketForDevice()) {
+      "ldpi" -> Pair(getBadgeImageUri(serviceBadge.sprites6[0]), "ldpi")
+      "mdpi" -> Pair(getBadgeImageUri(serviceBadge.sprites6[1]), "mdpi")
+      "hdpi" -> Pair(getBadgeImageUri(serviceBadge.sprites6[2]), "hdpi")
+      "xxhdpi" -> Pair(getBadgeImageUri(serviceBadge.sprites6[4]), "xxhdpi")
+      "xxxhdpi" -> Pair(getBadgeImageUri(serviceBadge.sprites6[5]), "xxxhdpi")
+      else -> Pair(getBadgeImageUri(serviceBadge.sprites6[3]), "xdpi")
+    }
+  }
+
+  private fun getTimestamp(bigDecimal: BigDecimal): Long {
+    return Timestamp(bigDecimal.toLong() * 1000).time
+  }
+
+  @JvmStatic
+  fun fromDatabaseBadge(badge: BadgeList.Badge): Badge {
+    return Badge(
+      badge.id,
+      fromCode(badge.category),
+      badge.name,
+      badge.description,
+      Uri.parse(badge.imageUrl),
+      badge.imageDensity,
+      badge.expiration,
+      badge.visible
+    )
+  }
+
+  @JvmStatic
+  fun toDatabaseBadge(badge: Badge): BadgeList.Badge {
+    return BadgeList.Badge.newBuilder()
+      .setId(badge.id)
+      .setCategory(badge.category.code)
+      .setDescription(badge.description)
+      .setExpiration(badge.expirationTimestamp)
+      .setVisible(badge.visible)
+      .setName(badge.name)
+      .setImageUrl(badge.imageUrl.toString())
+      .setImageDensity(badge.imageDensity)
+      .build()
+  }
+
+  @JvmStatic
+  fun fromServiceBadge(serviceBadge: SignalServiceProfile.Badge): Badge {
+    val uriAndDensity: Pair<Uri, String> = getBestBadgeImageUriForDevice(serviceBadge)
+    return Badge(
+      serviceBadge.id,
+      fromCode(serviceBadge.category),
+      serviceBadge.name,
+      serviceBadge.description,
+      uriAndDensity.first(),
+      uriAndDensity.second(),
+      serviceBadge.expiration?.let { getTimestamp(it) } ?: 0,
+      serviceBadge.isVisible
+    )
+  }
 }

app/src/main/java/org/thoughtcrime/securesms/badges/glide/BadgeSpriteTransformation.kt

@@ -0,0 +1,153 @@
+package org.thoughtcrime.securesms.badges.glide
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Rect
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation
+import java.security.MessageDigest
+
+/**
+ * Cuts out the badge of the requested size from the sprite sheet.
+ */
+class BadgeSpriteTransformation(
+  private val size: Size,
+  private val density: String,
+  private val isDarkTheme: Boolean
+) : BitmapTransformation() {
+
+  private val id = "BadgeSpriteTransformation(${size.code},$density,$isDarkTheme).$VERSION"
+
+  override fun updateDiskCacheKey(messageDigest: MessageDigest) {
+    messageDigest.update(id.toByteArray(CHARSET))
+  }
+
+  override fun equals(other: Any?): Boolean {
+    return (other as? BadgeSpriteTransformation)?.id == id
+  }
+
+  override fun hashCode(): Int {
+    return id.hashCode()
+  }
+
+  override fun transform(pool: BitmapPool, toTransform: Bitmap, outWidth: Int, outHeight: Int): Bitmap {
+    val outBitmap = pool.get(outWidth, outHeight, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(outBitmap)
+    val inBounds = getInBounds(density, size, isDarkTheme)
+    val outBounds = Rect(0, 0, outWidth, outHeight)
+
+    canvas.drawBitmap(toTransform, inBounds, outBounds, null)
+
+    return outBitmap
+  }
+
+  enum class Size(val code: String, val frameMap: Map<Density, FrameSet>) {
+    SMALL(
+      "small",
+      mapOf(
+        Density.LDPI to FrameSet(Frame(124, 1, 13, 13), Frame(145, 31, 13, 13)),
+        Density.MDPI to FrameSet(Frame(163, 1, 16, 16), Frame(189, 39, 16, 16)),
+        Density.HDPI to FrameSet(Frame(244, 1, 25, 25), Frame(283, 58, 25, 25)),
+        Density.XHDPI to FrameSet(Frame(323, 1, 32, 32), Frame(373, 75, 32, 32)),
+        Density.XXHDPI to FrameSet(Frame(483, 1, 48, 48), Frame(557, 111, 48, 48)),
+        Density.XXXHDPI to FrameSet(Frame(643, 1, 64, 64), Frame(741, 147, 64, 64))
+      )
+    ),
+    MEDIUM(
+      "medium",
+      mapOf(
+        Density.LDPI to FrameSet(Frame(124, 16, 19, 19), Frame(160, 31, 19, 19)),
+        Density.MDPI to FrameSet(Frame(163, 19, 24, 24), Frame(207, 39, 24, 24)),
+        Density.HDPI to FrameSet(Frame(244, 28, 37, 37), Frame(310, 58, 37, 37)),
+        Density.XHDPI to FrameSet(Frame(323, 35, 48, 48), Frame(407, 75, 48, 48)),
+        Density.XXHDPI to FrameSet(Frame(483, 51, 72, 72), Frame(607, 111, 72, 72)),
+        Density.XXXHDPI to FrameSet(Frame(643, 67, 96, 96), Frame(807, 147, 96, 96))
+      )
+    ),
+    LARGE(
+      "large",
+      mapOf(
+        Density.LDPI to FrameSet(Frame(145, 1, 28, 28), Frame(124, 46, 28, 28)),
+        Density.MDPI to FrameSet(Frame(189, 1, 36, 36), Frame(163, 57, 36, 36)),
+        Density.HDPI to FrameSet(Frame(283, 1, 55, 55), Frame(244, 85, 55, 55)),
+        Density.XHDPI to FrameSet(Frame(373, 1, 72, 72), Frame(323, 109, 72, 72)),
+        Density.XXHDPI to FrameSet(Frame(557, 1, 108, 108), Frame(483, 161, 108, 108)),
+        Density.XXXHDPI to FrameSet(Frame(741, 1, 144, 144), Frame(643, 213, 144, 144))
+      )
+    ),
+    BADGE_60(
+      "badge_60",
+      mapOf(
+        Density.LDPI to FrameSet(Frame(124, 76, 45, 45), Frame(124, 76, 45, 45)),
+        Density.MDPI to FrameSet(Frame(163, 101, 60, 60), Frame(163, 101, 60, 60)),
+        Density.HDPI to FrameSet(Frame(244, 151, 90, 90), Frame(244, 151, 90, 90)),
+        Density.XHDPI to FrameSet(Frame(323, 201, 120, 120), Frame(323, 201, 120, 120)),
+        Density.XXHDPI to FrameSet(Frame(483, 301, 180, 180), Frame(483, 301, 180, 180)),
+        Density.XXXHDPI to FrameSet(Frame(643, 401, 240, 240), Frame(643, 401, 240, 240))
+      )
+    ),
+    XLARGE(
+      "xlarge",
+      mapOf(
+        Density.LDPI to FrameSet(Frame(1, 1, 121, 121), Frame(1, 1, 121, 121)),
+        Density.MDPI to FrameSet(Frame(1, 1, 160, 160), Frame(1, 1, 160, 160)),
+        Density.HDPI to FrameSet(Frame(1, 1, 241, 241), Frame(1, 1, 241, 241)),
+        Density.XHDPI to FrameSet(Frame(1, 1, 320, 320), Frame(1, 1, 320, 320)),
+        Density.XXHDPI to FrameSet(Frame(1, 1, 480, 480), Frame(1, 1, 480, 480)),
+        Density.XXXHDPI to FrameSet(Frame(1, 1, 640, 640), Frame(1, 1, 640, 640))
+      )
+    );
+
+    companion object {
+      fun fromInteger(integer: Int): Size {
+        return when (integer) {
+          0 -> SMALL
+          1 -> MEDIUM
+          2 -> LARGE
+          3 -> XLARGE
+          4 -> BADGE_60
+          else -> LARGE
+        }
+      }
+    }
+  }
+
+  enum class Density(val density: String) {
+    LDPI("ldpi"),
+    MDPI("mdpi"),
+    HDPI("hdpi"),
+    XHDPI("xhdpi"),
+    XXHDPI("xxhdpi"),
+    XXXHDPI("xxxhdpi")
+  }
+
+  data class FrameSet(val light: Frame, val dark: Frame)
+
+  data class Frame(
+    val x: Int,
+    val y: Int,
+    val width: Int,
+    val height: Int
+  ) {
+    fun toBounds(): Rect {
+      return Rect(x, y, x + width, y + height)
+    }
+  }
+
+  companion object {
+    private const val VERSION = 2
+
+    private fun getDensity(density: String): Density {
+      return Density.values().first { it.density == density }
+    }
+
+    private fun getFrame(size: Size, density: Density, isDarkTheme: Boolean): Frame {
+      val frameSet: FrameSet = size.frameMap[density]!!
+      return if (isDarkTheme) frameSet.dark else frameSet.light
+    }
+
+    private fun getInBounds(density: String, size: Size, isDarkTheme: Boolean): Rect {
+      return getFrame(size, getDensity(density), isDarkTheme).toBounds()
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/badges/models/Badge.kt

@@ -1,66 +1,48 @@
 package org.thoughtcrime.securesms.badges.models
 
-import android.graphics.drawable.Drawable
+import android.animation.ObjectAnimator
 import android.net.Uri
-import android.os.Parcel
 import android.os.Parcelable
 import android.view.View
 import android.widget.ImageView
 import android.widget.TextView
-import androidx.core.content.ContextCompat
 import com.bumptech.glide.load.Key
-import com.bumptech.glide.request.target.CustomViewTarget
-import com.bumptech.glide.request.transition.Transition
-import org.signal.core.util.DimensionUnit
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy
+import kotlinx.parcelize.Parcelize
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.badges.Badges.selectable
+import org.thoughtcrime.securesms.badges.glide.BadgeSpriteTransformation
 import org.thoughtcrime.securesms.components.settings.PreferenceModel
 import org.thoughtcrime.securesms.mms.GlideApp
 import org.thoughtcrime.securesms.util.MappingAdapter
 import org.thoughtcrime.securesms.util.MappingViewHolder
+import org.thoughtcrime.securesms.util.ThemeUtil
 import java.security.MessageDigest
 
-typealias OnBadgeClicked = (Badge, Boolean) -> Unit
+typealias OnBadgeClicked = (Badge, Boolean, Boolean) -> Unit
 
 /**
  * A Badge that can be collected and displayed by a user.
  */
+@Parcelize
 data class Badge(
   val id: String,
   val category: Category,
-  val imageUrl: Uri,
   val name: String,
   val description: String,
+  val imageUrl: Uri,
+  val imageDensity: String,
   val expirationTimestamp: Long,
-  val visible: Boolean
+  val visible: Boolean,
 ) : Parcelable, Key {
 
-  constructor(parcel: Parcel) : this(
-    requireNotNull(parcel.readString()),
-    Category.fromCode(requireNotNull(parcel.readString())),
-    requireNotNull(parcel.readParcelable(Uri::class.java.classLoader)),
-    requireNotNull(parcel.readString()),
-    requireNotNull(parcel.readString()),
-    parcel.readLong(),
-    parcel.readByte() == 1.toByte()
-  )
-
-  override fun describeContents(): Int {
-    return 0
-  }
-
-  override fun writeToParcel(parcel: Parcel, flags: Int) {
-    parcel.writeString(id)
-    parcel.writeString(category.code)
-    parcel.writeParcelable(imageUrl, flags)
-    parcel.writeString(name)
-    parcel.writeString(description)
-    parcel.writeLong(expirationTimestamp)
-    parcel.writeByte(if (visible) 1 else 0)
-  }
+  fun isExpired(): Boolean = expirationTimestamp < System.currentTimeMillis() && expirationTimestamp > 0
+  fun isBoost(): Boolean = id == BOOST_BADGE_ID
 
   override fun updateDiskCacheKey(messageDigest: MessageDigest) {
     messageDigest.update(id.toByteArray(Key.CHARSET))
+    messageDigest.update(imageUrl.toString().toByteArray(Key.CHARSET))
+    messageDigest.update(imageDensity.toByteArray(Key.CHARSET))
   }
 
   fun resolveDescription(shortName: String): String {
@@ -89,14 +71,18 @@ data class Badge(
 
   class Model(
     val badge: Badge,
-    val isSelected: Boolean = false
+    val isSelected: Boolean = false,
+    val isFaded: Boolean = false
   ) : PreferenceModel<Model>() {
     override fun areItemsTheSame(newItem: Model): Boolean {
       return newItem.badge.id == badge.id
     }
 
     override fun areContentsTheSame(newItem: Model): Boolean {
-      return super.areContentsTheSame(newItem) && badge == newItem.badge && isSelected == newItem.isSelected
+      return super.areContentsTheSame(newItem) &&
+        badge == newItem.badge &&
+        isSelected == newItem.isSelected &&
+        isFaded == newItem.isFaded
     }
 
     override fun getChangePayload(newItem: Model): Any? {
@@ -110,32 +96,47 @@ data class Badge(
 
   class ViewHolder(itemView: View, private val onBadgeClicked: OnBadgeClicked) : MappingViewHolder<Model>(itemView) {
 
+    private val check: ImageView = itemView.findViewById(R.id.checkmark)
     private val badge: ImageView = itemView.findViewById(R.id.badge)
     private val name: TextView = itemView.findViewById(R.id.name)
-    private val target = Target(badge)
+
+    private var checkAnimator: ObjectAnimator? = null
+
+    init {
+      check.isSelected = true
+    }
 
     override fun bind(model: Model) {
       itemView.setOnClickListener {
-        onBadgeClicked(model.badge, model.isSelected)
+        onBadgeClicked(model.badge, model.isSelected, model.isFaded)
       }
 
+      checkAnimator?.cancel()
       if (payload.isNotEmpty()) {
-        if (model.isSelected) {
-          target.animateToStart()
+        checkAnimator = if (model.isSelected) {
+          ObjectAnimator.ofFloat(check, "alpha", 1f)
         } else {
-          target.animateToEnd()
+          ObjectAnimator.ofFloat(check, "alpha", 0f)
         }
+        checkAnimator?.start()
         return
       }
 
+      badge.alpha = if (model.badge.isExpired() || model.isFaded) 0.5f else 1f
+
       GlideApp.with(badge)
         .load(model.badge)
-        .into(target)
+        .downsample(DownsampleStrategy.NONE)
+        .diskCacheStrategy(DiskCacheStrategy.NONE)
+        .transform(
+          BadgeSpriteTransformation(BadgeSpriteTransformation.Size.BADGE_60, model.badge.imageDensity, ThemeUtil.isDarkTheme(context)),
+        )
+        .into(badge)
 
       if (model.isSelected) {
-        target.setAnimationToStart()
+        check.alpha = 1f
       } else {
-        target.setAnimationToEnd()
+        check.alpha = 0f
       }
 
       name.text = model.badge.name
@@ -158,61 +159,11 @@ data class Badge(
     }
   }
 
-  private class Target(view: ImageView) : CustomViewTarget<ImageView, Drawable>(view) {
+  companion object {
+    const val BOOST_BADGE_ID = "BOOST"
 
-    private val animator: BadgeAnimator = BadgeAnimator()
-
-    override fun onLoadFailed(errorDrawable: Drawable?) {
-      view.setImageDrawable(errorDrawable)
-    }
-
-    override fun onResourceReady(resource: Drawable, transition: Transition<in Drawable>?) {
-      val drawable = resource.selectable(
-        DimensionUnit.DP.toPixels(2.5f),
-        ContextCompat.getColor(view.context, R.color.signal_inverse_primary),
-        ContextCompat.getColor(view.context, R.color.signal_background_primary),
-        animator
-      )
-
-      view.setImageDrawable(drawable)
-    }
-
-    override fun onResourceCleared(placeholder: Drawable?) {
-      view.setImageDrawable(placeholder)
-    }
-
-    fun setAnimationToStart() {
-      animator.setState(BadgeAnimator.State.START)
-      view.drawable?.invalidateSelf()
-    }
-
-    fun setAnimationToEnd() {
-      animator.setState(BadgeAnimator.State.END)
-      view.drawable?.invalidateSelf()
-    }
-
-    fun animateToStart() {
-      animator.setState(BadgeAnimator.State.REVERSE)
-      view.drawable?.invalidateSelf()
-    }
-
-    fun animateToEnd() {
-      animator.setState(BadgeAnimator.State.FORWARD)
-      view.drawable?.invalidateSelf()
-    }
-  }
-
-  companion object CREATOR : Parcelable.Creator<Badge> {
     private val SELECTION_CHANGED = Any()
 
-    override fun createFromParcel(parcel: Parcel): Badge {
-      return Badge(parcel)
-    }
-
-    override fun newArray(size: Int): Array<Badge?> {
-      return arrayOfNulls(size)
-    }
-
     fun register(mappingAdapter: MappingAdapter, onBadgeClicked: OnBadgeClicked) {
       mappingAdapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it, onBadgeClicked) }, R.layout.badge_preference_view))
       mappingAdapter.registerFactory(EmptyModel::class.java, MappingAdapter.LayoutFactory({ EmptyViewHolder(it) }, R.layout.badge_preference_view))

app/src/main/java/org/thoughtcrime/securesms/badges/models/BadgeAnimator.kt

@@ -1,97 +0,0 @@
-package org.thoughtcrime.securesms.badges.models
-
-import org.thoughtcrime.securesms.util.Util
-
-class BadgeAnimator {
-
-  val duration = 250L
-
-  var state: State = State.START
-    private set
-
-  private var startTime: Long = 0L
-
-  fun getFraction(): Float {
-    return when (state) {
-      State.START -> 0f
-      State.END -> 1f
-      State.FORWARD -> Util.clamp((System.currentTimeMillis() - startTime) / duration.toFloat(), 0f, 1f)
-      State.REVERSE -> 1f - Util.clamp((System.currentTimeMillis() - startTime) / duration.toFloat(), 0f, 1f)
-    }
-  }
-
-  fun setState(newState: State) {
-    shouldInvalidate()
-
-    if (state == newState) {
-      return
-    }
-
-    if (newState == State.END || newState == State.START) {
-      state = newState
-      startTime = 0L
-      return
-    }
-
-    if (state == State.START && newState == State.REVERSE) {
-      return
-    }
-
-    if (state == State.END && newState == State.FORWARD) {
-      return
-    }
-
-    if (state == State.START && newState == State.FORWARD) {
-      state = State.FORWARD
-      startTime = System.currentTimeMillis()
-      return
-    }
-
-    if (state == State.END && newState == State.REVERSE) {
-      state = State.REVERSE
-      startTime = System.currentTimeMillis()
-      return
-    }
-
-    if (state == State.FORWARD && newState == State.REVERSE) {
-      val elapsed = System.currentTimeMillis() - startTime
-      val delta = duration - elapsed
-      startTime -= delta
-      state = State.REVERSE
-      return
-    }
-
-    if (state == State.REVERSE && newState == State.FORWARD) {
-      val elapsed = System.currentTimeMillis() - startTime
-      val delta = duration - elapsed
-      startTime -= delta
-      state = State.FORWARD
-      return
-    }
-  }
-
-  fun shouldInvalidate(): Boolean {
-    if (state == State.START || state == State.END) {
-      return false
-    }
-
-    if (state == State.FORWARD && getFraction() == 1f) {
-      state = State.END
-      return false
-    }
-
-    if (state == State.REVERSE && getFraction() == 0f) {
-      state = State.START
-      return false
-    }
-
-    return true
-  }
-
-  enum class State {
-    START,
-    FORWARD,
-    REVERSE,
-    END
-  }
-}

app/src/main/java/org/thoughtcrime/securesms/badges/models/BadgePreview.kt

@@ -0,0 +1,65 @@
+package org.thoughtcrime.securesms.badges.models
+
+import android.view.View
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.components.AvatarImageView
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+
+object BadgePreview {
+
+  fun register(mappingAdapter: MappingAdapter) {
+    mappingAdapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.featured_badge_preview_preference))
+    mappingAdapter.registerFactory(SubscriptionModel::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.subscription_flow_badge_preview_preference))
+  }
+
+  abstract class BadgeModel<T : BadgeModel<T>> : PreferenceModel<T>() {
+    abstract val badge: Badge?
+  }
+
+  data class Model(override val badge: Badge?) : BadgeModel<Model>() {
+    override fun areItemsTheSame(newItem: Model): Boolean {
+      return true
+    }
+
+    override fun areContentsTheSame(newItem: Model): Boolean {
+      return super.areContentsTheSame(newItem) && badge == newItem.badge
+    }
+
+    override fun getChangePayload(newItem: Model): Any? {
+      return Unit
+    }
+  }
+
+  data class SubscriptionModel(override val badge: Badge?) : BadgeModel<SubscriptionModel>() {
+    override fun areItemsTheSame(newItem: SubscriptionModel): Boolean {
+      return true
+    }
+
+    override fun areContentsTheSame(newItem: SubscriptionModel): Boolean {
+      return super.areContentsTheSame(newItem) && badge == newItem.badge
+    }
+
+    override fun getChangePayload(newItem: SubscriptionModel): Any? {
+      return Unit
+    }
+  }
+
+  class ViewHolder<T : BadgeModel<T>>(itemView: View) : MappingViewHolder<T>(itemView) {
+
+    private val avatar: AvatarImageView = itemView.findViewById(R.id.avatar)
+    private val badge: BadgeImageView = itemView.findViewById(R.id.badge)
+
+    override fun bind(model: T) {
+      if (payload.isEmpty()) {
+        avatar.setRecipient(Recipient.self())
+        avatar.disableQuickContact()
+      }
+
+      badge.setBadge(model.badge)
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/badges/models/ExpiredBadge.kt

@@ -0,0 +1,34 @@
+package org.thoughtcrime.securesms.badges.models
+
+import android.view.View
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+
+object ExpiredBadge {
+
+  class Model(val badge: Badge) : PreferenceModel<Model>() {
+    override fun areItemsTheSame(newItem: Model): Boolean {
+      return newItem.badge.id == badge.id
+    }
+
+    override fun areContentsTheSame(newItem: Model): Boolean {
+      return super.areContentsTheSame(newItem) && newItem.badge == badge
+    }
+  }
+
+  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
+
+    private val badge: BadgeImageView = itemView.findViewById(R.id.expired_badge)
+
+    override fun bind(model: Model) {
+      badge.setBadge(model.badge)
+    }
+  }
+
+  fun register(adapter: MappingAdapter) {
+    adapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.expired_badge_preference))
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/badges/models/FeaturedBadgePreview.kt

@@ -1,74 +0,0 @@
-package org.thoughtcrime.securesms.badges.models
-
-import android.graphics.drawable.Drawable
-import android.view.View
-import android.widget.ImageView
-import androidx.core.content.ContextCompat
-import com.bumptech.glide.request.target.CustomViewTarget
-import com.bumptech.glide.request.transition.Transition
-import org.signal.core.util.DimensionUnit
-import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.badges.Badges.insetWithOutline
-import org.thoughtcrime.securesms.components.AvatarImageView
-import org.thoughtcrime.securesms.components.settings.PreferenceModel
-import org.thoughtcrime.securesms.mms.GlideApp
-import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.util.MappingAdapter
-import org.thoughtcrime.securesms.util.MappingViewHolder
-
-object FeaturedBadgePreview {
-
-  fun register(mappingAdapter: MappingAdapter) {
-    mappingAdapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.featured_badge_preview_preference))
-  }
-
-  data class Model(val badge: Badge?) : PreferenceModel<Model>() {
-    override fun areItemsTheSame(newItem: Model): Boolean {
-      return newItem.badge?.id == badge?.id
-    }
-
-    override fun areContentsTheSame(newItem: Model): Boolean {
-      return super.areContentsTheSame(newItem) && badge == newItem.badge
-    }
-  }
-
-  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
-
-    private val avatar: AvatarImageView = itemView.findViewById(R.id.avatar)
-    private val badge: ImageView = itemView.findViewById(R.id.badge)
-    private val target: Target = Target(badge)
-
-    override fun bind(model: Model) {
-      avatar.setRecipient(Recipient.self())
-      avatar.disableQuickContact()
-
-      if (model.badge != null) {
-        GlideApp.with(badge)
-          .load(model.badge)
-          .into(target)
-      } else {
-        GlideApp.with(badge).clear(badge)
-        badge.setImageDrawable(null)
-      }
-    }
-  }
-
-  private class Target(view: ImageView) : CustomViewTarget<ImageView, Drawable>(view) {
-    override fun onLoadFailed(errorDrawable: Drawable?) {
-      view.setImageDrawable(errorDrawable)
-    }
-
-    override fun onResourceReady(resource: Drawable, transition: Transition<in Drawable>?) {
-      view.setImageDrawable(
-        resource.insetWithOutline(
-          DimensionUnit.DP.toPixels(2.5f),
-          ContextCompat.getColor(view.context, R.color.signal_background_primary)
-        )
-      )
-    }
-
-    override fun onResourceCleared(placeholder: Drawable?) {
-      view.setImageDrawable(placeholder)
-    }
-  }
-}

app/src/main/java/org/thoughtcrime/securesms/badges/models/LargeBadge.kt

@@ -1,10 +1,9 @@
 package org.thoughtcrime.securesms.badges.models
 
 import android.view.View
-import android.widget.ImageView
 import android.widget.TextView
 import org.thoughtcrime.securesms.R
-import org.thoughtcrime.securesms.mms.GlideApp
+import org.thoughtcrime.securesms.badges.BadgeImageView
 import org.thoughtcrime.securesms.util.MappingAdapter
 import org.thoughtcrime.securesms.util.MappingModel
 import org.thoughtcrime.securesms.util.MappingViewHolder
@@ -35,14 +34,12 @@ data class LargeBadge(
 
   class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
 
-    private val badge: ImageView = itemView.findViewById(R.id.badge)
+    private val badge: BadgeImageView = itemView.findViewById(R.id.badge)
     private val name: TextView = itemView.findViewById(R.id.name)
     private val description: TextView = itemView.findViewById(R.id.description)
 
     override fun bind(model: Model) {
-      GlideApp.with(badge)
-        .load(model.largeBadge.badge)
-        .into(badge)
+      badge.setBadge(model.largeBadge.badge)
 
       name.text = model.largeBadge.badge.name
       description.text = model.largeBadge.badge.resolveDescription(model.shortName)

app/src/main/java/org/thoughtcrime/securesms/badges/self/expired/ExpiredBadgeBottomSheetDialogFragment.kt

@@ -0,0 +1,106 @@
+package org.thoughtcrime.securesms.badges.self.expired
+
+import androidx.fragment.app.FragmentManager
+import androidx.navigation.fragment.findNavController
+import org.signal.core.util.DimensionUnit
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.badges.models.ExpiredBadge
+import org.thoughtcrime.securesms.components.settings.DSLConfiguration
+import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
+import org.thoughtcrime.securesms.components.settings.DSLSettingsBottomSheetFragment
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.util.BottomSheetUtil
+
+/**
+ * Bottom sheet displaying a fading badge with a notice and action for becoming a subscriber again.
+ */
+class ExpiredBadgeBottomSheetDialogFragment : DSLSettingsBottomSheetFragment(
+  peekHeightPercentage = 1f
+) {
+  override fun bindAdapter(adapter: DSLSettingsAdapter) {
+    ExpiredBadge.register(adapter)
+
+    adapter.submitList(getConfiguration().toMappingModelList())
+  }
+
+  private fun getConfiguration(): DSLConfiguration {
+    val badge = ExpiredBadgeBottomSheetDialogFragmentArgs.fromBundle(requireArguments()).badge
+
+    return configure {
+      customPref(ExpiredBadge.Model(badge))
+
+      sectionHeaderPref(
+        DSLSettingsText.from(
+          if (badge.isBoost()) {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__your_badge_has_expired
+          } else {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__subscription_cancelled
+          },
+          DSLSettingsText.CenterModifier
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(4f).toInt())
+
+      noPadTextPref(
+        DSLSettingsText.from(
+          if (badge.isBoost()) {
+            getString(R.string.ExpiredBadgeBottomSheetDialogFragment__your_boost_badge_has_expired)
+          } else {
+            getString(R.string.ExpiredBadgeBottomSheetDialogFragment__your_sustainer, badge.name)
+          },
+          DSLSettingsText.CenterModifier
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(16f).toInt())
+
+      noPadTextPref(
+        DSLSettingsText.from(
+          if (badge.isBoost()) {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__to_continue_supporting_technology
+          } else {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__you_can
+          },
+          DSLSettingsText.CenterModifier
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(92f).toInt())
+
+      primaryButton(
+        text = DSLSettingsText.from(
+          if (badge.isBoost()) {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__become_a_sustainer
+          } else {
+            R.string.ExpiredBadgeBottomSheetDialogFragment__renew_subscription
+          }
+        ),
+        onClick = {
+          dismiss()
+          findNavController().navigate(R.id.action_directly_to_subscribe)
+        }
+      )
+
+      secondaryButtonNoOutline(
+        text = DSLSettingsText.from(R.string.ExpiredBadgeBottomSheetDialogFragment__not_now),
+        onClick = {
+          dismiss()
+        }
+      )
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    fun show(badge: Badge, fragmentManager: FragmentManager) {
+      val args = ExpiredBadgeBottomSheetDialogFragmentArgs.Builder(badge).build()
+      val fragment = ExpiredBadgeBottomSheetDialogFragment()
+      fragment.arguments = args.toBundle()
+
+      fragment.show(fragmentManager, BottomSheetUtil.STANDARD_BOTTOM_SHEET_FRAGMENT_TAG)
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/badges/self/featured/SelectFeaturedBadgeFragment.kt

@@ -10,7 +10,7 @@ import org.thoughtcrime.securesms.badges.BadgeRepository
 import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.badges.Badges.displayBadges
 import org.thoughtcrime.securesms.badges.models.Badge
-import org.thoughtcrime.securesms.badges.models.FeaturedBadgePreview
+import org.thoughtcrime.securesms.badges.models.BadgePreview
 import org.thoughtcrime.securesms.components.recyclerview.OnScrollAnimationHelper
 import org.thoughtcrime.securesms.components.recyclerview.ToolbarShadowAnimationHelper
 import org.thoughtcrime.securesms.components.settings.DSLConfiguration
@@ -51,14 +51,14 @@ class SelectFeaturedBadgeFragment : DSLSettingsFragment(
   }
 
   override fun bindAdapter(adapter: DSLSettingsAdapter) {
-    Badge.register(adapter) { badge, isSelected ->
+    Badge.register(adapter) { badge, isSelected, _ ->
       if (!isSelected) {
         viewModel.setSelectedBadge(badge)
       }
     }
 
     val previewView: View = requireView().findViewById(R.id.preview)
-    val previewViewHolder = FeaturedBadgePreview.ViewHolder(previewView)
+    val previewViewHolder = BadgePreview.ViewHolder<BadgePreview.Model>(previewView)
 
     lifecycleDisposable.bindTo(viewLifecycleOwner.lifecycle)
     lifecycleDisposable += viewModel.events.subscribe { event: SelectFeaturedBadgeEvent ->
@@ -69,9 +69,17 @@ class SelectFeaturedBadgeFragment : DSLSettingsFragment(
       }
     }
 
+    var hasBoundPreview = false
     viewModel.state.observe(viewLifecycleOwner) { state ->
       save.isEnabled = state.stage == SelectFeaturedBadgeState.Stage.READY
-      previewViewHolder.bind(FeaturedBadgePreview.Model(state.selectedBadge))
+
+      if (hasBoundPreview) {
+        previewViewHolder.setPayload(listOf(Unit))
+      } else {
+        hasBoundPreview = true
+      }
+
+      previewViewHolder.bind(BadgePreview.Model(state.selectedBadge))
       adapter.submitList(getConfiguration(state).toMappingModelList())
     }
   }
@@ -79,7 +87,7 @@ class SelectFeaturedBadgeFragment : DSLSettingsFragment(
   private fun getConfiguration(state: SelectFeaturedBadgeState): DSLConfiguration {
     return configure {
       sectionHeaderPref(R.string.SelectFeaturedBadgeFragment__select_a_badge)
-      displayBadges(state.allUnlockedBadges, state.selectedBadge)
+      displayBadges(requireContext(), state.allUnlockedBadges, state.selectedBadge)
     }
   }
 }

app/src/main/java/org/thoughtcrime/securesms/badges/self/featured/SelectFeaturedBadgeViewModel.kt

@@ -29,10 +29,11 @@ class SelectFeaturedBadgeViewModel(private val repository: BadgeRepository) : Vi
 
   init {
     store.update(Recipient.live(Recipient.self().id).liveDataResolved) { recipient, state ->
+      val unexpiredBadges = recipient.badges.filterNot { it.isExpired() }
       state.copy(
         stage = if (state.stage == SelectFeaturedBadgeState.Stage.INIT) SelectFeaturedBadgeState.Stage.READY else state.stage,
-        selectedBadge = recipient.badges.firstOrNull(),
-        allUnlockedBadges = recipient.badges
+        selectedBadge = unexpiredBadges.firstOrNull(),
+        allUnlockedBadges = unexpiredBadges
       )
     }
   }

app/src/main/java/org/thoughtcrime/securesms/badges/self/overview/BadgesOverviewFragment.kt

@@ -13,7 +13,9 @@ import org.thoughtcrime.securesms.components.settings.DSLConfiguration
 import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
 import org.thoughtcrime.securesms.components.settings.DSLSettingsFragment
 import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
 import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.LifecycleDisposable
 
@@ -26,11 +28,19 @@ class BadgesOverviewFragment : DSLSettingsFragment(
 ) {
 
   private val lifecycleDisposable = LifecycleDisposable()
-  private val viewModel: BadgesOverviewViewModel by viewModels(factoryProducer = { BadgesOverviewViewModel.Factory(BadgeRepository(requireContext())) })
+  private val viewModel: BadgesOverviewViewModel by viewModels(
+    factoryProducer = {
+      BadgesOverviewViewModel.Factory(BadgeRepository(requireContext()), SubscriptionsRepository(ApplicationDependencies.getDonationsService()))
+    }
+  )
 
   override fun bindAdapter(adapter: DSLSettingsAdapter) {
-    Badge.register(adapter) { badge, _ ->
-      ViewBadgeBottomSheetDialogFragment.show(parentFragmentManager, Recipient.self().id, badge)
+    Badge.register(adapter) { badge, _, isFaded ->
+      if (badge.isExpired() || isFaded) {
+        findNavController().navigate(BadgesOverviewFragmentDirections.actionBadgeManageFragmentToExpiredBadgeDialog(badge))
+      } else {
+        ViewBadgeBottomSheetDialogFragment.show(parentFragmentManager, Recipient.self().id, badge)
+      }
     }
 
     lifecycleDisposable.bindTo(viewLifecycleOwner.lifecycle)
@@ -52,11 +62,17 @@ class BadgesOverviewFragment : DSLSettingsFragment(
     return configure {
       sectionHeaderPref(R.string.BadgesOverviewFragment__my_badges)
 
-      displayBadges(state.allUnlockedBadges)
+      displayBadges(
+        context = requireContext(),
+        badges = state.allUnlockedBadges,
+        fadedBadgeId = state.fadedBadgeId
+      )
 
-      switchPref(
+      asyncSwitchPref(
         title = DSLSettingsText.from(R.string.BadgesOverviewFragment__display_badges_on_profile),
         isChecked = state.displayBadgesOnProfile,
+        isEnabled = state.stage == BadgesOverviewState.Stage.READY && state.hasUnexpiredBadges,
+        isProcessing = state.stage == BadgesOverviewState.Stage.UPDATING_BADGE_DISPLAY_STATE,
         onClick = {
           viewModel.setDisplayBadgesOnProfile(!state.displayBadgesOnProfile)
         }
@@ -65,7 +81,7 @@ class BadgesOverviewFragment : DSLSettingsFragment(
       clickPref(
         title = DSLSettingsText.from(R.string.BadgesOverviewFragment__featured_badge),
         summary = state.featuredBadge?.name?.let { DSLSettingsText.from(it) },
-        isEnabled = state.stage == BadgesOverviewState.Stage.READY,
+        isEnabled = state.stage == BadgesOverviewState.Stage.READY && state.hasUnexpiredBadges,
         onClick = {
           findNavController().navigate(BadgesOverviewFragmentDirections.actionBadgeManageFragmentToFeaturedBadgeFragment())
         }

app/src/main/java/org/thoughtcrime/securesms/badges/self/overview/BadgesOverviewState.kt

@@ -6,11 +6,15 @@ data class BadgesOverviewState(
   val stage: Stage = Stage.INIT,
   val allUnlockedBadges: List<Badge> = listOf(),
   val featuredBadge: Badge? = null,
-  val displayBadgesOnProfile: Boolean = false
+  val displayBadgesOnProfile: Boolean = false,
+  val fadedBadgeId: String? = null
 ) {
+
+  val hasUnexpiredBadges = allUnlockedBadges.any { it.expirationTimestamp > System.currentTimeMillis() }
+
   enum class Stage {
     INIT,
     READY,
-    UPDATING
+    UPDATING_BADGE_DISPLAY_STATE
   }
 }

app/src/main/java/org/thoughtcrime/securesms/badges/self/overview/BadgesOverviewViewModel.kt

@@ -5,17 +5,25 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.disposables.CompositeDisposable
 import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.kotlin.subscribeBy
 import io.reactivex.rxjava3.subjects.PublishSubject
 import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.badges.BadgeRepository
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.livedata.Store
+import org.whispersystems.libsignal.util.guava.Optional
 
 private val TAG = Log.tag(BadgesOverviewViewModel::class.java)
 
-class BadgesOverviewViewModel(private val badgeRepository: BadgeRepository) : ViewModel() {
+class BadgesOverviewViewModel(
+  private val badgeRepository: BadgeRepository,
+  private val subscriptionsRepository: SubscriptionsRepository
+) : ViewModel() {
   private val store = Store(BadgesOverviewState())
   private val eventSubject = PublishSubject.create<BadgesOverviewEvent>()
 
@@ -29,12 +37,32 @@ class BadgesOverviewViewModel(private val badgeRepository: BadgeRepository) : Vi
       state.copy(
         stage = if (state.stage == BadgesOverviewState.Stage.INIT) BadgesOverviewState.Stage.READY else state.stage,
         allUnlockedBadges = recipient.badges,
-        displayBadgesOnProfile = recipient.badges.firstOrNull()?.visible == true
+        displayBadgesOnProfile = SignalStore.donationsValues().getDisplayBadgesOnProfile(),
+        featuredBadge = recipient.featuredBadge
       )
     }
+
+    disposables += Single.zip(
+      subscriptionsRepository.getActiveSubscription(),
+      subscriptionsRepository.getSubscriptions()
+    ) { active, all ->
+      if (!active.isActive && active.activeSubscription?.willCancelAtPeriodEnd() == true) {
+        Optional.fromNullable<String>(all.firstOrNull { it.level == active.activeSubscription?.level }?.badge?.id)
+      } else {
+        Optional.absent()
+      }
+    }.subscribeBy(
+      onSuccess = { badgeId ->
+        store.update { it.copy(fadedBadgeId = badgeId.orNull()) }
+      },
+      onError = { throwable ->
+        Log.w(TAG, "Could not retrieve data from server", throwable)
+      }
+    )
   }
 
   fun setDisplayBadgesOnProfile(displayBadgesOnProfile: Boolean) {
+    store.update { it.copy(stage = BadgesOverviewState.Stage.UPDATING_BADGE_DISPLAY_STATE) }
     disposables += badgeRepository.setVisibilityForAllBadges(displayBadgesOnProfile)
       .subscribe(
         {
@@ -52,9 +80,16 @@ class BadgesOverviewViewModel(private val badgeRepository: BadgeRepository) : Vi
     disposables.clear()
   }
 
-  class Factory(private val badgeRepository: BadgeRepository) : ViewModelProvider.Factory {
+  class Factory(
+    private val badgeRepository: BadgeRepository,
+    private val subscriptionsRepository: SubscriptionsRepository
+  ) : ViewModelProvider.Factory {
     override fun <T : ViewModel?> create(modelClass: Class<T>): T {
-      return requireNotNull(modelClass.cast(BadgesOverviewViewModel(badgeRepository)))
+      return requireNotNull(modelClass.cast(BadgesOverviewViewModel(badgeRepository, subscriptionsRepository)))
     }
   }
+
+  companion object {
+    private val TAG = Log.tag(BadgesOverviewViewModel::class.java)
+  }
 }

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

@@ -4,6 +4,7 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
 import androidx.viewpager2.widget.ViewPager2
@@ -15,10 +16,14 @@ import org.thoughtcrime.securesms.badges.BadgeRepository
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.badges.models.LargeBadge
 import org.thoughtcrime.securesms.components.FixedRoundedCornerBottomSheetDialogFragment
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
 import org.thoughtcrime.securesms.util.BottomSheetUtil
+import org.thoughtcrime.securesms.util.CommunicationActions
+import org.thoughtcrime.securesms.util.FeatureFlags
 import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.PlayServicesUtil
 import org.thoughtcrime.securesms.util.visible
 
 class ViewBadgeBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFragment() {
@@ -37,11 +42,28 @@ class ViewBadgeBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFr
     val pager: ViewPager2 = view.findViewById(R.id.pager)
     val tabs: TabLayout = view.findViewById(R.id.tab_layout)
     val action: MaterialButton = view.findViewById(R.id.action)
+    val noSupport: View = view.findViewById(R.id.no_support)
 
     if (getRecipientId() == Recipient.self().id) {
       action.visible = false
     }
 
+    @Suppress("CascadeIf")
+    if (PlayServicesUtil.getPlayServicesStatus(requireContext()) != PlayServicesUtil.PlayServicesStatus.SUCCESS) {
+      noSupport.visible = true
+      action.icon = ContextCompat.getDrawable(requireContext(), R.drawable.ic_open_20)
+      action.setText(R.string.preferences__donate_to_signal)
+      action.setOnClickListener {
+        CommunicationActions.openBrowserLink(requireContext(), getString(R.string.donate_url))
+      }
+    } else if (FeatureFlags.donorBadges()) {
+      action.setOnClickListener {
+        startActivity(AppSettingsActivity.subscriptions(requireContext()))
+      }
+    } else {
+      action.visible = false
+    }
+
     val adapter = MappingAdapter()
 
     LargeBadge.register(adapter)
@@ -68,6 +90,8 @@ class ViewBadgeBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFr
         dismissAllowingStateLoss()
       }
 
+      tabs.visible = state.allBadgesVisibleOnProfile.size > 1
+
       adapter.submitList(
         state.allBadgesVisibleOnProfile.map {
           LargeBadge.Model(LargeBadge(it), state.recipient.getShortDisplayName(requireContext()))
@@ -96,6 +120,10 @@ class ViewBadgeBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFr
       recipientId: RecipientId,
       startBadge: Badge? = null
     ) {
+      if (!FeatureFlags.displayDonorBadges()) {
+        return
+      }
+
       ViewBadgeBottomSheetDialogFragment().apply {
         arguments = Bundle().apply {
           putParcelable(ARG_START_BADGE, startBadge)

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

@@ -119,6 +119,7 @@ public final class AudioView extends FrameLayout {
 
       lottieDirection = REVERSE;
       this.playPauseButton.setOnClickListener(new PlayPauseClickedListener());
+      this.playPauseButton.setOnLongClickListener(v -> performLongClick());
       this.seekBar.setOnSeekBarChangeListener(new SeekBarModifiedListener());
 
       setTint(typedArray.getColor(R.styleable.AudioView_foregroundTintColor, Color.WHITE));

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

@@ -10,6 +10,7 @@ import android.graphics.PorterDuffColorFilter;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.View;
+import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.TextView;
 
@@ -207,9 +208,9 @@ public class ConversationItemFooter extends ConstraintLayout {
     setBackground(null);
   }
 
-  public @Nullable Projection getProjection() {
+  public @Nullable Projection getProjection(@NonNull ViewGroup coordinateRoot) {
     if (getVisibility() == VISIBLE) {
-      return Projection.relativeToViewRoot(this, new Projection.Corners(ViewUtil.dpToPx(11)));
+      return Projection.relativeToParent(coordinateRoot, this, new Projection.Corners(ViewUtil.dpToPx(11)));
     } else {
       return null;
     }

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

@@ -14,6 +14,7 @@ import androidx.core.content.ContextCompat;
 import com.annimon.stream.Stream;
 
 import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.badges.BadgeImageView;
 import org.thoughtcrime.securesms.mms.GlideRequests;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.whispersystems.libsignal.util.Pair;
@@ -26,6 +27,9 @@ public class ConversationTypingView extends ConstraintLayout {
   private AvatarImageView     avatar1;
   private AvatarImageView     avatar2;
   private AvatarImageView     avatar3;
+  private BadgeImageView      badge1;
+  private BadgeImageView      badge2;
+  private BadgeImageView      badge3;
   private View                bubble;
   private TypingIndicatorView indicator;
   private TextView            typistCount;
@@ -41,6 +45,9 @@ public class ConversationTypingView extends ConstraintLayout {
     avatar1     = findViewById(R.id.typing_avatar_1);
     avatar2     = findViewById(R.id.typing_avatar_2);
     avatar3     = findViewById(R.id.typing_avatar_3);
+    badge1      = findViewById(R.id.typing_badge_1);
+    badge2      = findViewById(R.id.typing_badge_2);
+    badge3      = findViewById(R.id.typing_badge_3);
     typistCount = findViewById(R.id.typing_count);
     bubble      = findViewById(R.id.typing_bubble);
     indicator   = findViewById(R.id.typing_indicator);
@@ -55,6 +62,9 @@ public class ConversationTypingView extends ConstraintLayout {
     avatar1.setVisibility(GONE);
     avatar2.setVisibility(GONE);
     avatar3.setVisibility(GONE);
+    badge1.setVisibility(GONE);
+    badge2.setVisibility(GONE);
+    badge3.setVisibility(GONE);
     typistCount.setVisibility(GONE);
 
     if (isGroupThread) {
@@ -75,15 +85,21 @@ public class ConversationTypingView extends ConstraintLayout {
   private void presentGroupThreadAvatars(@NonNull GlideRequests glideRequests, @NonNull List<Recipient> typists) {
     avatar1.setAvatar(glideRequests, typists.get(0), typists.size() == 1);
     avatar1.setVisibility(VISIBLE);
+    badge1.setBadgeFromRecipient(typists.get(0), glideRequests);
+    badge1.setVisibility(VISIBLE);
 
     if (typists.size() > 1) {
       avatar2.setAvatar(glideRequests, typists.get(1), false);
       avatar2.setVisibility(VISIBLE);
+      badge2.setBadgeFromRecipient(typists.get(1), glideRequests);
+      badge2.setVisibility(VISIBLE);
     }
 
     if (typists.size() == 3) {
       avatar3.setAvatar(glideRequests, typists.get(2), false);
       avatar3.setVisibility(VISIBLE);
+      badge3.setBadgeFromRecipient(typists.get(2), glideRequests);
+      badge3.setVisibility(VISIBLE);
     }
 
     if (typists.size() > 3) {

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

@@ -133,7 +133,7 @@ public class EmojiTextView extends AppCompatTextView {
     previousTransformationMethod = getTransformationMethod();
 
     if (useSystemEmoji || candidates == null || candidates.size() == 0) {
-      super.setText(new SpannableStringBuilder(Optional.fromNullable(text).or("")), BufferType.NORMAL);
+      super.setText(new SpannableStringBuilder(Optional.fromNullable(text).or("")), BufferType.SPANNABLE);
     } else {
       CharSequence emojified = EmojiProvider.emojify(candidates, text, this);
       super.setText(new SpannableStringBuilder(emojified), BufferType.SPANNABLE);
@@ -219,7 +219,7 @@ public class EmojiTextView extends AppCompatTextView {
       EmojiParser.CandidateList newCandidates = isInEditMode() ? null : EmojiProvider.getCandidates(newContent);
 
       if (useSystemEmoji || newCandidates == null || newCandidates.size() == 0) {
-        super.setText(newContent, BufferType.NORMAL);
+        super.setText(newContent, BufferType.SPANNABLE);
       } else {
         CharSequence emojified = EmojiProvider.emojify(newCandidates, newContent, this);
         super.setText(emojified, BufferType.SPANNABLE);

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

@@ -5,6 +5,7 @@ import android.text.TextUtils
 import android.util.AttributeSet
 import androidx.appcompat.widget.AppCompatTextView
 import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.util.ThrottledDebouncer
 import org.whispersystems.libsignal.util.guava.Optional
 
 open class SimpleEmojiTextView @JvmOverloads constructor(
@@ -14,17 +15,22 @@ open class SimpleEmojiTextView @JvmOverloads constructor(
 ) : AppCompatTextView(context, attrs, defStyleAttr) {
 
   private var bufferType: BufferType? = null
+  private val sizeChangeDebouncer: ThrottledDebouncer = ThrottledDebouncer(200)
 
   override fun setText(text: CharSequence?, type: BufferType?) {
     bufferType = type
     val candidates = if (isInEditMode) null else EmojiProvider.getCandidates(text)
     if (SignalStore.settings().isPreferSystemEmoji || candidates == null || candidates.size() == 0) {
-      super.setText(Optional.fromNullable(text).or(""), BufferType.NORMAL)
+      super.setText(Optional.fromNullable(text).or(""), type)
     } else {
+      val startDrawableSize: Int = compoundDrawables[0]?.let { it.intrinsicWidth + compoundDrawablePadding } ?: 0
+      val endDrawableSize: Int = compoundDrawables[1]?.let { it.intrinsicWidth + compoundDrawablePadding } ?: 0
+      val adjustedWidth: Int = width - startDrawableSize - endDrawableSize
+
       val newContent = if (width == 0 || maxLines == -1) {
         text
       } else {
-        TextUtils.ellipsize(text, paint, (width * maxLines).toFloat(), TextUtils.TruncateAt.END, false, null)
+        TextUtils.ellipsize(text, paint, (adjustedWidth * maxLines).toFloat(), TextUtils.TruncateAt.END, false, null)
       }
 
       val newCandidates = if (isInEditMode) null else EmojiProvider.getCandidates(newContent)
@@ -40,8 +46,10 @@ open class SimpleEmojiTextView @JvmOverloads constructor(
 
   override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
     super.onSizeChanged(width, height, oldWidth, oldHeight)
-    if (width > 0 && oldWidth != width) {
-      setText(text, bufferType ?: BufferType.NORMAL)
+    sizeChangeDebouncer.publish {
+      if (width > 0 && oldWidth != width) {
+        setText(text, bufferType ?: BufferType.SPANNABLE)
+      }
     }
   }
 }

app/src/main/java/org/thoughtcrime/securesms/components/menu/ActionItem.kt

@@ -0,0 +1,12 @@
+package org.thoughtcrime.securesms.components.menu
+
+import androidx.annotation.DrawableRes
+
+/**
+ * Represents an action to be rendered via [SignalContextMenu] or [SignalBottomActionBar]
+ */
+data class ActionItem(
+  @DrawableRes val iconRes: Int,
+  val title: CharSequence,
+  val action: Runnable
+)

app/src/main/java/org/thoughtcrime/securesms/components/menu/SignalBottomActionBar.kt

@@ -0,0 +1,109 @@
+package org.thoughtcrime.securesms.components.menu
+
+import android.content.Context
+import android.os.Build
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.Animation
+import android.view.animation.AnimationUtils
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.interpolator.view.animation.FastOutSlowInInterpolator
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.util.ViewUtil
+
+/**
+ * A bar that displays a set of action buttons. Intended as a replacement for ActionModes, this gives you a simple interface to add a bunch of actions, and
+ * the bar itself will handle putting things in the overflow and whatnot.
+ *
+ * Overflow items are rendered in a [SignalContextMenu].
+ */
+class SignalBottomActionBar(context: Context, attributeSet: AttributeSet) : LinearLayout(context, attributeSet) {
+
+  val items: MutableList<ActionItem> = mutableListOf()
+
+  val enterAnimation: Animation by lazy {
+    AnimationUtils.loadAnimation(context, R.anim.slide_fade_from_bottom).apply {
+      duration = 250
+      interpolator = FastOutSlowInInterpolator()
+    }
+  }
+
+  val exitAnimation: Animation by lazy {
+    AnimationUtils.loadAnimation(context, R.anim.slide_fade_to_bottom).apply {
+      duration = 250
+      interpolator = FastOutSlowInInterpolator()
+    }
+  }
+
+  init {
+    orientation = HORIZONTAL
+    setBackgroundResource(R.drawable.signal_bottom_action_bar_background)
+
+    if (Build.VERSION.SDK_INT >= 21) {
+      elevation = 20f
+    }
+  }
+
+  fun setItems(items: List<ActionItem>) {
+    this.items.clear()
+    this.items.addAll(items)
+    present(this.items)
+  }
+
+  private fun present(items: List<ActionItem>) {
+    if (width == 0) {
+      post { present(items) }
+      return
+    }
+
+    val widthDp: Float = ViewUtil.pxToDp(width.toFloat())
+    val minButtonWidthDp = 80
+    val maxButtons: Int = (widthDp / minButtonWidthDp).toInt()
+    val usableButtonCount = when {
+      items.size <= maxButtons -> items.size
+      else -> maxButtons - 1
+    }
+
+    val renderableItems: List<ActionItem> = items.subList(0, usableButtonCount)
+    val overflowItems: List<ActionItem> = if (renderableItems.size < items.size) items.subList(usableButtonCount, items.size) else emptyList()
+
+    removeAllViews()
+
+    renderableItems.forEach { item ->
+      val view: View = LayoutInflater.from(context).inflate(R.layout.signal_bottom_action_bar_item, this, false)
+      addView(view)
+      bindItem(view, item)
+    }
+
+    if (overflowItems.isNotEmpty()) {
+      val view: View = LayoutInflater.from(context).inflate(R.layout.signal_bottom_action_bar_item, this, false)
+      addView(view)
+      bindItem(
+        view,
+        ActionItem(
+          iconRes = R.drawable.ic_more_horiz_24,
+          title = context.getString(R.string.SignalBottomActionBar_more),
+          action = {
+            SignalContextMenu.Builder(view, parent as ViewGroup)
+              .preferredHorizontalPosition(SignalContextMenu.HorizontalPosition.END)
+              .offsetY(ViewUtil.dpToPx(8))
+              .show(overflowItems)
+          }
+        )
+      )
+    }
+  }
+
+  private fun bindItem(view: View, item: ActionItem) {
+    val icon: ImageView = view.findViewById(R.id.signal_bottom_action_bar_item_icon)
+    val title: TextView = view.findViewById(R.id.signal_bottom_action_bar_item_title)
+
+    icon.setImageResource(item.iconRes)
+    title.text = item.title
+    view.setOnClickListener { item.action.run() }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/menu/SignalContextMenu.kt

@@ -0,0 +1,233 @@
+package org.thoughtcrime.securesms.components.menu
+
+import android.content.Context
+import android.graphics.Rect
+import android.os.Build
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.PopupWindow
+import android.widget.TextView
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingModel
+import org.thoughtcrime.securesms.util.MappingViewHolder
+import org.thoughtcrime.securesms.util.ViewUtil
+
+/**
+ * A custom context menu that will show next to an anchor view and display several options. Basically a PopupMenu with custom UI and positioning rules.
+ *
+ * This will prefer showing the menu underneath the anchor, but if there's not enough space in the container, it will show it above the anchor and reverse the
+ * order of the menu items. If there's not enough room for either, it'll show it centered above the anchor. If there's not enough room then, it'll center it,
+ * chop off the part that doesn't fit, and make the menu scrollable.
+ */
+class SignalContextMenu private constructor(
+  val anchor: View,
+  val container: ViewGroup,
+  val items: List<ActionItem>,
+  val baseOffsetX: Int = 0,
+  val baseOffsetY: Int = 0,
+  val horizontalPosition: HorizontalPosition = HorizontalPosition.START,
+  val onDismiss: Runnable? = null
+) : PopupWindow(
+  LayoutInflater.from(anchor.context).inflate(R.layout.signal_context_menu, null),
+  ViewGroup.LayoutParams.WRAP_CONTENT,
+  ViewGroup.LayoutParams.WRAP_CONTENT
+) {
+
+  val context: Context = anchor.context
+
+  val mappingAdapter = MappingAdapter().apply {
+    registerFactory(DisplayItem::class.java, ItemViewHolderFactory())
+  }
+
+  init {
+    setBackgroundDrawable(ContextCompat.getDrawable(context, R.drawable.signal_context_menu_background))
+
+    isFocusable = true
+
+    if (onDismiss != null) {
+      setOnDismissListener { onDismiss.run() }
+    }
+
+    if (Build.VERSION.SDK_INT >= 21) {
+      elevation = 20f
+    }
+
+    contentView.findViewById<RecyclerView>(R.id.signal_context_menu_list).apply {
+      adapter = mappingAdapter
+      layoutManager = LinearLayoutManager(context)
+      itemAnimator = null
+    }
+
+    mappingAdapter.submitList(items.toAdapterItems())
+  }
+
+  private fun show() {
+    if (anchor.width == 0 || anchor.height == 0) {
+      anchor.post(this::show)
+      return
+    }
+
+    contentView.measure(
+      View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
+      View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+    )
+
+    val anchorRect = Rect(anchor.left, anchor.top, anchor.right, anchor.bottom).also {
+      if (anchor.parent != container) {
+        container.offsetDescendantRectToMyCoords(anchor, it)
+      }
+    }
+
+    val menuBottomBound = anchorRect.bottom + contentView.measuredHeight + baseOffsetY
+    val menuTopBound = anchorRect.top - contentView.measuredHeight - baseOffsetY
+
+    val screenBottomBound = container.height
+    val screenTopBound = container.y
+
+    val offsetY: Int
+
+    if (menuBottomBound < screenBottomBound) {
+      offsetY = baseOffsetY
+    } else if (menuTopBound > screenTopBound) {
+      offsetY = -(anchorRect.height() + contentView.measuredHeight + baseOffsetY)
+      mappingAdapter.submitList(items.reversed().toAdapterItems())
+    } else {
+      offsetY = -((anchorRect.height() / 2) + (contentView.measuredHeight / 2) + baseOffsetY)
+    }
+
+    val offsetX: Int = when (horizontalPosition) {
+      HorizontalPosition.START -> {
+        if (ViewUtil.isLtr(context)) {
+          baseOffsetX
+        } else {
+          -(baseOffsetX + contentView.measuredWidth)
+        }
+      }
+      HorizontalPosition.END -> {
+        if (ViewUtil.isLtr(context)) {
+          -(baseOffsetX + contentView.measuredWidth - anchorRect.width())
+        } else {
+          baseOffsetX - anchorRect.width()
+        }
+      }
+    }
+
+    showAsDropDown(anchor, offsetX, offsetY)
+  }
+
+  private fun List<ActionItem>.toAdapterItems(): List<DisplayItem> {
+    return this.mapIndexed { index, item ->
+      val displayType: DisplayType = when {
+        this.size == 1 -> DisplayType.ONLY
+        index == 0 -> DisplayType.TOP
+        index == this.size - 1 -> DisplayType.BOTTOM
+        else -> DisplayType.MIDDLE
+      }
+
+      DisplayItem(item, displayType)
+    }
+  }
+
+  private data class DisplayItem(
+    val item: ActionItem,
+    val displayType: DisplayType
+  ) : MappingModel<DisplayItem> {
+    override fun areItemsTheSame(newItem: DisplayItem): Boolean {
+      return this == newItem
+    }
+
+    override fun areContentsTheSame(newItem: DisplayItem): Boolean {
+      return this == newItem
+    }
+  }
+
+  private enum class DisplayType {
+    TOP, BOTTOM, MIDDLE, ONLY
+  }
+
+  private inner class ItemViewHolder(itemView: View) : MappingViewHolder<DisplayItem>(itemView) {
+    val icon: ImageView = itemView.findViewById(R.id.signal_context_menu_item_icon)
+    val title: TextView = itemView.findViewById(R.id.signal_context_menu_item_title)
+
+    override fun bind(model: DisplayItem) {
+      icon.setImageResource(model.item.iconRes)
+      title.text = model.item.title
+      itemView.setOnClickListener {
+        model.item.action.run()
+        dismiss()
+      }
+
+      if (Build.VERSION.SDK_INT >= 21) {
+        when (model.displayType) {
+          DisplayType.TOP -> itemView.setBackgroundResource(R.drawable.signal_context_menu_item_background_top)
+          DisplayType.BOTTOM -> itemView.setBackgroundResource(R.drawable.signal_context_menu_item_background_bottom)
+          DisplayType.MIDDLE -> itemView.setBackgroundResource(R.drawable.signal_context_menu_item_background_middle)
+          DisplayType.ONLY -> itemView.setBackgroundResource(R.drawable.signal_context_menu_item_background_only)
+        }
+      }
+    }
+  }
+
+  private inner class ItemViewHolderFactory : MappingAdapter.Factory<DisplayItem> {
+    override fun createViewHolder(parent: ViewGroup): MappingViewHolder<DisplayItem> {
+      return ItemViewHolder(LayoutInflater.from(parent.context).inflate(R.layout.signal_context_menu_item, parent, false))
+    }
+  }
+
+  enum class HorizontalPosition {
+    START, END
+  }
+
+  /**
+   * @param anchor The view to put the pop-up on
+   * @param container A parent of [anchor] that represents the acceptable boundaries of the popup
+   */
+  class Builder(
+    val anchor: View,
+    val container: ViewGroup
+  ) {
+
+    var onDismiss: Runnable? = null
+    var offsetX = 0
+    var offsetY = 0
+    var horizontalPosition = HorizontalPosition.START
+
+    fun onDismiss(onDismiss: Runnable): Builder {
+      this.onDismiss = onDismiss
+      return this
+    }
+
+    fun offsetX(offsetPx: Int): Builder {
+      this.offsetX = offsetPx
+      return this
+    }
+
+    fun offsetY(offsetPx: Int): Builder {
+      this.offsetY = offsetPx
+      return this
+    }
+
+    fun preferredHorizontalPosition(horizontalPosition: HorizontalPosition): Builder {
+      this.horizontalPosition = horizontalPosition
+      return this
+    }
+
+    fun show(items: List<ActionItem>) {
+      SignalContextMenu(
+        anchor = anchor,
+        container = container,
+        items = items,
+        baseOffsetX = offsetX,
+        baseOffsetY = offsetY,
+        horizontalPosition = horizontalPosition,
+        onDismiss = onDismiss
+      ).show()
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/recyclerview/DeleteItemAnimator.java

@@ -1,26 +0,0 @@
-package org.thoughtcrime.securesms.components.recyclerview;
-
-
-import androidx.recyclerview.widget.DefaultItemAnimator;
-import androidx.recyclerview.widget.RecyclerView;
-
-public class DeleteItemAnimator extends DefaultItemAnimator {
-
-  public DeleteItemAnimator() {
-    setSupportsChangeAnimations(false);
-  }
-
-  @Override
-  public boolean animateAdd(RecyclerView.ViewHolder viewHolder) {
-    dispatchAddFinished(viewHolder);
-    return false;
-  }
-
-  @Override
-  public boolean animateMove(RecyclerView.ViewHolder viewHolder, int fromX, int fromY, int toX, int toY) {
-    dispatchMoveFinished(viewHolder);
-    return false;
-  }
-
-
-}

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

@@ -11,7 +11,12 @@ import androidx.annotation.CallSuper
 import androidx.core.content.ContextCompat
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.switchmaterial.SwitchMaterial
+import org.signal.core.util.logging.Log
 import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.models.AsyncSwitch
+import org.thoughtcrime.securesms.components.settings.models.Button
+import org.thoughtcrime.securesms.components.settings.models.Space
+import org.thoughtcrime.securesms.components.settings.models.Text
 import org.thoughtcrime.securesms.util.CommunicationActions
 import org.thoughtcrime.securesms.util.MappingAdapter
 import org.thoughtcrime.securesms.util.MappingViewHolder
@@ -30,6 +35,10 @@ class DSLSettingsAdapter : MappingAdapter() {
     registerFactory(SectionHeaderPreference::class.java, LayoutFactory(::SectionHeaderPreferenceViewHolder, R.layout.dsl_section_header))
     registerFactory(SwitchPreference::class.java, LayoutFactory(::SwitchPreferenceViewHolder, R.layout.dsl_switch_preference_item))
     registerFactory(RadioPreference::class.java, LayoutFactory(::RadioPreferenceViewHolder, R.layout.dsl_radio_preference_item))
+    Text.register(this)
+    Space.register(this)
+    Button.register(this)
+    AsyncSwitch.register(this)
   }
 }
 
@@ -97,8 +106,13 @@ class RadioListPreferenceViewHolder(itemView: View) : PreferenceViewHolder<Radio
   override fun bind(model: RadioListPreference) {
     super.bind(model)
 
-    summaryView.visibility = View.VISIBLE
-    summaryView.text = model.listItems[model.selected]
+    if (model.selected >= 0) {
+      summaryView.visibility = View.VISIBLE
+      summaryView.text = model.listItems[model.selected]
+    } else {
+      summaryView.visibility = View.GONE
+      Log.w(TAG, "Detected a radio list without a default selection: ${model.dialogTitle}")
+    }
 
     itemView.setOnClickListener {
       var selection = -1
@@ -128,6 +142,10 @@ class RadioListPreferenceViewHolder(itemView: View) : PreferenceViewHolder<Radio
       }
     }
   }
+
+  companion object {
+    private val TAG = Log.tag(RadioListPreference::class.java)
+  }
 }
 
 class MultiSelectListPreferenceViewHolder(itemView: View) : PreferenceViewHolder<MultiSelectListPreference>(itemView) {

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

@@ -0,0 +1,53 @@
+package org.thoughtcrime.securesms.components.settings
+
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.EdgeEffect
+import androidx.annotation.LayoutRes
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.FixedRoundedCornerBottomSheetDialogFragment
+
+abstract class DSLSettingsBottomSheetFragment(
+  @LayoutRes private val layoutId: Int = R.layout.dsl_settings_bottom_sheet,
+  val layoutManagerProducer: (Context) -> RecyclerView.LayoutManager = { context -> LinearLayoutManager(context) },
+  override val peekHeightPercentage: Float = 1f
+) : FixedRoundedCornerBottomSheetDialogFragment() {
+
+  protected lateinit var recyclerView: RecyclerView
+    private set
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+    return inflater.inflate(layoutId, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    recyclerView = view.findViewById(R.id.recycler)
+    recyclerView.edgeEffectFactory = EdgeEffectFactory()
+    val adapter = DSLSettingsAdapter()
+
+    recyclerView.layoutManager = layoutManagerProducer(requireContext())
+    recyclerView.adapter = adapter
+
+    bindAdapter(adapter)
+  }
+
+  abstract fun bindAdapter(adapter: DSLSettingsAdapter)
+
+  private class EdgeEffectFactory : RecyclerView.EdgeEffectFactory() {
+    override fun createEdgeEffect(view: RecyclerView, direction: Int): EdgeEffect {
+      return super.createEdgeEffect(view, direction).apply {
+        if (Build.VERSION.SDK_INT > 21) {
+          color =
+            requireNotNull(ContextCompat.getColor(view.context, R.color.settings_ripple_color))
+        }
+      }
+    }
+  }
+}

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

@@ -3,35 +3,76 @@ package org.thoughtcrime.securesms.components.settings
 import android.content.Context
 import androidx.annotation.ColorInt
 import androidx.annotation.StringRes
+import androidx.annotation.StyleRes
+import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.util.SpanUtil
 
 sealed class DSLSettingsText {
 
+  protected abstract val modifiers: List<Modifier>
+
   private data class FromResource(
     @StringRes private val stringId: Int,
-    @ColorInt private val textColor: Int?
+    override val modifiers: List<Modifier>
   ) : DSLSettingsText() {
-    override fun resolve(context: Context): CharSequence {
-      val text = context.getString(stringId)
-
-      return if (textColor == null) {
-        text
-      } else {
-        SpanUtil.color(textColor, text)
-      }
+    override fun getCharSequence(context: Context): CharSequence {
+      return context.getString(stringId)
     }
   }
 
-  private data class FromCharSequence(private val charSequence: CharSequence) : DSLSettingsText() {
-    override fun resolve(context: Context): CharSequence = charSequence
+  private data class FromCharSequence(
+    private val charSequence: CharSequence,
+    override val modifiers: List<Modifier>
+  ) : DSLSettingsText() {
+    override fun getCharSequence(context: Context): CharSequence = charSequence
   }
 
-  abstract fun resolve(context: Context): CharSequence
+  protected abstract fun getCharSequence(context: Context): CharSequence
+
+  fun resolve(context: Context): CharSequence {
+    val text: CharSequence = getCharSequence(context)
+    return modifiers.fold(text) { t, m -> m.modify(context, t) }
+  }
 
   companion object {
-    fun from(@StringRes stringId: Int, @ColorInt textColor: Int? = null): DSLSettingsText =
-      FromResource(stringId, textColor)
+    fun from(@StringRes stringId: Int, @ColorInt textColor: Int): DSLSettingsText =
+      FromResource(stringId, listOf(ColorModifier(textColor)))
 
-    fun from(charSequence: CharSequence): DSLSettingsText = FromCharSequence(charSequence)
+    fun from(@StringRes stringId: Int, vararg modifiers: Modifier): DSLSettingsText =
+      FromResource(stringId, modifiers.toList())
+
+    fun from(charSequence: CharSequence, vararg modifiers: Modifier): DSLSettingsText =
+      FromCharSequence(charSequence, modifiers.toList())
+  }
+
+  interface Modifier {
+    fun modify(context: Context, charSequence: CharSequence): CharSequence
+  }
+
+  class ColorModifier(@ColorInt private val textColor: Int) : Modifier {
+    override fun modify(context: Context, charSequence: CharSequence): CharSequence {
+      return SpanUtil.color(textColor, charSequence)
+    }
+  }
+
+  object CenterModifier : Modifier {
+    override fun modify(context: Context, charSequence: CharSequence): CharSequence {
+      return SpanUtil.center(charSequence)
+    }
+  }
+
+  object Title2BoldModifier : TextAppearanceModifier(R.style.TextAppearance_Signal_Title2_Bold)
+  object Body1BoldModifier : TextAppearanceModifier(R.style.TextAppearance_Signal_Body1_Bold)
+
+  open class TextAppearanceModifier(@StyleRes private val textAppearance: Int) : Modifier {
+    override fun modify(context: Context, charSequence: CharSequence): CharSequence {
+      return SpanUtil.textAppearance(context, textAppearance, charSequence)
+    }
+  }
+
+  object BoldModifier : Modifier {
+    override fun modify(context: Context, charSequence: CharSequence): CharSequence {
+      return SpanUtil.bold(charSequence)
+    }
   }
 }

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

@@ -4,9 +4,13 @@ import android.content.Context
 import android.content.Intent
 import android.os.Bundle
 import androidx.navigation.NavDirections
+import io.reactivex.rxjava3.subjects.PublishSubject
+import io.reactivex.rxjava3.subjects.Subject
 import org.thoughtcrime.securesms.MainActivity
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.settings.DSLSettingsActivity
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentComponent
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentRepository
 import org.thoughtcrime.securesms.help.HelpFragment
 import org.thoughtcrime.securesms.keyvalue.SettingsValues
 import org.thoughtcrime.securesms.keyvalue.SignalStore
@@ -18,10 +22,13 @@ private const val START_LOCATION = "app.settings.start.location"
 private const val NOTIFICATION_CATEGORY = "android.intent.category.NOTIFICATION_PREFERENCES"
 private const val STATE_WAS_CONFIGURATION_UPDATED = "app.settings.state.configuration.updated"
 
-class AppSettingsActivity : DSLSettingsActivity() {
+class AppSettingsActivity : DSLSettingsActivity(), DonationPaymentComponent {
 
   private var wasConfigurationUpdated = false
 
+  override val donationPaymentRepository: DonationPaymentRepository by lazy { DonationPaymentRepository(this) }
+  override val googlePayResultPublisher: Subject<DonationPaymentComponent.GooglePayResult> = PublishSubject.create()
+
   override fun onCreate(savedInstanceState: Bundle?, ready: Boolean) {
     if (intent?.hasExtra(ARG_NAV_GRAPH) != true) {
       intent?.putExtra(ARG_NAV_GRAPH, R.navigation.app_settings)
@@ -40,6 +47,8 @@ class AppSettingsActivity : DSLSettingsActivity() {
         StartLocation.PROXY -> AppSettingsFragmentDirections.actionDirectToEditProxyFragment()
         StartLocation.NOTIFICATIONS -> AppSettingsFragmentDirections.actionDirectToNotificationsSettingsFragment()
         StartLocation.CHANGE_NUMBER -> AppSettingsFragmentDirections.actionDirectToChangeNumberFragment()
+        StartLocation.SUBSCRIPTIONS -> AppSettingsFragmentDirections.actionDirectToSubscriptions().setSkipToSubscribe(true)
+        StartLocation.MANAGE_SUBSCRIPTIONS -> AppSettingsFragmentDirections.actionDirectToSubscriptions()
       }
     }
 
@@ -79,8 +88,12 @@ class AppSettingsActivity : DSLSettingsActivity() {
     }
   }
 
-  companion object {
+  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+    super.onActivityResult(requestCode, resultCode, data)
+    googlePayResultPublisher.onNext(DonationPaymentComponent.GooglePayResult(requestCode, resultCode, data))
+  }
 
+  companion object {
     @JvmStatic
     fun home(context: Context): Intent = getIntentForStartLocation(context, StartLocation.HOME)
 
@@ -102,6 +115,12 @@ class AppSettingsActivity : DSLSettingsActivity() {
     @JvmStatic
     fun changeNumber(context: Context): Intent = getIntentForStartLocation(context, StartLocation.CHANGE_NUMBER)
 
+    @JvmStatic
+    fun subscriptions(context: Context): Intent = getIntentForStartLocation(context, StartLocation.SUBSCRIPTIONS)
+
+    @JvmStatic
+    fun manageSubscriptions(context: Context): Intent = getIntentForStartLocation(context, StartLocation.MANAGE_SUBSCRIPTIONS)
+
     private fun getIntentForStartLocation(context: Context, startLocation: StartLocation): Intent {
       return Intent(context, AppSettingsActivity::class.java)
         .putExtra(ARG_NAV_GRAPH, R.navigation.app_settings)
@@ -115,7 +134,9 @@ class AppSettingsActivity : DSLSettingsActivity() {
     HELP(2),
     PROXY(3),
     NOTIFICATIONS(4),
-    CHANGE_NUMBER(5);
+    CHANGE_NUMBER(5),
+    SUBSCRIPTIONS(6),
+    MANAGE_SUBSCRIPTIONS(7);
 
     companion object {
       fun fromCode(code: Int?): StartLocation {

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

@@ -2,8 +2,9 @@ package org.thoughtcrime.securesms.components.settings.app
 
 import android.view.View
 import android.widget.TextView
-import androidx.lifecycle.ViewModelProvider
+import androidx.fragment.app.viewModels
 import androidx.navigation.Navigation
+import androidx.navigation.fragment.findNavController
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.badges.BadgeImageView
 import org.thoughtcrime.securesms.components.AvatarImageView
@@ -14,27 +15,40 @@ import org.thoughtcrime.securesms.components.settings.DSLSettingsIcon
 import org.thoughtcrime.securesms.components.settings.DSLSettingsText
 import org.thoughtcrime.securesms.components.settings.PreferenceModel
 import org.thoughtcrime.securesms.components.settings.PreferenceViewHolder
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
 import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.phonenumbers.PhoneNumberFormatter
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.FeatureFlags
 import org.thoughtcrime.securesms.util.MappingAdapter
 import org.thoughtcrime.securesms.util.MappingViewHolder
+import org.thoughtcrime.securesms.util.PlayServicesUtil
 
 class AppSettingsFragment : DSLSettingsFragment(R.string.text_secure_normal__menu_settings) {
 
+  private val viewModel: AppSettingsViewModel by viewModels(
+    factoryProducer = {
+      AppSettingsViewModel.Factory(SubscriptionsRepository(ApplicationDependencies.getDonationsService()))
+    }
+  )
+
   override fun bindAdapter(adapter: DSLSettingsAdapter) {
     adapter.registerFactory(BioPreference::class.java, MappingAdapter.LayoutFactory(::BioPreferenceViewHolder, R.layout.bio_preference_item))
     adapter.registerFactory(PaymentsPreference::class.java, MappingAdapter.LayoutFactory(::PaymentsPreferenceViewHolder, R.layout.dsl_payments_preference))
-
-    val viewModel = ViewModelProvider(this)[AppSettingsViewModel::class.java]
+    adapter.registerFactory(SubscriptionPreference::class.java, MappingAdapter.LayoutFactory(::SubscriptionPreferenceViewHolder, R.layout.dsl_preference_item))
 
     viewModel.state.observe(viewLifecycleOwner) { state ->
       adapter.submitList(getConfiguration(state).toMappingModelList())
     }
   }
 
+  override fun onResume() {
+    super.onResume()
+    viewModel.refreshActiveSubscription()
+  }
+
   private fun getConfiguration(state: AppSettingsState): DSLConfiguration {
     return configure {
 
@@ -130,11 +144,41 @@ class AppSettingsFragment : DSLSettingsFragment(R.string.text_secure_normal__men
         }
       )
 
-      externalLinkPref(
-        title = DSLSettingsText.from(R.string.preferences__donate_to_signal),
-        icon = DSLSettingsIcon.from(R.drawable.ic_heart_24),
-        linkId = R.string.donate_url
-      )
+      if (FeatureFlags.donorBadges() && PlayServicesUtil.getPlayServicesStatus(requireContext()) == PlayServicesUtil.PlayServicesStatus.SUCCESS) {
+        customPref(
+          SubscriptionPreference(
+            title = DSLSettingsText.from(
+              if (state.hasActiveSubscription) {
+                R.string.preferences__subscription
+              } else {
+                R.string.preferences__become_a_signal_sustainer
+              }
+            ),
+            icon = DSLSettingsIcon.from(R.drawable.ic_heart_24),
+            isActive = state.hasActiveSubscription,
+            onClick = { isActive ->
+              findNavController()
+                .navigate(
+                  AppSettingsFragmentDirections.actionAppSettingsFragmentToSubscriptions()
+                    .setSkipToSubscribe(!isActive)
+                )
+            }
+          )
+        )
+        clickPref(
+          title = DSLSettingsText.from(R.string.preferences__signal_boost),
+          icon = DSLSettingsIcon.from(R.drawable.ic_boost_24),
+          onClick = {
+            findNavController().navigate(R.id.action_appSettingsFragment_to_boostsFragment)
+          }
+        )
+      } else {
+        externalLinkPref(
+          title = DSLSettingsText.from(R.string.preferences__donate_to_signal),
+          icon = DSLSettingsIcon.from(R.drawable.ic_heart_24),
+          linkId = R.string.donate_url
+        )
+      }
 
       if (FeatureFlags.internalUser()) {
         dividerPref()
@@ -149,6 +193,30 @@ class AppSettingsFragment : DSLSettingsFragment(R.string.text_secure_normal__men
     }
   }
 
+  private class SubscriptionPreference(
+    override val title: DSLSettingsText,
+    override val summary: DSLSettingsText? = null,
+    override val icon: DSLSettingsIcon? = null,
+    override val isEnabled: Boolean = true,
+    val isActive: Boolean = false,
+    val onClick: (Boolean) -> Unit
+  ) : PreferenceModel<SubscriptionPreference>() {
+    override fun areItemsTheSame(newItem: SubscriptionPreference): Boolean {
+      return true
+    }
+
+    override fun areContentsTheSame(newItem: SubscriptionPreference): Boolean {
+      return super.areContentsTheSame(newItem) && isActive == newItem.isActive
+    }
+  }
+
+  private class SubscriptionPreferenceViewHolder(itemView: View) : PreferenceViewHolder<SubscriptionPreference>(itemView) {
+    override fun bind(model: SubscriptionPreference) {
+      super.bind(model)
+      itemView.setOnClickListener { model.onClick(model.isActive) }
+    }
+  }
+
   private class BioPreference(val recipient: Recipient, val onClick: () -> Unit) : PreferenceModel<BioPreference>() {
     override fun areContentsTheSame(newItem: BioPreference): Boolean {
       return super.areContentsTheSame(newItem) && recipient.hasSameContent(newItem.recipient)

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

@@ -2,4 +2,8 @@ package org.thoughtcrime.securesms.components.settings.app
 
 import org.thoughtcrime.securesms.recipients.Recipient
 
-data class AppSettingsState(val self: Recipient, val unreadPaymentsCount: Int)
+data class AppSettingsState(
+  val self: Recipient,
+  val unreadPaymentsCount: Int,
+  val hasActiveSubscription: Boolean
+)

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

@@ -2,18 +2,55 @@ package org.thoughtcrime.securesms.components.settings.app
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
 import org.thoughtcrime.securesms.conversationlist.model.UnreadPaymentsLiveData
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.util.livedata.LiveDataUtil
+import org.thoughtcrime.securesms.util.FeatureFlags
+import org.thoughtcrime.securesms.util.livedata.Store
+import java.util.concurrent.TimeUnit
 
-class AppSettingsViewModel : ViewModel() {
+class AppSettingsViewModel(private val subscriptionsRepository: SubscriptionsRepository) : ViewModel() {
 
-  val unreadPaymentsLiveData = UnreadPaymentsLiveData()
-  val selfLiveData: LiveData<Recipient> = Recipient.self().live().liveData
+  private val store = Store(AppSettingsState(Recipient.self(), 0, false))
 
-  val state: LiveData<AppSettingsState> = LiveDataUtil.combineLatest(unreadPaymentsLiveData, selfLiveData) { payments, self ->
-    val unreadPaymentsCount = payments.transform { it.unreadCount }.or(0)
+  private val unreadPaymentsLiveData = UnreadPaymentsLiveData()
+  private val selfLiveData: LiveData<Recipient> = Recipient.self().live().liveData
 
-    AppSettingsState(self, unreadPaymentsCount)
+  val state: LiveData<AppSettingsState> = store.stateLiveData
+
+  init {
+    store.update(unreadPaymentsLiveData) { payments, state -> state.copy(unreadPaymentsCount = payments.transform { it.unreadCount }.or(0)) }
+    store.update(selfLiveData) { self, state -> state.copy(self = self) }
+  }
+
+  fun refreshActiveSubscription() {
+    if (!FeatureFlags.donorBadges()) {
+      return
+    }
+
+    store.update {
+      it.copy(hasActiveSubscription = TimeUnit.SECONDS.toMillis(SignalStore.donationsValues().getLastEndOfPeriod()) > System.currentTimeMillis())
+    }
+
+    subscriptionsRepository.getActiveSubscription().subscribeBy(
+      onSuccess = { subscription -> store.update { it.copy(hasActiveSubscription = subscription.isActive) } },
+      onError = { throwable ->
+        Log.w(TAG, "Could not load active subscription", throwable)
+      }
+    )
+  }
+
+  class Factory(private val subscriptionsRepository: SubscriptionsRepository) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+      return modelClass.cast(AppSettingsViewModel(subscriptionsRepository)) as T
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(AppSettingsViewModel::class.java)
   }
 }

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

@@ -10,9 +10,9 @@ import org.thoughtcrime.securesms.components.settings.app.changenumber.ChangeNum
 import org.thoughtcrime.securesms.components.settings.app.changenumber.ChangeNumberUtil.getCaptchaArguments
 import org.thoughtcrime.securesms.components.settings.app.changenumber.ChangeNumberUtil.getViewModel
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.thoughtcrime.securesms.registration.fragments.BaseEnterCodeFragment
+import org.thoughtcrime.securesms.registration.fragments.BaseEnterSmsCodeFragment
 
-class ChangeNumberEnterCodeFragment : BaseEnterCodeFragment<ChangeNumberViewModel>(R.layout.fragment_change_number_enter_code) {
+class ChangeNumberEnterSmsCodeFragment : BaseEnterSmsCodeFragment<ChangeNumberViewModel>(R.layout.fragment_change_number_enter_code) {
 
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
     super.onViewCreated(view, savedInstanceState)
@@ -54,10 +54,10 @@ class ChangeNumberEnterCodeFragment : BaseEnterCodeFragment<ChangeNumberViewMode
   }
 
   override fun navigateToRegistrationLock(timeRemaining: Long) {
-    findNavController().navigate(ChangeNumberEnterCodeFragmentDirections.actionChangeNumberEnterCodeFragmentToChangeNumberRegistrationLock(timeRemaining))
+    findNavController().navigate(ChangeNumberEnterSmsCodeFragmentDirections.actionChangeNumberEnterCodeFragmentToChangeNumberRegistrationLock(timeRemaining))
   }
 
   override fun navigateToKbsAccountLocked() {
-    findNavController().navigate(ChangeNumberEnterCodeFragmentDirections.actionChangeNumberEnterCodeFragmentToChangeNumberAccountLocked())
+    findNavController().navigate(ChangeNumberEnterSmsCodeFragmentDirections.actionChangeNumberEnterCodeFragmentToChangeNumberAccountLocked())
   }
 }

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

@@ -9,6 +9,7 @@ import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
 import org.thoughtcrime.securesms.components.settings.DSLSettingsFragment
 import org.thoughtcrime.securesms.components.settings.DSLSettingsText
 import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.mms.SentMediaQuality
 import org.thoughtcrime.securesms.util.Util
 import org.thoughtcrime.securesms.webrtc.CallBandwidthMode
 import kotlin.math.abs
@@ -18,6 +19,8 @@ class DataAndStorageSettingsFragment : DSLSettingsFragment(R.string.preferences_
   private val autoDownloadValues by lazy { resources.getStringArray(R.array.pref_media_download_entries) }
   private val autoDownloadLabels by lazy { resources.getStringArray(R.array.pref_media_download_values) }
 
+  private val sentMediaQualityLabels by lazy { SentMediaQuality.getLabels(requireContext()) }
+
   private val callBandwidthLabels by lazy { resources.getStringArray(R.array.pref_data_and_storage_call_bandwidth_values) }
 
   private lateinit var viewModel: DataAndStorageSettingsViewModel
@@ -84,6 +87,21 @@ class DataAndStorageSettingsFragment : DSLSettingsFragment(R.string.preferences_
 
       dividerPref()
 
+      sectionHeaderPref(R.string.DataAndStorageSettingsFragment__media_quality)
+
+      radioListPref(
+        title = DSLSettingsText.from(R.string.DataAndStorageSettingsFragment__sent_media_quality),
+        listItems = sentMediaQualityLabels,
+        selected = SentMediaQuality.values().indexOf(state.sentMediaQuality),
+        onSelected = { viewModel.setSentMediaQuality(SentMediaQuality.values()[it]) }
+      )
+
+      textPref(
+        summary = DSLSettingsText.from(R.string.DataAndStorageSettingsFragment__sending_high_quality_media_will_use_more_data)
+      )
+
+      dividerPref()
+
       sectionHeaderPref(R.string.DataAndStorageSettingsFragment__calls)
 
       radioListPref(

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

@@ -1,5 +1,6 @@
 package org.thoughtcrime.securesms.components.settings.app.data
 
+import org.thoughtcrime.securesms.mms.SentMediaQuality
 import org.thoughtcrime.securesms.webrtc.CallBandwidthMode
 
 data class DataAndStorageSettingsState(
@@ -8,5 +9,6 @@ data class DataAndStorageSettingsState(
   val wifiAutoDownloadValues: Set<String>,
   val roamingAutoDownloadValues: Set<String>,
   val callBandwidthMode: CallBandwidthMode,
-  val isProxyEnabled: Boolean
+  val isProxyEnabled: Boolean,
+  val sentMediaQuality: SentMediaQuality
 )

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

@@ -6,6 +6,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.mms.SentMediaQuality
 import org.thoughtcrime.securesms.util.TextSecurePreferences
 import org.thoughtcrime.securesms.util.livedata.Store
 import org.thoughtcrime.securesms.webrtc.CallBandwidthMode
@@ -46,6 +47,11 @@ class DataAndStorageSettingsViewModel(
     getStateAndCopyStorageUsage()
   }
 
+  fun setSentMediaQuality(sentMediaQuality: SentMediaQuality) {
+    SignalStore.settings().sentMediaQuality = sentMediaQuality
+    getStateAndCopyStorageUsage()
+  }
+
   private fun getStateAndCopyStorageUsage() {
     store.update { getState().copy(totalStorageUse = it.totalStorageUse) }
   }
@@ -62,7 +68,8 @@ class DataAndStorageSettingsViewModel(
       ApplicationDependencies.getApplication()
     ),
     callBandwidthMode = SignalStore.settings().callBandwidthMode,
-    isProxyEnabled = SignalStore.proxy().isProxyEnabled
+    isProxyEnabled = SignalStore.proxy().isProxyEnabled,
+    sentMediaQuality = SignalStore.settings().sentMediaQuality
   )
 
   class Factory(

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

@@ -18,13 +18,17 @@ import org.thoughtcrime.securesms.components.settings.configure
 import org.thoughtcrime.securesms.database.DatabaseFactory
 import org.thoughtcrime.securesms.database.LocalMetricsDatabase
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.jobs.DownloadLatestEmojiDataJob
 import org.thoughtcrime.securesms.jobs.RefreshAttributesJob
 import org.thoughtcrime.securesms.jobs.RefreshOwnProfileJob
 import org.thoughtcrime.securesms.jobs.RemoteConfigRefreshJob
 import org.thoughtcrime.securesms.jobs.RotateProfileKeyJob
 import org.thoughtcrime.securesms.jobs.StorageForcePushJob
+import org.thoughtcrime.securesms.jobs.SubscriptionReceiptRequestResponseJob
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.payments.DataExportUtil
 import org.thoughtcrime.securesms.util.ConversationUtil
+import org.thoughtcrime.securesms.util.FeatureFlags
 import org.thoughtcrime.securesms.util.concurrent.SimpleTask
 
 class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__internal_preferences) {
@@ -234,6 +238,14 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
         }
       )
 
+      clickPref(
+        title = DSLSettingsText.from(R.string.preferences__internal_force_emoji_download),
+        summary = DSLSettingsText.from(R.string.preferences__internal_force_emoji_download_description),
+        onClick = {
+          ApplicationDependencies.getJobManager().add(DownloadLatestEmojiDataJob(true))
+        }
+      )
+
       dividerPref()
 
       sectionHeaderPref(R.string.preferences__internal_sender_key)
@@ -308,6 +320,17 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
             }
           )
         }
+
+      if (FeatureFlags.donorBadges() && SignalStore.donationsValues().getSubscriber() != null) {
+        sectionHeaderPref(R.string.preferences__internal_badges)
+
+        clickPref(
+          title = DSLSettingsText.from(R.string.preferences__internal_badges_enqueue_redemption),
+          onClick = {
+            enqueueSubscriptionRedemption()
+          }
+        )
+      }
     }
   }
 
@@ -390,4 +413,8 @@ class InternalSettingsFragment : DSLSettingsFragment(R.string.preferences__inter
     LocalMetricsDatabase.getInstance(ApplicationDependencies.getApplication()).clear()
     Toast.makeText(context, "Cleared all local metrics state.", Toast.LENGTH_SHORT).show()
   }
+
+  private fun enqueueSubscriptionRedemption() {
+    SubscriptionReceiptRequestResponseJob.createSubscriptionContinuationJobChain().enqueue()
+  }
 }

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

@@ -0,0 +1,16 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+import org.thoughtcrime.securesms.badges.models.Badge
+
+/**
+ * Events that can arise from use of the donations apis.
+ */
+sealed class DonationEvent {
+  class GooglePayUnavailableError(val throwable: Throwable) : DonationEvent()
+  object RequestTokenSuccess : DonationEvent()
+  object RequestTokenError : DonationEvent()
+  class PaymentConfirmationError(val throwable: Throwable) : DonationEvent()
+  class PaymentConfirmationSuccess(val badge: Badge) : DonationEvent()
+  class SubscriptionCancellationFailed(val throwable: Throwable) : DonationEvent()
+  object SubscriptionCancelled : DonationEvent()
+}

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

@@ -0,0 +1,6 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+class DonationExceptions {
+  object TimedOutWaitingForTokenRedemption : Exception()
+  object RedemptionFailed : Exception()
+}

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

@@ -0,0 +1,11 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+import android.content.Intent
+import io.reactivex.rxjava3.subjects.Subject
+
+interface DonationPaymentComponent {
+  val donationPaymentRepository: DonationPaymentRepository
+  val googlePayResultPublisher: Subject<GooglePayResult>
+
+  class GooglePayResult(val requestCode: Int, val resultCode: Int, val data: Intent?)
+}

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

@@ -0,0 +1,301 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.ConnectivityManager
+import com.google.android.gms.wallet.PaymentData
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.schedulers.Schedulers
+import org.signal.core.util.concurrent.SignalExecutors
+import org.signal.core.util.logging.Log
+import org.signal.core.util.money.FiatMoney
+import org.signal.donations.GooglePayApi
+import org.signal.donations.GooglePayPaymentSource
+import org.signal.donations.StripeApi
+import org.thoughtcrime.securesms.database.DatabaseFactory
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.jobmanager.JobTracker
+import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint
+import org.thoughtcrime.securesms.jobs.BoostReceiptRequestResponseJob
+import org.thoughtcrime.securesms.jobs.SubscriptionReceiptRequestResponseJob
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.storage.StorageSyncHelper
+import org.thoughtcrime.securesms.subscription.LevelUpdate
+import org.thoughtcrime.securesms.subscription.LevelUpdateOperation
+import org.thoughtcrime.securesms.subscription.Subscriber
+import org.thoughtcrime.securesms.util.Environment
+import org.whispersystems.signalservice.api.subscriptions.IdempotencyKey
+import org.whispersystems.signalservice.api.subscriptions.SubscriberId
+import org.whispersystems.signalservice.api.subscriptions.SubscriptionClientSecret
+import org.whispersystems.signalservice.internal.EmptyResponse
+import org.whispersystems.signalservice.internal.ServiceResponse
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * Manages bindings with payment APIs
+ *
+ * Steps for setting up payments for a subscription:
+ * 1. Ask GooglePay for a payment token. This will pop up the Google Pay Sheet, which allows the user to select a payment method.
+ * 1. Generate and send a SubscriberId, which is a 32 byte ID representing this user, to Signal Service, which creates a Stripe Customer
+ * 1. Create a SetupIntent via the Stripe API
+ * 1. Create a PaymentMethod vai the Stripe API, utilizing the token from Google Pay
+ * 1. Confirm the SetupIntent via the Stripe API
+ * 1. Set the default PaymentMethod for the customer, using the PaymentMethod id, via the Signal service
+ *
+ * For Boosts:
+ * 1. Ask GooglePay for a payment token. This will pop up the Google Pay Sheet, which allows the user to select a payment method.
+ * 1. Create a PaymentIntent via the Stripe API
+ * 1. Create a PaymentMethod vai the Stripe API, utilizing the token from Google Pay
+ * 1. Confirm the PaymentIntent via the Stripe API
+ */
+class DonationPaymentRepository(activity: Activity) : StripeApi.PaymentIntentFetcher, StripeApi.SetupIntentHelper {
+
+  private val application = activity.application
+  private val googlePayApi = GooglePayApi(activity, StripeApi.Gateway(Environment.Donations.STRIPE_CONFIGURATION), Environment.Donations.GOOGLE_PAY_CONFIGURATION)
+  private val stripeApi = StripeApi(Environment.Donations.STRIPE_CONFIGURATION, this, this, ApplicationDependencies.getOkHttpClient())
+
+  fun isGooglePayAvailable(): Completable = googlePayApi.queryIsReadyToPay()
+
+  fun scheduleSyncForAccountRecordChange() {
+    SignalExecutors.BOUNDED.execute {
+      scheduleSyncForAccountRecordChangeSync()
+    }
+  }
+
+  fun scheduleSyncForAccountRecordChangeSync() {
+    DatabaseFactory.getRecipientDatabase(application).markNeedsSync(Recipient.self().id)
+    StorageSyncHelper.scheduleSyncForDataChange()
+  }
+
+  fun internetConnectionObserver(): Observable<Boolean> = Observable.create {
+    val observer = object : BroadcastReceiver() {
+      override fun onReceive(context: Context?, intent: Intent?) {
+        if (!it.isDisposed) {
+          it.onNext(NetworkConstraint.isMet(application))
+        }
+      }
+    }
+
+    it.setCancellable { application.unregisterReceiver(observer) }
+    application.registerReceiver(observer, IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION))
+  }
+
+  fun requestTokenFromGooglePay(price: FiatMoney, label: String, requestCode: Int) {
+    googlePayApi.requestPayment(price, label, requestCode)
+  }
+
+  fun onActivityResult(
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?,
+    expectedRequestCode: Int,
+    paymentsRequestCallback: GooglePayApi.PaymentRequestCallback
+  ) {
+    googlePayApi.onActivityResult(requestCode, resultCode, data, expectedRequestCode, paymentsRequestCallback)
+  }
+
+  fun continuePayment(price: FiatMoney, paymentData: PaymentData): Completable {
+    return stripeApi.createPaymentIntent(price)
+      .flatMapCompletable { result ->
+        when (result) {
+          is StripeApi.CreatePaymentIntentResult.AmountIsTooSmall -> Completable.error(Exception("Boost amount is too small"))
+          is StripeApi.CreatePaymentIntentResult.AmountIsTooLarge -> Completable.error(Exception("Boost amount is too large"))
+          is StripeApi.CreatePaymentIntentResult.CurrencyIsNotSupported -> Completable.error(Exception("Boost currency is not supported"))
+          is StripeApi.CreatePaymentIntentResult.Success -> confirmPayment(paymentData, result.paymentIntent)
+        }
+      }
+  }
+
+  fun continueSubscriptionSetup(paymentData: PaymentData): Completable {
+    return stripeApi.createSetupIntent()
+      .flatMapCompletable { result ->
+        stripeApi.confirmSetupIntent(GooglePayPaymentSource(paymentData), result.setupIntent)
+      }
+  }
+
+  fun cancelActiveSubscription(): Completable {
+    val localSubscriber = SignalStore.donationsValues().requireSubscriber()
+    return ApplicationDependencies.getDonationsService()
+      .cancelSubscription(localSubscriber.subscriberId)
+      .flatMap(ServiceResponse<EmptyResponse>::flattenResult).ignoreElement()
+  }
+
+  fun ensureSubscriberId(): Completable {
+    val subscriberId = SignalStore.donationsValues().getSubscriber()?.subscriberId ?: SubscriberId.generate()
+    return ApplicationDependencies
+      .getDonationsService()
+      .putSubscription(subscriberId)
+      .flatMap(ServiceResponse<EmptyResponse>::flattenResult).ignoreElement()
+      .doOnComplete {
+        SignalStore
+          .donationsValues()
+          .setSubscriber(Subscriber(subscriberId, SignalStore.donationsValues().getSubscriptionCurrency().currencyCode))
+
+        scheduleSyncForAccountRecordChangeSync()
+      }
+  }
+
+  private fun confirmPayment(paymentData: PaymentData, paymentIntent: StripeApi.PaymentIntent): Completable {
+    return Completable.create {
+      stripeApi.confirmPaymentIntent(GooglePayPaymentSource(paymentData), paymentIntent).blockingSubscribe()
+
+      val countDownLatch = CountDownLatch(1)
+      var finalJobState: JobTracker.JobState? = null
+
+      BoostReceiptRequestResponseJob.createJobChain(paymentIntent).enqueue { _, jobState ->
+        if (jobState.isComplete) {
+          finalJobState = jobState
+          countDownLatch.countDown()
+        }
+      }
+
+      try {
+        if (countDownLatch.await(10, TimeUnit.SECONDS)) {
+          when (finalJobState) {
+            JobTracker.JobState.SUCCESS -> {
+              Log.d(TAG, "Boost request response job chain succeeded.", true)
+              it.onComplete()
+            }
+            JobTracker.JobState.FAILURE -> {
+              Log.d(TAG, "Boost request response job chain failed permanently.", true)
+              it.onError(DonationExceptions.RedemptionFailed)
+            }
+            else -> {
+              Log.d(TAG, "Boost request response job chain ignored due to in-progress jobs.", true)
+              it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+            }
+          }
+        } else {
+          it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+        }
+      } catch (e: InterruptedException) {
+        it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+      }
+    }
+  }
+
+  fun setSubscriptionLevel(subscriptionLevel: String): Completable {
+    return getOrCreateLevelUpdateOperation(subscriptionLevel)
+      .flatMapCompletable { levelUpdateOperation ->
+        val subscriber = SignalStore.donationsValues().requireSubscriber()
+
+        Log.d(TAG, "Attempting to set user subscription level to $subscriptionLevel", true)
+        ApplicationDependencies.getDonationsService().updateSubscriptionLevel(
+          subscriber.subscriberId,
+          subscriptionLevel,
+          subscriber.currencyCode,
+          levelUpdateOperation.idempotencyKey.serialize(),
+          SubscriptionReceiptRequestResponseJob.MUTEX
+        ).flatMapCompletable {
+          if (it.status == 200 || it.status == 204) {
+            Log.d(TAG, "Successfully set user subscription to level $subscriptionLevel with response code ${it.status}", true)
+            SignalStore.donationsValues().clearUserManuallyCancelled()
+            SignalStore.donationsValues().clearLevelOperations()
+            LevelUpdate.updateProcessingState(false)
+            Completable.complete()
+          } else {
+            if (it.applicationError.isPresent) {
+              Log.w(TAG, "Failed to set user subscription to level $subscriptionLevel with response code ${it.status}", it.applicationError.get(), true)
+              SignalStore.donationsValues().clearLevelOperations()
+            } else {
+              Log.w(TAG, "Failed to set user subscription to level $subscriptionLevel", it.executionError.orNull(), true)
+            }
+
+            LevelUpdate.updateProcessingState(false)
+            it.flattenResult().ignoreElement()
+          }
+        }.andThen {
+          Log.d(TAG, "Enqueuing request response job chain.", true)
+          val countDownLatch = CountDownLatch(1)
+          var finalJobState: JobTracker.JobState? = null
+
+          SubscriptionReceiptRequestResponseJob.createSubscriptionContinuationJobChain().enqueue { _, jobState ->
+            if (jobState.isComplete) {
+              finalJobState = jobState
+              countDownLatch.countDown()
+            }
+          }
+
+          try {
+            if (countDownLatch.await(10, TimeUnit.SECONDS)) {
+              when (finalJobState) {
+                JobTracker.JobState.SUCCESS -> {
+                  Log.d(TAG, "Subscription request response job chain succeeded.", true)
+                  it.onComplete()
+                }
+                JobTracker.JobState.FAILURE -> {
+                  Log.d(TAG, "Subscription request response job chain failed permanently.", true)
+                  it.onError(DonationExceptions.RedemptionFailed)
+                }
+                else -> {
+                  Log.d(TAG, "Subscription request response job chain ignored due to in-progress jobs.", true)
+                  it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+                }
+              }
+            } else {
+              Log.d(TAG, "Subscription request response job timed out.", true)
+              it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+            }
+          } catch (e: InterruptedException) {
+            Log.w(TAG, "Subscription request response interrupted.", e, true)
+            it.onError(DonationExceptions.TimedOutWaitingForTokenRedemption)
+          }
+        }
+      }.doOnError {
+        LevelUpdate.updateProcessingState(false)
+      }.subscribeOn(Schedulers.io())
+  }
+
+  private fun getOrCreateLevelUpdateOperation(subscriptionLevel: String): Single<LevelUpdateOperation> = Single.fromCallable {
+    val levelUpdateOperation = SignalStore.donationsValues().getLevelOperation(subscriptionLevel)
+    if (levelUpdateOperation == null) {
+      val newOperation = LevelUpdateOperation(
+        idempotencyKey = IdempotencyKey.generate(),
+        level = subscriptionLevel
+      )
+
+      SignalStore.donationsValues().setLevelOperation(newOperation)
+      LevelUpdate.updateProcessingState(true)
+      newOperation
+    } else {
+      LevelUpdate.updateProcessingState(true)
+      levelUpdateOperation
+    }
+  }
+
+  override fun fetchPaymentIntent(price: FiatMoney, description: String?): Single<StripeApi.PaymentIntent> {
+    return ApplicationDependencies
+      .getDonationsService()
+      .createDonationIntentWithAmount(price.minimumUnitPrecisionString, price.currency.currencyCode)
+      .flatMap(ServiceResponse<SubscriptionClientSecret>::flattenResult)
+      .map {
+        StripeApi.PaymentIntent(it.id, it.clientSecret)
+      }
+  }
+
+  override fun fetchSetupIntent(): Single<StripeApi.SetupIntent> {
+    return Single.fromCallable { SignalStore.donationsValues().requireSubscriber() }
+      .flatMap { ApplicationDependencies.getDonationsService().createSubscriptionPaymentMethod(it.subscriberId) }
+      .flatMap(ServiceResponse<SubscriptionClientSecret>::flattenResult)
+      .map { StripeApi.SetupIntent(it.id, it.clientSecret) }
+  }
+
+  override fun setDefaultPaymentMethod(paymentMethodId: String): Completable {
+    return Single.fromCallable {
+      SignalStore.donationsValues().requireSubscriber()
+    }.flatMap {
+      ApplicationDependencies.getDonationsService().setDefaultPaymentMethodId(it.subscriberId, paymentMethodId)
+    }.flatMap(ServiceResponse<EmptyResponse>::flattenResult).ignoreElement()
+  }
+
+  companion object {
+    private val TAG = Log.tag(DonationPaymentRepository::class.java)
+  }
+}

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

@@ -0,0 +1,53 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+import io.reactivex.rxjava3.core.Single
+import org.signal.core.util.money.FiatMoney
+import org.thoughtcrime.securesms.badges.Badges
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
+import org.whispersystems.signalservice.api.services.DonationsService
+import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+import org.whispersystems.signalservice.api.subscriptions.SubscriptionLevels
+import org.whispersystems.signalservice.internal.ServiceResponse
+import java.util.Currency
+import java.util.Locale
+
+/**
+ * Repository which can query for the user's active subscription as well as a list of available subscriptions,
+ * in the currency indicated.
+ */
+class SubscriptionsRepository(private val donationsService: DonationsService) {
+
+  fun getActiveSubscription(): Single<ActiveSubscription> {
+    val localSubscription = SignalStore.donationsValues().getSubscriber()
+    return if (localSubscription != null) {
+      donationsService.getSubscription(localSubscription.subscriberId)
+        .flatMap(ServiceResponse<ActiveSubscription>::flattenResult)
+    } else {
+      Single.just(ActiveSubscription(null))
+    }
+  }
+
+  fun getSubscriptions(): Single<List<Subscription>> = donationsService.getSubscriptionLevels(Locale.getDefault())
+    .flatMap(ServiceResponse<SubscriptionLevels>::flattenResult)
+    .map { subscriptionLevels ->
+      subscriptionLevels.levels.map { (code, level) ->
+        Subscription(
+          id = code,
+          name = level.name,
+          badge = Badges.fromServiceBadge(level.badge),
+          prices = level.currencies.filter {
+            PlatformCurrencyUtil
+              .getAvailableCurrencyCodes()
+              .contains(it.key)
+          }.map { (currencyCode, price) ->
+            FiatMoney(price, Currency.getInstance(currencyCode))
+          }.toSet(),
+          level = code.toInt()
+        )
+      }.sortedBy {
+        it.level
+      }
+    }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/boost/Boost.kt

@@ -0,0 +1,246 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.boost
+
+import android.animation.Animator
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.text.Editable
+import android.text.Spanned
+import android.text.TextWatcher
+import android.text.method.DigitsKeyListener
+import android.view.View
+import androidx.annotation.VisibleForTesting
+import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.animation.doOnEnd
+import androidx.core.text.isDigitsOnly
+import androidx.core.widget.addTextChangedListener
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.google.android.material.button.MaterialButton
+import org.signal.core.util.money.FiatMoney
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.payments.FiatMoneyUtil
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+import org.thoughtcrime.securesms.util.ViewUtil
+import java.lang.Integer.min
+import java.text.DecimalFormatSymbols
+import java.util.Currency
+import java.util.Locale
+import java.util.regex.Pattern
+
+/**
+ * A Signal Boost is a one-time ephemeral show of support. Each boost level
+ * can unlock a corresponding badge for a time determined by the server.
+ */
+data class Boost(
+  val price: FiatMoney
+) {
+
+  /**
+   * A heading containing a 96dp rendering of the boost's badge.
+   */
+  class HeadingModel(
+    val boostBadge: Badge
+  ) : PreferenceModel<HeadingModel>() {
+    override fun areItemsTheSame(newItem: HeadingModel): Boolean = true
+
+    override fun areContentsTheSame(newItem: HeadingModel): Boolean {
+      return super.areContentsTheSame(newItem) && newItem.boostBadge == boostBadge
+    }
+  }
+
+  class LoadingModel : PreferenceModel<LoadingModel>() {
+    override fun areItemsTheSame(newItem: LoadingModel): Boolean = true
+  }
+
+  class LoadingViewHolder(itemView: View) : MappingViewHolder<LoadingModel>(itemView), DefaultLifecycleObserver {
+
+    private val animator: Animator = AnimatorSet().apply {
+      val fadeTo25Animator = ObjectAnimator.ofFloat(itemView, "alpha", 0.8f, 0.25f).apply {
+        duration = 1000L
+      }
+
+      val fadeTo80Animator = ObjectAnimator.ofFloat(itemView, "alpha", 0.25f, 0.8f).apply {
+        duration = 300L
+      }
+
+      playSequentially(fadeTo25Animator, fadeTo80Animator)
+      doOnEnd { start() }
+    }
+
+    init {
+      lifecycle.addObserver(this)
+    }
+
+    override fun bind(model: LoadingModel) {
+    }
+
+    override fun onResume(owner: LifecycleOwner) {
+      if (animator.isStarted) {
+        animator.resume()
+      } else {
+        animator.start()
+      }
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+      animator.pause()
+    }
+  }
+
+  /**
+   * A widget that allows a user to select from six different amounts, or enter a custom amount.
+   */
+  class SelectionModel(
+    val boosts: List<Boost>,
+    val selectedBoost: Boost?,
+    val currency: Currency,
+    override val isEnabled: Boolean,
+    val onBoostClick: (View, Boost) -> Unit,
+    val isCustomAmountFocused: Boolean,
+    val onCustomAmountChanged: (String) -> Unit,
+    val onCustomAmountFocusChanged: (Boolean) -> Unit,
+  ) : PreferenceModel<SelectionModel>(isEnabled = isEnabled) {
+    override fun areItemsTheSame(newItem: SelectionModel): Boolean = true
+
+    override fun areContentsTheSame(newItem: SelectionModel): Boolean {
+      return super.areContentsTheSame(newItem) &&
+        newItem.boosts == boosts &&
+        newItem.selectedBoost == selectedBoost &&
+        newItem.currency == currency &&
+        newItem.isCustomAmountFocused == isCustomAmountFocused
+    }
+  }
+
+  private class SelectionViewHolder(itemView: View) : MappingViewHolder<SelectionModel>(itemView) {
+
+    private val boost1: MaterialButton = itemView.findViewById(R.id.boost_1)
+    private val boost2: MaterialButton = itemView.findViewById(R.id.boost_2)
+    private val boost3: MaterialButton = itemView.findViewById(R.id.boost_3)
+    private val boost4: MaterialButton = itemView.findViewById(R.id.boost_4)
+    private val boost5: MaterialButton = itemView.findViewById(R.id.boost_5)
+    private val boost6: MaterialButton = itemView.findViewById(R.id.boost_6)
+    private val custom: AppCompatEditText = itemView.findViewById(R.id.boost_custom)
+
+    private var filter: MoneyFilter? = null
+
+    init {
+      custom.filters = emptyArray()
+    }
+
+    override fun bind(model: SelectionModel) {
+      itemView.isEnabled = model.isEnabled
+
+      model.boosts.zip(listOf(boost1, boost2, boost3, boost4, boost5, boost6)).forEach { (boost, button) ->
+        button.isSelected = boost == model.selectedBoost && !model.isCustomAmountFocused
+        button.text = FiatMoneyUtil.format(
+          context.resources,
+          boost.price,
+          FiatMoneyUtil
+            .formatOptions()
+            .numberOnly()
+            .trimZerosAfterDecimal()
+        )
+        button.setOnClickListener {
+          model.onBoostClick(it, boost)
+          custom.clearFocus()
+        }
+      }
+
+      if (filter == null || filter?.currency != model.currency) {
+        custom.removeTextChangedListener(filter)
+
+        filter = MoneyFilter(model.currency) {
+          model.onCustomAmountChanged(it)
+        }
+
+        custom.keyListener = filter
+        custom.addTextChangedListener(filter)
+
+        custom.setText("")
+      }
+
+      custom.setOnFocusChangeListener { _, hasFocus ->
+        model.onCustomAmountFocusChanged(hasFocus)
+      }
+
+      if (model.isCustomAmountFocused && !custom.hasFocus()) {
+        ViewUtil.focusAndShowKeyboard(custom)
+      } else if (!model.isCustomAmountFocused && custom.hasFocus()) {
+        ViewUtil.hideKeyboard(context, custom)
+        custom.clearFocus()
+      }
+    }
+  }
+
+  private class HeadingViewHolder(itemView: View) : MappingViewHolder<HeadingModel>(itemView) {
+
+    private val badgeImageView: BadgeImageView = itemView as BadgeImageView
+
+    override fun bind(model: HeadingModel) {
+      badgeImageView.setBadge(model.boostBadge)
+    }
+  }
+
+  @VisibleForTesting
+  class MoneyFilter(val currency: Currency, private val onCustomAmountChanged: (String) -> Unit = {}) : DigitsKeyListener(false, true), TextWatcher {
+
+    val separator = DecimalFormatSymbols.getInstance().decimalSeparator
+    val separatorCount = min(1, currency.defaultFractionDigits)
+    val prefix: String = currency.getSymbol(Locale.getDefault())
+    val pattern: Pattern = "[0-9]*($separator){0,$separatorCount}[0-9]{0,${currency.defaultFractionDigits}}".toPattern()
+
+    override fun filter(
+      source: CharSequence,
+      start: Int,
+      end: Int,
+      dest: Spanned,
+      dstart: Int,
+      dend: Int
+    ): CharSequence? {
+
+      val result = dest.subSequence(0, dstart).toString() + source.toString() + dest.subSequence(dend, dest.length)
+      val resultWithoutCurrencyPrefix = result.removePrefix(prefix)
+
+      if (result.length == 1 && !result.isDigitsOnly() && result != separator.toString()) {
+        return dest.subSequence(dstart, dend)
+      }
+
+      val matcher = pattern.matcher(resultWithoutCurrencyPrefix)
+
+      if (!matcher.matches()) {
+        return dest.subSequence(dstart, dend)
+      }
+
+      return null
+    }
+
+    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
+
+    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
+
+    override fun afterTextChanged(s: Editable?) {
+      if (s.isNullOrEmpty()) return
+
+      val hasPrefix = s.startsWith(prefix)
+      if (hasPrefix && s.length == prefix.length) {
+        s.clear()
+      } else if (!hasPrefix) {
+        s.insert(0, prefix)
+      }
+
+      onCustomAmountChanged(s.removePrefix(prefix).toString())
+    }
+  }
+
+  companion object {
+    fun register(adapter: MappingAdapter) {
+      adapter.registerFactory(SelectionModel::class.java, MappingAdapter.LayoutFactory({ SelectionViewHolder(it) }, R.layout.boost_preference))
+      adapter.registerFactory(HeadingModel::class.java, MappingAdapter.LayoutFactory({ HeadingViewHolder(it) }, R.layout.boost_preview_preference))
+      adapter.registerFactory(LoadingModel::class.java, MappingAdapter.LayoutFactory({ LoadingViewHolder(it) }, R.layout.boost_loading_preference))
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/boost/BoostFragment.kt

@@ -0,0 +1,308 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.boost
+
+import android.text.SpannableStringBuilder
+import android.view.View
+import androidx.appcompat.app.AlertDialog
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.viewModels
+import androidx.navigation.NavOptions
+import androidx.navigation.fragment.findNavController
+import androidx.recyclerview.widget.RecyclerView
+import com.airbnb.lottie.LottieAnimationView
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.signal.core.util.DimensionUnit
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.badges.models.BadgePreview
+import org.thoughtcrime.securesms.components.KeyboardAwareLinearLayout
+import org.thoughtcrime.securesms.components.settings.DSLConfiguration
+import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
+import org.thoughtcrime.securesms.components.settings.DSLSettingsBottomSheetFragment
+import org.thoughtcrime.securesms.components.settings.DSLSettingsIcon
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationEvent
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationExceptions
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentComponent
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.CurrencySelection
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.GooglePayButton
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.NetworkFailure
+import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.components.settings.models.Progress
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.help.HelpFragment
+import org.thoughtcrime.securesms.keyboard.findListener
+import org.thoughtcrime.securesms.util.BottomSheetUtil.requireCoordinatorLayout
+import org.thoughtcrime.securesms.util.CommunicationActions
+import org.thoughtcrime.securesms.util.LifecycleDisposable
+import org.thoughtcrime.securesms.util.Projection
+import org.thoughtcrime.securesms.util.SpanUtil
+
+/**
+ * UX to allow users to donate ephemerally.
+ */
+class BoostFragment : DSLSettingsBottomSheetFragment(
+  layoutId = R.layout.boost_bottom_sheet
+) {
+
+  private val viewModel: BoostViewModel by viewModels(
+    factoryProducer = {
+      BoostViewModel.Factory(BoostRepository(ApplicationDependencies.getDonationsService()), donationPaymentComponent.donationPaymentRepository, FETCH_BOOST_TOKEN_REQUEST_CODE)
+    }
+  )
+
+  private val lifecycleDisposable = LifecycleDisposable()
+
+  private lateinit var boost1AnimationView: LottieAnimationView
+  private lateinit var boost2AnimationView: LottieAnimationView
+  private lateinit var boost3AnimationView: LottieAnimationView
+  private lateinit var boost4AnimationView: LottieAnimationView
+  private lateinit var boost5AnimationView: LottieAnimationView
+  private lateinit var boost6AnimationView: LottieAnimationView
+
+  private lateinit var processingDonationPaymentDialog: AlertDialog
+  private lateinit var donationPaymentComponent: DonationPaymentComponent
+
+  private val sayThanks: CharSequence by lazy {
+    SpannableStringBuilder(requireContext().getString(R.string.BoostFragment__say_thanks_and_earn, 30))
+      .append(" ")
+      .append(
+        SpanUtil.learnMore(requireContext(), ContextCompat.getColor(requireContext(), R.color.signal_accent_primary)) {
+          CommunicationActions.openBrowserLink(requireContext(), getString(R.string.sustainer_boost_and_badges))
+        }
+      )
+  }
+
+  override fun bindAdapter(adapter: DSLSettingsAdapter) {
+    donationPaymentComponent = findListener()!!
+    viewModel.refresh()
+
+    CurrencySelection.register(adapter)
+    BadgePreview.register(adapter)
+    Boost.register(adapter)
+    GooglePayButton.register(adapter)
+    Progress.register(adapter)
+    NetworkFailure.register(adapter)
+
+    processingDonationPaymentDialog = MaterialAlertDialogBuilder(requireContext())
+      .setView(R.layout.processing_payment_dialog)
+      .setCancelable(false)
+      .create()
+
+    recyclerView.overScrollMode = RecyclerView.OVER_SCROLL_IF_CONTENT_SCROLLS
+
+    boost1AnimationView = requireView().findViewById(R.id.boost1_animation)
+    boost2AnimationView = requireView().findViewById(R.id.boost2_animation)
+    boost3AnimationView = requireView().findViewById(R.id.boost3_animation)
+    boost4AnimationView = requireView().findViewById(R.id.boost4_animation)
+    boost5AnimationView = requireView().findViewById(R.id.boost5_animation)
+    boost6AnimationView = requireView().findViewById(R.id.boost6_animation)
+
+    KeyboardAwareLinearLayout(requireContext()).apply {
+      addOnKeyboardHiddenListener {
+        recyclerView.post { recyclerView.requestLayout() }
+      }
+
+      addOnKeyboardShownListener {
+        recyclerView.post { recyclerView.scrollToPosition(adapter.itemCount - 1) }
+      }
+
+      requireCoordinatorLayout().addView(this)
+    }
+
+    viewModel.state.observe(viewLifecycleOwner) { state ->
+      adapter.submitList(getConfiguration(state).toMappingModelList())
+    }
+
+    lifecycleDisposable.bindTo(viewLifecycleOwner.lifecycle)
+    lifecycleDisposable += viewModel.events.subscribe { event: DonationEvent ->
+      when (event) {
+        is DonationEvent.GooglePayUnavailableError -> Unit
+        is DonationEvent.PaymentConfirmationError -> onPaymentError(event.throwable)
+        is DonationEvent.PaymentConfirmationSuccess -> onPaymentConfirmed(event.badge)
+        DonationEvent.RequestTokenError -> onPaymentError(null)
+        DonationEvent.RequestTokenSuccess -> Log.i(TAG, "Successfully got request token from Google Pay")
+        DonationEvent.SubscriptionCancelled -> Unit
+        is DonationEvent.SubscriptionCancellationFailed -> Unit
+      }
+    }
+    lifecycleDisposable += donationPaymentComponent.googlePayResultPublisher.subscribe {
+      viewModel.onActivityResult(it.requestCode, it.resultCode, it.data)
+    }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+    processingDonationPaymentDialog.hide()
+  }
+
+  private fun getConfiguration(state: BoostState): DSLConfiguration {
+    if (state.stage == BoostState.Stage.PAYMENT_PIPELINE) {
+      processingDonationPaymentDialog.show()
+    } else {
+      processingDonationPaymentDialog.hide()
+    }
+
+    return configure {
+      customPref(BadgePreview.SubscriptionModel(state.boostBadge))
+
+      sectionHeaderPref(
+        title = DSLSettingsText.from(
+          R.string.BoostFragment__give_signal_a_boost,
+          DSLSettingsText.CenterModifier, DSLSettingsText.Title2BoldModifier
+        )
+      )
+
+      noPadTextPref(
+        title = DSLSettingsText.from(
+          sayThanks,
+          DSLSettingsText.CenterModifier
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(28f).toInt())
+
+      customPref(
+        CurrencySelection.Model(
+          selectedCurrency = state.currencySelection,
+          isEnabled = state.stage == BoostState.Stage.READY,
+          onClick = {
+            findNavController().navigate(BoostFragmentDirections.actionBoostFragmentToSetDonationCurrencyFragment(true, viewModel.getSupportedCurrencyCodes().toTypedArray()))
+          }
+        )
+      )
+
+      @Suppress("CascadeIf")
+      if (state.stage == BoostState.Stage.INIT) {
+        customPref(
+          Boost.LoadingModel()
+        )
+      } else if (state.stage == BoostState.Stage.FAILURE) {
+        space(DimensionUnit.DP.toPixels(20f).toInt())
+        customPref(
+          NetworkFailure.Model {
+            viewModel.retry()
+          }
+        )
+      } else {
+        customPref(
+          Boost.SelectionModel(
+            boosts = state.boosts,
+            selectedBoost = state.selectedBoost,
+            currency = state.customAmount.currency,
+            isCustomAmountFocused = state.isCustomAmountFocused,
+            isEnabled = state.stage == BoostState.Stage.READY,
+            onBoostClick = { view, boost ->
+              startAnimationAboveSelectedBoost(view)
+              viewModel.setSelectedBoost(boost)
+            },
+            onCustomAmountChanged = {
+              viewModel.setCustomAmount(it)
+            },
+            onCustomAmountFocusChanged = {
+              viewModel.setCustomAmountFocused(it)
+            }
+          )
+        )
+      }
+
+      space(DimensionUnit.DP.toPixels(16f).toInt())
+
+      customPref(
+        GooglePayButton.Model(
+          onClick = this@BoostFragment::onGooglePayButtonClicked,
+          isEnabled = state.stage == BoostState.Stage.READY
+        )
+      )
+
+      secondaryButtonNoOutline(
+        text = DSLSettingsText.from(R.string.SubscribeFragment__more_payment_options),
+        icon = DSLSettingsIcon.from(R.drawable.ic_open_20, R.color.signal_accent_primary),
+        onClick = {
+          CommunicationActions.openBrowserLink(requireContext(), getString(R.string.donate_url))
+        }
+      )
+    }
+  }
+
+  private fun onGooglePayButtonClicked() {
+    viewModel.requestTokenFromGooglePay(getString(R.string.preferences__signal_boost))
+  }
+
+  private fun onPaymentConfirmed(boostBadge: Badge) {
+    findNavController().navigate(
+      BoostFragmentDirections.actionBoostFragmentToBoostThanksForYourSupportBottomSheetDialog(boostBadge).setIsBoost(true),
+      NavOptions.Builder().setPopUpTo(R.id.boostFragment, true).build()
+    )
+  }
+
+  private fun onPaymentError(throwable: Throwable?) {
+    if (throwable is DonationExceptions.TimedOutWaitingForTokenRedemption) {
+      Log.w(TAG, "Timed out while redeeming token", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__redemption_still_pending)
+        .setMessage(R.string.DonationsErrors__you_might_not_see_your_badge_right_away)
+        .setPositiveButton(android.R.string.ok) { dialog, _ ->
+          dialog.dismiss()
+          findNavController().popBackStack()
+        }
+        .show()
+    } else if (throwable is DonationExceptions.RedemptionFailed) {
+      Log.w(TAG, "Error occurred while trying to redeem token", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__redemption_failed)
+        .setMessage(R.string.DonationsErrors__please_contact_support)
+        .setPositiveButton(R.string.Subscription__contact_support) { dialog, _ ->
+          dialog.dismiss()
+          requireActivity().finish()
+          requireActivity().startActivity(AppSettingsActivity.help(requireContext(), HelpFragment.DONATION_INDEX))
+        }
+        .show()
+    } else {
+      Log.w(TAG, "Error occurred while processing payment", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__payment_failed)
+        .setMessage(R.string.DonationsErrors__your_payment)
+        .setPositiveButton(android.R.string.ok) { dialog, _ ->
+          dialog.dismiss()
+          findNavController().popBackStack()
+        }
+        .show()
+    }
+  }
+
+  private fun startAnimationAboveSelectedBoost(view: View) {
+    val animationView = getAnimationContainer(view)
+    val viewProjection = Projection.relativeToViewRoot(view, null)
+    val animationProjection = Projection.relativeToViewRoot(animationView, null)
+    val viewHorizontalCenter = viewProjection.x + viewProjection.width / 2f
+    val animationHorizontalCenter = animationProjection.x + animationProjection.width / 2f
+    val animationBottom = animationProjection.y + animationProjection.height
+
+    animationView.translationY = -(animationBottom - viewProjection.y) + (viewProjection.height / 2f)
+    animationView.translationX = viewHorizontalCenter - animationHorizontalCenter
+
+    animationView.playAnimation()
+
+    viewProjection.release()
+    animationProjection.release()
+  }
+
+  private fun getAnimationContainer(view: View): LottieAnimationView {
+    return when (view.id) {
+      R.id.boost_1 -> boost1AnimationView
+      R.id.boost_2 -> boost2AnimationView
+      R.id.boost_3 -> boost3AnimationView
+      R.id.boost_4 -> boost4AnimationView
+      R.id.boost_5 -> boost5AnimationView
+      R.id.boost_6 -> boost6AnimationView
+      else -> throw AssertionError()
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(BoostFragment::class.java)
+    private const val FETCH_BOOST_TOKEN_REQUEST_CODE = 2000
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/boost/BoostRepository.kt

@@ -0,0 +1,33 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.boost
+
+import io.reactivex.rxjava3.core.Single
+import org.signal.core.util.money.FiatMoney
+import org.thoughtcrime.securesms.badges.Badges
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
+import org.whispersystems.signalservice.api.profiles.SignalServiceProfile
+import org.whispersystems.signalservice.api.services.DonationsService
+import org.whispersystems.signalservice.internal.ServiceResponse
+import java.math.BigDecimal
+import java.util.Currency
+import java.util.Locale
+
+class BoostRepository(private val donationsService: DonationsService) {
+
+  fun getBoosts(): Single<Map<Currency, List<Boost>>> {
+    return donationsService.boostAmounts
+      .flatMap(ServiceResponse<Map<String, List<BigDecimal>>>::flattenResult)
+      .map { result ->
+        result
+          .filter { PlatformCurrencyUtil.getAvailableCurrencyCodes().contains(it.key) }
+          .mapKeys { (code, _) -> Currency.getInstance(code) }
+          .mapValues { (currency, prices) -> prices.map { Boost(FiatMoney(it, currency)) } }
+      }
+  }
+
+  fun getBoostBadge(): Single<Badge> {
+    return donationsService.getBoostBadge(Locale.getDefault())
+      .flatMap(ServiceResponse<SignalServiceProfile.Badge>::flattenResult)
+      .map(Badges::fromServiceBadge)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/boost/BoostState.kt

@@ -0,0 +1,26 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.boost
+
+import org.signal.core.util.money.FiatMoney
+import org.thoughtcrime.securesms.badges.models.Badge
+import java.math.BigDecimal
+import java.util.Currency
+
+data class BoostState(
+  val boostBadge: Badge? = null,
+  val currencySelection: Currency,
+  val isGooglePayAvailable: Boolean = false,
+  val boosts: List<Boost> = listOf(),
+  val selectedBoost: Boost? = null,
+  val customAmount: FiatMoney = FiatMoney(BigDecimal.ZERO, currencySelection),
+  val isCustomAmountFocused: Boolean = false,
+  val stage: Stage = Stage.INIT,
+  val supportedCurrencyCodes: List<String> = emptyList()
+) {
+  enum class Stage {
+    INIT,
+    READY,
+    TOKEN_REQUEST,
+    PAYMENT_PIPELINE,
+    FAILURE
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/boost/BoostViewModel.kt

@@ -0,0 +1,222 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.boost
+
+import android.content.Intent
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import com.google.android.gms.wallet.PaymentData
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import io.reactivex.rxjava3.subjects.PublishSubject
+import org.signal.core.util.logging.Log
+import org.signal.core.util.money.FiatMoney
+import org.signal.donations.GooglePayApi
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationEvent
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentRepository
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
+import org.thoughtcrime.securesms.util.livedata.Store
+import java.math.BigDecimal
+import java.text.DecimalFormatSymbols
+import java.util.Currency
+
+class BoostViewModel(
+  private val boostRepository: BoostRepository,
+  private val donationPaymentRepository: DonationPaymentRepository,
+  private val fetchTokenRequestCode: Int
+) : ViewModel() {
+
+  private val store = Store(BoostState(currencySelection = SignalStore.donationsValues().getBoostCurrency()))
+  private val eventPublisher: PublishSubject<DonationEvent> = PublishSubject.create()
+  private val disposables = CompositeDisposable()
+  private val networkDisposable: Disposable
+
+  val state: LiveData<BoostState> = store.stateLiveData
+  val events: Observable<DonationEvent> = eventPublisher.observeOn(AndroidSchedulers.mainThread())
+
+  private var boostToPurchase: Boost? = null
+
+  init {
+    networkDisposable = donationPaymentRepository
+      .internetConnectionObserver()
+      .distinctUntilChanged()
+      .subscribe { isConnected ->
+        if (isConnected) {
+          retry()
+        }
+      }
+  }
+
+  override fun onCleared() {
+    networkDisposable.dispose()
+    disposables.dispose()
+  }
+
+  fun getSupportedCurrencyCodes(): List<String> {
+    return store.state.supportedCurrencyCodes
+  }
+
+  fun retry() {
+    if (!disposables.isDisposed && store.state.stage == BoostState.Stage.FAILURE) {
+      store.update { it.copy(stage = BoostState.Stage.INIT) }
+      refresh()
+    }
+  }
+
+  fun refresh() {
+    disposables.clear()
+
+    val currencyObservable = SignalStore.donationsValues().observableBoostCurrency
+    val allBoosts = boostRepository.getBoosts()
+    val boostBadge = boostRepository.getBoostBadge()
+
+    disposables += Observable.combineLatest(currencyObservable, allBoosts.toObservable(), boostBadge.toObservable()) { currency, boostMap, badge ->
+      val boostList = if (currency in boostMap) {
+        boostMap[currency]!!
+      } else {
+        SignalStore.donationsValues().setBoostCurrency(PlatformCurrencyUtil.USD)
+        listOf()
+      }
+
+      BoostInfo(boostList, boostList[2], badge, boostMap.keys)
+    }.subscribeBy(
+      onNext = { info ->
+        store.update {
+          it.copy(
+            boosts = info.boosts,
+            selectedBoost = if (it.selectedBoost in info.boosts) it.selectedBoost else info.defaultBoost,
+            boostBadge = it.boostBadge ?: info.boostBadge,
+            stage = if (it.stage == BoostState.Stage.INIT || it.stage == BoostState.Stage.FAILURE) BoostState.Stage.READY else it.stage,
+            supportedCurrencyCodes = info.supportedCurrencies.map(Currency::getCurrencyCode)
+          )
+        }
+      },
+      onError = { throwable ->
+        Log.w(TAG, "Could not load boost information", throwable)
+        store.update {
+          it.copy(stage = BoostState.Stage.FAILURE)
+        }
+      }
+    )
+
+    disposables += donationPaymentRepository.isGooglePayAvailable().subscribeBy(
+      onComplete = { store.update { it.copy(isGooglePayAvailable = true) } },
+      onError = { eventPublisher.onNext(DonationEvent.GooglePayUnavailableError(it)) }
+    )
+
+    disposables += currencyObservable.subscribeBy { currency ->
+      store.update {
+        it.copy(
+          currencySelection = currency,
+          isCustomAmountFocused = false,
+          customAmount = FiatMoney(
+            BigDecimal.ZERO, currency
+          )
+        )
+      }
+    }
+  }
+
+  fun onActivityResult(
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    val boost = boostToPurchase
+    boostToPurchase = null
+
+    donationPaymentRepository.onActivityResult(
+      requestCode, resultCode, data, this.fetchTokenRequestCode,
+      object : GooglePayApi.PaymentRequestCallback {
+        override fun onSuccess(paymentData: PaymentData) {
+          if (boost != null) {
+            eventPublisher.onNext(DonationEvent.RequestTokenSuccess)
+
+            donationPaymentRepository.continuePayment(boost.price, paymentData).subscribeBy(
+              onError = { throwable ->
+                store.update { it.copy(stage = BoostState.Stage.READY) }
+                eventPublisher.onNext(DonationEvent.PaymentConfirmationError(throwable))
+              },
+              onComplete = {
+                store.update { it.copy(stage = BoostState.Stage.READY) }
+                eventPublisher.onNext(DonationEvent.PaymentConfirmationSuccess(store.state.boostBadge!!))
+              }
+            )
+          } else {
+            store.update { it.copy(stage = BoostState.Stage.READY) }
+          }
+        }
+
+        override fun onError() {
+          store.update { it.copy(stage = BoostState.Stage.READY) }
+          eventPublisher.onNext(DonationEvent.RequestTokenError)
+        }
+
+        override fun onCancelled() {
+          store.update { it.copy(stage = BoostState.Stage.READY) }
+        }
+      }
+    )
+  }
+
+  fun requestTokenFromGooglePay(label: String) {
+    val snapshot = store.state
+    if (snapshot.selectedBoost == null) {
+      return
+    }
+
+    store.update { it.copy(stage = BoostState.Stage.PAYMENT_PIPELINE) }
+
+    boostToPurchase = if (snapshot.isCustomAmountFocused) {
+      Boost(snapshot.customAmount)
+    } else {
+      snapshot.selectedBoost
+    }
+
+    donationPaymentRepository.requestTokenFromGooglePay(snapshot.selectedBoost.price, label, fetchTokenRequestCode)
+  }
+
+  fun setSelectedBoost(boost: Boost) {
+    store.update {
+      it.copy(
+        isCustomAmountFocused = false,
+        selectedBoost = boost
+      )
+    }
+  }
+
+  fun setCustomAmount(amount: String) {
+    val bigDecimalAmount = if (amount.isEmpty() || amount == DecimalFormatSymbols.getInstance().decimalSeparator.toString()) {
+      BigDecimal.ZERO
+    } else {
+      BigDecimal(amount)
+    }
+
+    store.update { it.copy(customAmount = FiatMoney(bigDecimalAmount, it.customAmount.currency)) }
+  }
+
+  fun setCustomAmountFocused(isFocused: Boolean) {
+    store.update { it.copy(isCustomAmountFocused = isFocused) }
+  }
+
+  private data class BoostInfo(val boosts: List<Boost>, val defaultBoost: Boost?, val boostBadge: Badge, val supportedCurrencies: Set<Currency>)
+
+  class Factory(
+    private val boostRepository: BoostRepository,
+    private val donationPaymentRepository: DonationPaymentRepository,
+    private val fetchTokenRequestCode: Int
+  ) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+      return modelClass.cast(BoostViewModel(boostRepository, donationPaymentRepository, fetchTokenRequestCode))!!
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(BoostViewModel::class.java)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/currency/SetCurrencyFragment.kt

@@ -0,0 +1,50 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.currency
+
+import androidx.fragment.app.viewModels
+import org.thoughtcrime.securesms.components.settings.DSLConfiguration
+import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
+import org.thoughtcrime.securesms.components.settings.DSLSettingsBottomSheetFragment
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentComponent
+import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.keyboard.findListener
+import java.util.Locale
+
+/**
+ * Simple fragment for selecting a currency for Donations
+ */
+class SetCurrencyFragment : DSLSettingsBottomSheetFragment() {
+
+  private lateinit var donationPaymentComponent: DonationPaymentComponent
+
+  private val viewModel: SetCurrencyViewModel by viewModels(
+    factoryProducer = {
+      val args = SetCurrencyFragmentArgs.fromBundle(requireArguments())
+      SetCurrencyViewModel.Factory(args.isBoost, args.supportedCurrencyCodes.toList())
+    }
+  )
+
+  override fun bindAdapter(adapter: DSLSettingsAdapter) {
+    donationPaymentComponent = findListener()!!
+
+    viewModel.state.observe(viewLifecycleOwner) { state ->
+      adapter.submitList(getConfiguration(state).toMappingModelList())
+    }
+  }
+
+  private fun getConfiguration(state: SetCurrencyState): DSLConfiguration {
+    return configure {
+      state.currencies.forEach { currency ->
+        clickPref(
+          title = DSLSettingsText.from(currency.getDisplayName(Locale.getDefault())),
+          summary = DSLSettingsText.from(currency.currencyCode),
+          onClick = {
+            viewModel.setSelectedCurrency(currency.currencyCode)
+            donationPaymentComponent.donationPaymentRepository.scheduleSyncForAccountRecordChange()
+            dismissAllowingStateLoss()
+          }
+        )
+      }
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/currency/SetCurrencyState.kt

@@ -0,0 +1,8 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.currency
+
+import java.util.Currency
+
+data class SetCurrencyState(
+  val selectedCurrencyCode: String = "",
+  val currencies: List<Currency> = listOf()
+)

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/currency/SetCurrencyViewModel.kt

@@ -0,0 +1,91 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.currency
+
+import androidx.annotation.VisibleForTesting
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import org.thoughtcrime.securesms.BuildConfig
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.subscription.Subscriber
+import org.thoughtcrime.securesms.util.livedata.Store
+import org.whispersystems.signalservice.api.subscriptions.SubscriberId
+import java.util.Currency
+import java.util.Locale
+
+class SetCurrencyViewModel(
+  private val isBoost: Boolean,
+  supportedCurrencyCodes: List<String>
+) : ViewModel() {
+
+  private val store = Store(
+    SetCurrencyState(
+      selectedCurrencyCode = if (isBoost) {
+        SignalStore.donationsValues().getBoostCurrency().currencyCode
+      } else {
+        SignalStore.donationsValues().getSubscriptionCurrency().currencyCode
+      },
+      currencies = supportedCurrencyCodes
+        .map(Currency::getInstance)
+        .sortedWith(CurrencyComparator(BuildConfig.DEFAULT_CURRENCIES.split(",")))
+    )
+  )
+
+  val state: LiveData<SetCurrencyState> = store.stateLiveData
+
+  fun setSelectedCurrency(selectedCurrencyCode: String) {
+    store.update { it.copy(selectedCurrencyCode = selectedCurrencyCode) }
+
+    if (isBoost) {
+      SignalStore.donationsValues().setBoostCurrency(Currency.getInstance(selectedCurrencyCode))
+    } else {
+      val currency = Currency.getInstance(selectedCurrencyCode)
+      val subscriber = SignalStore.donationsValues().getSubscriber(currency)
+
+      if (subscriber != null) {
+        SignalStore.donationsValues().setSubscriber(subscriber)
+      } else {
+        SignalStore.donationsValues().setSubscriber(
+          Subscriber(
+            subscriberId = SubscriberId.generate(),
+            currencyCode = currency.currencyCode
+          )
+        )
+      }
+    }
+  }
+
+  @VisibleForTesting
+  class CurrencyComparator(private val defaults: List<String>) : Comparator<Currency> {
+
+    companion object {
+      private const val USD = "USD"
+    }
+
+    override fun compare(o1: Currency, o2: Currency): Int {
+      val isO1Default = o1.currencyCode in defaults
+      val isO2Default = o2.currencyCode in defaults
+
+      return if (o1.currencyCode == o2.currencyCode) {
+        0
+      } else if (o1.currencyCode == USD) {
+        -1
+      } else if (o2.currencyCode == USD) {
+        1
+      } else if (isO1Default && isO2Default) {
+        o1.getDisplayName(Locale.getDefault()).compareTo(o2.getDisplayName(Locale.getDefault()))
+      } else if (isO1Default) {
+        -1
+      } else if (isO2Default) {
+        1
+      } else {
+        o1.getDisplayName(Locale.getDefault()).compareTo(o2.getDisplayName(Locale.getDefault()))
+      }
+    }
+  }
+
+  class Factory(private val isBoost: Boolean, private val supportedCurrencyCodes: List<String>) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+      return modelClass.cast(SetCurrencyViewModel(isBoost, supportedCurrencyCodes))!!
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/manage/ActiveSubscriptionPreference.kt

@@ -0,0 +1,77 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.manage
+
+import android.view.View
+import android.widget.TextView
+import com.google.android.material.button.MaterialButton
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.payments.FiatMoneyUtil
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.thoughtcrime.securesms.util.DateUtils
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+import java.util.Locale
+
+/**
+ * DSL renderable item that displays active subscription information on the user's
+ * manage donations page.
+ */
+object ActiveSubscriptionPreference {
+
+  class Model(
+    val subscription: Subscription,
+    val onAddBoostClick: () -> Unit,
+    val renewalTimestamp: Long = -1L
+  ) : PreferenceModel<Model>() {
+    override fun areItemsTheSame(newItem: Model): Boolean {
+      return subscription.id == newItem.subscription.id
+    }
+
+    override fun areContentsTheSame(newItem: Model): Boolean {
+      return super.areContentsTheSame(newItem) &&
+        subscription == newItem.subscription &&
+        renewalTimestamp == newItem.renewalTimestamp
+    }
+  }
+
+  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
+
+    val badge: BadgeImageView = itemView.findViewById(R.id.my_support_badge)
+    val title: TextView = itemView.findViewById(R.id.my_support_title)
+    val price: TextView = itemView.findViewById(R.id.my_support_price)
+    val expiry: TextView = itemView.findViewById(R.id.my_support_expiry)
+    val boost: MaterialButton = itemView.findViewById(R.id.my_support_boost)
+
+    override fun bind(model: Model) {
+      badge.setBadge(model.subscription.badge)
+      title.text = model.subscription.name
+
+      price.text = context.getString(
+        R.string.MySupportPreference__s_per_month,
+        FiatMoneyUtil.format(
+          context.resources,
+          model.subscription.prices.first { it.currency == SignalStore.donationsValues().getSubscriptionCurrency() },
+          FiatMoneyUtil.formatOptions()
+        )
+      )
+
+      expiry.text = context.getString(
+        R.string.MySupportPreference__renews_s,
+        DateUtils.formatDateWithYear(
+          Locale.getDefault(),
+          model.renewalTimestamp
+        )
+      )
+
+      boost.setOnClickListener {
+        model.onAddBoostClick()
+      }
+    }
+  }
+
+  fun register(adapter: MappingAdapter) {
+    adapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.my_support_preference))
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/manage/ManageDonationsEvent.kt

@@ -0,0 +1,6 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.manage
+
+enum class ManageDonationsEvent {
+  NOT_SUBSCRIBED,
+  ERROR_GETTING_SUBSCRIPTION
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/manage/ManageDonationsFragment.kt

@@ -0,0 +1,163 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.manage
+
+import android.os.Bundle
+import android.widget.Toast
+import androidx.fragment.app.viewModels
+import androidx.navigation.NavOptions
+import androidx.navigation.fragment.findNavController
+import org.signal.core.util.DimensionUnit
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.BadgePreview
+import org.thoughtcrime.securesms.components.settings.DSLConfiguration
+import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
+import org.thoughtcrime.securesms.components.settings.DSLSettingsFragment
+import org.thoughtcrime.securesms.components.settings.DSLSettingsIcon
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
+import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.components.settings.models.IndeterminateLoadingCircle
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.thoughtcrime.securesms.util.LifecycleDisposable
+import java.util.concurrent.TimeUnit
+
+/**
+ * Fragment displayed when a user enters "Subscriptions" via app settings but is already
+ * a subscriber. Used to manage their current subscription, view badges, and boost.
+ */
+class ManageDonationsFragment : DSLSettingsFragment() {
+
+  private val viewModel: ManageDonationsViewModel by viewModels(
+    factoryProducer = {
+      ManageDonationsViewModel.Factory(SubscriptionsRepository(ApplicationDependencies.getDonationsService()))
+    }
+  )
+
+  private val lifecycleDisposable = LifecycleDisposable()
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val args = ManageDonationsFragmentArgs.fromBundle(requireArguments())
+    if (args.skipToSubscribe) {
+      findNavController().navigate(
+        ManageDonationsFragmentDirections.actionManageDonationsFragmentToSubscribeFragment(),
+        NavOptions.Builder().setPopUpTo(R.id.manageDonationsFragment, true).build()
+      )
+    }
+  }
+
+  override fun onResume() {
+    super.onResume()
+    viewModel.refresh()
+  }
+
+  override fun bindAdapter(adapter: DSLSettingsAdapter) {
+    val args = ManageDonationsFragmentArgs.fromBundle(requireArguments())
+    if (args.skipToSubscribe) {
+      return
+    }
+
+    ActiveSubscriptionPreference.register(adapter)
+    IndeterminateLoadingCircle.register(adapter)
+    BadgePreview.register(adapter)
+
+    viewModel.state.observe(viewLifecycleOwner) { state ->
+      adapter.submitList(getConfiguration(state).toMappingModelList())
+    }
+
+    lifecycleDisposable.bindTo(viewLifecycleOwner.lifecycle)
+    lifecycleDisposable += viewModel.events.subscribe { event: ManageDonationsEvent ->
+      when (event) {
+        ManageDonationsEvent.NOT_SUBSCRIBED -> handleUserIsNotSubscribed()
+        ManageDonationsEvent.ERROR_GETTING_SUBSCRIPTION -> handleErrorGettingSubscription()
+      }
+    }
+  }
+
+  private fun getConfiguration(state: ManageDonationsState): DSLConfiguration {
+    return configure {
+      customPref(
+        BadgePreview.Model(
+          badge = state.featuredBadge
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(8f).toInt())
+
+      sectionHeaderPref(
+        title = DSLSettingsText.from(
+          R.string.SubscribeFragment__signal_is_powered_by_people_like_you,
+          DSLSettingsText.CenterModifier, DSLSettingsText.Title2BoldModifier
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(32f).toInt())
+
+      noPadTextPref(
+        title = DSLSettingsText.from(
+          R.string.ManageDonationsFragment__my_support,
+          DSLSettingsText.Body1BoldModifier, DSLSettingsText.BoldModifier
+        )
+      )
+
+      if (state.transactionState is ManageDonationsState.TransactionState.NotInTransaction) {
+        val activeSubscription = state.transactionState.activeSubscription
+        if (activeSubscription.isActive) {
+          val subscription: Subscription? = state.availableSubscriptions.firstOrNull { activeSubscription.activeSubscription.level == it.level }
+          if (subscription != null) {
+            space(DimensionUnit.DP.toPixels(12f).toInt())
+
+            customPref(
+              ActiveSubscriptionPreference.Model(
+                subscription = subscription,
+                onAddBoostClick = {
+                  findNavController().navigate(ManageDonationsFragmentDirections.actionManageDonationsFragmentToBoosts())
+                },
+                renewalTimestamp = TimeUnit.SECONDS.toMillis(activeSubscription.activeSubscription.endOfCurrentPeriod)
+              )
+            )
+
+            dividerPref()
+          } else {
+            customPref(IndeterminateLoadingCircle)
+          }
+        } else {
+          customPref(IndeterminateLoadingCircle)
+        }
+      } else {
+        customPref(IndeterminateLoadingCircle)
+      }
+
+      clickPref(
+        title = DSLSettingsText.from(R.string.ManageDonationsFragment__manage_subscription),
+        icon = DSLSettingsIcon.from(R.drawable.ic_person_white_24dp),
+        onClick = {
+          findNavController().navigate(ManageDonationsFragmentDirections.actionManageDonationsFragmentToSubscribeFragment())
+        }
+      )
+
+      clickPref(
+        title = DSLSettingsText.from(R.string.ManageDonationsFragment__badges),
+        icon = DSLSettingsIcon.from(R.drawable.ic_badge_24),
+        onClick = {
+          findNavController().navigate(ManageDonationsFragmentDirections.actionManageDonationsFragmentToSubscriptionBadgeManageFragment())
+        }
+      )
+
+      externalLinkPref(
+        title = DSLSettingsText.from(R.string.ManageDonationsFragment__subscription_faq),
+        icon = DSLSettingsIcon.from(R.drawable.ic_help_24),
+        linkId = R.string.donate_url
+      )
+    }
+  }
+
+  private fun handleUserIsNotSubscribed() {
+    findNavController().popBackStack()
+  }
+
+  private fun handleErrorGettingSubscription() {
+    Toast.makeText(requireContext(), R.string.ManageDonationsFragment__error_getting_subscription, Toast.LENGTH_LONG).show()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/manage/ManageDonationsState.kt

@@ -0,0 +1,17 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.manage
+
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+
+data class ManageDonationsState(
+  val featuredBadge: Badge? = null,
+  val transactionState: TransactionState = TransactionState.Init,
+  val availableSubscriptions: List<Subscription> = emptyList()
+) {
+  sealed class TransactionState {
+    object Init : TransactionState()
+    object InTransaction : TransactionState()
+    class NotInTransaction(val activeSubscription: ActiveSubscription) : TransactionState()
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/manage/ManageDonationsViewModel.kt

@@ -0,0 +1,89 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.manage
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import io.reactivex.rxjava3.subjects.PublishSubject
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.subscription.LevelUpdate
+import org.thoughtcrime.securesms.util.livedata.Store
+import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+
+class ManageDonationsViewModel(
+  private val subscriptionsRepository: SubscriptionsRepository
+) : ViewModel() {
+
+  private val store = Store(ManageDonationsState())
+  private val eventPublisher = PublishSubject.create<ManageDonationsEvent>()
+  private val disposables = CompositeDisposable()
+
+  val state: LiveData<ManageDonationsState> = store.stateLiveData
+  val events: Observable<ManageDonationsEvent> = eventPublisher.observeOn(AndroidSchedulers.mainThread())
+
+  init {
+    store.update(Recipient.self().live().liveDataResolved) { self, state ->
+      state.copy(featuredBadge = self.featuredBadge)
+    }
+  }
+
+  override fun onCleared() {
+    disposables.clear()
+  }
+
+  fun refresh() {
+    disposables.clear()
+
+    val levelUpdateOperationEdges: Observable<Boolean> = LevelUpdate.isProcessing.distinctUntilChanged()
+    val activeSubscription: Single<ActiveSubscription> = subscriptionsRepository.getActiveSubscription()
+
+    disposables += levelUpdateOperationEdges.flatMapSingle { isProcessing ->
+      if (isProcessing) {
+        Single.just(ManageDonationsState.TransactionState.InTransaction)
+      } else {
+        activeSubscription.map { ManageDonationsState.TransactionState.NotInTransaction(it) }
+      }
+    }.subscribeBy(
+      onNext = { transactionState ->
+        store.update {
+          it.copy(transactionState = transactionState)
+        }
+
+        if (transactionState is ManageDonationsState.TransactionState.NotInTransaction && !transactionState.activeSubscription.isActive) {
+          eventPublisher.onNext(ManageDonationsEvent.NOT_SUBSCRIBED)
+        }
+      },
+      onError = {
+        eventPublisher.onNext(ManageDonationsEvent.ERROR_GETTING_SUBSCRIPTION)
+      }
+    )
+
+    disposables += subscriptionsRepository.getSubscriptions().subscribeBy(
+      onSuccess = { subs ->
+        store.update { it.copy(availableSubscriptions = subs) }
+      },
+      onError = {
+        Log.w(TAG, "Error retrieving subscriptions data", it)
+      }
+    )
+  }
+
+  class Factory(
+    private val subscriptionsRepository: SubscriptionsRepository
+  ) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+      return modelClass.cast(ManageDonationsViewModel(subscriptionsRepository))!!
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(ManageDonationsViewModel::class.java)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/models/CurrencySelection.kt

@@ -0,0 +1,45 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.models
+
+import android.view.View
+import android.widget.TextView
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+import java.util.Currency
+
+object CurrencySelection {
+
+  fun register(adapter: MappingAdapter) {
+    adapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.subscription_currency_selection))
+  }
+
+  class Model(
+    val selectedCurrency: Currency,
+    override val isEnabled: Boolean,
+    val onClick: () -> Unit
+  ) : PreferenceModel<Model>(isEnabled = isEnabled) {
+    override fun areItemsTheSame(newItem: Model): Boolean {
+      return true
+    }
+
+    override fun areContentsTheSame(newItem: Model): Boolean {
+      return super.areContentsTheSame(newItem) &&
+        newItem.selectedCurrency == selectedCurrency
+    }
+  }
+
+  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
+
+    private val spinner: TextView = itemView.findViewById(R.id.subscription_currency_selection_spinner)
+
+    override fun bind(model: Model) {
+      spinner.text = model.selectedCurrency.currencyCode
+
+      itemView.setOnClickListener { model.onClick() }
+
+      itemView.isEnabled = model.isEnabled
+      itemView.isClickable = model.isEnabled
+    }
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/models/GooglePayButton.kt

@@ -0,0 +1,31 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.models
+
+import android.view.View
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+
+object GooglePayButton {
+
+  class Model(val onClick: () -> Unit, override val isEnabled: Boolean) : PreferenceModel<Model>(isEnabled = isEnabled) {
+    override fun areItemsTheSame(newItem: Model): Boolean = true
+  }
+
+  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
+
+    private val googlePayButton: View = findViewById(R.id.googlepay_button)
+
+    override fun bind(model: Model) {
+      googlePayButton.isEnabled = model.isEnabled
+      googlePayButton.setOnClickListener {
+        googlePayButton.isEnabled = false
+        model.onClick()
+      }
+    }
+  }
+
+  fun register(adapter: MappingAdapter) {
+    adapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.google_pay_button_pref))
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/models/NetworkFailure.kt

@@ -0,0 +1,34 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.models
+
+import android.view.View
+import com.google.android.material.button.MaterialButton
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.util.MappingAdapter
+import org.thoughtcrime.securesms.util.MappingViewHolder
+
+/**
+ * NetworkFailure will display a "card" to the user informing them that there
+ * was a failure and give them a button which allows them to retry fetching data.
+ */
+object NetworkFailure {
+
+  class Model(
+    val onRetryClick: () -> Unit
+  ) : PreferenceModel<Model>() {
+    override fun areItemsTheSame(newItem: Model): Boolean = true
+  }
+
+  class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
+
+    private val retryButton = itemView.findViewById<MaterialButton>(R.id.retry_button)
+
+    override fun bind(model: Model) {
+      retryButton.setOnClickListener { model.onRetryClick() }
+    }
+  }
+
+  fun register(mappingAdapter: MappingAdapter) {
+    mappingAdapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory({ ViewHolder(it) }, R.layout.network_failure_pref))
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/subscribe/SubscribeFragment.kt

@@ -0,0 +1,334 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.subscribe
+
+import android.graphics.Color
+import android.text.SpannableStringBuilder
+import androidx.appcompat.app.AlertDialog
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.viewModels
+import androidx.navigation.fragment.findNavController
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.snackbar.Snackbar
+import org.signal.core.util.DimensionUnit
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.thoughtcrime.securesms.badges.models.BadgePreview
+import org.thoughtcrime.securesms.components.settings.DSLConfiguration
+import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
+import org.thoughtcrime.securesms.components.settings.DSLSettingsFragment
+import org.thoughtcrime.securesms.components.settings.DSLSettingsIcon
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationEvent
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationExceptions
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentComponent
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.CurrencySelection
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.GooglePayButton
+import org.thoughtcrime.securesms.components.settings.app.subscription.models.NetworkFailure
+import org.thoughtcrime.securesms.components.settings.configure
+import org.thoughtcrime.securesms.components.settings.models.Progress
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.help.HelpFragment
+import org.thoughtcrime.securesms.keyboard.findListener
+import org.thoughtcrime.securesms.payments.FiatMoneyUtil
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.thoughtcrime.securesms.util.CommunicationActions
+import org.thoughtcrime.securesms.util.LifecycleDisposable
+import org.thoughtcrime.securesms.util.SpanUtil
+import java.util.Calendar
+import java.util.concurrent.TimeUnit
+
+/**
+ * UX for creating and changing a subscription
+ */
+class SubscribeFragment : DSLSettingsFragment(
+  layoutId = R.layout.subscribe_fragment
+) {
+
+  private val lifecycleDisposable = LifecycleDisposable()
+
+  private val supportTechSummary: CharSequence by lazy {
+    SpannableStringBuilder(requireContext().getString(R.string.SubscribeFragment__support_technology_that_is_built_for_you_not))
+      .append(" ")
+      .append(
+        SpanUtil.readMore(requireContext(), ContextCompat.getColor(requireContext(), R.color.signal_accent_primary)) {
+          findNavController().navigate(SubscribeFragmentDirections.actionSubscribeFragmentToSubscribeLearnMoreBottomSheetDialog())
+        }
+      )
+  }
+
+  private lateinit var processingDonationPaymentDialog: AlertDialog
+  private lateinit var donationPaymentComponent: DonationPaymentComponent
+
+  private val viewModel: SubscribeViewModel by viewModels(
+    factoryProducer = {
+      SubscribeViewModel.Factory(SubscriptionsRepository(ApplicationDependencies.getDonationsService()), donationPaymentComponent.donationPaymentRepository, FETCH_SUBSCRIPTION_TOKEN_REQUEST_CODE)
+    }
+  )
+
+  override fun onResume() {
+    super.onResume()
+    viewModel.refreshActiveSubscription()
+  }
+
+  override fun bindAdapter(adapter: DSLSettingsAdapter) {
+    donationPaymentComponent = findListener()!!
+    viewModel.refresh()
+
+    BadgePreview.register(adapter)
+    CurrencySelection.register(adapter)
+    Subscription.register(adapter)
+    GooglePayButton.register(adapter)
+    Progress.register(adapter)
+    NetworkFailure.register(adapter)
+
+    processingDonationPaymentDialog = MaterialAlertDialogBuilder(requireContext())
+      .setView(R.layout.processing_payment_dialog)
+      .setCancelable(false)
+      .create()
+
+    viewModel.state.observe(viewLifecycleOwner) { state ->
+      adapter.submitList(getConfiguration(state).toMappingModelList())
+    }
+
+    lifecycleDisposable.bindTo(viewLifecycleOwner.lifecycle)
+    lifecycleDisposable += viewModel.events.subscribe {
+      when (it) {
+        is DonationEvent.GooglePayUnavailableError -> Unit
+        is DonationEvent.PaymentConfirmationError -> onPaymentError(it.throwable)
+        is DonationEvent.PaymentConfirmationSuccess -> onPaymentConfirmed(it.badge)
+        DonationEvent.RequestTokenError -> onPaymentError(null)
+        DonationEvent.RequestTokenSuccess -> Log.w(TAG, "Successfully got request token from Google Pay")
+        DonationEvent.SubscriptionCancelled -> onSubscriptionCancelled()
+        is DonationEvent.SubscriptionCancellationFailed -> onSubscriptionFailedToCancel(it.throwable)
+      }
+    }
+    lifecycleDisposable += donationPaymentComponent.googlePayResultPublisher.subscribe {
+      viewModel.onActivityResult(it.requestCode, it.resultCode, it.data)
+    }
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+    processingDonationPaymentDialog.hide()
+  }
+
+  private fun getConfiguration(state: SubscribeState): DSLConfiguration {
+    if (state.hasInProgressSubscriptionTransaction || state.stage == SubscribeState.Stage.PAYMENT_PIPELINE) {
+      processingDonationPaymentDialog.show()
+    } else {
+      processingDonationPaymentDialog.hide()
+    }
+
+    val areFieldsEnabled = state.stage == SubscribeState.Stage.READY && !state.hasInProgressSubscriptionTransaction
+
+    return configure {
+      customPref(BadgePreview.SubscriptionModel(state.selectedSubscription?.badge))
+
+      sectionHeaderPref(
+        title = DSLSettingsText.from(
+          R.string.SubscribeFragment__signal_is_powered_by_people_like_you,
+          DSLSettingsText.CenterModifier, DSLSettingsText.Title2BoldModifier
+        )
+      )
+
+      noPadTextPref(
+        title = DSLSettingsText.from(supportTechSummary, DSLSettingsText.CenterModifier)
+      )
+
+      space(DimensionUnit.DP.toPixels(16f).toInt())
+
+      customPref(
+        CurrencySelection.Model(
+          selectedCurrency = state.currencySelection,
+          isEnabled = areFieldsEnabled && state.activeSubscription?.isActive != true,
+          onClick = {
+            val selectableCurrencies = viewModel.getSelectableCurrencyCodes()
+            if (selectableCurrencies != null) {
+              findNavController().navigate(SubscribeFragmentDirections.actionSubscribeFragmentToSetDonationCurrencyFragment(false, selectableCurrencies.toTypedArray()))
+            }
+          }
+        )
+      )
+
+      space(DimensionUnit.DP.toPixels(4f).toInt())
+
+      @Suppress("CascadeIf")
+      if (state.stage == SubscribeState.Stage.INIT) {
+        customPref(
+          Subscription.LoaderModel()
+        )
+      } else if (state.stage == SubscribeState.Stage.FAILURE) {
+        space(DimensionUnit.DP.toPixels(69f).toInt())
+        customPref(
+          NetworkFailure.Model {
+            viewModel.refresh()
+          }
+        )
+        space(DimensionUnit.DP.toPixels(75f).toInt())
+      } else {
+        state.subscriptions.forEach {
+          val isActive = state.activeSubscription?.activeSubscription?.level == it.level
+          customPref(
+            Subscription.Model(
+              subscription = it,
+              isSelected = state.selectedSubscription == it,
+              isEnabled = areFieldsEnabled,
+              isActive = isActive,
+              willRenew = isActive && state.activeSubscription?.activeSubscription?.willCancelAtPeriodEnd() ?: false,
+              onClick = { viewModel.setSelectedSubscription(it) },
+              renewalTimestamp = TimeUnit.SECONDS.toMillis(state.activeSubscription?.activeSubscription?.endOfCurrentPeriod ?: 0L),
+              selectedCurrency = state.currencySelection
+            )
+          )
+        }
+      }
+
+      if (state.activeSubscription?.isActive == true) {
+        space(DimensionUnit.DP.toPixels(16f).toInt())
+
+        val activeAndSameLevel = state.activeSubscription.isActive &&
+          state.selectedSubscription?.level == state.activeSubscription.activeSubscription?.level
+        val isExpiring = state.activeSubscription.isActive && state.activeSubscription.activeSubscription?.willCancelAtPeriodEnd() == true
+
+        primaryButton(
+          text = DSLSettingsText.from(R.string.SubscribeFragment__update_subscription),
+          isEnabled = areFieldsEnabled && (!activeAndSameLevel || isExpiring),
+          onClick = {
+            val price = viewModel.getPriceOfSelectedSubscription() ?: return@primaryButton
+            val calendar = Calendar.getInstance()
+
+            calendar.add(Calendar.MONTH, 1)
+            MaterialAlertDialogBuilder(requireContext())
+              .setTitle(R.string.SubscribeFragment__update_subscription_question)
+              .setMessage(
+                getString(
+                  R.string.SubscribeFragment__you_will_be_charged_the_full_amount_s_of,
+                  FiatMoneyUtil.format(
+                    requireContext().resources,
+                    price,
+                    FiatMoneyUtil.formatOptions().trimZerosAfterDecimal()
+                  )
+                )
+              )
+              .setPositiveButton(R.string.SubscribeFragment__update) { dialog, _ ->
+                dialog.dismiss()
+                viewModel.updateSubscription()
+              }
+              .setNegativeButton(android.R.string.cancel) { dialog, _ ->
+                dialog.dismiss()
+              }
+              .show()
+          }
+        )
+
+        secondaryButtonNoOutline(
+          text = DSLSettingsText.from(R.string.SubscribeFragment__cancel_subscription),
+          isEnabled = areFieldsEnabled,
+          onClick = {
+            MaterialAlertDialogBuilder(requireContext())
+              .setTitle(R.string.SubscribeFragment__confirm_cancellation)
+              .setMessage(R.string.SubscribeFragment__you_wont_be_charged_again)
+              .setPositiveButton(R.string.SubscribeFragment__confirm) { d, _ ->
+                d.dismiss()
+                viewModel.cancel()
+              }
+              .setNegativeButton(R.string.SubscribeFragment__not_now) { d, _ ->
+                d.dismiss()
+              }
+              .show()
+          }
+        )
+      } else {
+        space(DimensionUnit.DP.toPixels(16f).toInt())
+
+        customPref(
+          GooglePayButton.Model(
+            onClick = this@SubscribeFragment::onGooglePayButtonClicked,
+            isEnabled = areFieldsEnabled && state.selectedSubscription != null
+          )
+        )
+
+        secondaryButtonNoOutline(
+          text = DSLSettingsText.from(R.string.SubscribeFragment__more_payment_options),
+          icon = DSLSettingsIcon.from(R.drawable.ic_open_20, R.color.signal_accent_primary),
+          onClick = {
+            CommunicationActions.openBrowserLink(requireContext(), getString(R.string.donate_url))
+          }
+        )
+      }
+    }
+  }
+
+  private fun onGooglePayButtonClicked() {
+    viewModel.requestTokenFromGooglePay()
+  }
+
+  private fun onPaymentConfirmed(badge: Badge) {
+    findNavController().navigate(
+      SubscribeFragmentDirections.actionSubscribeFragmentToSubscribeThanksForYourSupportBottomSheetDialog(badge).setIsBoost(false),
+    )
+  }
+
+  private fun onPaymentError(throwable: Throwable?) {
+    if (throwable is DonationExceptions.TimedOutWaitingForTokenRedemption) {
+      Log.w(TAG, "Timeout occurred while redeeming token", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__redemption_still_pending)
+        .setMessage(R.string.DonationsErrors__you_might_not_see_your_badge_right_away)
+        .setPositiveButton(android.R.string.ok) { dialog, _ ->
+          dialog.dismiss()
+          requireActivity().finish()
+          requireActivity().startActivity(AppSettingsActivity.subscriptions(requireContext()))
+        }
+        .show()
+    } else if (throwable is DonationExceptions.RedemptionFailed) {
+      Log.w(TAG, "Error occurred while trying to redeem token", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__redemption_failed)
+        .setMessage(R.string.DonationsErrors__please_contact_support)
+        .setPositiveButton(R.string.Subscription__contact_support) { dialog, _ ->
+          dialog.dismiss()
+          requireActivity().finish()
+          requireActivity().startActivity(AppSettingsActivity.help(requireContext(), HelpFragment.DONATION_INDEX))
+        }
+        .show()
+    } else {
+      Log.w(TAG, "Error occurred while processing payment", throwable, true)
+      MaterialAlertDialogBuilder(requireContext())
+        .setTitle(R.string.DonationsErrors__payment_failed)
+        .setMessage(R.string.DonationsErrors__your_payment)
+        .setPositiveButton(android.R.string.ok) { dialog, _ ->
+          dialog.dismiss()
+        }
+        .show()
+    }
+  }
+
+  private fun onSubscriptionCancelled() {
+    Snackbar.make(requireView(), R.string.SubscribeFragment__your_subscription_has_been_cancelled, Snackbar.LENGTH_LONG)
+      .setTextColor(Color.WHITE)
+      .show()
+
+    requireActivity().finish()
+    requireActivity().startActivity(AppSettingsActivity.home(requireContext()))
+  }
+
+  private fun onSubscriptionFailedToCancel(throwable: Throwable) {
+    Log.w(TAG, "Failed to cancel subscription", throwable, true)
+    MaterialAlertDialogBuilder(requireContext())
+      .setTitle(R.string.DonationsErrors__failed_to_cancel_subscription)
+      .setMessage(R.string.DonationsErrors__subscription_cancellation_requires_an_internet_connection)
+      .setPositiveButton(android.R.string.ok) { dialog, _ ->
+        dialog.dismiss()
+        findNavController().popBackStack()
+      }
+      .show()
+  }
+
+  companion object {
+    private val TAG = Log.tag(SubscribeFragment::class.java)
+    private const val FETCH_SUBSCRIPTION_TOKEN_REQUEST_CODE = 1000
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/subscribe/SubscribeLearnMoreBottomSheetDialogFragment.kt

@@ -0,0 +1,17 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.subscribe
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.FixedRoundedCornerBottomSheetDialogFragment
+
+class SubscribeLearnMoreBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFragment() {
+
+  override val peekHeightPercentage: Float = 1f
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+    return inflater.inflate(R.layout.subscribe_learn_more_bottom_sheet_dialog_fragment, container, false)
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/subscribe/SubscribeState.kt

@@ -0,0 +1,24 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.subscribe
+
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+import java.util.Currency
+
+data class SubscribeState(
+  val currencySelection: Currency,
+  val subscriptions: List<Subscription> = listOf(),
+  val selectedSubscription: Subscription? = null,
+  val activeSubscription: ActiveSubscription? = null,
+  val isGooglePayAvailable: Boolean = false,
+  val stage: Stage = Stage.INIT,
+  val hasInProgressSubscriptionTransaction: Boolean = false,
+) {
+  enum class Stage {
+    INIT,
+    READY,
+    TOKEN_REQUEST,
+    PAYMENT_PIPELINE,
+    CANCELLING,
+    FAILURE
+  }
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/subscribe/SubscribeViewModel.kt

@@ -0,0 +1,275 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.subscribe
+
+import android.content.Intent
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import com.google.android.gms.wallet.PaymentData
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.kotlin.plusAssign
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import io.reactivex.rxjava3.subjects.PublishSubject
+import org.signal.core.util.logging.Log
+import org.signal.core.util.money.FiatMoney
+import org.signal.donations.GooglePayApi
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationEvent
+import org.thoughtcrime.securesms.components.settings.app.subscription.DonationPaymentRepository
+import org.thoughtcrime.securesms.components.settings.app.subscription.SubscriptionsRepository
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.subscription.LevelUpdate
+import org.thoughtcrime.securesms.subscription.Subscriber
+import org.thoughtcrime.securesms.subscription.Subscription
+import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
+import org.thoughtcrime.securesms.util.livedata.Store
+import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
+import org.whispersystems.signalservice.api.subscriptions.SubscriberId
+import java.util.Currency
+
+class SubscribeViewModel(
+  private val subscriptionsRepository: SubscriptionsRepository,
+  private val donationPaymentRepository: DonationPaymentRepository,
+  private val fetchTokenRequestCode: Int
+) : ViewModel() {
+
+  private val store = Store(SubscribeState(currencySelection = SignalStore.donationsValues().getSubscriptionCurrency()))
+  private val eventPublisher: PublishSubject<DonationEvent> = PublishSubject.create()
+  private val disposables = CompositeDisposable()
+  private val networkDisposable: Disposable
+
+  val state: LiveData<SubscribeState> = store.stateLiveData
+  val events: Observable<DonationEvent> = eventPublisher.observeOn(AndroidSchedulers.mainThread())
+
+  private var subscriptionToPurchase: Subscription? = null
+  private val activeSubscriptionSubject = PublishSubject.create<ActiveSubscription>()
+
+  init {
+    networkDisposable = donationPaymentRepository
+      .internetConnectionObserver()
+      .distinctUntilChanged()
+      .subscribe { isConnected ->
+        if (isConnected) {
+          retry()
+        }
+      }
+  }
+
+  override fun onCleared() {
+    networkDisposable.dispose()
+    disposables.dispose()
+  }
+
+  fun getPriceOfSelectedSubscription(): FiatMoney? {
+    return store.state.selectedSubscription?.prices?.first { it.currency == store.state.currencySelection }
+  }
+
+  fun getSelectableCurrencyCodes(): List<String>? {
+    return store.state.subscriptions.firstOrNull()?.prices?.map { it.currency.currencyCode }
+  }
+
+  fun retry() {
+    if (!disposables.isDisposed && store.state.stage == SubscribeState.Stage.FAILURE) {
+      store.update { it.copy(stage = SubscribeState.Stage.INIT) }
+      refresh()
+    }
+  }
+
+  fun refresh() {
+    disposables.clear()
+
+    val currency: Observable<Currency> = SignalStore.donationsValues().observableSubscriptionCurrency
+    val allSubscriptions: Single<List<Subscription>> = subscriptionsRepository.getSubscriptions()
+
+    refreshActiveSubscription()
+
+    disposables += LevelUpdate.isProcessing.subscribeBy {
+      store.update { state ->
+        state.copy(
+          hasInProgressSubscriptionTransaction = it
+        )
+      }
+    }
+
+    disposables += allSubscriptions.subscribeBy(
+      onSuccess = { subscriptions ->
+        if (subscriptions.isNotEmpty()) {
+          val priceCurrencies = subscriptions[0].prices.map { it.currency }
+          val selectedCurrency = SignalStore.donationsValues().getSubscriptionCurrency()
+
+          if (selectedCurrency !in priceCurrencies) {
+            Log.w(TAG, "Unsupported currency selection. Defaulting to USD. $currency isn't supported.")
+            val usd = PlatformCurrencyUtil.USD
+            val newSubscriber = SignalStore.donationsValues().getSubscriber(usd) ?: Subscriber(SubscriberId.generate(), usd.currencyCode)
+            SignalStore.donationsValues().setSubscriber(newSubscriber)
+            donationPaymentRepository.scheduleSyncForAccountRecordChange()
+          }
+        }
+      },
+      onError = {}
+    )
+
+    disposables += Observable.combineLatest(allSubscriptions.toObservable(), activeSubscriptionSubject, ::Pair).subscribeBy(
+      onNext = { (subs, active) ->
+        store.update {
+          it.copy(
+            subscriptions = subs,
+            selectedSubscription = it.selectedSubscription ?: resolveSelectedSubscription(active, subs),
+            activeSubscription = active,
+            stage = if (it.stage == SubscribeState.Stage.INIT || it.stage == SubscribeState.Stage.FAILURE) SubscribeState.Stage.READY else it.stage,
+          )
+        }
+      },
+      onError = this::handleSubscriptionDataLoadFailure
+    )
+
+    disposables += donationPaymentRepository.isGooglePayAvailable().subscribeBy(
+      onComplete = { store.update { it.copy(isGooglePayAvailable = true) } },
+      onError = { eventPublisher.onNext(DonationEvent.GooglePayUnavailableError(it)) }
+    )
+
+    disposables += currency.subscribe { selection ->
+      store.update { it.copy(currencySelection = selection) }
+    }
+  }
+
+  private fun handleSubscriptionDataLoadFailure(throwable: Throwable) {
+    Log.w(TAG, "Could not load subscription data", throwable)
+    store.update {
+      it.copy(stage = SubscribeState.Stage.FAILURE)
+    }
+  }
+
+  fun refreshActiveSubscription() {
+    subscriptionsRepository
+      .getActiveSubscription()
+      .subscribeBy(
+        onSuccess = { activeSubscriptionSubject.onNext(it) },
+        onError = { activeSubscriptionSubject.onNext(ActiveSubscription(null)) }
+      )
+  }
+
+  private fun resolveSelectedSubscription(activeSubscription: ActiveSubscription, subscriptions: List<Subscription>): Subscription? {
+    return if (activeSubscription.isActive) {
+      subscriptions.firstOrNull { it.level == activeSubscription.activeSubscription.level }
+    } else {
+      subscriptions.firstOrNull()
+    }
+  }
+
+  fun cancel() {
+    store.update { it.copy(stage = SubscribeState.Stage.CANCELLING) }
+    disposables += donationPaymentRepository.cancelActiveSubscription().subscribeBy(
+      onComplete = {
+        eventPublisher.onNext(DonationEvent.SubscriptionCancelled)
+        SignalStore.donationsValues().setLastEndOfPeriod(0L)
+        SignalStore.donationsValues().clearLevelOperations()
+        SignalStore.donationsValues().markUserManuallyCancelled()
+        refreshActiveSubscription()
+        store.update { it.copy(stage = SubscribeState.Stage.READY) }
+      },
+      onError = { throwable ->
+        eventPublisher.onNext(DonationEvent.SubscriptionCancellationFailed(throwable))
+        store.update { it.copy(stage = SubscribeState.Stage.READY) }
+      }
+    )
+  }
+
+  fun onActivityResult(
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    val subscription = subscriptionToPurchase
+    subscriptionToPurchase = null
+
+    donationPaymentRepository.onActivityResult(
+      requestCode, resultCode, data, this.fetchTokenRequestCode,
+      object : GooglePayApi.PaymentRequestCallback {
+        override fun onSuccess(paymentData: PaymentData) {
+          if (subscription != null) {
+            eventPublisher.onNext(DonationEvent.RequestTokenSuccess)
+
+            val ensureSubscriberId = donationPaymentRepository.ensureSubscriberId()
+            val continueSetup = donationPaymentRepository.continueSubscriptionSetup(paymentData)
+            val setLevel = donationPaymentRepository.setSubscriptionLevel(subscription.level.toString())
+
+            store.update { it.copy(stage = SubscribeState.Stage.PAYMENT_PIPELINE) }
+
+            ensureSubscriberId.andThen(continueSetup).andThen(setLevel).subscribeBy(
+              onError = { throwable ->
+                refreshActiveSubscription()
+                store.update { it.copy(stage = SubscribeState.Stage.READY) }
+                eventPublisher.onNext(DonationEvent.PaymentConfirmationError(throwable))
+              },
+              onComplete = {
+                store.update { it.copy(stage = SubscribeState.Stage.READY) }
+                eventPublisher.onNext(DonationEvent.PaymentConfirmationSuccess(subscription.badge))
+              }
+            )
+          } else {
+            store.update { it.copy(stage = SubscribeState.Stage.READY) }
+          }
+        }
+
+        override fun onError() {
+          store.update { it.copy(stage = SubscribeState.Stage.READY) }
+          eventPublisher.onNext(DonationEvent.RequestTokenError)
+        }
+
+        override fun onCancelled() {
+          store.update { it.copy(stage = SubscribeState.Stage.READY) }
+        }
+      }
+    )
+  }
+
+  fun updateSubscription() {
+    store.update { it.copy(stage = SubscribeState.Stage.PAYMENT_PIPELINE) }
+    donationPaymentRepository.setSubscriptionLevel(store.state.selectedSubscription!!.level.toString())
+      .subscribeBy(
+        onComplete = {
+          store.update { it.copy(stage = SubscribeState.Stage.READY) }
+          eventPublisher.onNext(DonationEvent.PaymentConfirmationSuccess(store.state.selectedSubscription!!.badge))
+        },
+        onError = { throwable ->
+          store.update { it.copy(stage = SubscribeState.Stage.READY) }
+          eventPublisher.onNext(DonationEvent.PaymentConfirmationError(throwable))
+        }
+      )
+  }
+
+  fun requestTokenFromGooglePay() {
+    val snapshot = store.state
+    if (snapshot.selectedSubscription == null) {
+      return
+    }
+
+    store.update { it.copy(stage = SubscribeState.Stage.TOKEN_REQUEST) }
+
+    val selectedCurrency = snapshot.currencySelection
+
+    subscriptionToPurchase = snapshot.selectedSubscription
+    donationPaymentRepository.requestTokenFromGooglePay(snapshot.selectedSubscription.prices.first { it.currency == selectedCurrency }, snapshot.selectedSubscription.name, fetchTokenRequestCode)
+  }
+
+  fun setSelectedSubscription(subscription: Subscription) {
+    store.update { it.copy(selectedSubscription = subscription) }
+  }
+
+  class Factory(
+    private val subscriptionsRepository: SubscriptionsRepository,
+    private val donationPaymentRepository: DonationPaymentRepository,
+    private val fetchTokenRequestCode: Int
+  ) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+      return modelClass.cast(SubscribeViewModel(subscriptionsRepository, donationPaymentRepository, fetchTokenRequestCode))!!
+    }
+  }
+
+  companion object {
+    private val TAG = Log.tag(SubscribeViewModel::class.java)
+  }
+}

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

@@ -0,0 +1,170 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription.thanks
+
+import android.animation.Animator
+import android.content.DialogInterface
+import android.os.Bundle
+import android.text.SpannableStringBuilder
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.core.content.ContextCompat
+import androidx.navigation.fragment.findNavController
+import com.airbnb.lottie.LottieAnimationView
+import com.airbnb.lottie.LottieDrawable
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.switchmaterial.SwitchMaterial
+import io.reactivex.rxjava3.kotlin.subscribeBy
+import org.signal.core.util.logging.Log
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.animation.AnimationCompleteListener
+import org.thoughtcrime.securesms.badges.BadgeImageView
+import org.thoughtcrime.securesms.badges.BadgeRepository
+import org.thoughtcrime.securesms.components.FixedRoundedCornerBottomSheetDialogFragment
+import org.thoughtcrime.securesms.components.settings.app.AppSettingsActivity
+import org.thoughtcrime.securesms.keyvalue.SignalStore
+import org.thoughtcrime.securesms.recipients.Recipient
+import org.thoughtcrime.securesms.util.SpanUtil
+import org.thoughtcrime.securesms.util.visible
+
+class ThanksForYourSupportBottomSheetDialogFragment : FixedRoundedCornerBottomSheetDialogFragment() {
+
+  override val peekHeightPercentage: Float = 1f
+
+  private lateinit var switch: SwitchMaterial
+  private lateinit var heading: TextView
+
+  private lateinit var badgeRepository: BadgeRepository
+  private lateinit var controlState: ControlState
+
+  private enum class ControlState {
+    FEATURE,
+    DISPLAY
+  }
+
+  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+    return inflater.inflate(R.layout.thanks_for_your_support_bottom_sheet_dialog_fragment, container, false)
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    badgeRepository = BadgeRepository(requireContext())
+
+    val badgeView: BadgeImageView = view.findViewById(R.id.thanks_bottom_sheet_badge)
+    val lottie: LottieAnimationView = view.findViewById(R.id.thanks_bottom_sheet_lottie)
+    val badgeName: TextView = view.findViewById(R.id.thanks_bottom_sheet_badge_name)
+    val done: MaterialButton = view.findViewById(R.id.thanks_bottom_sheet_done)
+    val controlText: TextView = view.findViewById(R.id.thanks_bottom_sheet_control_text)
+    val controlNote: View = view.findViewById(R.id.thanks_bottom_sheet_featured_note)
+    val subhead: TextView = view.findViewById(R.id.thanks_bottom_sheet_subhead)
+
+    heading = view.findViewById(R.id.thanks_bottom_sheet_heading)
+    switch = view.findViewById(R.id.thanks_bottom_sheet_switch)
+
+    val args = ThanksForYourSupportBottomSheetDialogFragmentArgs.fromBundle(requireArguments())
+
+    badgeView.setBadge(args.badge)
+    badgeName.text = args.badge.name
+
+    if (args.badge.isBoost()) {
+      if (Recipient.self().badges.any { !it.isBoost() }) {
+        subhead.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__youve_earned_a_boost_badge_help_signal)
+      } else {
+        subhead.text = SpannableStringBuilder(getString(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__youve_earned_a_boost_badge_help_signal))
+          .append(" ")
+          .append(getString(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__you_can_also))
+          .append(
+            SpanUtil.clickable(
+              getString(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__become_a_montly_sustainer),
+              ContextCompat.getColor(requireContext(), R.color.signal_accent_primary),
+            ) {
+              requireActivity().finish()
+              requireActivity().startActivity(AppSettingsActivity.subscriptions(requireContext()))
+            }
+          )
+      }
+    } else {
+      subhead.text = getString(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__youve_earned_s_badge_help_signal, args.badge.name)
+    }
+
+    val otherBadges = Recipient.self().badges.filterNot { it.id == args.badge.id }
+    val hasOtherBadges = otherBadges.isNotEmpty()
+    val displayingBadges = SignalStore.donationsValues().getDisplayBadgesOnProfile()
+
+    if (hasOtherBadges && displayingBadges) {
+      switch.isChecked = false
+      controlText.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__make_featured_badge)
+      controlNote.visible = true
+      controlState = ControlState.FEATURE
+    } else if (hasOtherBadges && !displayingBadges) {
+      switch.isChecked = false
+      controlText.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__display_on_profile)
+      controlNote.visible = false
+      controlState = ControlState.DISPLAY
+    } else {
+      switch.isChecked = true
+      controlText.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__display_on_profile)
+      controlNote.visible = false
+      controlState = ControlState.DISPLAY
+    }
+
+    if (args.isBoost) {
+      presentBoostCopy()
+      badgeView.visibility = View.INVISIBLE
+      lottie.visible = true
+      lottie.playAnimation()
+      lottie.addAnimatorListener(object : AnimationCompleteListener() {
+        override fun onAnimationEnd(animation: Animator?) {
+          lottie.removeAnimatorListener(this)
+          lottie.setMinAndMaxFrame(30, 91)
+          lottie.repeatMode = LottieDrawable.RESTART
+          lottie.repeatCount = LottieDrawable.INFINITE
+          lottie.frame = 30
+          lottie.playAnimation()
+        }
+      })
+    } else {
+      presentSubscriptionCopy()
+      lottie.visible = false
+    }
+
+    done.setOnClickListener { dismissAllowingStateLoss() }
+  }
+
+  override fun onDismiss(dialog: DialogInterface) {
+    val controlChecked = switch.isChecked
+    val args = ThanksForYourSupportBottomSheetDialogFragmentArgs.fromBundle(requireArguments())
+
+    if (controlState == ControlState.DISPLAY) {
+      badgeRepository.setVisibilityForAllBadges(controlChecked).subscribeBy(
+        onError = {
+          Log.w(TAG, "Failure while updating badge visibility", it)
+        }
+      )
+    } else if (controlChecked) {
+      badgeRepository.setFeaturedBadge(args.badge).subscribeBy(
+        onError = {
+          Log.w(TAG, "Failure while updating featured badge", it)
+        }
+      )
+    }
+
+    if (args.isBoost) {
+      findNavController().popBackStack()
+    } else {
+      requireActivity().finish()
+      requireActivity().startActivity(AppSettingsActivity.manageSubscriptions(requireContext()))
+    }
+  }
+
+  private fun presentBoostCopy() {
+    heading.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__thanks_for_the_boost)
+  }
+
+  private fun presentSubscriptionCopy() {
+    heading.setText(R.string.SubscribeThanksForYourSupportBottomSheetDialogFragment__thanks_for_your_support)
+  }
+
+  companion object {
+    private val TAG = Log.tag(ThanksForYourSupportBottomSheetDialogFragment::class.java)
+  }
+}

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

@@ -10,6 +10,7 @@ import android.os.Bundle
 import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
+import android.widget.FrameLayout
 import android.widget.TextView
 import android.widget.Toast
 import androidx.appcompat.widget.Toolbar
@@ -30,6 +31,7 @@ import org.thoughtcrime.securesms.MuteDialog
 import org.thoughtcrime.securesms.PushContactSelectionActivity
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.VerifyIdentityActivity
+import org.thoughtcrime.securesms.badges.BadgeImageView
 import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.badges.Badges.displayBadges
 import org.thoughtcrime.securesms.badges.models.Badge
@@ -77,6 +79,7 @@ import org.thoughtcrime.securesms.recipients.ui.sharablegrouplink.ShareableGroup
 import org.thoughtcrime.securesms.util.CommunicationActions
 import org.thoughtcrime.securesms.util.ContextUtil
 import org.thoughtcrime.securesms.util.ExpirationUtil
+import org.thoughtcrime.securesms.util.FeatureFlags
 import org.thoughtcrime.securesms.util.ThemeUtil
 import org.thoughtcrime.securesms.util.ViewUtil
 import org.thoughtcrime.securesms.util.views.SimpleProgressDialog
@@ -126,7 +129,9 @@ class ConversationSettingsFragment : DSLSettingsFragment(
   private lateinit var callback: Callback
 
   private lateinit var toolbar: Toolbar
+  private lateinit var toolbarAvatarContainer: FrameLayout
   private lateinit var toolbarAvatar: AvatarImageView
+  private lateinit var toolbarBadge: BadgeImageView
   private lateinit var toolbarTitle: TextView
   private lateinit var toolbarBackground: View
 
@@ -140,7 +145,9 @@ class ConversationSettingsFragment : DSLSettingsFragment(
 
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
     toolbar = view.findViewById(R.id.toolbar)
+    toolbarAvatarContainer = view.findViewById(R.id.toolbar_avatar_container)
     toolbarAvatar = view.findViewById(R.id.toolbar_avatar)
+    toolbarBadge = view.findViewById(R.id.toolbar_badge)
     toolbarTitle = view.findViewById(R.id.toolbar_title)
     toolbarBackground = view.findViewById(R.id.toolbar_background)
 
@@ -164,7 +171,7 @@ class ConversationSettingsFragment : DSLSettingsFragment(
   }
 
   override fun getOnScrollAnimationHelper(toolbarShadow: View): OnScrollAnimationHelper {
-    return ConversationSettingsOnUserScrolledAnimationHelper(toolbarAvatar, toolbarTitle, toolbarBackground, toolbarShadow)
+    return ConversationSettingsOnUserScrolledAnimationHelper(toolbarAvatarContainer, toolbarTitle, toolbarBackground, toolbarShadow)
   }
 
   override fun onOptionsItemSelected(item: MenuItem): Boolean {
@@ -194,7 +201,7 @@ class ConversationSettingsFragment : DSLSettingsFragment(
 
     val recipientId = args.recipientId
     if (recipientId != null) {
-      Badge.register(adapter) { badge, _ ->
+      Badge.register(adapter) { badge, _, _ ->
         ViewBadgeBottomSheetDialogFragment.show(parentFragmentManager, recipientId, badge)
       }
     }
@@ -208,6 +215,10 @@ class ConversationSettingsFragment : DSLSettingsFragment(
           .withFixedSize(ViewUtil.dpToPx(80))
           .load(state.recipient)
 
+        if (FeatureFlags.displayDonorBadges() && !state.recipient.isSelf) {
+          toolbarBadge.setBadgeFromRecipient(state.recipient)
+        }
+
         state.withRecipientSettingsState {
           toolbarTitle.text = state.recipient.getDisplayName(requireContext())
         }
@@ -314,18 +325,16 @@ class ConversationSettingsFragment : DSLSettingsFragment(
         }
       }
 
-      state.withRecipientSettingsState { recipientState ->
-        if (recipientState.displayInternalRecipientDetails) {
-          customPref(
-            InternalPreference.Model(
-              recipient = state.recipient,
-              onInternalDetailsClicked = {
-                val action = ConversationSettingsFragmentDirections.actionConversationSettingsFragmentToInternalDetailsSettingsFragment(state.recipient.id)
-                navController.navigate(action)
-              }
-            )
+      if (state.displayInternalRecipientDetails) {
+        customPref(
+          InternalPreference.Model(
+            recipient = state.recipient,
+            onInternalDetailsClicked = {
+              val action = ConversationSettingsFragmentDirections.actionConversationSettingsFragmentToInternalDetailsSettingsFragment(state.recipient.id)
+              navController.navigate(action)
+            }
           )
-        }
+        )
       }
 
       customPref(
@@ -489,7 +498,13 @@ class ConversationSettingsFragment : DSLSettingsFragment(
 
           sectionHeaderPref(R.string.ManageProfileFragment_badges)
 
-          displayBadges(state.recipient.badges)
+          displayBadges(requireContext(), state.recipient.badges)
+
+          textPref(
+            summary = DSLSettingsText.from(
+              R.string.ConversationSettingsFragment__get_badges
+            )
+          )
         }
 
         if (recipientSettingsState.selfHasGroups) {
@@ -662,7 +677,7 @@ class ConversationSettingsFragment : DSLSettingsFragment(
         val blockUnblockIcon = if (isBlocked) unblockIcon else blockIcon
 
         clickPref(
-          title = DSLSettingsText.from(title, titleTint),
+          title = if (titleTint != null) DSLSettingsText.from(title, titleTint) else DSLSettingsText.from(title),
           icon = DSLSettingsIcon.from(blockUnblockIcon),
           onClick = {
             if (state.recipient.isBlocked) {

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

@@ -16,6 +16,7 @@ data class ConversationSettingsState(
   val canModifyBlockedState: Boolean = false,
   val sharedMedia: Cursor? = null,
   val sharedMediaIds: List<Long> = listOf(),
+  val displayInternalRecipientDetails: Boolean = false,
   private val sharedMediaLoaded: Boolean = false,
   private val specificSettingsState: SpecificSettingsState,
 ) {
@@ -49,8 +50,7 @@ sealed class SpecificSettingsState {
     val selfHasGroups: Boolean = false,
     val canShowMoreGroupsInCommon: Boolean = false,
     val groupsInCommonExpanded: Boolean = false,
-    val contactLinkState: ContactLinkState = ContactLinkState.NONE,
-    val displayInternalRecipientDetails: Boolean
+    val contactLinkState: ContactLinkState = ContactLinkState.NONE
   ) : SpecificSettingsState() {
 
     override val isLoaded: Boolean = true

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

@@ -71,7 +71,8 @@ sealed class ConversationSettingsViewModel(
         state.copy(
           sharedMedia = cursor.orNull(),
           sharedMediaIds = ids,
-          sharedMediaLoaded = true
+          sharedMediaLoaded = true,
+          displayInternalRecipientDetails = repository.isInternalRecipientDetailsEnabled()
         )
       } else {
         cursor.orNull().ensureClosed()
@@ -102,10 +103,8 @@ sealed class ConversationSettingsViewModel(
 
   override fun onCleared() {
     cleared = true
-    store.update { state ->
-      openedMediaCursors.forEach { it.ensureClosed() }
-      state.copy(sharedMedia = null)
-    }
+    openedMediaCursors.forEach { it.ensureClosed() }
+    store.clear()
   }
 
   private fun Cursor?.ensureClosed() {
@@ -121,9 +120,7 @@ sealed class ConversationSettingsViewModel(
     private val repository: ConversationSettingsRepository
   ) : ConversationSettingsViewModel(
     repository,
-    SpecificSettingsState.RecipientSettingsState(
-      displayInternalRecipientDetails = repository.isInternalRecipientDetailsEnabled()
-    )
+    SpecificSettingsState.RecipientSettingsState()
   ) {
 
     private val liveRecipient = Recipient.live(recipientId)

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

@@ -1,5 +1,6 @@
 package org.thoughtcrime.securesms.components.settings.conversation
 
+import android.content.Context
 import android.graphics.Color
 import android.text.TextUtils
 import android.widget.Toast
@@ -7,6 +8,7 @@ import androidx.fragment.app.viewModels
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.signal.core.util.concurrent.SignalExecutors
 import org.thoughtcrime.securesms.R
 import org.thoughtcrime.securesms.components.settings.DSLConfiguration
 import org.thoughtcrime.securesms.components.settings.DSLSettingsAdapter
@@ -14,16 +16,20 @@ import org.thoughtcrime.securesms.components.settings.DSLSettingsFragment
 import org.thoughtcrime.securesms.components.settings.DSLSettingsText
 import org.thoughtcrime.securesms.components.settings.configure
 import org.thoughtcrime.securesms.database.DatabaseFactory
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.groups.GroupId
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientForeverObserver
 import org.thoughtcrime.securesms.recipients.RecipientId
+import org.thoughtcrime.securesms.subscription.Subscriber
 import org.thoughtcrime.securesms.util.Base64
 import org.thoughtcrime.securesms.util.Hex
 import org.thoughtcrime.securesms.util.SpanUtil
 import org.thoughtcrime.securesms.util.Util
 import org.thoughtcrime.securesms.util.livedata.Store
+import org.whispersystems.signalservice.api.push.ACI
 import java.util.Objects
-import java.util.UUID
 
 /**
  * Shows internal details about a recipient that you can view from the conversation settings.
@@ -55,79 +61,126 @@ class InternalConversationSettingsFragment : DSLSettingsFragment(
         summary = DSLSettingsText.from(recipient.id.serialize())
       )
 
-      val uuid = recipient.uuid.transform(UUID::toString).or("null")
+      if (!recipient.isGroup) {
+        val uuid = recipient.aci.transform(ACI::toString).or("null")
+        longClickPref(
+          title = DSLSettingsText.from("UUID"),
+          summary = DSLSettingsText.from(uuid),
+          onLongClick = { copyToClipboard(uuid) }
+        )
+      }
+
+      if (state.groupId != null) {
+        val groupId: String = state.groupId.toString()
+        longClickPref(
+          title = DSLSettingsText.from("GroupId"),
+          summary = DSLSettingsText.from(groupId),
+          onLongClick = { copyToClipboard(groupId) }
+        )
+      }
+
+      val threadId: String = if (state.threadId != null) state.threadId.toString() else "N/A"
       longClickPref(
-        title = DSLSettingsText.from("UUID"),
-        summary = DSLSettingsText.from(uuid),
-        onLongClick = { copyToClipboard(uuid) }
+        title = DSLSettingsText.from("ThreadId"),
+        summary = DSLSettingsText.from(threadId),
+        onLongClick = { copyToClipboard(threadId) }
       )
 
-      textPref(
-        title = DSLSettingsText.from("Profile Name"),
-        summary = DSLSettingsText.from("[${recipient.profileName.givenName}] [${state.recipient.profileName.familyName}]")
-      )
+      if (!recipient.isGroup) {
+        textPref(
+          title = DSLSettingsText.from("Profile Name"),
+          summary = DSLSettingsText.from("[${recipient.profileName.givenName}] [${state.recipient.profileName.familyName}]")
+        )
 
-      val profileKeyBase64 = recipient.profileKey?.let(Base64::encodeBytes) ?: "None"
-      longClickPref(
-        title = DSLSettingsText.from("Profile Key (Base64)"),
-        summary = DSLSettingsText.from(profileKeyBase64),
-        onLongClick = { copyToClipboard(profileKeyBase64) }
-      )
+        val profileKeyBase64 = recipient.profileKey?.let(Base64::encodeBytes) ?: "None"
+        longClickPref(
+          title = DSLSettingsText.from("Profile Key (Base64)"),
+          summary = DSLSettingsText.from(profileKeyBase64),
+          onLongClick = { copyToClipboard(profileKeyBase64) }
+        )
 
-      val profileKeyHex = recipient.profileKey?.let(Hex::toStringCondensed) ?: ""
-      longClickPref(
-        title = DSLSettingsText.from("Profile Key (Hex)"),
-        summary = DSLSettingsText.from(profileKeyHex),
-        onLongClick = { copyToClipboard(profileKeyHex) }
-      )
+        val profileKeyHex = recipient.profileKey?.let(Hex::toStringCondensed) ?: ""
+        longClickPref(
+          title = DSLSettingsText.from("Profile Key (Hex)"),
+          summary = DSLSettingsText.from(profileKeyHex),
+          onLongClick = { copyToClipboard(profileKeyHex) }
+        )
 
-      textPref(
-        title = DSLSettingsText.from("Sealed Sender Mode"),
-        summary = DSLSettingsText.from(recipient.unidentifiedAccessMode.toString())
-      )
+        textPref(
+          title = DSLSettingsText.from("Sealed Sender Mode"),
+          summary = DSLSettingsText.from(recipient.unidentifiedAccessMode.toString())
+        )
+      }
 
       textPref(
         title = DSLSettingsText.from("Profile Sharing (AKA \"Whitelisted\")"),
         summary = DSLSettingsText.from(recipient.isProfileSharing.toString())
       )
 
-      textPref(
-        title = DSLSettingsText.from("Capabilities"),
-        summary = DSLSettingsText.from(buildCapabilitySpan(recipient))
-      )
+      if (!recipient.isGroup) {
+        textPref(
+          title = DSLSettingsText.from("Capabilities"),
+          summary = DSLSettingsText.from(buildCapabilitySpan(recipient))
+        )
+      }
 
-      sectionHeaderPref(DSLSettingsText.from("Actions"))
+      if (!recipient.isGroup) {
+        sectionHeaderPref(DSLSettingsText.from("Actions"))
 
-      clickPref(
-        title = DSLSettingsText.from("Disable Profile Sharing"),
-        summary = DSLSettingsText.from("Clears profile sharing/whitelisted status, which should cause the Message Request UI to show."),
-        onClick = {
-          MaterialAlertDialogBuilder(requireContext())
-            .setTitle("Are you sure?")
-            .setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
-            .setPositiveButton(android.R.string.ok) { _, _ -> DatabaseFactory.getRecipientDatabase(requireContext()).setProfileSharing(recipient.id, false) }
-            .show()
+        clickPref(
+          title = DSLSettingsText.from("Disable Profile Sharing"),
+          summary = DSLSettingsText.from("Clears profile sharing/whitelisted status, which should cause the Message Request UI to show."),
+          onClick = {
+            MaterialAlertDialogBuilder(requireContext())
+              .setTitle("Are you sure?")
+              .setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
+              .setPositiveButton(android.R.string.ok) { _, _ -> DatabaseFactory.getRecipientDatabase(requireContext()).setProfileSharing(recipient.id, false) }
+              .show()
+          }
+        )
+
+        clickPref(
+          title = DSLSettingsText.from("Delete Session"),
+          summary = DSLSettingsText.from("Deletes the session, essentially guaranteeing an encryption error if they send you a message."),
+          onClick = {
+            MaterialAlertDialogBuilder(requireContext())
+              .setTitle("Are you sure?")
+              .setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
+              .setPositiveButton(android.R.string.ok) { _, _ ->
+                if (recipient.hasAci()) {
+                  DatabaseFactory.getSessionDatabase(context).deleteAllFor(recipient.requireAci().toString())
+                }
+                if (recipient.hasE164()) {
+                  DatabaseFactory.getSessionDatabase(context).deleteAllFor(recipient.requireE164())
+                }
+              }
+              .show()
+          }
+        )
+      }
+
+      if (recipient.isSelf) {
+        sectionHeaderPref(DSLSettingsText.from("Donations"))
+
+        val subscriber: Subscriber? = SignalStore.donationsValues().getSubscriber()
+        val summary = if (subscriber != null) {
+          """currency code: ${subscriber.currencyCode}
+            |subscriber id: ${subscriber.subscriberId.serialize()}
+          """.trimMargin()
+        } else {
+          "None"
         }
-      )
 
-      clickPref(
-        title = DSLSettingsText.from("Delete Session"),
-        summary = DSLSettingsText.from("Deletes the session, essentially guaranteeing an encryption error if they send you a message."),
-        onClick = {
-          MaterialAlertDialogBuilder(requireContext())
-            .setTitle("Are you sure?")
-            .setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
-            .setPositiveButton(android.R.string.ok) { _, _ ->
-              if (recipient.hasUuid()) {
-                DatabaseFactory.getSessionDatabase(context).deleteAllFor(recipient.requireUuid().toString())
-              }
-              if (recipient.hasE164()) {
-                DatabaseFactory.getSessionDatabase(context).deleteAllFor(recipient.requireE164())
-              }
+        longClickPref(
+          title = DSLSettingsText.from("Subscriber ID"),
+          summary = DSLSettingsText.from(summary),
+          onLongClick = {
+            if (subscriber != null) {
+              copyToClipboard(subscriber.subscriberId.serialize())
             }
-            .show()
-        }
-      )
+          }
+        )
+      }
     }
   }
 
@@ -162,17 +215,30 @@ class InternalConversationSettingsFragment : DSLSettingsFragment(
     val recipientId: RecipientId
   ) : ViewModel(), RecipientForeverObserver {
 
-    private val store = Store(InternalState(Recipient.resolved(recipientId)))
+    private val store = Store(
+      InternalState(
+        recipient = Recipient.resolved(recipientId),
+        threadId = null,
+        groupId = null
+      )
+    )
 
     val state = store.stateLiveData
     val liveRecipient = Recipient.live(recipientId)
 
     init {
       liveRecipient.observeForever(this)
+
+      SignalExecutors.BOUNDED.execute {
+        val context: Context = ApplicationDependencies.getApplication()
+        val threadId: Long? = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipientId)
+        val groupId: GroupId? = DatabaseFactory.getGroupDatabase(context).getGroup(recipientId).transform { it.id }.orNull()
+        store.update { state -> state.copy(threadId = threadId, groupId = groupId) }
+      }
     }
 
     override fun onRecipientChanged(recipient: Recipient) {
-      store.update { InternalState(recipient) }
+      store.update { state -> state.copy(recipient = recipient) }
     }
 
     override fun onCleared() {
@@ -187,6 +253,8 @@ class InternalConversationSettingsFragment : DSLSettingsFragment(
   }
 
   data class InternalState(
-    val recipient: Recipient
+    val recipient: Recipient,
+    val threadId: Long?,
+    val groupId: GroupId?
   )
 }

app/src/main/java/org/thoughtcrime/securesms/components/settings/conversation/preferences/AvatarPreference.kt

@@ -49,13 +49,19 @@ object AvatarPreference {
     }
 
     override fun bind(model: Model) {
-      badge.setBadgeFromRecipient(model.recipient)
-      badge.setOnClickListener {
-        val badge = model.recipient.badges.firstOrNull()
-        if (badge != null) {
-          model.onBadgeClick(badge)
+      if (model.recipient.isSelf) {
+        badge.setBadge(null)
+        badge.setOnClickListener(null)
+      } else {
+        badge.setBadgeFromRecipient(model.recipient)
+        badge.setOnClickListener {
+          val badge = model.recipient.badges.firstOrNull()
+          if (badge != null) {
+            model.onBadgeClick(badge)
+          }
         }
       }
+
       avatar.setAvatar(model.recipient)
       avatar.disableQuickContact()
       avatar.setOnClickListener { model.onAvatarClick(avatar) }

app/src/main/java/org/thoughtcrime/securesms/components/settings/conversation/preferences/ButtonStripPreference.kt

@@ -41,27 +41,24 @@ object ButtonStripPreference {
   class ViewHolder(itemView: View) : MappingViewHolder<Model>(itemView) {
 
     private val message: View = itemView.findViewById(R.id.message)
-    private val messageLabel: View = itemView.findViewById(R.id.message_label)
+    private val messageContainer: View = itemView.findViewById(R.id.button_strip_message_container)
     private val videoCall: View = itemView.findViewById(R.id.start_video)
-    private val videoLabel: View = itemView.findViewById(R.id.start_video_label)
+    private val videoContainer: View = itemView.findViewById(R.id.button_strip_video_container)
     private val audioCall: ImageView = itemView.findViewById(R.id.start_audio)
     private val audioLabel: TextView = itemView.findViewById(R.id.start_audio_label)
+    private val audioContainer: View = itemView.findViewById(R.id.button_strip_audio_container)
     private val mute: ImageView = itemView.findViewById(R.id.mute)
     private val muteLabel: TextView = itemView.findViewById(R.id.mute_label)
+    private val muteContainer: View = itemView.findViewById(R.id.button_strip_mute_container)
     private val search: View = itemView.findViewById(R.id.search)
-    private val searchLabel: View = itemView.findViewById(R.id.search_label)
+    private val searchContainer: View = itemView.findViewById(R.id.button_strip_search_container)
 
     override fun bind(model: Model) {
-      message.visible = model.state.isMessageAvailable
-      messageLabel.visible = model.state.isMessageAvailable
-      videoCall.visible = model.state.isVideoAvailable
-      videoLabel.visible = model.state.isVideoAvailable
-      audioCall.visible = model.state.isAudioAvailable
-      audioLabel.visible = model.state.isAudioAvailable
-      mute.visible = model.state.isMuteAvailable
-      muteLabel.visible = model.state.isMuteAvailable
-      search.visible = model.state.isSearchAvailable
-      searchLabel.visible = model.state.isSearchAvailable
+      messageContainer.visible = model.state.isMessageAvailable
+      videoContainer.visible = model.state.isVideoAvailable
+      audioContainer.visible = model.state.isAudioAvailable
+      muteContainer.visible = model.state.isMuteAvailable
+      searchContainer.visible = model.state.isSearchAvailable
 
       if (model.state.isAudioSecure) {
         audioLabel.setText(R.string.ConversationSettingsFragment__audio)

app/src/main/java/org/thoughtcrime/securesms/components/settings/conversation/preferences/RecipientPreference.kt

@@ -3,6 +3,7 @@ package org.thoughtcrime.securesms.components.settings.conversation.preferences
 import android.view.View
 import android.widget.TextView
 import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.badges.BadgeImageView
 import org.thoughtcrime.securesms.components.AvatarImageView
 import org.thoughtcrime.securesms.components.settings.PreferenceModel
 import org.thoughtcrime.securesms.recipients.Recipient
@@ -40,11 +41,13 @@ object RecipientPreference {
     private val name: TextView = itemView.findViewById(R.id.recipient_name)
     private val about: TextView = itemView.findViewById(R.id.recipient_about)
     private val admin: View = itemView.findViewById(R.id.admin)
+    private val badge: BadgeImageView = itemView.findViewById(R.id.recipient_badge)
 
     override fun bind(model: Model) {
       itemView.setOnClickListener { model.onClick() }
 
       avatar.setRecipient(model.recipient)
+      badge.setBadgeFromRecipient(model.recipient)
       name.text = if (model.recipient.isSelf) {
         context.getString(R.string.Recipient_you)
       } else {

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

@@ -1,7 +1,12 @@
 package org.thoughtcrime.securesms.components.settings
 
 import androidx.annotation.CallSuper
+import androidx.annotation.Px
 import androidx.annotation.StringRes
+import org.thoughtcrime.securesms.components.settings.models.AsyncSwitch
+import org.thoughtcrime.securesms.components.settings.models.Button
+import org.thoughtcrime.securesms.components.settings.models.Space
+import org.thoughtcrime.securesms.components.settings.models.Text
 import org.thoughtcrime.securesms.util.MappingModel
 import org.thoughtcrime.securesms.util.MappingModelList
 
@@ -52,6 +57,17 @@ class DSLConfiguration {
     children.add(preference)
   }
 
+  fun asyncSwitchPref(
+    title: DSLSettingsText,
+    isEnabled: Boolean = true,
+    isChecked: Boolean,
+    isProcessing: Boolean,
+    onClick: () -> Unit
+  ) {
+    val preference = AsyncSwitch.Model(title, isEnabled, isChecked, isProcessing, onClick)
+    children.add(preference)
+  }
+
   fun switchPref(
     title: DSLSettingsText,
     summary: DSLSettingsText? = null,
@@ -121,6 +137,35 @@ class DSLConfiguration {
     children.add(preference)
   }
 
+  fun noPadTextPref(title: DSLSettingsText) {
+    val preference = Text(title)
+    children.add(Text.Model(preference))
+  }
+
+  fun space(@Px pixels: Int) {
+    val preference = Space(pixels)
+    children.add(Space.Model(preference))
+  }
+
+  fun primaryButton(
+    text: DSLSettingsText,
+    isEnabled: Boolean = true,
+    onClick: () -> Unit
+  ) {
+    val preference = Button.Model.Primary(text, null, isEnabled, onClick)
+    children.add(preference)
+  }
+
+  fun secondaryButtonNoOutline(
+    text: DSLSettingsText,
+    icon: DSLSettingsIcon? = null,
+    isEnabled: Boolean = true,
+    onClick: () -> Unit
+  ) {
+    val preference = Button.Model.SecondaryNoOutline(text, icon, isEnabled, onClick)
+    children.add(preference)
+  }
+
   fun textPref(
     title: DSLSettingsText? = null,
     summary: DSLSettingsText? = null

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

@@ -0,0 +1,54 @@
+package org.thoughtcrime.securesms.components.settings.models
+
+import android.view.View
+import android.widget.ViewSwitcher
+import com.google.android.material.switchmaterial.SwitchMaterial
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.settings.DSLSettingsText
+import org.thoughtcrime.securesms.components.settings.PreferenceModel
+import org.thoughtcrime.securesms.components.settings.PreferenceViewHolder
+import org.thoughtcrime.securesms.util.MappingAdapter
+
+/**
+ * Switch that will perform a long-running async operation (normally network) that requires a
+ * progress spinner to replace the switch after a press.
+ */
+object AsyncSwitch {
+
+  fun register(adapter: MappingAdapter) {
+    adapter.registerFactory(Model::class.java, MappingAdapter.LayoutFactory(AsyncSwitch::ViewHolder, R.layout.dsl_async_switch_preference_item))
+  }
+
+  class Model(
+    override val title: DSLSettingsText,
+    override val isEnabled: Boolean,
+    val isChecked: Boolean,
+    val isProcessing: Boolean,
+    val onClick: () -> Unit
+  ) : PreferenceModel<Model>() {
+    override fun areContentsTheSame(newItem: Model): Boolean {
+      return super.areContentsTheSame(newItem) && isChecked == newItem.isChecked && isProcessing == newItem.isProcessing
+    }
+  }
+
+  class ViewHolder(itemView: View) : PreferenceViewHolder<Model>(itemView) {
+    private val switchWidget: SwitchMaterial = itemView.findViewById(R.id.switch_widget)
+    private val switcher: ViewSwitcher = itemView.findViewById(R.id.switcher)
+
+    override fun bind(model: Model) {
+      super.bind(model)
+      switchWidget.isEnabled = model.isEnabled
+      switchWidget.isChecked = model.isChecked
+      itemView.isEnabled = !model.isProcessing
+      switcher.displayedChild = if (model.isProcessing) 1 else 0
+
+      itemView.setOnClickListener {
+        if (!model.isProcessing) {
+          itemView.isEnabled = false
+          switcher.displayedChild = 1
+          model.onClick()
+        }
+      }
+    }
+  }
+}