feat: add real media albums across backend, web, and android

- add backend media-group endpoint with atomic message and attachment creation

- switch web composer to send multi-media albums through the new endpoint

- switch Android batch media sending to upload first and create one album message with caption

android/app/src/main/java/ru/daemonlord/messenger/data/media/repository/NetworkMediaRepository.kt

@@ -32,8 +32,7 @@ class NetworkMediaRepository @Inject constructor(
     @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : MediaRepository {
 
-    override suspend fun uploadAndAttach(
-        messageId: Long,
+    override suspend fun uploadMedia(
         fileName: String,
         mimeType: String,
         bytes: ByteArray,
@@ -68,15 +67,6 @@ class NetworkMediaRepository @Inject constructor(
                     )
                 }
             }
-
-            mediaApiService.createAttachment(
-                request = AttachmentCreateRequestDto(
-                    messageId = messageId,
-                    fileUrl = uploadInfo.fileUrl,
-                    fileType = uploadPayload.mimeType,
-                    fileSize = uploadPayload.bytes.size.toLong(),
-                )
-            )
             AppResult.Success(
                 UploadedAttachment(
                     fileUrl = uploadInfo.fileUrl,
@@ -89,6 +79,33 @@ class NetworkMediaRepository @Inject constructor(
         }
     }
 
+    override suspend fun uploadAndAttach(
+        messageId: Long,
+        fileName: String,
+        mimeType: String,
+        bytes: ByteArray,
+    ): AppResult<UploadedAttachment> = withContext(ioDispatcher) {
+        when (val uploadResult = uploadMedia(fileName = fileName, mimeType = mimeType, bytes = bytes)) {
+            is AppResult.Success -> {
+                try {
+                    mediaApiService.createAttachment(
+                        request = AttachmentCreateRequestDto(
+                            messageId = messageId,
+                            fileUrl = uploadResult.data.fileUrl,
+                            fileType = uploadResult.data.fileType,
+                            fileSize = uploadResult.data.fileSize,
+                        )
+                    )
+                    AppResult.Success(uploadResult.data)
+                } catch (error: Throwable) {
+                    AppResult.Error(error.toAppError())
+                }
+            }
+
+            is AppResult.Error -> uploadResult
+        }
+    }
+
     private fun prepareUploadPayload(
         fileName: String,
         mimeType: String,

android/app/src/main/java/ru/daemonlord/messenger/data/message/api/MessageApiService.kt

@@ -10,6 +10,8 @@ import retrofit2.http.Query
 import ru.daemonlord.messenger.data.message.dto.MessageCreateRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageForwardRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageForwardBulkRequestDto
+import ru.daemonlord.messenger.data.message.dto.MessageMediaGroupCreateRequestDto
+import ru.daemonlord.messenger.data.message.dto.MessageMediaGroupResponseDto
 import ru.daemonlord.messenger.data.message.dto.MessageReadDto
 import ru.daemonlord.messenger.data.message.dto.MessageReactionDto
 import ru.daemonlord.messenger.data.message.dto.MessageReactionToggleRequestDto
@@ -41,6 +43,11 @@ interface MessageApiService {
         @Body request: MessageCreateRequestDto,
     ): MessageReadDto
 
+    @POST("/api/v1/messages/media-group")
+    suspend fun sendMediaGroup(
+        @Body request: MessageMediaGroupCreateRequestDto,
+    ): MessageMediaGroupResponseDto
+
     @PUT("/api/v1/messages/{message_id}")
     suspend fun editMessage(
         @Path("message_id") messageId: Long,

android/app/src/main/java/ru/daemonlord/messenger/data/message/dto/MessageDtos.kt

@@ -50,6 +50,51 @@ data class MessageCreateRequestDto(
     val replyToMessageId: Long? = null,
 )
 
+@Serializable
+data class MessageMediaGroupAttachmentRequestDto(
+    @SerialName("file_url")
+    val fileUrl: String,
+    @SerialName("file_type")
+    val fileType: String,
+    @SerialName("file_size")
+    val fileSize: Long,
+    @SerialName("waveform_points")
+    val waveformPoints: List<Int>? = null,
+)
+
+@Serializable
+data class MessageMediaGroupCreateRequestDto(
+    @SerialName("chat_id")
+    val chatId: Long,
+    val text: String? = null,
+    @SerialName("client_message_id")
+    val clientMessageId: String,
+    @SerialName("reply_to_message_id")
+    val replyToMessageId: Long? = null,
+    val attachments: List<MessageMediaGroupAttachmentRequestDto>,
+)
+
+@Serializable
+data class MessageMediaGroupAttachmentReadDto(
+    val id: Long,
+    @SerialName("message_id")
+    val messageId: Long,
+    @SerialName("file_url")
+    val fileUrl: String,
+    @SerialName("file_type")
+    val fileType: String,
+    @SerialName("file_size")
+    val fileSize: Long,
+    @SerialName("waveform_points")
+    val waveformPoints: List<Int>? = null,
+)
+
+@Serializable
+data class MessageMediaGroupResponseDto(
+    val message: MessageReadDto,
+    val attachments: List<MessageMediaGroupAttachmentReadDto> = emptyList(),
+)
+
 @Serializable
 data class MessageUpdateRequestDto(
     val text: String,

android/app/src/main/java/ru/daemonlord/messenger/data/message/repository/NetworkMessageRepository.kt

@@ -26,11 +26,14 @@ import ru.daemonlord.messenger.domain.common.AppError
 import ru.daemonlord.messenger.domain.common.AppResult
 import ru.daemonlord.messenger.domain.media.repository.MediaRepository
 import ru.daemonlord.messenger.domain.message.model.MessageItem
+import ru.daemonlord.messenger.domain.message.model.OutgoingMediaItem
 import ru.daemonlord.messenger.domain.message.model.MessageReaction
 import ru.daemonlord.messenger.domain.message.repository.MessageRepository
 import ru.daemonlord.messenger.data.message.dto.MessageCreateRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageForwardRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageForwardBulkRequestDto
+import ru.daemonlord.messenger.data.message.dto.MessageMediaGroupAttachmentRequestDto
+import ru.daemonlord.messenger.data.message.dto.MessageMediaGroupCreateRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageReactionToggleRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageStatusUpdateRequestDto
 import ru.daemonlord.messenger.data.message.dto.MessageUpdateRequestDto
@@ -395,6 +398,118 @@ class NetworkMessageRepository @Inject constructor(
         }
     }
 
+    override suspend fun sendMediaGroupMessage(
+        chatId: Long,
+        items: List<OutgoingMediaItem>,
+        caption: String?,
+        replyToMessageId: Long?,
+    ): AppResult<Unit> = withContext(ioDispatcher) {
+        if (items.isEmpty()) {
+            return@withContext AppResult.Error(AppError.Server("Media group is empty"))
+        }
+        val messageType = inferMediaGroupType(items = items)
+        val tempId = -System.currentTimeMillis()
+        val now = java.time.Instant.now().toString()
+        val tempMessage = MessageEntity(
+            id = tempId,
+            chatId = chatId,
+            senderId = currentUserId ?: 0L,
+            senderDisplayName = null,
+            senderUsername = null,
+            senderAvatarUrl = null,
+            replyToMessageId = replyToMessageId,
+            replyPreviewText = null,
+            replyPreviewSenderName = null,
+            forwardedFromMessageId = null,
+            forwardedFromDisplayName = null,
+            type = messageType,
+            text = caption,
+            status = "pending",
+            attachmentWaveformJson = null,
+            createdAt = now,
+            updatedAt = null,
+        )
+        messageDao.upsertMessages(listOf(tempMessage))
+        chatDao.updateLastMessage(
+            chatId = chatId,
+            lastMessageText = caption,
+            lastMessageType = messageType,
+            lastMessageCreatedAt = now,
+            updatedSortAt = now,
+        )
+        try {
+            val uploadedAttachments = mutableListOf<ru.daemonlord.messenger.domain.media.model.UploadedAttachment>()
+            for (item in items) {
+                when (val uploadResult = mediaRepository.uploadMedia(
+                    fileName = item.fileName,
+                    mimeType = item.mimeType,
+                    bytes = item.bytes,
+                )) {
+                    is AppResult.Success -> uploadedAttachments.add(uploadResult.data)
+                    is AppResult.Error -> {
+                        messageDao.deleteMessage(tempId)
+                        return@withContext AppResult.Error(uploadResult.reason)
+                    }
+                }
+            }
+
+            val created = messageApiService.sendMediaGroup(
+                request = MessageMediaGroupCreateRequestDto(
+                    chatId = chatId,
+                    text = caption,
+                    clientMessageId = UUID.randomUUID().toString(),
+                    replyToMessageId = replyToMessageId,
+                    attachments = uploadedAttachments.map {
+                        MessageMediaGroupAttachmentRequestDto(
+                            fileUrl = it.fileUrl,
+                            fileType = it.fileType,
+                            fileSize = it.fileSize,
+                        )
+                    },
+                )
+            )
+
+            messageDao.deleteMessage(tempId)
+            messageDao.upsertMessages(listOf(created.message.toEntity()))
+            messageDao.upsertAttachments(
+                if (created.attachments.isNotEmpty()) {
+                    created.attachments.map { attachment ->
+                        MessageAttachmentEntity(
+                            id = attachment.id,
+                            messageId = attachment.messageId,
+                            fileUrl = attachment.fileUrl,
+                            fileType = attachment.fileType,
+                            fileSize = attachment.fileSize,
+                            waveformPointsJson = null,
+                        )
+                    }
+                } else {
+                    uploadedAttachments.mapIndexed { index, attachment ->
+                        MessageAttachmentEntity(
+                            id = tempId - index - 1,
+                            messageId = created.message.id,
+                            fileUrl = attachment.fileUrl,
+                            fileType = attachment.fileType,
+                            fileSize = attachment.fileSize,
+                            waveformPointsJson = null,
+                        )
+                    }
+                }
+            )
+            chatDao.updateLastMessage(
+                chatId = chatId,
+                lastMessageText = created.message.text,
+                lastMessageType = created.message.type,
+                lastMessageCreatedAt = created.message.createdAt,
+                updatedSortAt = created.message.createdAt,
+            )
+            AppResult.Success(Unit)
+        } catch (error: Throwable) {
+            messageDao.deleteMessage(tempId)
+            AppResult.Error(error.toAppError())
+        }
+    }
+
     override suspend fun sendImageUrlMessage(
         chatId: Long,
         imageUrl: String,
@@ -589,6 +704,17 @@ class NetworkMessageRepository @Inject constructor(
         }
     }
 
+    private fun inferMediaGroupType(items: List<OutgoingMediaItem>): String {
+        val resolvedTypes = items.map { mapMimeToMessageType(mimeType = it.mimeType, fileName = it.fileName) }
+        return when {
+            resolvedTypes.all { it == "image" } -> "image"
+            resolvedTypes.all { it == "audio" || it == "voice" } -> "audio"
+            resolvedTypes.all { it == "video" } -> "video"
+            resolvedTypes.all { it == "image" || it == "video" } -> "video"
+            else -> "file"
+        }
+    }
+
     private suspend fun flushPendingActions(chatId: Long) {
         val pending = pendingMessageActionDao.listPending(limit = 100)
         for (action in pending) {

android/app/src/main/java/ru/daemonlord/messenger/domain/media/repository/MediaRepository.kt

@@ -4,6 +4,12 @@ import ru.daemonlord.messenger.domain.common.AppResult
 import ru.daemonlord.messenger.domain.media.model.UploadedAttachment
 
 interface MediaRepository {
+    suspend fun uploadMedia(
+        fileName: String,
+        mimeType: String,
+        bytes: ByteArray,
+    ): AppResult<UploadedAttachment>
+
     suspend fun uploadAndAttach(
         messageId: Long,
         fileName: String,

android/app/src/main/java/ru/daemonlord/messenger/domain/message/model/OutgoingMediaItem.kt

@@ -0,0 +1,7 @@
+package ru.daemonlord.messenger.domain.message.model
+
+data class OutgoingMediaItem(
+    val fileName: String,
+    val mimeType: String,
+    val bytes: ByteArray,
+)

android/app/src/main/java/ru/daemonlord/messenger/domain/message/repository/MessageRepository.kt

@@ -3,6 +3,7 @@ package ru.daemonlord.messenger.domain.message.repository
 import kotlinx.coroutines.flow.Flow
 import ru.daemonlord.messenger.domain.common.AppResult
 import ru.daemonlord.messenger.domain.message.model.MessageItem
+import ru.daemonlord.messenger.domain.message.model.OutgoingMediaItem
 import ru.daemonlord.messenger.domain.message.model.MessageReaction
 
 interface MessageRepository {
@@ -20,6 +21,12 @@ interface MessageRepository {
         caption: String? = null,
         replyToMessageId: Long? = null,
     ): AppResult<Unit>
+    suspend fun sendMediaGroupMessage(
+        chatId: Long,
+        items: List<OutgoingMediaItem>,
+        caption: String? = null,
+        replyToMessageId: Long? = null,
+    ): AppResult<Unit>
     suspend fun sendImageUrlMessage(
         chatId: Long,
         imageUrl: String,

android/app/src/main/java/ru/daemonlord/messenger/domain/message/usecase/SendMediaGroupMessageUseCase.kt

@@ -0,0 +1,24 @@
+package ru.daemonlord.messenger.domain.message.usecase
+
+import ru.daemonlord.messenger.domain.common.AppResult
+import ru.daemonlord.messenger.domain.message.model.OutgoingMediaItem
+import ru.daemonlord.messenger.domain.message.repository.MessageRepository
+import javax.inject.Inject
+
+class SendMediaGroupMessageUseCase @Inject constructor(
+    private val messageRepository: MessageRepository,
+) {
+    suspend operator fun invoke(
+        chatId: Long,
+        items: List<OutgoingMediaItem>,
+        caption: String? = null,
+        replyToMessageId: Long? = null,
+    ): AppResult<Unit> {
+        return messageRepository.sendMediaGroupMessage(
+            chatId = chatId,
+            items = items,
+            caption = caption,
+            replyToMessageId = replyToMessageId,
+        )
+    }
+}

android/app/src/main/java/ru/daemonlord/messenger/ui/chat/ChatViewModel.kt

@@ -28,6 +28,7 @@ import ru.daemonlord.messenger.domain.chat.usecase.ObserveChatsUseCase
 import ru.daemonlord.messenger.domain.common.AppError
 import ru.daemonlord.messenger.domain.common.AppResult
 import ru.daemonlord.messenger.domain.message.model.MessageItem
+import ru.daemonlord.messenger.domain.message.model.OutgoingMediaItem
 import ru.daemonlord.messenger.domain.message.usecase.DeleteMessageUseCase
 import ru.daemonlord.messenger.domain.message.usecase.EditMessageUseCase
 import ru.daemonlord.messenger.domain.message.usecase.ForwardMessageBulkUseCase
@@ -38,6 +39,7 @@ import ru.daemonlord.messenger.domain.message.usecase.MarkMessageDeliveredUseCas
 import ru.daemonlord.messenger.domain.message.usecase.MarkMessageReadUseCase
 import ru.daemonlord.messenger.domain.message.usecase.ObserveMessagesUseCase
 import ru.daemonlord.messenger.domain.message.usecase.SendImageUrlMessageUseCase
+import ru.daemonlord.messenger.domain.message.usecase.SendMediaGroupMessageUseCase
 import ru.daemonlord.messenger.domain.message.usecase.SendMediaMessageUseCase
 import ru.daemonlord.messenger.domain.message.usecase.SendTextMessageUseCase
 import ru.daemonlord.messenger.domain.message.usecase.SyncRecentMessagesUseCase
@@ -60,6 +62,7 @@ class ChatViewModel @Inject constructor(
     private val sendTextMessageUseCase: SendTextMessageUseCase,
     private val sendImageUrlMessageUseCase: SendImageUrlMessageUseCase,
     private val sendMediaMessageUseCase: SendMediaMessageUseCase,
+    private val sendMediaGroupMessageUseCase: SendMediaGroupMessageUseCase,
     private val editMessageUseCase: EditMessageUseCase,
     private val deleteMessageUseCase: DeleteMessageUseCase,
     private val markMessageDeliveredUseCase: MarkMessageDeliveredUseCase,
@@ -668,36 +671,39 @@ class ChatViewModel @Inject constructor(
             _uiState.update { it.copy(isUploadingMedia = true, errorMessage = null) }
             val caption = uiState.value.inputText.trim().ifBlank { null }
             val replyToMessageId = uiState.value.replyToMessage?.id
-            items.forEachIndexed { index, item ->
-                when (
-                    val result = sendMediaMessageUseCase(
-                        chatId = chatId,
-                        fileName = item.fileName,
-                        mimeType = item.mimeType,
-                        bytes = item.bytes,
-                        caption = if (index == 0) caption else null,
-                        replyToMessageId = if (index == 0) replyToMessageId else null,
-                    )
-                ) {
-                    is AppResult.Success -> Unit
-                    is AppResult.Error -> {
-                        _uiState.update {
-                            it.copy(
-                                isUploadingMedia = false,
-                                errorMessage = result.reason.toUiMessage(),
-                            )
-                        }
-                        return@launch
+            when (
+                val result = sendMediaGroupMessageUseCase(
+                    chatId = chatId,
+                    items = items.map { item ->
+                        OutgoingMediaItem(
+                            fileName = item.fileName,
+                            mimeType = item.mimeType,
+                            bytes = item.bytes,
+                        )
+                    },
+                    caption = caption,
+                    replyToMessageId = replyToMessageId,
+                )
+            ) {
+                is AppResult.Success -> {
+                    _uiState.update {
+                        it.copy(
+                            isUploadingMedia = false,
+                            inputText = "",
+                            replyToMessage = null,
+                            editingMessage = null,
+                        )
+                    }
+                }
+
+                is AppResult.Error -> {
+                    _uiState.update {
+                        it.copy(
+                            isUploadingMedia = false,
+                            errorMessage = result.reason.toUiMessage(),
+                        )
                     }
                 }
-            }
-            _uiState.update {
-                it.copy(
-                    isUploadingMedia = false,
-                    inputText = "",
-                    replyToMessage = null,
-                    editingMessage = null,
-                )
             }
         }
     }