feat(drive): Make files available offline (WPB-23968)

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

@@ -62,6 +62,12 @@ 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.GetConversationNameUseCase
+import com.wire.kalium.cells.domain.usecase.GetUserNameUseCase
+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 +265,28 @@ 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
+
+    @ViewModelScoped
+    @Provides
+    fun provideGetConversationNamesUseCase(cellsScope: CellsScope): GetConversationNameUseCase = cellsScope.getConversationName
+
+    @ViewModelScoped
+    @Provides
+    fun provideGetUserNamesUseCase(cellsScope: CellsScope): GetUserNameUseCase = cellsScope.getUserName
 }

app/src/main/kotlin/com/wire/android/ui/home/conversations/model/messagetypes/multipart/MultipartAttachmentsViewModel.kt

@@ -29,9 +29,9 @@
 import com.wire.android.ui.common.multipart.MultipartAttachmentUi
 import com.wire.android.ui.common.multipart.toUiModel
 import com.wire.android.util.FileManager
-import com.wire.kalium.cells.domain.usecase.download.DownloadCellFileUseCase
 import com.wire.kalium.cells.domain.usecase.GetEditorUrlUseCase
 import com.wire.kalium.cells.domain.usecase.GetWireCellConfigurationUseCase
+import com.wire.kalium.cells.domain.usecase.download.DownloadCellFileUseCase
 import com.wire.kalium.common.functional.onSuccess
 import com.wire.kalium.logic.data.asset.AssetTransferStatus
 import com.wire.kalium.logic.data.asset.KaliumFileSystem
@@ -122,7 +122,11 @@
             attachment.isImage() && !attachment.fileNotFound() -> openInImageViewer(attachment.uuid)
             attachment.isEditSupported && isCollaboraEnabled && featureFlags.collaboraIntegration ->
                 openOnlineEditor(attachment.uuid)
-            attachment.fileNotFound() -> { refreshHelper.refresh(attachment.uuid) }
+
+            attachment.fileNotFound() -> {
+                refreshHelper.refresh(attachment.uuid)
+            }
+
             attachment.localFileAvailable() -> openLocalFile(attachment)
             attachment.canOpenWithUrl() -> openUrl(attachment)
             else -> downloadAsset(attachment)
@@ -167,6 +171,7 @@
 
         download(
             assetId = attachment.uuid,
+            conversationId = null, // TODO to replace with real conversation id in next PR
             outFilePath = path,
             assetSize = attachment.assetSize ?: 0,
         ) { progress ->

app/src/test/kotlin/com/wire/android/ui/home/conversations/model/messagetypes/multipart/MultipartAttachmentsViewModelTest.kt

@@ -258,7 +258,7 @@ class MultipartAttachmentsViewModelTest {
             coEvery { refreshHelper.refresh(any()) } returns Unit
             coEvery { fileManager.openWithExternalApp(any(), any(), any(), any()) } returns Unit
             coEvery { fileManager.openUrlWithExternalApp(any(), any(), any()) } returns Unit
-            coEvery { download(any(), any(), any(), any(), any()) } returns Unit.right()
+            coEvery { download(any(), any(), any(), any(), any(), any(), any(), any()) } returns Unit.right()
             coEvery { getWireCellsConfig() } returns null
 
             return this to MultipartAttachmentsViewModelImpl(

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

@@ -17,18 +17,21 @@
  */
 package com.wire.android.feature.cells.ui
 
+import androidx.compose.animation.AnimatedContent
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.paging.compose.collectAsLazyPagingItems
 import com.ramcosta.composedestinations.generated.cells.destinations.AddRemoveTagsScreenDestination
 import com.ramcosta.composedestinations.generated.cells.destinations.PublicLinkScreenDestination
 import com.ramcosta.composedestinations.generated.cells.destinations.SearchScreenDestination
 import com.wire.android.feature.cells.R
+import com.wire.android.feature.cells.ui.common.OfflineBanner
 import com.wire.android.feature.cells.ui.search.DriveSearchScreenType
 import com.wire.android.navigation.NavigationCommand
 import com.wire.android.navigation.WireNavigator
@@ -47,26 +50,33 @@ fun AllFilesScreen(
 ) {
 
     val pagingListItems = viewModel.nodesFlow.collectAsLazyPagingItems()
+    val isOnline by viewModel.isOnline.collectAsState()
 
     WireScaffold(
         modifier = modifier,
         topBar = {
             Column {
-                SearchTopBar(
-                    modifier = Modifier,
-                    isSearchActive = false,
-                    searchBarHint = stringResource(R.string.search_label),
-                    searchQueryTextState = rememberTextFieldState(),
-                    onTap = {
-                        navigator.navigate(
-                            NavigationCommand(
-                                SearchScreenDestination(
-                                    screenType = DriveSearchScreenType.DRIVE,
+                AnimatedContent(isOnline) {
+                    if (it) {
+                        SearchTopBar(
+                            modifier = Modifier,
+                            isSearchActive = false,
+                            searchBarHint = stringResource(R.string.search_label),
+                            searchQueryTextState = rememberTextFieldState(),
+                            onTap = {
+                                navigator.navigate(
+                                    NavigationCommand(
+                                        SearchScreenDestination(
+                                            screenType = DriveSearchScreenType.DRIVE,
+                                        )
+                                    )
                                 )
-                            )
+                            },
                         )
-                    },
-                )
+                    } else {
+                        OfflineBanner()
+                    }
+                }
             }
         },
     ) { innerPadding ->
@@ -78,6 +88,7 @@ fun AllFilesScreen(
             openFolder = { _, _, _ -> },
             menuState = viewModel.menu,
             isAllFiles = true,
+            isOffline = !isOnline,
             isRestoreInProgress = viewModel.isRestoreInProgress.collectAsState().value,
             isDeleteInProgress = viewModel.isDeleteInProgress.collectAsState().value,
             isRecycleBin = viewModel.isRecycleBin(),

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

@@ -19,7 +19,6 @@
 
 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,131 @@
         isAllFiles: Boolean,
         isSearching: Boolean,
         isCollaboraEnabled: Boolean,
-    ): List<NodeBottomSheetAction> =
-        when {
-            isRecycleBin -> {
-                buildList {
-                    add(NodeBottomSheetAction.RESTORE)
-                    add(NodeBottomSheetAction.DELETE_PERMANENTLY)
+        isOnline: Boolean = true,
+    ): List<NodeBottomSheetAction> {
+        if (!isOnline) {
+            return buildList {
+                val canOpenOffline = cellNode is CellNodeUi.Folder ||
+                        (cellNode is CellNodeUi.File && cellNode.localFileAvailable())
+                if (canOpenOffline) {
+                    add(NodeBottomSheetAction.OPEN)
+                }
+                if (cellNode is CellNodeUi.File && cellNode.isAvailableOffline) {
+                    add(NodeBottomSheetAction.REMOVE_OFFLINE_ACCESS)
                 }
             }
+        }
+        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 -> {
+
+                    add(NodeBottomSheetAction.OPEN)
+
+                    if (cellNode.localFileAvailable()) {
+                        add(NodeBottomSheetAction.SHARE)
+                    }
+
+                    add(
+                        if (cellNode.isAvailableOffline) {
+                            NodeBottomSheetAction.REMOVE_OFFLINE_ACCESS
+                        } else {
+                            NodeBottomSheetAction.MAKE_AVAILABLE_OFFLINE
+                        },
+                    )
+                }
             }
+        } else {
+            add(NodeBottomSheetAction.OPEN)
+        }
+    }
+
+    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.PUBLIC_LINK,
+                NodeBottomSheetAction.MOVE,
+                NodeBottomSheetAction.RENAME,
+                NodeBottomSheetAction.DELETE,
+            ),
+        )
+    }
+
     internal sealed interface MenuActionResult
     internal data class Action(val action: CellViewAction) : MenuActionResult
+    internal data class Open(val node: CellNodeUi) : 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?,
@@ -103,6 +169,7 @@
         onResult: (MenuActionResult) -> Unit,
     ) {
         val result = when (action) {
+            NodeBottomSheetAction.OPEN -> Open(node)
             NodeBottomSheetAction.SHARE -> {
                 if (node is CellNodeUi.File) {
                     Share(node)
@@ -137,6 +204,22 @@
             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)