Add archive media apis.

2026-04-22 18:00:02 +01:00 · 2024-03-05 11:00:29 -05:00
parent ccc9752485
commit 218964cbda
18 changed files with 785 additions and 62 deletions
--- a/app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/backup/InternalBackupPlaygroundFragment.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/backup/InternalBackupPlaygroundFragment.kt
@@ -12,7 +12,11 @@ import android.os.Bundle
 import android.widget.Toast
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -20,12 +24,26 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
+import androidx.compose.material3.Tab
+import androidx.compose.material3.TabRow
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextAlign
@@ -34,6 +52,7 @@ import androidx.compose.ui.unit.dp
 import androidx.fragment.app.viewModels
 import org.signal.core.ui.Buttons
 import org.signal.core.ui.Dividers
+import org.signal.core.ui.Snackbars
 import org.signal.core.ui.theme.SignalTheme
 import org.signal.core.util.bytes
 import org.signal.core.util.getLength
@@ -88,47 +107,95 @@ class InternalBackupPlaygroundFragment : ComposeFragment() {
  @Composable
  override fun FragmentContent() {
    val state by viewModel.state
+    val mediaState by viewModel.mediaState

-    Screen(
-      state = state,
-      onExportClicked = { viewModel.export() },
-      onImportMemoryClicked = { viewModel.import() },
-      onImportFileClicked = {
-        val intent = Intent().apply {
-          action = Intent.ACTION_GET_CONTENT
-          type = "application/octet-stream"
-          addCategory(Intent.CATEGORY_OPENABLE)
-        }
+    LaunchedEffect(Unit) {
+      viewModel.loadMedia()
+    }

-        importFileLauncher.launch(intent)
+    Tabs(
+      mainContent = {
+        Screen(
+          state = state,
+          onExportClicked = { viewModel.export() },
+          onImportMemoryClicked = { viewModel.import() },
+          onImportFileClicked = {
+            val intent = Intent().apply {
+              action = Intent.ACTION_GET_CONTENT
+              type = "application/octet-stream"
+              addCategory(Intent.CATEGORY_OPENABLE)
+            }
+
+            importFileLauncher.launch(intent)
+          },
+          onPlaintextClicked = { viewModel.onPlaintextToggled() },
+          onSaveToDiskClicked = {
+            val intent = Intent().apply {
+              action = Intent.ACTION_CREATE_DOCUMENT
+              type = "application/octet-stream"
+              addCategory(Intent.CATEGORY_OPENABLE)
+              putExtra(Intent.EXTRA_TITLE, "backup-${if (state.plaintext) "plaintext" else "encrypted"}-${System.currentTimeMillis()}.bin")
+            }
+
+            exportFileLauncher.launch(intent)
+          },
+          onUploadToRemoteClicked = { viewModel.uploadBackupToRemote() },
+          onCheckRemoteBackupStateClicked = { viewModel.checkRemoteBackupState() },
+          onValidateFileClicked = {
+            val intent = Intent().apply {
+              action = Intent.ACTION_GET_CONTENT
+              type = "application/octet-stream"
+              addCategory(Intent.CATEGORY_OPENABLE)
+            }
+
+            validateFileLauncher.launch(intent)
+          }
+        )
      },
-      onPlaintextClicked = { viewModel.onPlaintextToggled() },
-      onSaveToDiskClicked = {
-        val intent = Intent().apply {
-          action = Intent.ACTION_CREATE_DOCUMENT
-          type = "application/octet-stream"
-          addCategory(Intent.CATEGORY_OPENABLE)
-          putExtra(Intent.EXTRA_TITLE, "backup-${if (state.plaintext) "plaintext" else "encrypted"}-${System.currentTimeMillis()}.bin")
-        }
-
-        exportFileLauncher.launch(intent)
-      },
-      onUploadToRemoteClicked = { viewModel.uploadBackupToRemote() },
-      onCheckRemoteBackupStateClicked = { viewModel.checkRemoteBackupState() },
-      onValidateFileClicked = {
-        val intent = Intent().apply {
-          action = Intent.ACTION_GET_CONTENT
-          type = "application/octet-stream"
-          addCategory(Intent.CATEGORY_OPENABLE)
-        }
-
-        validateFileLauncher.launch(intent)
+      mediaContent = { snackbarHostState ->
+        MediaList(
+          state = mediaState,
+          snackbarHostState = snackbarHostState,
+          backupAttachmentMedia = { viewModel.backupAttachmentMedia(it) },
+          deleteBackupAttachmentMedia = { viewModel.deleteBackupAttachmentMedia(it) },
+          batchBackupAttachmentMedia = { viewModel.backupAttachmentMedia(it) },
+          batchDeleteBackupAttachmentMedia = { viewModel.deleteBackupAttachmentMedia(it) }
+        )
      }
    )
  }
+}

-  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-    super.onActivityResult(requestCode, resultCode, data)
+@Composable
+fun Tabs(
+  mainContent: @Composable () -> Unit,
+  mediaContent: @Composable (snackbarHostState: SnackbarHostState) -> Unit
+) {
+  val tabs = listOf("Main", "Media")
+  var tabIndex by remember { mutableIntStateOf(0) }
+
+  val snackbarHostState: SnackbarHostState = remember { SnackbarHostState() }
+
+  Scaffold(
+    snackbarHost = { Snackbars.Host(snackbarHostState) },
+    topBar = {
+      TabRow(selectedTabIndex = tabIndex) {
+        tabs.forEachIndexed { index, tab ->
+          Tab(
+            text = { Text(tab) },
+            selected = index == tabIndex,
+            onClick = { tabIndex = index }
+          )
+        }
+      }
+    }
+  ) {
+    Surface(modifier = Modifier.padding(it)) {
+      when (tabIndex) {
+        0 -> mainContent()
+        1 -> mediaContent(snackbarHostState)
+      }
+    }
  }
 }

@@ -198,9 +265,11 @@ fun Screen(
        BackupState.NONE -> {
          StateLabel("")
        }
+
        BackupState.EXPORT_IN_PROGRESS -> {
          StateLabel("Export in progress...")
        }
+
        BackupState.EXPORT_DONE -> {
          StateLabel("Export complete. Sitting in memory. You can click 'Import' to import that data, save it to a file, or upload it to remote.")

@@ -210,6 +279,7 @@ fun Screen(
            Text("Save to file")
          }
        }
+
        BackupState.IMPORT_IN_PROGRESS -> {
          StateLabel("Import in progress...")
        }
@@ -229,12 +299,15 @@ fun Screen(
        is InternalBackupPlaygroundViewModel.RemoteBackupState.Available -> {
          StateLabel("Exists/allocated. ${state.remoteBackupState.response.mediaCount} media items, using ${state.remoteBackupState.response.usedSpace} bytes (${state.remoteBackupState.response.usedSpace.bytes.inMebiBytes.roundedString(3)} MiB)")
        }
+
        InternalBackupPlaygroundViewModel.RemoteBackupState.GeneralError -> {
          StateLabel("Hit an unknown error. Check the logs.")
        }
+
        InternalBackupPlaygroundViewModel.RemoteBackupState.NotFound -> {
          StateLabel("Not found.")
        }
+
        InternalBackupPlaygroundViewModel.RemoteBackupState.Unknown -> {
          StateLabel("Hit the button above to check the state.")
        }
@@ -255,12 +328,15 @@ fun Screen(
        BackupUploadState.NONE -> {
          StateLabel("")
        }
+
        BackupUploadState.UPLOAD_IN_PROGRESS -> {
          StateLabel("Upload in progress...")
        }
+
        BackupUploadState.UPLOAD_DONE -> {
          StateLabel("Upload complete.")
        }
+
        BackupUploadState.UPLOAD_FAILED -> {
          StateLabel("Upload failed.")
        }
@@ -278,6 +354,124 @@ private fun StateLabel(text: String) {
  )
 }

+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun MediaList(
+  state: InternalBackupPlaygroundViewModel.MediaState,
+  snackbarHostState: SnackbarHostState,
+  backupAttachmentMedia: (InternalBackupPlaygroundViewModel.BackupAttachment) -> Unit,
+  deleteBackupAttachmentMedia: (InternalBackupPlaygroundViewModel.BackupAttachment) -> Unit,
+  batchBackupAttachmentMedia: (Set<String>) -> Unit,
+  batchDeleteBackupAttachmentMedia: (Set<String>) -> Unit
+) {
+  LaunchedEffect(state.error?.id) {
+    state.error?.let {
+      snackbarHostState.showSnackbar(it.errorText)
+    }
+  }
+
+  var selectionState by remember { mutableStateOf(MediaMultiSelectState()) }
+
+  Box(modifier = Modifier.fillMaxSize()) {
+    LazyColumn(modifier = Modifier.fillMaxSize()) {
+      items(
+        count = state.attachments.size,
+        key = { index -> state.attachments[index].id }
+      ) { index ->
+        val attachment = state.attachments[index]
+        Row(
+          modifier = Modifier
+            .combinedClickable(
+              onClick = {
+                if (selectionState.selecting) {
+                  selectionState = selectionState.copy(selected = if (selectionState.selected.contains(attachment.mediaId)) selectionState.selected - attachment.mediaId else selectionState.selected + attachment.mediaId)
+                }
+              },
+              onLongClick = {
+                selectionState = if (selectionState.selecting) MediaMultiSelectState() else MediaMultiSelectState(selecting = true, selected = setOf(attachment.mediaId))
+              }
+            )
+            .padding(horizontal = 16.dp, vertical = 8.dp)
+        ) {
+          if (selectionState.selecting) {
+            Checkbox(
+              checked = selectionState.selected.contains(attachment.mediaId),
+              onCheckedChange = { selected ->
+                selectionState = selectionState.copy(selected = if (selected) selectionState.selected + attachment.mediaId else selectionState.selected - attachment.mediaId)
+              }
+            )
+          }
+
+          Column(modifier = Modifier.weight(1f, true)) {
+            Text(text = "Attachment ${attachment.title}")
+            Text(text = "State: ${attachment.state}")
+          }
+
+          if (attachment.state == InternalBackupPlaygroundViewModel.BackupAttachment.State.INIT ||
+            attachment.state == InternalBackupPlaygroundViewModel.BackupAttachment.State.IN_PROGRESS
+          ) {
+            CircularProgressIndicator()
+          } else {
+            Button(
+              enabled = !selectionState.selecting,
+              onClick = {
+                when (attachment.state) {
+                  InternalBackupPlaygroundViewModel.BackupAttachment.State.LOCAL_ONLY -> backupAttachmentMedia(attachment)
+                  InternalBackupPlaygroundViewModel.BackupAttachment.State.UPLOADED -> deleteBackupAttachmentMedia(attachment)
+                  else -> throw AssertionError("Unsupported state: ${attachment.state}")
+                }
+              }
+            ) {
+              Text(
+                text = when (attachment.state) {
+                  InternalBackupPlaygroundViewModel.BackupAttachment.State.LOCAL_ONLY -> "Backup"
+                  InternalBackupPlaygroundViewModel.BackupAttachment.State.UPLOADED -> "Remote Delete"
+                  else -> throw AssertionError("Unsupported state: ${attachment.state}")
+                }
+              )
+            }
+          }
+        }
+      }
+    }
+
+    if (selectionState.selecting) {
+      Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = Modifier
+          .align(Alignment.BottomCenter)
+          .padding(bottom = 24.dp)
+          .background(
+            color = MaterialTheme.colorScheme.secondaryContainer,
+            shape = RoundedCornerShape(8.dp)
+          )
+          .padding(8.dp)
+      ) {
+        Button(onClick = { selectionState = MediaMultiSelectState() }) {
+          Text("Cancel")
+        }
+        Button(onClick = {
+          batchBackupAttachmentMedia(selectionState.selected)
+          selectionState = MediaMultiSelectState()
+        }) {
+          Text("Backup")
+        }
+        Button(onClick = {
+          batchDeleteBackupAttachmentMedia(selectionState.selected)
+          selectionState = MediaMultiSelectState()
+        }) {
+          Text("Delete")
+        }
+      }
+    }
+  }
+}
+
+private data class MediaMultiSelectState(
+  val selecting: Boolean = false,
+  val selected: Set<String> = emptySet()
+)
+
@Preview(name = "Light Theme", group = "screen", uiMode = Configuration.UI_MODE_NIGHT_NO)
@Preview(name = "Dark Theme", group = "screen", uiMode = Configuration.UI_MODE_NIGHT_YES)
@Composable
--- a/app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/backup/InternalBackupPlaygroundViewModel.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/backup/InternalBackupPlaygroundViewModel.kt
@@ -13,17 +13,27 @@ import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 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.schedulers.Schedulers
+import org.signal.core.util.Base64
 import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.attachments.DatabaseAttachment
 import org.thoughtcrime.securesms.backup.v2.BackupMetadata
 import org.thoughtcrime.securesms.backup.v2.BackupRepository
+import org.thoughtcrime.securesms.database.SignalDatabase
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.whispersystems.signalservice.api.NetworkResult
+import org.whispersystems.signalservice.api.backup.BackupKey
 import java.io.ByteArrayInputStream
 import java.io.InputStream
+import java.util.UUID
+import kotlin.random.Random

 class InternalBackupPlaygroundViewModel : ViewModel() {

+  private val backupKey = SignalStore.svr().getOrCreateMasterKey().deriveBackupKey()
+
  var backupData: ByteArray? = null

  val disposables = CompositeDisposable()
@@ -31,6 +41,9 @@ class InternalBackupPlaygroundViewModel : ViewModel() {
  private val _state: MutableState<ScreenState> = mutableStateOf(ScreenState(backupState = BackupState.NONE, uploadState = BackupUploadState.NONE, plaintext = false))
  val state: State<ScreenState> = _state

+  private val _mediaState: MutableState<MediaState> = mutableStateOf(MediaState())
+  val mediaState: State<MediaState> = _mediaState
+
  fun export() {
    _state.value = _state.value.copy(backupState = BackupState.EXPORT_IN_PROGRESS)
    val plaintext = _state.value.plaintext
@@ -117,9 +130,11 @@ class InternalBackupPlaygroundViewModel : ViewModel() {
          result is NetworkResult.Success -> {
            _state.value = _state.value.copy(remoteBackupState = RemoteBackupState.Available(result.result))
          }
+
          result is NetworkResult.StatusCodeError && result.code == 404 -> {
            _state.value = _state.value.copy(remoteBackupState = RemoteBackupState.NotFound)
          }
+
          else -> {
            _state.value = _state.value.copy(remoteBackupState = RemoteBackupState.GeneralError)
          }
@@ -127,6 +142,98 @@ class InternalBackupPlaygroundViewModel : ViewModel() {
      }
  }

+  fun loadMedia() {
+    disposables += Single
+      .fromCallable { SignalDatabase.attachments.debugGetLatestAttachments() }
+      .subscribeOn(Schedulers.io())
+      .observeOn(Schedulers.single())
+      .subscribeBy {
+        _mediaState.set { update(attachments = it.map { a -> BackupAttachment.from(backupKey, a) }) }
+      }
+
+    disposables += Single
+      .fromCallable { BackupRepository.debugGetArchivedMediaState() }
+      .subscribeOn(Schedulers.io())
+      .observeOn(Schedulers.single())
+      .subscribeBy { result ->
+        when (result) {
+          is NetworkResult.Success -> _mediaState.set { update(archiveStateLoaded = true, backedUpMediaIds = result.result.map { it.mediaId }.toSet()) }
+          else -> _mediaState.set { copy(error = MediaStateError(errorText = "$result")) }
+        }
+      }
+  }
+
+  fun backupAttachmentMedia(mediaIds: Set<String>) {
+    disposables += Single.fromCallable { mediaIds.mapNotNull { mediaState.value.idToAttachment[it]?.dbAttachment }.toList() }
+      .map { BackupRepository.archiveMedia(it) }
+      .subscribeOn(Schedulers.io())
+      .observeOn(Schedulers.single())
+      .doOnSubscribe { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds + mediaIds) } }
+      .doOnTerminate { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds - mediaIds) } }
+      .subscribeBy { result ->
+        when (result) {
+          is NetworkResult.Success -> {
+            val response = result.result
+            val successes = response.responses.filter { it.status == 200 }
+            val failures = response.responses - successes.toSet()
+
+            _mediaState.set {
+              var updated = update(backedUpMediaIds = backedUpMediaIds + successes.map { it.mediaId })
+              if (failures.isNotEmpty()) {
+                updated = updated.copy(error = MediaStateError(errorText = failures.toString()))
+              }
+              updated
+            }
+          }
+
+          else -> _mediaState.set { copy(error = MediaStateError(errorText = "$result")) }
+        }
+      }
+  }
+
+  fun backupAttachmentMedia(attachment: BackupAttachment) {
+    disposables += Single.fromCallable { BackupRepository.archiveMedia(attachment.dbAttachment) }
+      .subscribeOn(Schedulers.io())
+      .observeOn(Schedulers.single())
+      .doOnSubscribe { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds + attachment.mediaId) } }
+      .doOnTerminate { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds - attachment.mediaId) } }
+      .subscribeBy {
+        when (it) {
+          is NetworkResult.Success -> {
+            _mediaState.set { update(backedUpMediaIds = backedUpMediaIds + attachment.mediaId) }
+          }
+
+          else -> _mediaState.set { copy(error = MediaStateError(errorText = "$it")) }
+        }
+      }
+  }
+
+  fun deleteBackupAttachmentMedia(mediaIds: Set<String>) {
+    deleteBackupAttachmentMedia(mediaIds.mapNotNull { mediaState.value.idToAttachment[it] }.toList())
+  }
+
+  fun deleteBackupAttachmentMedia(attachment: BackupAttachment) {
+    deleteBackupAttachmentMedia(listOf(attachment))
+  }
+
+  private fun deleteBackupAttachmentMedia(attachments: List<BackupAttachment>) {
+    val ids = attachments.map { it.mediaId }.toSet()
+    disposables += Single.fromCallable { BackupRepository.deleteArchivedMedia(attachments.map { it.dbAttachment }) }
+      .subscribeOn(Schedulers.io())
+      .observeOn(Schedulers.single())
+      .doOnSubscribe { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds + ids) } }
+      .doOnTerminate { _mediaState.set { update(inProgressMediaIds = inProgressMediaIds - ids) } }
+      .subscribeBy {
+        when (it) {
+          is NetworkResult.Success -> {
+            _mediaState.set { update(backedUpMediaIds = backedUpMediaIds - ids) }
+          }
+
+          else -> _mediaState.set { copy(error = MediaStateError(errorText = "$it")) }
+        }
+      }
+  }
+
  override fun onCleared() {
    disposables.clear()
  }
@@ -152,4 +259,77 @@ class InternalBackupPlaygroundViewModel : ViewModel() {
    object GeneralError : RemoteBackupState()
    data class Available(val response: BackupMetadata) : RemoteBackupState()
  }
+
+  data class MediaState(
+    val backupStateLoaded: Boolean = false,
+    val attachments: List<BackupAttachment> = emptyList(),
+    val backedUpMediaIds: Set<String> = emptySet(),
+    val inProgressMediaIds: Set<String> = emptySet(),
+    val error: MediaStateError? = null
+  ) {
+    val idToAttachment: Map<String, BackupAttachment> = attachments.associateBy { it.mediaId }
+
+    fun update(
+      archiveStateLoaded: Boolean = this.backupStateLoaded,
+      attachments: List<BackupAttachment> = this.attachments,
+      backedUpMediaIds: Set<String> = this.backedUpMediaIds,
+      inProgressMediaIds: Set<String> = this.inProgressMediaIds
+    ): MediaState {
+      val updatedAttachments = if (archiveStateLoaded) {
+        attachments.map {
+          val state = if (inProgressMediaIds.contains(it.mediaId)) {
+            BackupAttachment.State.IN_PROGRESS
+          } else if (backedUpMediaIds.contains(it.mediaId)) {
+            BackupAttachment.State.UPLOADED
+          } else {
+            BackupAttachment.State.LOCAL_ONLY
+          }
+
+          it.copy(state = state)
+        }
+      } else {
+        attachments
+      }
+
+      return copy(
+        backupStateLoaded = archiveStateLoaded,
+        attachments = updatedAttachments,
+        backedUpMediaIds = backedUpMediaIds
+      )
+    }
+  }
+
+  data class BackupAttachment(
+    val dbAttachment: DatabaseAttachment,
+    val state: State = State.INIT,
+    val mediaId: String = Base64.encodeUrlSafeWithPadding(Random.nextBytes(15))
+  ) {
+    val id: Any = dbAttachment.attachmentId
+    val title: String = dbAttachment.attachmentId.toString()
+
+    enum class State {
+      INIT,
+      LOCAL_ONLY,
+      UPLOADED,
+      IN_PROGRESS
+    }
+
+    companion object {
+      fun from(backupKey: BackupKey, dbAttachment: DatabaseAttachment): BackupAttachment {
+        return BackupAttachment(
+          dbAttachment = dbAttachment,
+          mediaId = backupKey.deriveMediaId(Base64.decode(dbAttachment.dataHash!!)).toString()
+        )
+      }
+    }
+  }
+
+  data class MediaStateError(
+    val id: UUID = UUID.randomUUID(),
+    val errorText: String
+  )
+
+  fun <T> MutableState<T>.set(update: T.() -> T) {
+    this.value = this.value.update()
+  }
 }