fix: move message asset paths to conversation-scoped cache VM [WPB-25002]

app/src/main/kotlin/com/wire/android/di/ViewModelScoped.kt

@@ -22,6 +22,7 @@ import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.lifecycle.ViewModel
 import com.sebaslogen.resaca.KeyInScopeResolver
 import com.sebaslogen.resaca.hilt.hiltViewModelScoped
+import kotlin.time.Duration
 
 /**
  * Common assisted factory contract for scoped ViewModels that receive [ScopedArgs].
@@ -44,10 +45,10 @@ interface AssistedViewModelFactory<VM : ViewModel, R : ScopedArgs> {
 @Suppress("BOUNDS_NOT_ALLOWED_IF_BOUNDED_BY_TYPE_PARAMETER")
 @Composable
 inline fun <reified T, reified S, reified R : ScopedArgs, reified F : AssistedViewModelFactory<T, R>>
-        hiltViewModelScoped(arguments: R): S where T : ViewModel, T : S = when {
+        hiltViewModelScoped(arguments: R, clearDelay: Duration? = null): S where T : ViewModel, T : S = when {
     LocalInspectionMode.current -> ViewModelScopedPreviews.firstNotNullOf { it as? S }
     espresso -> ViewModelScopedPreviews.firstNotNullOf { it as? S }
-    else -> hiltViewModelScoped<T, F>(key = arguments.key?.toString()) { factory ->
+    else -> hiltViewModelScoped<T, F>(key = arguments.key?.toString(), clearDelay = clearDelay) { factory ->
         factory.create(arguments)
     }
 }
@@ -58,14 +59,19 @@ inline fun <reified T, reified S, reified R : ScopedArgs, reified F : AssistedVi
         hiltViewModelScoped(
     arguments: R,
     noinline keyInScopeResolver: KeyInScopeResolver<String>,
+    clearDelay: Duration? = null,
 ): S where T : ViewModel, T : S = when {
     LocalInspectionMode.current -> ViewModelScopedPreviews.firstNotNullOf { it as? S }
     espresso -> ViewModelScopedPreviews.firstNotNullOf { it as? S }
     else -> {
         val scopedKey = requireNotNull(arguments.key?.toString()) {
             "Scoped key must not be null for ${T::class.qualifiedName}"
         }
-        hiltViewModelScoped<T, F, String>(key = scopedKey, keyInScopeResolver = keyInScopeResolver) { factory ->
+        hiltViewModelScoped<T, F, String>(
+            key = scopedKey,
+            keyInScopeResolver = keyInScopeResolver,
+            clearDelay = clearDelay
+        ) { factory ->
             factory.create(arguments)
         }
     }

app/src/main/kotlin/com/wire/android/ui/home/conversations/messages/item/ConversationAssetPathsViewModel.kt

@@ -0,0 +1,122 @@
+/*
+ * Wire
+ * Copyright (C) 2026 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+package com.wire.android.ui.home.conversations.messages.item
+
+import androidx.compose.runtime.mutableStateMapOf
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.wire.android.util.dispatchers.DispatcherProvider
+import com.wire.kalium.logic.data.asset.AssetTransferStatus
+import com.wire.kalium.logic.data.id.ConversationId
+import com.wire.kalium.logic.feature.asset.GetMessageAssetUseCase
+import com.wire.kalium.logic.feature.asset.MessageAssetResult
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+interface ConversationAssetPathsViewModel {
+    fun localAssetPath(messageId: String): String? = null
+    fun localAssetPath(
+        conversationId: ConversationId,
+        messageId: String,
+        assetStatus: AssetTransferStatus?,
+        downloadIfNeeded: Boolean = false,
+    ): String? = null
+
+    fun resolveIfNeeded(
+        conversationId: ConversationId,
+        messageId: String,
+        transferStatus: AssetTransferStatus,
+        downloadIfNeeded: Boolean = false,
+    ) {}
+}
+
+object ConversationAssetPathsViewModelPreview : ConversationAssetPathsViewModel
+
+@HiltViewModel
+class ConversationAssetPathsViewModelImpl @Inject constructor(
+    private val getMessageAsset: GetMessageAssetUseCase,
+    private val dispatchers: DispatcherProvider,
+) : ViewModel(), ConversationAssetPathsViewModel {
+
+    private val localAssetPaths = mutableStateMapOf<String, String>()
+    private val resolvingJobs = mutableMapOf<String, Job>()
+
+    override fun localAssetPath(messageId: String): String? = localAssetPaths[messageId]
+
+    override fun localAssetPath(
+        conversationId: ConversationId,
+        messageId: String,
+        assetStatus: AssetTransferStatus?,
+        downloadIfNeeded: Boolean,
+    ): String? = localAssetPaths[messageId].also { path ->
+        if (path == null && resolvingJobs[messageId]?.isActive != true) {
+            resolveIfNeeded(
+                conversationId = conversationId,
+                messageId = messageId,
+                transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
+                downloadIfNeeded = downloadIfNeeded,
+            )
+        }
+    }
+
+    override fun resolveIfNeeded(
+        conversationId: ConversationId,
+        messageId: String,
+        transferStatus: AssetTransferStatus,
+        downloadIfNeeded: Boolean
+    ) {
+        val shouldResolve = when {
+            downloadIfNeeded ->
+                transferStatus == AssetTransferStatus.NOT_DOWNLOADED ||
+                    transferStatus == AssetTransferStatus.DOWNLOAD_IN_PROGRESS ||
+                    transferStatus == AssetTransferStatus.SAVED_INTERNALLY ||
+                    transferStatus == AssetTransferStatus.UPLOADED
+
+            else -> transferStatus == AssetTransferStatus.SAVED_INTERNALLY
+        }
+
+        if (!shouldResolve || localAssetPaths[messageId] != null || resolvingJobs[messageId]?.isActive == true) {
+            return
+        }
+
+        resolvingJobs[messageId] = viewModelScope.launch(dispatchers.io()) {
+            try {
+                when (val result = getMessageAsset(conversationId, messageId).await()) {
+                    is MessageAssetResult.Success -> {
+                        val resolvedPath = result.decodedAssetPath.toString()
+                        withContext(dispatchers.main()) {
+                            localAssetPaths[messageId] = resolvedPath
+                        }
+                    }
+
+                    is MessageAssetResult.Failure -> Unit
+                }
+            } finally {
+                withContext(dispatchers.main()) {
+                    if (resolvingJobs[messageId] === this@launch) {
+                        resolvingJobs.remove(messageId)
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/kotlin/com/wire/android/ui/home/conversations/messages/item/MessageContentAndStatus.kt

@@ -24,14 +24,13 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
-import com.wire.android.ui.home.conversations.LocalAssetLocalPathKeyInScopeResolver
+import androidx.compose.ui.platform.LocalInspectionMode
+import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import com.wire.android.R
-import com.wire.android.di.hiltViewModelScoped
 import com.wire.android.media.audiomessage.AudioMessageArgs
 import com.wire.android.model.Clickable
 import com.wire.android.ui.common.applyIf
@@ -78,6 +77,11 @@ internal fun UIMessage.Regular.MessageContentAndStatus(
     conversationDetailsData: ConversationDetailsData,
     accent: Accent = Accent.Unknown,
 ) {
+    val conversationAssetPathsViewModel: ConversationAssetPathsViewModel = when {
+        LocalInspectionMode.current -> ConversationAssetPathsViewModelPreview
+        else -> hiltViewModel<ConversationAssetPathsViewModelImpl>(key = message.conversationId.toString())
+    }
+
     val onAssetClickable = remember(message) {
         Clickable(enabled = isAvailable, onClick = {
             onAssetClicked(header.messageId)
@@ -115,7 +119,8 @@ internal fun UIMessage.Regular.MessageContentAndStatus(
                 onLinkClick = onLinkClicked,
                 onReplyClick = onReplyClickable,
                 messageStyle = messageStyle,
-                accent = accent
+                accent = accent,
+                conversationAssetPathsViewModel = conversationAssetPathsViewModel
             )
             if (!messageStyle.isBubble()) {
                 if (messageContent is PartialDeliverable && messageContent.deliveryStatus.hasAnyFailures) {
@@ -161,85 +166,41 @@ private fun MessageContent(
     onOpenProfile: (String) -> Unit,
     onLinkClick: (String) -> Unit,
     onReplyClick: Clickable,
-    accent: Accent
+    accent: Accent,
+    conversationAssetPathsViewModel: ConversationAssetPathsViewModel
 ) {
     when (messageContent) {
         is UIMessageContent.ImageMessage -> {
-            val args = AssetLocalPathArgs(message.conversationId, message.header.messageId)
-            val keyInScopeResolver = LocalAssetLocalPathKeyInScopeResolver.current
-            val viewModel: AssetLocalPathViewModel =
-                if (keyInScopeResolver != null && keyInScopeResolver(args.key)) {
-                    hiltViewModelScoped<
-                            AssetLocalPathViewModelImpl,
-                            AssetLocalPathViewModel,
-                            AssetLocalPathArgs,
-                            AssetLocalPathViewModelImpl.Factory,
-                            >(
-                        arguments = args,
-                        keyInScopeResolver = keyInScopeResolver,
-                    )
-                } else {
-                    hiltViewModelScoped<
-                        AssetLocalPathViewModelImpl,
-                        AssetLocalPathViewModel,
-                        AssetLocalPathArgs,
-                        AssetLocalPathViewModelImpl.Factory,
-                        >(
-                        args
-                    )
-                }
-            LaunchedEffect(assetStatus) {
-                viewModel.resolveIfNeeded(
-                    transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
-                    downloadIfNeeded = true
-                )
-            }
+            val messageId = message.header.messageId
+            val localAssetPath = conversationAssetPathsViewModel.localAssetPath(
+                conversationId = message.conversationId,
+                messageId = messageId,
+                assetStatus = assetStatus,
+                downloadIfNeeded = true
+            )
 
             MessageImage(
                 imgParams = messageContent.params,
                 transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
                 onImageClick = onImageClick,
                 messageStyle = messageStyle,
-                assetPath = viewModel.localAssetPath?.toPath(normalize = true)
+                assetPath = localAssetPath?.toPath(normalize = true)
             )
         }
 
         is UIMessageContent.VideoMessage -> {
-            val args = AssetLocalPathArgs(message.conversationId, message.header.messageId)
-            val keyInScopeResolver = LocalAssetLocalPathKeyInScopeResolver.current
-            val viewModel: AssetLocalPathViewModel =
-                if (keyInScopeResolver != null && keyInScopeResolver(args.key)) {
-                    hiltViewModelScoped<
-                            AssetLocalPathViewModelImpl,
-                            AssetLocalPathViewModel,
-                            AssetLocalPathArgs,
-                            AssetLocalPathViewModelImpl.Factory,
-                            >(
-                        arguments = args,
-                        keyInScopeResolver = keyInScopeResolver,
-                    )
-                } else {
-                    hiltViewModelScoped<
-                        AssetLocalPathViewModelImpl,
-                        AssetLocalPathViewModel,
-                        AssetLocalPathArgs,
-                        AssetLocalPathViewModelImpl.Factory,
-                        >(
-                        args
-                    )
-                }
-            LaunchedEffect(assetStatus) {
-                viewModel.resolveIfNeeded(
-                    transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
-                    downloadIfNeeded = false
-                )
-            }
+            val messageId = message.header.messageId
+            val localAssetPath = conversationAssetPathsViewModel.localAssetPath(
+                conversationId = message.conversationId,
+                messageId = messageId,
+                assetStatus = assetStatus
+            )
 
             VideoMessage(
                 assetSize = messageContent.assetSizeInBytes,
                 assetName = messageContent.assetName,
                 assetExtension = messageContent.assetExtension,
-                assetDataPath = viewModel.localAssetPath,
+                assetDataPath = localAssetPath,
                 params = messageContent.params,
                 duration = messageContent.duration,
                 transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
@@ -333,41 +294,18 @@ private fun MessageContent(
         }
 
         is UIMessageContent.AssetMessage -> {
-            val args = AssetLocalPathArgs(message.conversationId, message.header.messageId)
-            val keyInScopeResolver = LocalAssetLocalPathKeyInScopeResolver.current
-            val viewModel: AssetLocalPathViewModel =
-                if (keyInScopeResolver != null && keyInScopeResolver(args.key)) {
-                    hiltViewModelScoped<
-                            AssetLocalPathViewModelImpl,
-                            AssetLocalPathViewModel,
-                            AssetLocalPathArgs,
-                            AssetLocalPathViewModelImpl.Factory,
-                            >(
-                        arguments = args,
-                        keyInScopeResolver = keyInScopeResolver,
-                    )
-                } else {
-                    hiltViewModelScoped<
-                        AssetLocalPathViewModelImpl,
-                        AssetLocalPathViewModel,
-                        AssetLocalPathArgs,
-                        AssetLocalPathViewModelImpl.Factory,
-                        >(
-                        args
-                    )
-                }
-            LaunchedEffect(assetStatus) {
-                viewModel.resolveIfNeeded(
-                    transferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
-                    downloadIfNeeded = false
-                )
-            }
+            val messageId = message.header.messageId
+            val localAssetPath = conversationAssetPathsViewModel.localAssetPath(
+                conversationId = message.conversationId,
+                messageId = messageId,
+                assetStatus = assetStatus
+            )
 
             MessageAsset(
                 assetName = messageContent.assetName,
                 assetExtension = messageContent.assetExtension,
                 assetSizeInBytes = messageContent.assetSizeInBytes,
-                assetDataPath = viewModel.localAssetPath,
+                assetDataPath = localAssetPath,
                 assetTransferStatus = assetStatus ?: AssetTransferStatus.NOT_DOWNLOADED,
                 onAssetClick = onAssetClick,
                 messageStyle = messageStyle