Handle unresolvable attachments in picker (#6285)

- Update `StorageHelper` and `AttachmentMetaDataMapper` to safely handle cases where content URIs (e.g. cloud-backed files) cannot be opened.
- Introduce `hasUnresolvedAttachments` state in `AttachmentsPickerViewModel` to track failed attachment resolutions.
- Show a toast message in both View-based and Compose attachment pickers when files are unavailable and need to be downloaded to the device.
- Add `clearUnresolvedAttachments` to reset the error state after it has been consumed by the UI.
- Add unit tests for unresolved attachment scenarios in `AttachmentsPickerViewModelTest`.

Author: andremion

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/messages/attachments/AttachmentsPicker.kt

@@ -16,6 +16,7 @@
 
 package io.getstream.chat.android.compose.ui.messages.attachments
 
+import android.widget.Toast
 import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.foundation.background
@@ -35,6 +36,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.Surface
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
@@ -43,6 +45,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.painterResource
@@ -102,6 +105,20 @@ public fun AttachmentsPicker(
         }
     }
     BackHandler(onBack = dismissAction)
+
+    val context = LocalContext.current
+    val hasUnresolvedAttachments = attachmentsPickerViewModel.hasUnresolvedAttachments
+    LaunchedEffect(hasUnresolvedAttachments) {
+        if (hasUnresolvedAttachments) {
+            Toast.makeText(
+                context,
+                context.getString(R.string.stream_ui_attachment_picker_error_unresolvable_attachments),
+                Toast.LENGTH_LONG,
+            ).show()
+            attachmentsPickerViewModel.clearUnresolvedAttachments()
+        }
+    }
+
     // Cross-validate requested tabFactories with the allowed ones from BE
     val filter = remember { AttachmentsPickerTabFactoryFilter() }
     val allowedFactories = filter.filterAllowedFactories(tabFactories, attachmentsPickerViewModel.channel, messageMode)

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/util/StorageHelperWrapper.kt

@@ -22,6 +22,7 @@ import io.getstream.chat.android.models.Attachment
 import io.getstream.chat.android.ui.common.helper.internal.AttachmentFilter
 import io.getstream.chat.android.ui.common.helper.internal.StorageHelper
 import io.getstream.chat.android.ui.common.state.messages.composer.AttachmentMetaData
+import io.getstream.log.taggedLogger
 
 /**
  * Wrapper around the [StorageHelper] class, with some extra functionality that makes it easier to
@@ -39,6 +40,8 @@ public class StorageHelperWrapper(
     private val attachmentFilter: AttachmentFilter = AttachmentFilter(),
 ) {
 
+    private val logger by taggedLogger("Chat:StorageHelperWrapper")
+
     /**
      * Loads a list of file metadata from the system and filters it against file types accepted by the backend.
      *
@@ -71,12 +74,20 @@ public class StorageHelperWrapper(
     /**
      * Loads attachment files from the provided metadata, so that we can upload them.
      *
+     * Attachments whose underlying content cannot be resolved (e.g. cloud-backed URIs from
+     * Google Drive that are not locally available) are skipped and a warning is logged.
+     *
      * @param metaData The list of attachment meta data that we transform.
-     * @return List of [Attachment]s with files prepared for uploading.
+     * @return List of [Attachment]s with files prepared for uploading. May be smaller than
+     * [metaData] if some entries could not be resolved.
      */
     private fun getAttachmentsFromMetaData(metaData: List<AttachmentMetaData>): List<Attachment> {
-        return metaData.map {
+        return metaData.mapNotNull {
             val fileFromUri = storageHelper.getCachedFileFromUri(context, it)
+            if (fileFromUri == null && it.uri != null) {
+                logger.w { "[getAttachmentsFromMetaData] Skipping unresolvable attachment: ${it.title} (${it.uri})" }
+                return@mapNotNull null
+            }
 
             Attachment(
                 upload = fileFromUri,

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/viewmodel/messages/AttachmentsPickerViewModel.kt

@@ -131,6 +131,22 @@ public class AttachmentsPickerViewModel @JvmOverloads constructor(
         savedStateHandle.get<Boolean>(KEY_IS_SHOWING_ATTACHMENTS) ?: false,
     )
 
+    /**
+     * Set to `true` when one or more selected attachments could not be resolved (e.g. the
+     * content URI points to a cloud file that is not locally available). The UI layer should
+     * observe this flag and show an appropriate message, then call [clearUnresolvedAttachments]
+     * to reset it.
+     */
+    internal var hasUnresolvedAttachments: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * Resets the [hasUnresolvedAttachments] flag after the UI has consumed the event.
+     */
+    internal fun clearUnresolvedAttachments() {
+        hasUnresolvedAttachments = false
+    }
+
     /**
      * Loads all the items based on the current type.
      */
@@ -220,9 +236,14 @@ public class AttachmentsPickerViewModel @JvmOverloads constructor(
      */
     public fun getSelectedAttachments(): List<Attachment> {
         val dataSet = if (attachmentsPickerMode == Files) files else images
-        val selectedAttachments = dataSet.filter { it.isSelected }
-
-        return storageHelper.getAttachmentsForUpload(selectedAttachments.map { it.attachmentMetaData })
+        val selectedMetaData = dataSet
+            .filter(AttachmentPickerItemState::isSelected)
+            .map(AttachmentPickerItemState::attachmentMetaData)
+        val attachments = storageHelper.getAttachmentsForUpload(selectedMetaData)
+        if (attachments.size < selectedMetaData.size) {
+            hasUnresolvedAttachments = true
+        }
+        return attachments
     }
 
     /**
@@ -274,6 +295,9 @@ public class AttachmentsPickerViewModel @JvmOverloads constructor(
             val attachments = withContext(DispatcherProvider.IO) {
                 getAttachmentsFromMetaData(metadata)
             }
+            if (attachments.size < metadata.size) {
+                hasUnresolvedAttachments = true
+            }
             onComplete(attachments)
         }
     }

stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/viewmodel/messages/AttachmentsPickerViewModelTest.kt

@@ -202,6 +202,83 @@ internal class AttachmentsPickerViewModelTest {
         assertEquals(expectedAttachments, result)
     }
 
+    @Test
+    fun `Given metadata with unresolvable URIs When getting attachments async Should set hasUnresolvedAttachments`() = runTest {
+        val metadata = listOf(imageAttachment1, imageAttachment2)
+        val storageHelper: StorageHelperWrapper = mock {
+            whenever(it.getAttachmentsForUpload(metadata)) doReturn listOf(Attachment(type = "image", upload = mock()))
+        }
+        val viewModel = AttachmentsPickerViewModel(storageHelper, channelState)
+
+        assertFalse(viewModel.hasUnresolvedAttachments)
+
+        var result: List<Attachment>? = null
+        viewModel.getAttachmentsFromMetadataAsync(metadata) { result = it }
+        advanceUntilIdle()
+
+        assertEquals(1, result?.size)
+        assertTrue(viewModel.hasUnresolvedAttachments)
+    }
+
+    @Test
+    fun `Given selected images with unresolvable URIs When getting selected async Should set hasUnresolvedAttachments`() = runTest {
+        val storageHelper: StorageHelperWrapper = mock {
+            whenever(it.getMedia()) doReturn listOf(imageAttachment1, imageAttachment2)
+            whenever(it.getAttachmentsForUpload(any())) doReturn listOf(Attachment(type = "image", upload = mock()))
+        }
+        val viewModel = AttachmentsPickerViewModel(storageHelper, channelState)
+
+        viewModel.changeAttachmentState(true)
+        viewModel.loadData()
+        viewModel.changeSelectedAttachments(viewModel.images.first())
+        viewModel.changeSelectedAttachments(viewModel.images.last())
+
+        assertFalse(viewModel.hasUnresolvedAttachments)
+
+        var result: List<Attachment>? = null
+        viewModel.getSelectedAttachmentsAsync { result = it }
+        advanceUntilIdle()
+
+        assertEquals(1, result?.size)
+        assertTrue(viewModel.hasUnresolvedAttachments)
+    }
+
+    @Test
+    fun `Given hasUnresolvedAttachments is true When clearing Should reset to false`() = runTest {
+        val metadata = listOf(imageAttachment1, imageAttachment2)
+        val storageHelper: StorageHelperWrapper = mock {
+            whenever(it.getAttachmentsForUpload(metadata)) doReturn listOf(Attachment(type = "image", upload = mock()))
+        }
+        val viewModel = AttachmentsPickerViewModel(storageHelper, channelState)
+
+        viewModel.getAttachmentsFromMetadataAsync(metadata) {}
+        advanceUntilIdle()
+        assertTrue(viewModel.hasUnresolvedAttachments)
+
+        viewModel.clearUnresolvedAttachments()
+        assertFalse(viewModel.hasUnresolvedAttachments)
+    }
+
+    @Test
+    fun `Given all attachments resolved When getting attachments async Should not set hasUnresolvedAttachments`() = runTest {
+        val metadata = listOf(imageAttachment1, imageAttachment2)
+        val expectedAttachments = listOf(
+            Attachment(type = "image", upload = mock()),
+            Attachment(type = "image", upload = mock()),
+        )
+        val storageHelper: StorageHelperWrapper = mock {
+            whenever(it.getAttachmentsForUpload(metadata)) doReturn expectedAttachments
+        }
+        val viewModel = AttachmentsPickerViewModel(storageHelper, channelState)
+
+        var result: List<Attachment>? = null
+        viewModel.getAttachmentsFromMetadataAsync(metadata) { result = it }
+        advanceUntilIdle()
+
+        assertEquals(2, result?.size)
+        assertFalse(viewModel.hasUnresolvedAttachments)
+    }
+
     companion object {
 
         private val imageAttachment1 = AttachmentMetaData(

stream-chat-android-ui-common/src/main/kotlin/io/getstream/chat/android/ui/common/helper/internal/StorageHelper.kt

@@ -25,6 +25,7 @@ import android.webkit.MimeTypeMap
 import io.getstream.chat.android.client.internal.file.StreamFileManager
 import io.getstream.chat.android.models.AttachmentType
 import io.getstream.chat.android.ui.common.state.messages.composer.AttachmentMetaData
+import io.getstream.log.taggedLogger
 import java.io.File
 
 /**
@@ -43,6 +44,7 @@ import java.io.File
 @Suppress("TooManyFunctions")
 public class StorageHelper {
     private val fileManager = StreamFileManager()
+    private val logger by taggedLogger("Chat:StorageHelper")
 
     /**
      * Retrieves or creates a cached copy of a file from the given attachment metadata.
@@ -55,26 +57,33 @@ public class StorageHelper {
      * to prevent naming conflicts. The file name is derived from the attachment's title with
      * proper extension handling.
      *
+     * Content URIs backed by cloud storage providers (e.g. Google Drive) may fail to provide
+     * an input stream if the file is not locally available. In such cases this method returns
+     * `null` instead of throwing.
+     *
      * @param context The Android context used to access the content resolver and cache directory.
      * @param attachmentMetaData The attachment metadata containing either a file or URI reference.
-     * @return A [File] object pointing to the cached file, or `null` if both file and URI are null.
-     *
-     * @throws java.io.IOException If there's an error reading from the URI or writing to cache.
+     * @return A [File] object pointing to the cached file, or `null` if both file and URI are null
+     * or if the content could not be read from the URI.
      */
+    @Suppress("TooGenericExceptionCaught")
     public fun getCachedFileFromUri(
         context: Context,
         attachmentMetaData: AttachmentMetaData,
     ): File? {
         if (attachmentMetaData.file == null && attachmentMetaData.uri == null) {
             return null
         }
-        if (attachmentMetaData.file != null) {
-            return attachmentMetaData.file!!
-        }
+        attachmentMetaData.file?.let { return it }
 
+        val uri = attachmentMetaData.uri ?: return null
         val fileName = attachmentMetaData.getTitleWithExtension()
-        val inputStream = context.contentResolver.openInputStream(attachmentMetaData.uri!!)
-            ?: return null
+        val inputStream = try {
+            context.contentResolver.openInputStream(uri)
+        } catch (e: Exception) {
+            logger.e(e) { "[getCachedFileFromUri] Failed to open input stream for URI: $uri" }
+            null
+        } ?: return null
         return fileManager.writeFileInTimestampedCache(
             context = context,
             fileName = fileName,

stream-chat-android-ui-common/src/main/res/values/strings.xml

@@ -42,6 +42,7 @@
     <string name="stream_ui_message_composer_permissions_files_allow_more_visual_media">Allow access to more visual media</string>
 
     <!-- Attachment system picker -->
+    <string name="stream_ui_attachment_picker_error_unresolvable_attachments">Some files could not be loaded and were skipped.</string>
     <string name="stream_ui_message_composer_attachment_picker_files">Files</string>
     <string name="stream_ui_message_composer_attachment_picker_media">Media</string>
     <string name="stream_ui_message_composer_attachment_picker_capture">Capture</string>

stream-chat-android-ui-components/src/main/kotlin/io/getstream/chat/android/ui/feature/messages/composer/attachment/picker/AttachmentsPickerDialogFragment.kt

@@ -23,6 +23,7 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.CheckedTextView
 import android.widget.FrameLayout
+import android.widget.Toast
 import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.core.view.descendants
 import androidx.viewpager2.widget.ViewPager2
@@ -62,7 +63,15 @@ public class AttachmentsPickerDialogFragment : BottomSheetDialogFragment() {
      * A listener that is invoked when attachment picking has been completed
      */
     private var attachmentSelectionListener: AttachmentSelectionListener? = AttachmentSelectionListener { attachments ->
-        attachmentsSelectionListener?.onAttachmentsSelected(attachments.map { it.toAttachment(requireContext()) })
+        val resolved = attachments.mapNotNull { it.toAttachment(requireContext()) }
+        if (resolved.size < attachments.size) {
+            Toast.makeText(
+                requireContext(),
+                R.string.stream_ui_attachment_picker_error_unresolvable_attachments,
+                Toast.LENGTH_LONG,
+            ).show()
+        }
+        attachmentsSelectionListener?.onAttachmentsSelected(resolved)
     }
 
     /**

stream-chat-android-ui-components/src/main/kotlin/io/getstream/chat/android/ui/feature/messages/composer/internal/AttachmentMetaDataMapper.kt

@@ -21,8 +21,18 @@ import io.getstream.chat.android.models.Attachment
 import io.getstream.chat.android.ui.common.helper.internal.StorageHelper
 import io.getstream.chat.android.ui.common.state.messages.composer.AttachmentMetaData
 
-internal fun AttachmentMetaData.toAttachment(context: Context): Attachment {
+/**
+ * Converts this metadata into an [Attachment] ready for upload.
+ *
+ * @param context Used to access the content resolver for caching the file.
+ * @return The attachment, or `null` when the content URI cannot be resolved
+ * (e.g. a cloud-backed file that is not locally available).
+ */
+internal fun AttachmentMetaData.toAttachment(context: Context): Attachment? {
     val fileFromUri = StorageHelper().getCachedFileFromUri(context, this)
+    if (fileFromUri == null && uri != null) {
+        return null
+    }
     return Attachment(
         upload = fileFromUri,
         type = type,