feat: Make files available offline (WPB-23968)

app/src/main/kotlin/com/wire/android/di/accountScoped/CellsModule.kt

@@ -62,6 +62,10 @@ import com.wire.kalium.cells.domain.usecase.publiclink.SetPublicLinkExpirationUs
 import com.wire.kalium.cells.domain.usecase.publiclink.UpdatePublicLinkPasswordUseCase
 import com.wire.kalium.cells.domain.usecase.versioning.GetNodeVersionsUseCase
 import com.wire.kalium.cells.domain.usecase.versioning.RestoreNodeVersionUseCase
+import com.wire.kalium.cells.domain.usecase.offline.DeleteOfflineFileUseCase
+import com.wire.kalium.cells.domain.usecase.offline.GetOfflineFileUseCase
+import com.wire.kalium.cells.domain.usecase.offline.ObserveOfflineFilesUseCase
+import com.wire.kalium.cells.domain.usecase.offline.SaveOfflineFileUseCase
 import com.wire.kalium.cells.paginatedConversationsFlowUseCase
 import com.wire.kalium.cells.paginatedFilesFlowUseCase
 import com.wire.kalium.logic.CoreLogic
@@ -259,4 +263,20 @@ class CellsModule {
     @Provides
     fun provideGetPaginatedConversationsFlowUseCase(cellsScope: CellsScope): GetPaginatedCellConversationsFlowUseCase =
         cellsScope.paginatedConversationsFlowUseCase
+
+    @ViewModelScoped
+    @Provides
+    fun provideSaveOfflineFileUseCase(cellsScope: CellsScope): SaveOfflineFileUseCase = cellsScope.saveOfflineFile
+
+    @ViewModelScoped
+    @Provides
+    fun provideDeleteOfflineFileUseCase(cellsScope: CellsScope): DeleteOfflineFileUseCase = cellsScope.deleteOfflineFile
+
+    @ViewModelScoped
+    @Provides
+    fun provideObserveOfflineFilesUseCase(cellsScope: CellsScope): ObserveOfflineFilesUseCase = cellsScope.observeOfflineFiles
+
+    @ViewModelScoped
+    @Provides
+    fun provideGetOfflineFileUseCase(cellsScope: CellsScope): GetOfflineFileUseCase = cellsScope.getOfflineFile
 }

features/cells/src/main/java/com/wire/android/feature/cells/ui/CellFileActionsMenu.kt

@@ -19,7 +19,6 @@ package com.wire.android.feature.cells.ui
 
 import com.wire.android.feature.cells.ui.model.CellNodeUi
 import com.wire.android.feature.cells.ui.model.NodeBottomSheetAction
-import com.wire.android.feature.cells.ui.model.OpenLoadState
 import com.wire.android.feature.cells.ui.model.isEditSupported
 import com.wire.android.feature.cells.ui.model.localFileAvailable
 import com.wire.kalium.logic.featureFlags.KaliumConfigs
@@ -36,64 +35,115 @@ class CellFileActionsMenu @Inject constructor(
         isAllFiles: Boolean,
         isSearching: Boolean,
         isCollaboraEnabled: Boolean,
-    ): List<NodeBottomSheetAction> =
-        when {
-            isRecycleBin -> {
-                buildList {
-                    add(NodeBottomSheetAction.RESTORE)
-                    add(NodeBottomSheetAction.DELETE_PERMANENTLY)
-                }
-            }
+    ): List<NodeBottomSheetAction> {
+        return when {
+            isRecycleBin -> recycleBinActions()
 
             isAllFiles || isSearching -> {
-                buildList {
-                    if (cellNode is CellNodeUi.File && cellNode.openLoadState is OpenLoadState.Loading) {
-                        add(NodeBottomSheetAction.CANCEL_LOADING)
-                    } else {
-                        if (cellNode is CellNodeUi.File && cellNode.localFileAvailable()) {
-                            add(NodeBottomSheetAction.SHARE)
-                        }
-                        add(NodeBottomSheetAction.PUBLIC_LINK)
-                    }
-                }
+                commonActions(cellNode)
             }
 
             isConversationFiles -> {
-                buildList {
-                    if (cellNode is CellNodeUi.File && cellNode.openLoadState is OpenLoadState.Loading) {
-                        add(NodeBottomSheetAction.CANCEL_LOADING)
-                    } else {
-                        if (cellNode is CellNodeUi.File && cellNode.localFileAvailable()) {
-                            add(NodeBottomSheetAction.SHARE)
-                        }
-                        add(NodeBottomSheetAction.PUBLIC_LINK)
-
-                        if (isCollaboraEnabled && featureFlags.collaboraIntegration && cellNode.isEditSupported()) {
-                            add(NodeBottomSheetAction.EDIT)
-                        }
-
-                        if (featureFlags.collaboraIntegration && cellNode.isEditSupported()) {
-                            add(NodeBottomSheetAction.VERSION_HISTORY)
-                        }
-
-                        add(NodeBottomSheetAction.ADD_REMOVE_TAGS)
-                        add(NodeBottomSheetAction.MOVE)
-                        add(NodeBottomSheetAction.RENAME)
-                        add(NodeBottomSheetAction.DELETE)
-                    }
+                val common = commonActions(cellNode)
+                val isTerminal = cellNode is CellNodeUi.File &&
+                        (cellNode.isOpenLoading || cellNode.downloadProgress != null)
+                if (isTerminal) {
+                    common
+                } else {
+                    common + conversationActions(
+                        cellNode = cellNode,
+                        isCollaboraEnabled = isCollaboraEnabled,
+                    )
                 }
             }
 
-            else -> {
-                emptyList()
+            else -> emptyList()
+        }
+    }
+
+    private fun recycleBinActions(): List<NodeBottomSheetAction> = listOf(
+        NodeBottomSheetAction.RESTORE,
+        NodeBottomSheetAction.DELETE_PERMANENTLY,
+    )
+
+    private fun commonActions(
+        cellNode: CellNodeUi,
+    ): List<NodeBottomSheetAction> = buildList {
+
+        if (cellNode is CellNodeUi.File) {
+
+            when {
+                cellNode.isOpenLoading -> {
+                    add(NodeBottomSheetAction.CANCEL_LOADING)
+                    return@buildList
+                }
+
+                cellNode.downloadProgress != null -> {
+                    add(NodeBottomSheetAction.CANCEL_DOWNLOAD)
+                    return@buildList
+                }
+
+                else -> {
+                    if (cellNode.localFileAvailable()) {
+                        add(NodeBottomSheetAction.SHARE)
+                    }
+
+                    add(NodeBottomSheetAction.PUBLIC_LINK)
+
+                    add(
+                        if (cellNode.isAvailableOffline) {
+                            NodeBottomSheetAction.REMOVE_OFFLINE_ACCESS
+                        } else {
+                            NodeBottomSheetAction.MAKE_AVAILABLE_OFFLINE
+                        },
+                    )
+                }
             }
+        } else {
+            add(NodeBottomSheetAction.PUBLIC_LINK)
         }
+    }
+
+    private fun conversationActions(
+        cellNode: CellNodeUi,
+        isCollaboraEnabled: Boolean,
+    ): List<NodeBottomSheetAction> = buildList {
+
+        val canEdit = cellNode is CellNodeUi.File &&
+                isCollaboraEnabled &&
+                featureFlags.collaboraIntegration &&
+                cellNode.isEditSupported()
+
+        if (canEdit) {
+            add(NodeBottomSheetAction.EDIT)
+        }
+
+        if (
+            cellNode is CellNodeUi.File &&
+            featureFlags.collaboraIntegration &&
+            cellNode.isEditSupported()
+        ) {
+            add(NodeBottomSheetAction.VERSION_HISTORY)
+        }
+
+        addAll(
+            listOf(
+                NodeBottomSheetAction.ADD_REMOVE_TAGS,
+                NodeBottomSheetAction.MOVE,
+                NodeBottomSheetAction.RENAME,
+                NodeBottomSheetAction.DELETE,
+            ),
+        )
+    }
 
     internal sealed interface MenuActionResult
     internal data class Action(val action: CellViewAction) : MenuActionResult
     internal data class Share(val node: CellNodeUi.File) : MenuActionResult
     internal data class Edit(val node: CellNodeUi) : MenuActionResult
     internal data class CancelLoading(val node: CellNodeUi) : MenuActionResult
+    internal data class CancelDownload(val node: CellNodeUi) : MenuActionResult
+    internal data class MakeAvailableOffline(val node: CellNodeUi.File) : MenuActionResult
+    internal data class RemoveOfflineAccess(val node: CellNodeUi.File) : MenuActionResult
 
     internal fun onMenuItemAction(
         conversationId: String?,
@@ -137,6 +187,22 @@ class CellFileActionsMenu @Inject constructor(
             NodeBottomSheetAction.EDIT -> Edit(node)
             NodeBottomSheetAction.VERSION_HISTORY -> Action(ShowVersionHistoryScreen(node.uuid, node.name ?: ""))
             NodeBottomSheetAction.CANCEL_LOADING -> CancelLoading(node)
+            NodeBottomSheetAction.CANCEL_DOWNLOAD -> CancelDownload(node)
+            NodeBottomSheetAction.MAKE_AVAILABLE_OFFLINE -> {
+                if (node is CellNodeUi.File) {
+                    MakeAvailableOffline(node)
+                } else {
+                    Action(ShowPublicLinkScreen(node))
+                }
+            }
+
+            NodeBottomSheetAction.REMOVE_OFFLINE_ACCESS -> {
+                if (node is CellNodeUi.File) {
+                    RemoveOfflineAccess(node)
+                } else {
+                    Action(ShowPublicLinkScreen(node))
+                }
+            }
         }
 
         onResult(result)

features/cells/src/main/java/com/wire/android/feature/cells/ui/CellFileLocalPathCache.kt

@@ -37,6 +37,7 @@ import javax.inject.Singleton
  *
  * - [fileReadyEvents]: emitted when a slow download finishes so the UI can show a snackbar.
  * - [openLoadStates]: per-uuid Loading / Ready / Error state consumed by paging combines.
+ * - [downloadProgresses]: per-uuid offline-download progress
  */
 @Singleton
 class CellFileLocalPathCache @Inject constructor() {
@@ -47,6 +48,9 @@ class CellFileLocalPathCache @Inject constructor() {
     private val _openLoadStates = MutableStateFlow<Map<String, OpenLoadState>>(emptyMap())
     internal val openLoadStates: StateFlow<Map<String, OpenLoadState>> = _openLoadStates.asStateFlow()
 
+    private val _downloadProgresses = MutableStateFlow<Map<String, Float?>>(emptyMap())
+    internal val downloadProgresses: StateFlow<Map<String, Float?>> = _downloadProgresses.asStateFlow()
+
     // Session-level guard: records the local path once a download completes so that a
     // subsequent tap opens the file immediately, even if the paging source hasn't refreshed
     // yet with the new localPath from the DB.
@@ -57,6 +61,10 @@ class CellFileLocalPathCache @Inject constructor() {
 
     internal fun getCompletedPath(uuid: String): String? = completedPaths[uuid]
 
+    internal fun clearCompletedPath(uuid: String) {
+        completedPaths.remove(uuid)
+    }
+
     fun emitFileReady(file: CellNodeUi.File) {
         _fileReadyChannel.trySend(file)
     }
@@ -65,4 +73,10 @@ class CellFileLocalPathCache @Inject constructor() {
         _openLoadStates.update { it + (uuid to state) }
 
     internal fun clearOpenLoadState(uuid: String) = _openLoadStates.update { it - uuid }
+
+    internal fun setDownloadProgress(uuid: String, progress: Float?) =
+        _downloadProgresses.update { it + (uuid to progress) }
+
+    internal fun clearDownloadProgress(uuid: String) =
+        _downloadProgresses.update { it - uuid }
 }

features/cells/src/main/java/com/wire/android/feature/cells/ui/CellFilesScreen.kt

@@ -31,8 +31,8 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Text
 import androidx.compose.material3.pulltorefresh.PullToRefreshBox
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.State