feat(chat bubbles): reactively update sender name - WPB-19514

WireMessaging/Sources/WireMessagingAssembly/ConversationsAssembly.swift

@@ -19,18 +19,21 @@
 public import UIKit
 import WireMessagingUI
 public import WireMessagingDomain
+import Combine
 
 public enum WireMessagingAssembly {
 
     @MainActor
     public static func makeConversationScreen(
-        loadMessagesRepo: any (LoadConversationMessagesRepositoryProtocol & MonitorMessagesRepositoryProtocol)
+        loadMessagesRepo: any (LoadConversationMessagesRepositoryProtocol & MonitorMessagesRepositoryProtocol),
+        senderNameObserverProvider: SenderNameObserverProvider?
     ) -> UIViewController {
         ConversationMessagesViewController(
             viewModel: ConversationMessagesViewModel(
-                dataSource: ConversationMessagesDataSource(
+                dataSource: ConversationDataSource(
                     loadMessagesUseCase: LoadConversationMessagesUseCase(repo: loadMessagesRepo),
-                    monitorMessagesUseCase: MonitorMessagesUseCase(repo: loadMessagesRepo)
+                    monitorMessagesUseCase: MonitorMessagesUseCase(repo: loadMessagesRepo),
+                    senderNameObserverProvider: AnySenderNameObserverProvider(senderNameObserverProvider)
                 )
             )
         )

WireMessaging/Sources/WireMessagingDomain/Conversation/UserModel.swift

@@ -18,16 +18,26 @@
 
 public import Foundation
 
+// To be refined later
 public struct UserModel: Sendable {
-    // To be refined later
+
+    // 'objectID' to abstract id from data layer hide behind abstract 'any Sendable'
+    // used as a way to map domain models back to data models
+    public let objectID: any Sendable
+
     public let remoteIdentifier: UUID
     public let name: String?
     public let handle: String?
 
-    public init(remoteIdentifier: UUID, name: String?, handle: String?) {
+    public init(
+        objectID: any Sendable,
+        remoteIdentifier: UUID,
+        name: String?,
+        handle: String?
+    ) {
         self.remoteIdentifier = remoteIdentifier
         self.name = name
         self.handle = handle
+        self.objectID = objectID
     }
-
 }

WireMessaging/Sources/WireMessagingDomain/SenderNamePublisherProvider.swift

@@ -0,0 +1,26 @@
+//
+// Wire
+// Copyright (C) 2025 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/.
+//
+
+import Foundation
+public import Combine
+
+public protocol SenderNameObserverProtocol {
+    var authorChangedPublisher: AnyPublisher<String, Never>? { get }
+}
+
+public typealias SenderNameObserverProvider = (UserModel?) -> (any SenderNameObserverProtocol)?

WireMessaging/Sources/WireMessagingUI/Conversation/MessageCollectionViewCell.swift → WireMessaging/Sources/WireMessagingUI/Conversation/AnySenderNameObserverProvider.swift

@@ -16,25 +16,22 @@
 // along with this program. If not, see http://www.gnu.org/licenses/.
 //
 
-import SwiftUI
-import UIKit
+package import WireMessagingDomain
 
-class MessageCollectionViewCell: UICollectionViewCell {
+// Need to be wrapped to type eraser as @unchecked Sendable to be able to pass to datasource actor
+// also performs mapping of domain model which is just raw string
+// to UI model which is Attributed string
+package struct AnySenderNameObserverProvider: @unchecked Sendable {
 
-    // reuse identifier for each message type
-    // one for now, later will be improved
-    static let reuseIdentifier = "MessageCollectionViewCell"
+    private var observerProvider: SenderNameObserverProvider?
 
-    var messageType: MessageType? {
-        didSet {
-            guard let messageType else { return }
-            switch messageType {
-            case let .text(viewModel):
-                let config = UIHostingConfiguration {
-                    TextMessageView(viewModel: viewModel)
-                }
-                contentConfiguration = config
-            }
-        }
+    package init(
+        _ observerProvider: SenderNameObserverProvider?
+    ) {
+        self.observerProvider = observerProvider
+    }
+
+    func get(for model: UserModel?) -> (any SenderNameObserverProtocol)? {
+        observerProvider?(model)
     }
 }

WireMessaging/Sources/WireMessagingUI/Conversation/ConversationMessagesDataSource.swift → WireMessaging/Sources/WireMessagingUI/Conversation/ConversationDataSource.swift

@@ -16,52 +16,55 @@
 // along with this program. If not, see http://www.gnu.org/licenses/.
 //
 
+import Combine
 import Foundation
 package import UIKit
 package import WireMessagingDomain
 
-package enum MessagesSection: Sendable {
+package enum ConversationSection: Sendable {
     // one section for now, later we'd have probably one section for a day
     case main
 }
 
-package typealias MessagesSnapshot = NSDiffableDataSourceSnapshot<MessagesSection, MessageType>
+package typealias ConversationSnapshot = NSDiffableDataSourceSnapshot<ConversationSection, ConversationElement>
 
-package protocol ConversationMessagesDataSourceProtocol: Sendable {
-    func updatesStream() async -> AsyncStream<MessagesUpdate>
+package protocol ConversationDataSourceProtocol: Sendable {
+    func makeUpdatesStream() async -> AsyncStream<MessagesUpdate>
     func loadInitialMessages() async
     func reset() async
 }
 
 /// Actor to synchronise access to all that needed to conversation screen
 /// Does all calculations in background
-package actor ConversationMessagesDataSource: @preconcurrency ConversationMessagesDataSourceProtocol {
+package actor ConversationDataSource: @preconcurrency ConversationDataSourceProtocol {
 
     // AsyncStream because Combine's AnyPublisher is not Sendable
     // As it's a stream, has to be one subscriber only
     private var updatesStreamContinuation: AsyncStream<MessagesUpdate>.Continuation?
-    package func updatesStream() async -> AsyncStream<MessagesUpdate> {
+    package func makeUpdatesStream() async -> AsyncStream<MessagesUpdate> {
         let (stream, continuation) = AsyncStream.makeStream(of: MessagesUpdate.self)
         updatesStreamContinuation = continuation
         return stream
     }
 
     private let loadMessagesUseCase: any LoadConversationMessagesUseCaseProtocol
     private let monitorMessagesUseCase: any MonitorMessagesUseCaseProtocol
+    private let senderNameObserverProvider: AnySenderNameObserverProvider
 
     // here on later stages will be injected uses cases and
     // provider to ask for publishers needed for View Models
     package init(
         loadMessagesUseCase: any LoadConversationMessagesUseCaseProtocol,
-        monitorMessagesUseCase: any MonitorMessagesUseCaseProtocol
+        monitorMessagesUseCase: any MonitorMessagesUseCaseProtocol,
+        senderNameObserverProvider: AnySenderNameObserverProvider
     ) {
         self.loadMessagesUseCase = loadMessagesUseCase
         self.monitorMessagesUseCase = monitorMessagesUseCase
+        self.senderNameObserverProvider = senderNameObserverProvider
     }
 
     // store cached message view models
-    private var messages: [MessageType] = []
-    private var snapshot = MessagesSnapshot()
+    private var snapshot = ConversationSnapshot()
 
     private var observeTask: Task<Void, Never>?
 
@@ -76,7 +79,11 @@ package actor ConversationMessagesDataSource: @preconcurrency ConversationMessag
         let messages = await loadMessagesUseCase.loadMessages(offset: 0)
 
         snapshot.appendSections([.main])
-        snapshot.appendItems(messages.reversed().toUIModel())
+        snapshot.appendItems(
+            messages
+                .reversed()
+                .map { mapToUIModel($0) }
+        )
         updatesStreamContinuation?.yield(.initiallyLoaded(snapshot))
 
         subscribeToNotifications()
@@ -86,13 +93,36 @@ package actor ConversationMessagesDataSource: @preconcurrency ConversationMessag
         for await event in monitorMessagesUseCase.messagesUpdatesStream {
             switch event {
             case let .inserted(model):
-                let uiModel = model.toUIModel()
+                let uiModel = mapToUIModel(model)
                 snapshot.appendItems([uiModel])
                 updatesStreamContinuation?.yield(.messageAdded(snapshot))
             }
         }
     }
 
+    private func mapToUIModel(_ model: MessageModel) -> ConversationElement {
+        switch model.kind {
+        case let .text(textModel):
+            let senderState: SenderViewModel.State = if let name = model.sender?.name {
+                .exists(AttributedString(stringLiteral: name))
+            } else {
+                .empty
+            }
+            return ConversationElement.text(
+                TextMessageViewModel(
+                    content: AttributedString(stringLiteral: textModel.text ?? ""),
+                    senderViewModel: SenderViewModel(
+                        state: senderState,
+                        namePublisher: senderNameObserverProvider
+                            .get(for: model.sender)?.authorChangedPublisher
+                    )
+                )
+            )
+        default: fatalError()
+        }
+
+    }
+
     package func reset() async {
         // Need to be called to clean up subscription and avoid memory leak
         observeTask?.cancel()
@@ -138,29 +168,3 @@ package actor ConversationMessagesDataSource: @preconcurrency ConversationMessag
     }
 
 }
-
-extension [MessageModel] {
-    func toUIModel() -> [MessageType] {
-        map { $0.toUIModel() }
-    }
-}
-
-extension MessageModel {
-    func toUIModel() -> MessageType {
-        switch kind {
-        case let .text(textModel):
-            let senderState: SenderViewModel.State = if let name = sender?.name {
-                .exists(AttributedString(stringLiteral: name))
-            } else {
-                .empty
-            }
-            return MessageType.text(
-                TextMessageViewModel(
-                    content: AttributedString(stringLiteral: textModel.text ?? ""),
-                    senderViewModel: SenderViewModel(state: senderState)
-                )
-            )
-        default: fatalError()
-        }
-    }
-}

WireMessaging/Sources/WireMessagingUI/Conversation/MessageType.swift → WireMessaging/Sources/WireMessagingUI/Conversation/ConversationElement.swift

@@ -18,7 +18,7 @@
 
 import Foundation
 
-package enum MessageType: Hashable, Sendable {
+package enum ConversationElement: Hashable, Sendable {
 
     case text(TextMessageViewModel)
     // case image, video, system, etc

WireMessaging/Sources/WireMessagingUI/Conversation/ConversationMessagesViewController.swift

@@ -21,7 +21,7 @@ package import SwiftUI
 
 package final class ConversationMessagesViewController: UIViewController {
 
-    typealias DataSource = UICollectionViewDiffableDataSource<MessagesSection, MessageType>
+    typealias DataSource = UICollectionViewDiffableDataSource<ConversationSection, ConversationElement>
 
     let viewModel: any ConversationMessagesViewModelProtocol
 
@@ -64,7 +64,7 @@ package final class ConversationMessagesViewController: UIViewController {
     }
 
     private func observeUpdates() async {
-        let stream = await viewModel.updatesStream()
+        let stream = await viewModel.makeUpdatesStream()
         for await update in stream {
             switch update {
             case let .initiallyLoaded(snapshot):
@@ -138,7 +138,7 @@ package final class ConversationMessagesViewController: UIViewController {
             }
     }
 
-    private func setContent(cell: UICollectionViewCell, message: MessageType) {
+    private func setContent(cell: UICollectionViewCell, message: ConversationElement) {
         switch message {
         case let .text(viewModel):
             let config = UIHostingConfiguration {
@@ -164,9 +164,12 @@ private struct ConversationMessagesViewControllerPreview: UIViewControllerRepres
     func makeUIViewController(context: Context) -> ConversationMessagesViewController {
         ConversationMessagesViewController(
             viewModel: ConversationMessagesViewModel(
-                dataSource: ConversationMessagesDataSource(
+                dataSource: ConversationDataSource(
                     loadMessagesUseCase: MockLoadConversationMessagesUseCaseProtocol(),
-                    monitorMessagesUseCase: MockMonitorMessagesUseCaseProtocol()
+                    monitorMessagesUseCase: MockMonitorMessagesUseCaseProtocol(),
+                    senderNameObserverProvider: AnySenderNameObserverProvider { _ in
+                        nil
+                    }
                 )
             )
         )

WireMessaging/Sources/WireMessagingUI/Conversation/ConversationMessagesViewModel.swift

@@ -20,7 +20,7 @@ import Foundation
 
 @MainActor
 package protocol ConversationMessagesViewModelProtocol {
-    func updatesStream() async -> AsyncStream<MessagesUpdate>
+    func makeUpdatesStream() async -> AsyncStream<MessagesUpdate>
     func onViewReady()
     func onWillDisappear()
 }
@@ -31,14 +31,14 @@ package protocol ConversationMessagesViewModelProtocol {
 // since DataSource is actor and works on background thread
 package struct ConversationMessagesViewModel: ConversationMessagesViewModelProtocol {
 
-    private let dataSource: any ConversationMessagesDataSourceProtocol
+    private let dataSource: any ConversationDataSourceProtocol
 
-    package init(dataSource: any ConversationMessagesDataSourceProtocol) {
+    package init(dataSource: any ConversationDataSourceProtocol) {
         self.dataSource = dataSource
     }
 
-    package func updatesStream() async -> AsyncStream<MessagesUpdate> {
-        await dataSource.updatesStream()
+    package func makeUpdatesStream() async -> AsyncStream<MessagesUpdate> {
+        await dataSource.makeUpdatesStream()
     }
 
     package func onViewReady() {

WireMessaging/Sources/WireMessagingUI/Conversation/Message Views/SenderView/SenderViewModel.swift

@@ -16,18 +16,27 @@
 // along with this program. If not, see http://www.gnu.org/licenses/.
 //
 
-import Foundation
+package import Foundation
+package import Combine
 
-class SenderViewModel: ObservableObject {
+package class SenderViewModel: ObservableObject {
 
-    enum State {
+    package enum State {
         case empty
         case exists(AttributedString)
     }
 
     @Published var state: State
 
-    init(state: State) {
+    private var cancellables: Set<AnyCancellable> = []
+
+    package init(
+        state: State,
+        namePublisher: AnyPublisher<String, Never>?
+    ) {
         self.state = state
+        namePublisher?.sink { [weak self] name in
+            self?.state = .exists(AttributedString(name))
+        }.store(in: &cancellables)
     }
 }

WireMessaging/Sources/WireMessagingUI/Conversation/MessageUpdateType.swift

@@ -20,8 +20,8 @@ import Foundation
 
 package enum MessagesUpdate: Sendable {
 
-    case initiallyLoaded(MessagesSnapshot)
-    case messageAdded(MessagesSnapshot)
+    case initiallyLoaded(ConversationSnapshot)
+    case messageAdded(ConversationSnapshot)
     // later to be added more updates like:
     // loaded new messages, new or older
     // re-sent failed message

wire-ios/Wire-iOS/Sources/UserInterface/Conversation/Content/LoadConversationMessagesRepository.swift

@@ -173,6 +173,7 @@ extension ZMMessage {
 extension ZMUser {
     func toDomain() -> UserModel {
         UserModel(
+            objectID: objectID,
             remoteIdentifier: remoteIdentifier,
             name: name,
             handle: handle