feat(accounts): add platform credential slots

androidApp/src/main/kotlin/dev/obiente/nextcloudnative/AndroidAccountCredentialTransitions.kt

@@ -0,0 +1,193 @@
+package dev.obiente.nextcloudnative
+
+import dev.obiente.nextcloudnative.app.NextcloudSession
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.withContext
+
+internal fun removeActiveAndroidAccountCredentialState(
+    state: AndroidAccountCredentialState,
+): AndroidAccountCredentialState = state.registry.activeAccountId?.let(state::remove) ?: state
+
+internal suspend fun replaceAndroidActiveStateWithAccountLeases(
+    replacement: AndroidAccountCredentialState,
+    previousSession: NextcloudSession?,
+    replacedSession: NextcloudSession?,
+    suspectEncrypted: String?,
+    guard: AndroidAccountOperationGuard = ANDROID_ACCOUNT_OPERATION_GUARD,
+    coordinator: AndroidFileRangeSessionCoordinator = ANDROID_FILE_RANGE_SESSION_COORDINATOR,
+    replace: suspend (AndroidAccountCredentialState, NextcloudSession?, String?, NextcloudSession?) -> Unit,
+) {
+    val replacementSession = requireNotNull(replacement.activeSession)
+    val accountIdentities = listOfNotNull(previousSession, replacementSession, replacedSession)
+        .map(NextcloudDocumentIds::accountKey)
+    guard.withAccounts(accountIdentities) {
+        quiesceAndroidFileRangesBeforeCredentialReplacement(replacedSession, replacementSession, coordinator)
+        replace(replacement, previousSession, suspectEncrypted, replacedSession)
+    }
+}
+
+internal suspend fun rollbackUnavailableAndroidAccountRemoval(
+    active: Boolean = false,
+    recovered: AndroidAccountCredentialState,
+    persistRecovered: suspend (AndroidAccountCredentialState) -> Unit,
+    clearCleanup: suspend () -> Unit,
+) {
+    if (!active) persistRecovered(recovered)
+    clearCleanup()
+}
+
+internal suspend fun retryAndroidAccountRemovalCleanup(
+    accountOwnedByRegistry: Boolean?,
+    removeAccountOwnedWork: suspend () -> Unit,
+    clearCleanup: suspend () -> Unit,
+) {
+    when (accountOwnedByRegistry) {
+        true -> clearCleanup()
+        false -> {
+            removeAccountOwnedWork()
+            clearCleanup()
+        }
+        null -> error("Account ownership is unavailable; pending cleanup cannot run safely.")
+    }
+}
+
+internal fun androidAccountRemovalCleanupRetryFailure(failure: Exception) = IllegalStateException(
+    "Previous account cleanup must finish before this account can be added again.",
+    failure,
+)
+
+internal suspend fun retryAndroidAccountOwnedStateCleanup(
+    session: NextcloudSession,
+    pending: AndroidPendingAccountRemovalCleanup,
+    retry: suspend (NextcloudSession, String, String?, String?, String?) -> Unit,
+) {
+    retry(
+        session,
+        pending.workIdentity,
+        pending.previewCacheIdentity,
+        pending.durableMutationIdentity,
+        pending.legacyAccountScopeDigest,
+    )
+}
+
+internal suspend fun resumeAndroidQueuedUploadsAfterSelection(
+    resume: suspend () -> Unit,
+    notifyDocumentRootsChanged: () -> Unit,
+    recordFailure: () -> Unit,
+) {
+    try {
+        resume()
+    } catch (cancelled: CancellationException) {
+        throw cancelled
+    } catch (_: Exception) {
+        recordFailure()
+    } finally {
+        notifyDocumentRootsChanged()
+    }
+}
+
+internal suspend fun removeAndroidAccountCredentialData(
+    active: Boolean,
+    prepareAccountRemoval: suspend () -> Unit = {},
+    removeQueuedUploads: suspend () -> Unit,
+    clearActiveAccount: suspend () -> Unit,
+    rollbackActiveRemoval: suspend () -> Unit,
+    persistInactiveRemoval: suspend () -> Unit,
+    rollbackInactiveRemoval: suspend () -> Unit,
+    completeCommittedCleanup: suspend () -> Unit = {},
+    recordCommittedCleanupFailure: (Exception) -> Unit = {},
+) {
+    prepareAccountRemoval()
+    if (active) {
+        try {
+            clearActiveAccount()
+        } catch (failure: Exception) {
+            withContext(NonCancellable) {
+                runCatching { rollbackActiveRemoval() }
+                    .onFailure(failure::addSuppressed)
+            }
+            throw failure
+        }
+        finishCommittedAndroidAccountRemovalCleanup(
+            removeQueuedUploads,
+            completeCommittedCleanup,
+            recordCommittedCleanupFailure,
+        )
+        return
+    }
+
+    try {
+        persistInactiveRemoval()
+    } catch (failure: Exception) {
+        withContext(NonCancellable) {
+            runCatching { rollbackInactiveRemoval() }
+                .onFailure(failure::addSuppressed)
+        }
+        throw failure
+    }
+    finishCommittedAndroidAccountRemovalCleanup(
+        removeQueuedUploads,
+        completeCommittedCleanup,
+        recordCommittedCleanupFailure,
+    )
+}
+
+internal suspend fun removeUnavailableAndroidAccountCredentialData(
+    accountIdentity: String,
+    active: Boolean = false,
+    prepareAccountRemoval: suspend () -> Unit,
+    removeAccountOwnedWorkWithoutCredentials: suspend (String) -> Unit,
+    persistRemoval: suspend () -> Unit,
+    clearActiveAccount: suspend () -> Unit = persistRemoval,
+    rollbackRemoval: suspend () -> Unit,
+    completeCommittedCleanup: suspend () -> Unit = {},
+    recordCommittedCleanupFailure: (Exception) -> Unit = {},
+) {
+    require(accountIdentity.isNotBlank())
+    removeAndroidAccountCredentialData(
+        active = active,
+        prepareAccountRemoval = prepareAccountRemoval,
+        removeQueuedUploads = { removeAccountOwnedWorkWithoutCredentials(accountIdentity) },
+        clearActiveAccount = clearActiveAccount,
+        rollbackActiveRemoval = rollbackRemoval,
+        persistInactiveRemoval = persistRemoval,
+        rollbackInactiveRemoval = rollbackRemoval,
+        completeCommittedCleanup = completeCommittedCleanup,
+        recordCommittedCleanupFailure = recordCommittedCleanupFailure,
+    )
+}
+
+private suspend fun finishCommittedAndroidAccountRemovalCleanup(
+    removeQueuedUploads: suspend () -> Unit,
+    completeCommittedCleanup: suspend () -> Unit,
+    recordFailure: (Exception) -> Unit,
+) {
+    try {
+        removeQueuedUploads()
+        completeCommittedCleanup()
+    } catch (cancelled: CancellationException) {
+        throw cancelled
+    } catch (failure: Exception) {
+        recordFailure(failure)
+    }
+}
+
+internal suspend fun removeRecoveredAndroidAccountCredentialData(
+    prepareAccountRemoval: suspend () -> Unit = {},
+    removeQueuedUploads: suspend () -> Unit,
+    clearRecoveredAccount: suspend () -> Unit,
+    rollbackRecoveredAccount: suspend () -> Unit,
+    completeCommittedCleanup: suspend () -> Unit = {},
+    recordCommittedCleanupFailure: (Exception) -> Unit = {},
+) = removeAndroidAccountCredentialData(
+    active = true,
+    prepareAccountRemoval = prepareAccountRemoval,
+    removeQueuedUploads = removeQueuedUploads,
+    clearActiveAccount = clearRecoveredAccount,
+    rollbackActiveRemoval = rollbackRecoveredAccount,
+    persistInactiveRemoval = {},
+    rollbackInactiveRemoval = {},
+    completeCommittedCleanup = completeCommittedCleanup,
+    recordCommittedCleanupFailure = recordCommittedCleanupFailure,
+)

androidApp/src/main/kotlin/dev/obiente/nextcloudnative/AndroidAccountFileListing.kt

@@ -0,0 +1,57 @@
+package dev.obiente.nextcloudnative
+
+import dev.obiente.nextcloudnative.app.NextcloudFile
+import dev.obiente.nextcloudnative.app.NextcloudFileListing
+import dev.obiente.nextcloudnative.app.NextcloudFileListingHttpException
+import dev.obiente.nextcloudnative.app.NextcloudFileListingSource
+import dev.obiente.nextcloudnative.app.NextcloudSession
+import java.io.IOException
+
+internal data class AndroidDavFileListingResponse(val status: Int, val files: List<NextcloudFile>)
+
+/** The caller may reuse a lease only while its enclosing account operation still owns it. */
+internal suspend fun loadAndroidAccountFileListing(
+    session: NextcloudSession,
+    resolveSession: suspend () -> NextcloudSession?,
+    cache: AndroidFileReadCache,
+    path: String,
+    accountLeaseHeld: Boolean = false,
+    guard: AndroidAccountOperationGuard = ANDROID_ACCOUNT_OPERATION_GUARD,
+    request: suspend () -> AndroidDavFileListingResponse,
+): NextcloudFileListing {
+    val read: suspend () -> NextcloudFileListing = {
+        readAndroidAccountFileListing(cache, NextcloudDocumentIds.accountKey(session), path, request)
+    }
+    return if (accountLeaseHeld) read() else withRetainedAndroidAccountFileRead(session, resolveSession, guard, read)
+}
+
+private suspend fun readAndroidAccountFileListing(
+    cache: AndroidFileReadCache,
+    accountId: String,
+    path: String,
+    request: suspend () -> AndroidDavFileListingResponse,
+): NextcloudFileListing = try {
+    val response = request()
+    if (response.status == 207) {
+        val files = response.files.drop(1)
+            .sortedWith(compareByDescending<NextcloudFile> { it.isDirectory }.thenBy { it.name.lowercase() })
+        runCatching { cache.storeListing(accountId, path, files) }
+        NextcloudFileListing(files, NextcloudFileListingSource.Network)
+    } else {
+        val cached = if (response.status >= 500) cache.cachedListing(accountId, path) else null
+        cached?.let { NextcloudFileListing(it.files, NextcloudFileListingSource.Cache) }
+            ?: throw NextcloudFileListingHttpException(response.status)
+    }
+} catch (failure: IOException) {
+    cache.cachedListing(accountId, path)?.files
+        ?.let { NextcloudFileListing(it, NextcloudFileListingSource.Cache) }
+        ?: throw failure
+}
+
+internal fun requireAndroidDocumentDirectory(
+    reference: NextcloudDocumentReference,
+    findDocument: (String) -> NextcloudFile,
+) {
+    if (reference.isRoot) return
+    require(findDocument(reference.path).isDirectory) { "The selected parent is not a folder." }
+}