Merge branch 'master' into dc/ios-link-creation-profile-improvements

2024-12-17 17:20:21 +01:00 · 2024-08-22 21:47:47 +04:00
parent 367c636d6f ef1897f865
commit cc0733755d
29 changed files with 809 additions and 509 deletions
@@ -357,17 +357,17 @@ func apiGetChatItemInfo(type: ChatType, id: Int64, itemId: Int64) async throws -
    throw r
 }

-func apiForwardChatItem(toChatType: ChatType, toChatId: Int64, fromChatType: ChatType, fromChatId: Int64, itemId: Int64, ttl: Int?) async -> ChatItem? {
-    let cmd: ChatCommand = .apiForwardChatItem(toChatType: toChatType, toChatId: toChatId, fromChatType: fromChatType, fromChatId: fromChatId, itemId: itemId, ttl: ttl)
+func apiForwardChatItems(toChatType: ChatType, toChatId: Int64, fromChatType: ChatType, fromChatId: Int64, itemIds: [Int64], ttl: Int?) async -> [ChatItem]? {
+    let cmd: ChatCommand = .apiForwardChatItems(toChatType: toChatType, toChatId: toChatId, fromChatType: fromChatType, fromChatId: fromChatId, itemIds: itemIds, ttl: ttl)
    return await processSendMessageCmd(toChatType: toChatType, cmd: cmd)
 }

-func apiSendMessage(type: ChatType, id: Int64, file: CryptoFile?, quotedItemId: Int64?, msg: MsgContent, live: Bool = false, ttl: Int? = nil) async -> ChatItem? {
-    let cmd: ChatCommand = .apiSendMessage(type: type, id: id, file: file, quotedItemId: quotedItemId, msg: msg, live: live, ttl: ttl)
+func apiSendMessages(type: ChatType, id: Int64, live: Bool = false, ttl: Int? = nil, composedMessages: [ComposedMessage]) async -> [ChatItem]? {
+    let cmd: ChatCommand = .apiSendMessages(type: type, id: id, live: live, ttl: ttl, composedMessages: composedMessages)
    return await processSendMessageCmd(toChatType: type, cmd: cmd)
 }

-private func processSendMessageCmd(toChatType: ChatType, cmd: ChatCommand) async -> ChatItem? {
+private func processSendMessageCmd(toChatType: ChatType, cmd: ChatCommand) async -> [ChatItem]? {
    let chatModel = ChatModel.shared
    let r: ChatResponse
    if toChatType == .direct {
@@ -380,10 +380,13 @@ private func processSendMessageCmd(toChatType: ChatType, cmd: ChatCommand) async
            }
        })
        r = await chatSendCmd(cmd, bgTask: false)
-        if case let .newChatItem(_, aChatItem) = r {
-            cItem = aChatItem.chatItem
-            chatModel.messageDelivery[aChatItem.chatItem.id] = endTask
-            return cItem
+        if case let .newChatItems(_, aChatItems) = r {
+            let cItems = aChatItems.map { $0.chatItem }
+            if let cItemLast = cItems.last {
+                cItem = cItemLast
+                chatModel.messageDelivery[cItemLast.id] = endTask
+            }
+            return cItems
        }
        if let networkErrorAlert = networkErrorAlert(r) {
            AlertManager.shared.showAlert(networkErrorAlert)
@@ -394,18 +397,18 @@ private func processSendMessageCmd(toChatType: ChatType, cmd: ChatCommand) async
        return nil
    } else {
        r = await chatSendCmd(cmd, bgDelay: msgDelay)
-        if case let .newChatItem(_, aChatItem) = r {
-            return aChatItem.chatItem
+        if case let .newChatItems(_, aChatItems) = r {
+            return aChatItems.map { $0.chatItem }
        }
        sendMessageErrorAlert(r)
        return nil
    }
 }

-func apiCreateChatItem(noteFolderId: Int64, file: CryptoFile?, msg: MsgContent) async -> ChatItem? {
-    let r = await chatSendCmd(.apiCreateChatItem(noteFolderId: noteFolderId, file: file, msg: msg))
-    if case let .newChatItem(_, aChatItem) = r { return aChatItem.chatItem }
-    createChatItemErrorAlert(r)
+func apiCreateChatItems(noteFolderId: Int64, composedMessages: [ComposedMessage]) async -> [ChatItem]? {
+    let r = await chatSendCmd(.apiCreateChatItems(noteFolderId: noteFolderId, composedMessages: composedMessages))
+    if case let .newChatItems(_, aChatItems) = r { return aChatItems.map { $0.chatItem } }
+    createChatItemsErrorAlert(r)
    return nil
 }

@@ -417,8 +420,8 @@ private func sendMessageErrorAlert(_ r: ChatResponse) {
    )
 }

-private func createChatItemErrorAlert(_ r: ChatResponse) {
-    logger.error("apiCreateChatItem error: \(String(describing: r))")
+private func createChatItemsErrorAlert(_ r: ChatResponse) {
+    logger.error("apiCreateChatItems error: \(String(describing: r))")
    AlertManager.shared.showAlertMsg(
        title: "Error creating message",
        message: "Error: \(responseError(r))"
@@ -1782,23 +1785,25 @@ func processReceivedMsg(_ res: ChatResponse) async {
                n.networkStatuses = ns
            }
        }
-    case let .newChatItem(user, aChatItem):
-        let cInfo = aChatItem.chatInfo
-        let cItem = aChatItem.chatItem
-        await MainActor.run {
-            if active(user) {
-                m.addChatItem(cInfo, cItem)
-            } else if cItem.isRcvNew && cInfo.ntfsEnabled {
-                m.increaseUnreadCounter(user: user)
+    case let .newChatItems(user, chatItems):
+        for chatItem in chatItems {
+            let cInfo = chatItem.chatInfo
+            let cItem = chatItem.chatItem
+            await MainActor.run {
+                if active(user) {
+                    m.addChatItem(cInfo, cItem)
+                } else if cItem.isRcvNew && cInfo.ntfsEnabled {
+                    m.increaseUnreadCounter(user: user)
+                }
            }
-        }
-        if let file = cItem.autoReceiveFile() {
-            Task {
-                await receiveFile(user: user, fileId: file.fileId, auto: true)
+            if let file = cItem.autoReceiveFile() {
+                Task {
+                    await receiveFile(user: user, fileId: file.fileId, auto: true)
+                }
+            }
+            if cItem.showNotification {
+                NtfManager.shared.notifyMessageReceived(user, cInfo, cItem)
            }
-        }
-        if cItem.showNotification {
-            NtfManager.shared.notifyMessageReceived(user, cInfo, cItem)
        }
    case let .chatItemStatusUpdated(user, aChatItem):
        let cInfo = aChatItem.chatInfo
@@ -1808,10 +1813,15 @@ func processReceivedMsg(_ res: ChatResponse) async {
        }
        if let endTask = m.messageDelivery[cItem.id] {
            switch cItem.meta.itemStatus {
+            case .sndNew: ()
            case .sndSent: endTask()
+            case .sndRcvd: endTask()
            case .sndErrorAuth: endTask()
            case .sndError: endTask()
-            default: ()
+            case .sndWarning: endTask()
+            case .rcvNew: ()
+            case .rcvRead: ()
+            case .invalid: ()
            }
        }
    case let .chatItemUpdated(user, aChatItem):
@@ -751,6 +751,7 @@ struct ComposeView: View {
            case .linkPreview:
                sent = await send(checkLinkPreview(), quoted: quoted, live: live, ttl: ttl)
            case let .mediaPreviews(mediaPreviews: media):
+                // TODO batch send: batch media previews
                let last = media.count - 1
                if last >= 0 {
                    for i in 0..<last {
@@ -887,22 +888,26 @@ struct ComposeView: View {
        }

        func send(_ mc: MsgContent, quoted: Int64?, file: CryptoFile? = nil, live: Bool = false, ttl: Int?) async -> ChatItem? {
-            if let chatItem = chat.chatInfo.chatType == .local
-                ? await apiCreateChatItem(noteFolderId: chat.chatInfo.apiId, file: file, msg: mc)
-                : await apiSendMessage(
+            if let chatItems = chat.chatInfo.chatType == .local
+                ? await apiCreateChatItems(
+                    noteFolderId: chat.chatInfo.apiId,
+                    composedMessages: [ComposedMessage(fileSource: file, msgContent: mc)]
+                )
+                : await apiSendMessages(
                    type: chat.chatInfo.chatType,
                    id: chat.chatInfo.apiId,
-                    file: file,
-                    quotedItemId: quoted,
-                    msg: mc,
                    live: live,
-                    ttl: ttl
+                    ttl: ttl,
+                    composedMessages: [ComposedMessage(fileSource: file, quotedItemId: quoted, msgContent: mc)]
                ) {
                await MainActor.run {
                    chatModel.removeLiveDummy(animated: false)
-                    chatModel.addChatItem(chat.chatInfo, chatItem)
+                    for chatItem in chatItems {
+                        chatModel.addChatItem(chat.chatInfo, chatItem)
+                    }
                }
-                return chatItem
+                // UI only supports sending one item at a time
+                return chatItems.first
            }
            if let file = file {
                removeFile(file.filePath)
@@ -911,18 +916,21 @@ struct ComposeView: View {
        }

        func forwardItem(_ forwardedItem: ChatItem, _ fromChatInfo: ChatInfo, _ ttl: Int?) async -> ChatItem? {
-            if let chatItem = await apiForwardChatItem(
+            if let chatItems = await apiForwardChatItems(
                toChatType: chat.chatInfo.chatType,
                toChatId: chat.chatInfo.apiId,
                fromChatType: fromChatInfo.chatType,
                fromChatId: fromChatInfo.apiId,
-                itemId: forwardedItem.id,
+                itemIds: [forwardedItem.id],
                ttl: ttl
            ) {
                await MainActor.run {
-                    chatModel.addChatItem(chat.chatInfo, chatItem)
+                    for chatItem in chatItems {
+                        chatModel.addChatItem(chat.chatInfo, chatItem)
+                    }
                }
-                return chatItem
+                // TODO batch send: forward multiple messages
+                return chatItems.first
            }
            return nil
        }
@@ -160,7 +160,7 @@ struct TerminalView_Previews: PreviewProvider {
        let chatModel = ChatModel()
        chatModel.terminalItems = [
            .resp(.now, ChatResponse.response(type: "contactSubscribed", json: "{}")),
-            .resp(.now, ChatResponse.response(type: "newChatItem", json: "{}"))
+            .resp(.now, ChatResponse.response(type: "newChatItems", json: "{}"))
        ]
        return NavigationView {
            TerminalView()
@@ -571,17 +571,22 @@ func receivedMsgNtf(_ res: ChatResponse) async -> (String, NSENotification)? {
 //            TODO profile update
    case let .receivedContactRequest(user, contactRequest):
        return (UserContact(contactRequest: contactRequest).id, .nse(createContactRequestNtf(user, contactRequest)))
-    case let .newChatItem(user, aChatItem):
-        let cInfo = aChatItem.chatInfo
-        var cItem = aChatItem.chatItem
-        if !cInfo.ntfsEnabled {
-            ntfBadgeCountGroupDefault.set(max(0, ntfBadgeCountGroupDefault.get() - 1))
+    case let .newChatItems(user, chatItems):
+        // Received items are created one at a time
+        if let chatItem = chatItems.first {
+            let cInfo = chatItem.chatInfo
+            var cItem = chatItem.chatItem
+            if !cInfo.ntfsEnabled {
+                ntfBadgeCountGroupDefault.set(max(0, ntfBadgeCountGroupDefault.get() - 1))
+            }
+            if let file = cItem.autoReceiveFile() {
+                cItem = autoReceiveFile(file) ?? cItem
+            }
+            let ntf: NSENotification = cInfo.ntfsEnabled ? .nse(createMessageReceivedNtf(user, cInfo, cItem)) : .empty
+            return cItem.showNotification ? (chatItem.chatId, ntf) : nil
+        } else {
+            return nil
        }
-        if let file = cItem.autoReceiveFile() {
-            cItem = autoReceiveFile(file) ?? cItem
-        }
-        let ntf: NSENotification = cInfo.ntfsEnabled ? .nse(createMessageReceivedNtf(user, cInfo, cItem)) : .empty
-        return cItem.showNotification ? (aChatItem.chatId, ntf) : nil
    case let .rcvFileSndCancelled(_, aChatItem, _):
        cleanupFile(aChatItem)
        return nil
@@ -54,32 +54,30 @@ func apiGetChats(userId: User.ID) throws -> Array<ChatData> {
    throw r
 }

-func apiSendMessage(
+func apiSendMessages(
    chatInfo: ChatInfo,
-    cryptoFile: CryptoFile?,
-    msgContent: MsgContent
-) throws -> AChatItem {
+    composedMessages: [ComposedMessage]
+) throws -> [AChatItem] {
    let r = sendSimpleXCmd(
        chatInfo.chatType == .local
-        ? .apiCreateChatItem(
+        ? .apiCreateChatItems(
            noteFolderId: chatInfo.apiId,
-            file: cryptoFile,
-            msg: msgContent
+            composedMessages: composedMessages
        )
-        : .apiSendMessage(
+        : .apiSendMessages(
            type: chatInfo.chatType,
            id: chatInfo.apiId,
-            file: cryptoFile,
-            quotedItemId: nil,
-            msg: msgContent,
            live: false,
-            ttl: nil
+            ttl: nil,
+            composedMessages: composedMessages
        )
    )
-    if case let .newChatItem(_, chatItem) = r {
-        return chatItem
+    if case let .newChatItems(_, chatItems) = r {
+        return chatItems
    } else {
-        if let filePath = cryptoFile?.filePath { removeFile(filePath) }
+        for composedMessage in composedMessages {
+            if let filePath = composedMessage.fileSource?.filePath { removeFile(filePath) }
+        }
        throw r
    }
 }
@@ -141,23 +141,25 @@ class ShareModel: ObservableObject {
                do {
                    SEChatState.shared.set(.sendingMessage)
                    await waitForOtherProcessesToSuspend()
-                    let ci = try apiSendMessage(
+                    let chatItems = try apiSendMessages(
                        chatInfo: selected.chatInfo,
-                        cryptoFile: sharedContent.cryptoFile,
-                        msgContent: sharedContent.msgContent(comment: self.comment)
+                        composedMessages: [ComposedMessage(fileSource: sharedContent.cryptoFile, msgContent: sharedContent.msgContent(comment: self.comment))]
                    )
                    if selected.chatInfo.chatType == .local {
                        completion()
                    } else {
-                        await MainActor.run { self.bottomBar = .loadingBar(progress: 0) }
-                        if let e = await handleEvents(
-                            isGroupChat: ci.chatInfo.chatType == .group,
-                            isWithoutFile: sharedContent.cryptoFile == nil,
-                            chatItemId: ci.chatItem.id
-                        ) {
-                            await MainActor.run { errorAlert = e }
-                        } else {
-                            completion()
+                        // TODO batch send: share multiple items
+                        if let ci = chatItems.first {
+                            await MainActor.run { self.bottomBar = .loadingBar(progress: 0) }
+                            if let e = await handleEvents(
+                                isGroupChat: ci.chatInfo.chatType == .group,
+                                isWithoutFile: sharedContent.cryptoFile == nil,
+                                chatItemId: ci.chatItem.id
+                            ) {
+                                await MainActor.run { errorAlert = e }
+                            } else {
+                                completion()
+                            }
                        }
                    }
                } catch {
@@ -42,13 +42,13 @@ public enum ChatCommand {
    case apiGetChats(userId: Int64)
    case apiGetChat(type: ChatType, id: Int64, pagination: ChatPagination, search: String)
    case apiGetChatItemInfo(type: ChatType, id: Int64, itemId: Int64)
-    case apiSendMessage(type: ChatType, id: Int64, file: CryptoFile?, quotedItemId: Int64?, msg: MsgContent, live: Bool, ttl: Int?)
-    case apiCreateChatItem(noteFolderId: Int64, file: CryptoFile?, msg: MsgContent)
+    case apiSendMessages(type: ChatType, id: Int64, live: Bool, ttl: Int?, composedMessages: [ComposedMessage])
+    case apiCreateChatItems(noteFolderId: Int64, composedMessages: [ComposedMessage])
    case apiUpdateChatItem(type: ChatType, id: Int64, itemId: Int64, msg: MsgContent, live: Bool)
    case apiDeleteChatItem(type: ChatType, id: Int64, itemIds: [Int64], mode: CIDeleteMode)
    case apiDeleteMemberChatItem(groupId: Int64, itemIds: [Int64])
    case apiChatItemReaction(type: ChatType, id: Int64, itemId: Int64, add: Bool, reaction: MsgReaction)
-    case apiForwardChatItem(toChatType: ChatType, toChatId: Int64, fromChatType: ChatType, fromChatId: Int64, itemId: Int64, ttl: Int?)
+    case apiForwardChatItems(toChatType: ChatType, toChatId: Int64, fromChatType: ChatType, fromChatId: Int64, itemIds: [Int64], ttl: Int?)
    case apiGetNtfToken
    case apiRegisterToken(token: DeviceToken, notificationMode: NotificationsMode)
    case apiVerifyToken(token: DeviceToken, nonce: String, code: String)
@@ -191,20 +191,20 @@ public enum ChatCommand {
            case let .apiGetChat(type, id, pagination, search): return "/_get chat \(ref(type, id)) \(pagination.cmdString)" +
                (search == "" ? "" : " search=\(search)")
            case let .apiGetChatItemInfo(type, id, itemId): return "/_get item info \(ref(type, id)) \(itemId)"
-            case let .apiSendMessage(type, id, file, quotedItemId, mc, live, ttl):
-                let msg = encodeJSON(ComposedMessage(fileSource: file, quotedItemId: quotedItemId, msgContent: mc))
+            case let .apiSendMessages(type, id, live, ttl, composedMessages):
+                let msgs = encodeJSON(composedMessages)
                let ttlStr = ttl != nil ? "\(ttl!)" : "default"
-                return "/_send \(ref(type, id)) live=\(onOff(live)) ttl=\(ttlStr) json \(msg)"
-            case let .apiCreateChatItem(noteFolderId, file, mc):
-                let msg = encodeJSON(ComposedMessage(fileSource: file, msgContent: mc))
-                return "/_create *\(noteFolderId) json \(msg)"
+                return "/_send \(ref(type, id)) live=\(onOff(live)) ttl=\(ttlStr) json \(msgs)"
+            case let .apiCreateChatItems(noteFolderId, composedMessages):
+                let msgs = encodeJSON(composedMessages)
+                return "/_create *\(noteFolderId) json \(msgs)"
            case let .apiUpdateChatItem(type, id, itemId, mc, live): return "/_update item \(ref(type, id)) \(itemId) live=\(onOff(live)) \(mc.cmdString)"
            case let .apiDeleteChatItem(type, id, itemIds, mode): return "/_delete item \(ref(type, id)) \(itemIds.map({ "\($0)" }).joined(separator: ",")) \(mode.rawValue)"
            case let .apiDeleteMemberChatItem(groupId, itemIds): return "/_delete member item #\(groupId) \(itemIds.map({ "\($0)" }).joined(separator: ","))"
            case let .apiChatItemReaction(type, id, itemId, add, reaction): return "/_reaction \(ref(type, id)) \(itemId) \(onOff(add)) \(encodeJSON(reaction))"
-            case let .apiForwardChatItem(toChatType, toChatId, fromChatType, fromChatId, itemId, ttl):
+            case let .apiForwardChatItems(toChatType, toChatId, fromChatType, fromChatId, itemIds, ttl):
                let ttlStr = ttl != nil ? "\(ttl!)" : "default"
-                return "/_forward \(ref(toChatType, toChatId)) \(ref(fromChatType, fromChatId)) \(itemId) ttl=\(ttlStr)"
+                return "/_forward \(ref(toChatType, toChatId)) \(ref(fromChatType, fromChatId)) \(itemIds.map({ "\($0)" }).joined(separator: ",")) ttl=\(ttlStr)"
            case .apiGetNtfToken: return "/_ntf get "
            case let .apiRegisterToken(token, notificationMode): return "/_ntf register \(token.cmdString) \(notificationMode.rawValue)"
            case let .apiVerifyToken(token, nonce, code): return "/_ntf verify \(token.cmdString) \(nonce) \(code)"
@@ -349,14 +349,14 @@ public enum ChatCommand {
            case .apiGetChats: return "apiGetChats"
            case .apiGetChat: return "apiGetChat"
            case .apiGetChatItemInfo: return "apiGetChatItemInfo"
-            case .apiSendMessage: return "apiSendMessage"
-            case .apiCreateChatItem: return "apiCreateChatItem"
+            case .apiSendMessages: return "apiSendMessages"
+            case .apiCreateChatItems: return "apiCreateChatItems"
            case .apiUpdateChatItem: return "apiUpdateChatItem"
            case .apiDeleteChatItem: return "apiDeleteChatItem"
            case .apiConnectContactViaAddress: return "apiConnectContactViaAddress"
            case .apiDeleteMemberChatItem: return "apiDeleteMemberChatItem"
            case .apiChatItemReaction: return "apiChatItemReaction"
-            case .apiForwardChatItem: return "apiForwardChatItem"
+            case .apiForwardChatItems: return "apiForwardChatItems"
            case .apiGetNtfToken: return "apiGetNtfToken"
            case .apiRegisterToken: return "apiRegisterToken"
            case .apiVerifyToken: return "apiVerifyToken"
@@ -592,7 +592,7 @@ public enum ChatResponse: Decodable, Error {
    case memberSubErrors(user: UserRef, memberSubErrors: [MemberSubError])
    case groupEmpty(user: UserRef, groupInfo: GroupInfo)
    case userContactLinkSubscribed
-    case newChatItem(user: UserRef, chatItem: AChatItem)
+    case newChatItems(user: UserRef, chatItems: [AChatItem])
    case chatItemStatusUpdated(user: UserRef, chatItem: AChatItem)
    case chatItemUpdated(user: UserRef, chatItem: AChatItem)
    case chatItemNotChanged(user: UserRef, chatItem: AChatItem)
@@ -763,7 +763,7 @@ public enum ChatResponse: Decodable, Error {
            case .memberSubErrors: return "memberSubErrors"
            case .groupEmpty: return "groupEmpty"
            case .userContactLinkSubscribed: return "userContactLinkSubscribed"
-            case .newChatItem: return "newChatItem"
+            case .newChatItems: return "newChatItems"
            case .chatItemStatusUpdated: return "chatItemStatusUpdated"
            case .chatItemUpdated: return "chatItemUpdated"
            case .chatItemNotChanged: return "chatItemNotChanged"
@@ -932,7 +932,9 @@ public enum ChatResponse: Decodable, Error {
            case let .memberSubErrors(u, memberSubErrors): return withUser(u, String(describing: memberSubErrors))
            case let .groupEmpty(u, groupInfo): return withUser(u, String(describing: groupInfo))
            case .userContactLinkSubscribed: return noDetails
-            case let .newChatItem(u, chatItem): return withUser(u, String(describing: chatItem))
+            case let .newChatItems(u, chatItems):
+                let itemsString = chatItems.map { chatItem in String(describing: chatItem) }.joined(separator: "\n")
+                return withUser(u, itemsString)
            case let .chatItemStatusUpdated(u, chatItem): return withUser(u, String(describing: chatItem))
            case let .chatItemUpdated(u, chatItem): return withUser(u, String(describing: chatItem))
            case let .chatItemNotChanged(u, chatItem): return withUser(u, String(describing: chatItem))
@@ -1119,10 +1121,16 @@ public enum ChatPagination: Hashable {
    }
 }

-struct ComposedMessage: Encodable {
-    var fileSource: CryptoFile?
+public struct ComposedMessage: Encodable {
+    public var fileSource: CryptoFile?
    var quotedItemId: Int64?
    var msgContent: MsgContent
+
+    public init(fileSource: CryptoFile? = nil, quotedItemId: Int64? = nil, msgContent: MsgContent) {
+        self.fileSource = fileSource
+        self.quotedItemId = quotedItemId
+        self.msgContent = msgContent
+    }
 }

 public struct ArchiveConfig: Encodable {
@@ -1848,7 +1856,6 @@ public enum ChatErrorType: Decodable, Hashable {
    case inlineFileProhibited(fileId: Int64)
    case invalidQuote
    case invalidForward
-    case forwardNoFile
    case invalidChatItemUpdate
    case invalidChatItemDelete
    case hasCurrentCall
@@ -846,15 +846,15 @@ object ChatController {
    return null
  }

-  suspend fun apiSendMessage(rh: Long?, type: ChatType, id: Long, file: CryptoFile? = null, quotedItemId: Long? = null, mc: MsgContent, live: Boolean = false, ttl: Int? = null): AChatItem? {
-    val cmd = CC.ApiSendMessage(type, id, file, quotedItemId, mc, live, ttl)
+  suspend fun apiSendMessages(rh: Long?, type: ChatType, id: Long, live: Boolean = false, ttl: Int? = null, composedMessages: List<ComposedMessage>): List<AChatItem>? {
+    val cmd = CC.ApiSendMessages(type, id, live, ttl, composedMessages)
    return processSendMessageCmd(rh, cmd)
  }

-  private suspend fun processSendMessageCmd(rh: Long?, cmd: CC): AChatItem? {
+  private suspend fun processSendMessageCmd(rh: Long?, cmd: CC): List<AChatItem>? {
    val r = sendCmd(rh, cmd)
    return when (r) {
-      is CR.NewChatItem -> r.chatItem
+      is CR.NewChatItems -> r.chatItems
      else -> {
        if (!(networkErrorAlert(r))) {
          apiErrorAlert("processSendMessageCmd", generalGetString(MR.strings.error_sending_message), r)
@@ -863,13 +863,13 @@ object ChatController {
      }
    }
  }
-   suspend fun apiCreateChatItem(rh: Long?, noteFolderId: Long, file: CryptoFile? = null, mc: MsgContent): AChatItem? {
-    val cmd = CC.ApiCreateChatItem(noteFolderId, file, mc)
+   suspend fun apiCreateChatItems(rh: Long?, noteFolderId: Long, composedMessages: List<ComposedMessage>): List<AChatItem>? {
+    val cmd = CC.ApiCreateChatItems(noteFolderId, composedMessages)
    val r = sendCmd(rh, cmd)
    return when (r) {
-      is CR.NewChatItem -> r.chatItem
+      is CR.NewChatItems -> r.chatItems
      else -> {
-        apiErrorAlert("apiCreateChatItem", generalGetString(MR.strings.error_creating_message), r)
+        apiErrorAlert("apiCreateChatItems", generalGetString(MR.strings.error_creating_message), r)
        null
      }
    }
@@ -885,9 +885,9 @@ object ChatController {
    }
  }

-  suspend fun apiForwardChatItem(rh: Long?, toChatType: ChatType, toChatId: Long, fromChatType: ChatType, fromChatId: Long, itemId: Long, ttl: Int?): ChatItem? {
-    val cmd = CC.ApiForwardChatItem(toChatType, toChatId, fromChatType, fromChatId, itemId, ttl)
-    return processSendMessageCmd(rh, cmd)?.chatItem
+  suspend fun apiForwardChatItems(rh: Long?, toChatType: ChatType, toChatId: Long, fromChatType: ChatType, fromChatId: Long, itemIds: List<Long>, ttl: Int?): List<ChatItem>? {
+    val cmd = CC.ApiForwardChatItems(toChatType, toChatId, fromChatType, fromChatId, itemIds, ttl)
+    return processSendMessageCmd(rh, cmd)?.map { it.chatItem }
  }


@@ -2132,27 +2132,30 @@ object ChatController {
          chatModel.networkStatuses[s.agentConnId] = s.networkStatus
        }
      }
-      is CR.NewChatItem -> withBGApi {
-        val cInfo = r.chatItem.chatInfo
-        val cItem = r.chatItem.chatItem
-        if (active(r.user)) {
-          withChats {
-            addChatItem(rhId, cInfo, cItem)
+      is CR.NewChatItems -> withBGApi {
+        r.chatItems.forEach { chatItem ->
+          val cInfo = chatItem.chatInfo
+          val cItem = chatItem.chatItem
+          if (active(r.user)) {
+            withChats {
+              addChatItem(rhId, cInfo, cItem)
+            }
+          } else if (cItem.isRcvNew && cInfo.ntfsEnabled) {
+            chatModel.increaseUnreadCounter(rhId, r.user)
          }
-        } else if (cItem.isRcvNew && cInfo.ntfsEnabled) {
-          chatModel.increaseUnreadCounter(rhId, r.user)
-        }
-        val file = cItem.file
-        val mc = cItem.content.msgContent
-        if (file != null &&
+          val file = cItem.file
+          val mc = cItem.content.msgContent
+          if (file != null &&
            appPrefs.privacyAcceptImages.get() &&
            ((mc is MsgContent.MCImage && file.fileSize <= MAX_IMAGE_SIZE_AUTO_RCV)
                || (mc is MsgContent.MCVideo && file.fileSize <= MAX_VIDEO_SIZE_AUTO_RCV)
-                || (mc is MsgContent.MCVoice && file.fileSize <= MAX_VOICE_SIZE_AUTO_RCV && file.fileStatus !is CIFileStatus.RcvAccepted))) {
-          receiveFile(rhId, r.user, file.fileId, auto = true)
-        }
-        if (cItem.showNotification && (allowedToShowNotification() || chatModel.chatId.value != cInfo.id || chatModel.remoteHostId() != rhId)) {
-          ntfManager.notifyMessageReceived(r.user, cInfo, cItem)
+                || (mc is MsgContent.MCVoice && file.fileSize <= MAX_VOICE_SIZE_AUTO_RCV && file.fileStatus !is CIFileStatus.RcvAccepted))
+          ) {
+            receiveFile(rhId, r.user, file.fileId, auto = true)
+          }
+          if (cItem.showNotification && (allowedToShowNotification() || chatModel.chatId.value != cInfo.id || chatModel.remoteHostId() != rhId)) {
+            ntfManager.notifyMessageReceived(r.user, cInfo, cItem)
+          }
        }
      }
      is CR.ChatItemStatusUpdated -> {
@@ -2863,13 +2866,13 @@ sealed class CC {
  class ApiGetChats(val userId: Long): CC()
  class ApiGetChat(val type: ChatType, val id: Long, val pagination: ChatPagination, val search: String = ""): CC()
  class ApiGetChatItemInfo(val type: ChatType, val id: Long, val itemId: Long): CC()
-  class ApiSendMessage(val type: ChatType, val id: Long, val file: CryptoFile?, val quotedItemId: Long?, val mc: MsgContent, val live: Boolean, val ttl: Int?): CC()
-  class ApiCreateChatItem(val noteFolderId: Long, val file: CryptoFile?, val mc: MsgContent): CC()
+  class ApiSendMessages(val type: ChatType, val id: Long, val live: Boolean, val ttl: Int?, val composedMessages: List<ComposedMessage>): CC()
+  class ApiCreateChatItems(val noteFolderId: Long, val composedMessages: List<ComposedMessage>): CC()
  class ApiUpdateChatItem(val type: ChatType, val id: Long, val itemId: Long, val mc: MsgContent, val live: Boolean): CC()
  class ApiDeleteChatItem(val type: ChatType, val id: Long, val itemIds: List<Long>, val mode: CIDeleteMode): CC()
  class ApiDeleteMemberChatItem(val groupId: Long, val itemIds: List<Long>): CC()
  class ApiChatItemReaction(val type: ChatType, val id: Long, val itemId: Long, val add: Boolean, val reaction: MsgReaction): CC()
-  class ApiForwardChatItem(val toChatType: ChatType, val toChatId: Long, val fromChatType: ChatType, val fromChatId: Long, val itemId: Long, val ttl: Int?): CC()
+  class ApiForwardChatItems(val toChatType: ChatType, val toChatId: Long, val fromChatType: ChatType, val fromChatId: Long, val itemIds: List<Long>, val ttl: Int?): CC()
  class ApiNewGroup(val userId: Long, val incognito: Boolean, val groupProfile: GroupProfile): CC()
  class ApiAddMember(val groupId: Long, val contactId: Long, val memberRole: GroupMemberRole): CC()
  class ApiJoinGroup(val groupId: Long): CC()
@@ -3008,20 +3011,22 @@ sealed class CC {
    is ApiGetChats -> "/_get chats $userId pcc=on"
    is ApiGetChat -> "/_get chat ${chatRef(type, id)} ${pagination.cmdString}" + (if (search == "") "" else " search=$search")
    is ApiGetChatItemInfo -> "/_get item info ${chatRef(type, id)} $itemId"
-    is ApiSendMessage -> {
+    is ApiSendMessages -> {
+      val msgs = json.encodeToString(composedMessages)
      val ttlStr = if (ttl != null) "$ttl" else "default"
-      "/_send ${chatRef(type, id)} live=${onOff(live)} ttl=${ttlStr} json ${json.encodeToString(ComposedMessage(file, quotedItemId, mc))}"
+      "/_send ${chatRef(type, id)} live=${onOff(live)} ttl=${ttlStr} json $msgs"
    }
-    is ApiCreateChatItem -> {
-      "/_create *$noteFolderId json ${json.encodeToString(ComposedMessage(file, null, mc))}"
+    is ApiCreateChatItems -> {
+      val msgs = json.encodeToString(composedMessages)
+      "/_create *$noteFolderId json $msgs"
    }
    is ApiUpdateChatItem -> "/_update item ${chatRef(type, id)} $itemId live=${onOff(live)} ${mc.cmdString}"
    is ApiDeleteChatItem -> "/_delete item ${chatRef(type, id)} ${itemIds.joinToString(",")} ${mode.deleteMode}"
    is ApiDeleteMemberChatItem -> "/_delete member item #$groupId ${itemIds.joinToString(",")}"
    is ApiChatItemReaction -> "/_reaction ${chatRef(type, id)} $itemId ${onOff(add)} ${json.encodeToString(reaction)}"
-    is ApiForwardChatItem -> {
+    is ApiForwardChatItems -> {
      val ttlStr = if (ttl != null) "$ttl" else "default"
-      "/_forward ${chatRef(toChatType, toChatId)} ${chatRef(fromChatType, fromChatId)} $itemId ttl=${ttlStr}"
+      "/_forward ${chatRef(toChatType, toChatId)} ${chatRef(fromChatType, fromChatId)} ${itemIds.joinToString(",")} ttl=${ttlStr}"
    }
    is ApiNewGroup -> "/_group $userId incognito=${onOff(incognito)} ${json.encodeToString(groupProfile)}"
    is ApiAddMember -> "/_add #$groupId $contactId ${memberRole.memberRole}"
@@ -3158,13 +3163,13 @@ sealed class CC {
    is ApiGetChats -> "apiGetChats"
    is ApiGetChat -> "apiGetChat"
    is ApiGetChatItemInfo -> "apiGetChatItemInfo"
-    is ApiSendMessage -> "apiSendMessage"
-    is ApiCreateChatItem -> "apiCreateChatItem"
+    is ApiSendMessages -> "apiSendMessages"
+    is ApiCreateChatItems -> "apiCreateChatItems"
    is ApiUpdateChatItem -> "apiUpdateChatItem"
    is ApiDeleteChatItem -> "apiDeleteChatItem"
    is ApiDeleteMemberChatItem -> "apiDeleteMemberChatItem"
    is ApiChatItemReaction -> "apiChatItemReaction"
-    is ApiForwardChatItem -> "apiForwardChatItem"
+    is ApiForwardChatItems -> "apiForwardChatItems"
    is ApiNewGroup -> "apiNewGroup"
    is ApiAddMember -> "apiAddMember"
    is ApiJoinGroup -> "apiJoinGroup"
@@ -4790,7 +4795,7 @@ sealed class CR {
  @Serializable @SerialName("memberSubErrors") class MemberSubErrors(val user: UserRef, val memberSubErrors: List<MemberSubError>): CR()
  @Serializable @SerialName("groupEmpty") class GroupEmpty(val user: UserRef, val group: GroupInfo): CR()
  @Serializable @SerialName("userContactLinkSubscribed") class UserContactLinkSubscribed: CR()
-  @Serializable @SerialName("newChatItem") class NewChatItem(val user: UserRef, val chatItem: AChatItem): CR()
+  @Serializable @SerialName("newChatItems") class NewChatItems(val user: UserRef, val chatItems: List<AChatItem>): CR()
  @Serializable @SerialName("chatItemStatusUpdated") class ChatItemStatusUpdated(val user: UserRef, val chatItem: AChatItem): CR()
  @Serializable @SerialName("chatItemUpdated") class ChatItemUpdated(val user: UserRef, val chatItem: AChatItem): CR()
  @Serializable @SerialName("chatItemNotChanged") class ChatItemNotChanged(val user: UserRef, val chatItem: AChatItem): CR()
@@ -4966,7 +4971,7 @@ sealed class CR {
    is MemberSubErrors -> "memberSubErrors"
    is GroupEmpty -> "groupEmpty"
    is UserContactLinkSubscribed -> "userContactLinkSubscribed"
-    is NewChatItem -> "newChatItem"
+    is NewChatItems -> "newChatItems"
    is ChatItemStatusUpdated -> "chatItemStatusUpdated"
    is ChatItemUpdated -> "chatItemUpdated"
    is ChatItemNotChanged -> "chatItemNotChanged"
@@ -5134,7 +5139,7 @@ sealed class CR {
    is MemberSubErrors -> withUser(user, json.encodeToString(memberSubErrors))
    is GroupEmpty -> withUser(user, json.encodeToString(group))
    is UserContactLinkSubscribed -> noDetails()
-    is NewChatItem -> withUser(user, json.encodeToString(chatItem))
+    is NewChatItems -> withUser(user, chatItems.joinToString("\n") { json.encodeToString(it) })
    is ChatItemStatusUpdated -> withUser(user, json.encodeToString(chatItem))
    is ChatItemUpdated -> withUser(user, json.encodeToString(chatItem))
    is ChatItemNotChanged -> withUser(user, json.encodeToString(chatItem))
@@ -380,24 +380,28 @@ fun ComposeView(

  suspend fun send(chat: Chat, mc: MsgContent, quoted: Long?, file: CryptoFile? = null, live: Boolean = false, ttl: Int?): ChatItem? {
    val cInfo = chat.chatInfo
-    val aChatItem = if (chat.chatInfo.chatType == ChatType.Local)
-      chatModel.controller.apiCreateChatItem(rh = chat.remoteHostId, noteFolderId = chat.chatInfo.apiId, file = file, mc = mc)
+    val chatItems = if (chat.chatInfo.chatType == ChatType.Local)
+      chatModel.controller.apiCreateChatItems(
+        rh = chat.remoteHostId,
+        noteFolderId = chat.chatInfo.apiId,
+        composedMessages = listOf(ComposedMessage(file, null, mc))
+      )
    else
-      chatModel.controller.apiSendMessage(
-      rh = chat.remoteHostId,
-      type = cInfo.chatType,
-      id = cInfo.apiId,
-      file = file,
-      quotedItemId = quoted,
-      mc = mc,
-      live = live,
-      ttl = ttl
-    )
-    if (aChatItem != null) {
-      withChats {
-        addChatItem(chat.remoteHostId, cInfo, aChatItem.chatItem)
+      chatModel.controller.apiSendMessages(
+        rh = chat.remoteHostId,
+        type = cInfo.chatType,
+        id = cInfo.apiId,
+        live = live,
+        ttl = ttl,
+        composedMessages = listOf(ComposedMessage(file, quoted, mc))
+      )
+    if (!chatItems.isNullOrEmpty()) {
+      chatItems.forEach { aChatItem ->
+        withChats {
+          addChatItem(chat.remoteHostId, cInfo, aChatItem.chatItem)
+        }
      }
-      return aChatItem.chatItem
+      return chatItems.first().chatItem
    }
    if (file != null) removeFile(file.filePath)
    return null
@@ -414,21 +418,22 @@ fun ComposeView(
    }

    suspend fun forwardItem(rhId: Long?, forwardedItem: ChatItem, fromChatInfo: ChatInfo, ttl: Int?): ChatItem? {
-      val chatItem = controller.apiForwardChatItem(
+      val chatItems = controller.apiForwardChatItems(
        rh = rhId,
        toChatType = chat.chatInfo.chatType,
        toChatId = chat.chatInfo.apiId,
        fromChatType = fromChatInfo.chatType,
        fromChatId = fromChatInfo.apiId,
-        itemId = forwardedItem.id,
+        itemIds = listOf(forwardedItem.id),
        ttl = ttl
      )
-      if (chatItem != null) {
+      chatItems?.forEach { chatItem ->
        withChats {
          addChatItem(rhId, chat.chatInfo, chatItem)
        }
      }
-      return chatItem
+      // TODO batch send: forward multiple messages
+      return chatItems?.firstOrNull()
    }

    fun checkLinkPreview(): MsgContent {
@@ -519,6 +524,7 @@ fun ComposeView(
        ComposePreview.NoPreview -> msgs.add(MsgContent.MCText(msgText))
        is ComposePreview.CLinkPreview -> msgs.add(checkLinkPreview())
        is ComposePreview.MediaPreview -> {
+          // TODO batch send: batch media previews
          preview.content.forEachIndexed { index, it ->
            val file = when (it) {
              is UploadContent.SimpleImage ->
@@ -46,7 +46,7 @@ mySquaringBot _user cc = do
      CRContactConnected _ contact _ -> do
        contactConnected contact
        sendMessage cc contact welcomeMessage
-      CRNewChatItem _ (AChatItem _ SMDRcv (DirectChat contact) ChatItem {content = mc@CIRcvMsgContent {}}) -> do
+      CRNewChatItems {chatItems = (AChatItem _ SMDRcv (DirectChat contact) ChatItem {content = mc@CIRcvMsgContent {}}) : _} -> do
        let msg = T.unpack $ ciContentToText mc
            number_ = readMaybe msg :: Maybe Integer
        sendMessage cc contact $ case number_ of
@@ -40,7 +40,7 @@ broadcastBot BroadcastBotOpts {publishers, welcomeMessage, prohibitedMessage} _u
      CRContactConnected _ ct _ -> do
        contactConnected ct
        sendMessage cc ct welcomeMessage
-      CRNewChatItem _ (AChatItem _ SMDRcv (DirectChat ct) ci@ChatItem {content = CIRcvMsgContent mc})
+      CRNewChatItems {chatItems = (AChatItem _ SMDRcv (DirectChat ct) ci@ChatItem {content = CIRcvMsgContent mc}) : _}
        | publisher `elem` publishers ->
          if allowContent mc
            then do
@@ -73,7 +73,7 @@ crDirectoryEvent = \case
  CRGroupDeleted {groupInfo} -> Just $ DEGroupDeleted groupInfo
  CRChatItemUpdated {chatItem = AChatItem _ SMDRcv (DirectChat ct) _} -> Just $ DEItemEditIgnored ct
  CRChatItemsDeleted {chatItemDeletions = ((ChatItemDeletion (AChatItem _ SMDRcv (DirectChat ct) _) _) : _), byUser = False} -> Just $ DEItemDeleteIgnored ct
-  CRNewChatItem {chatItem = AChatItem _ SMDRcv (DirectChat ct) ci@ChatItem {content = CIRcvMsgContent mc, meta = CIMeta {itemLive}}} ->
+  CRNewChatItems {chatItems = (AChatItem _ SMDRcv (DirectChat ct) ci@ChatItem {content = CIRcvMsgContent mc, meta = CIMeta {itemLive}}) : _} ->
    Just $ case (mc, itemLive) of
      (MCText t, Nothing) -> DEContactCommand ct ciId $ fromRight err $ A.parseOnly (directoryCmdP <* A.endOfInput) $ T.dropWhileEnd isSpace t
      _ -> DEUnsupportedMessage ct ciId