Tapping on user avatar/name in the timeline opens the room member details (#1020)

* Implementation completed

* changelog

* code improvement

* Apply suggestions from code review

Co-authored-by: Stefan Ceriu <stefanc@matrix.org>

* pr suggestions

---------

Co-authored-by: Stefan Ceriu <stefanc@matrix.org>

ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift

@@ -95,6 +95,11 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 return .room(roomID: roomID)
             case (.dismissRoom, .roomDetails):
                 return .initial
+
+            case (.presentRoomMemberDetails(let member), .room(let roomID)):
+                return .roomMemberDetails(roomID: roomID, member: member)
+            case (.dismissRoomMemberDetails, .roomMemberDetails(let roomID, _)):
+                return .room(roomID: roomID)
                 
             case (.presentMediaViewer(let file, let title), .room(let roomID)):
                 return .mediaViewer(roomID: roomID, file: file, title: title)
@@ -122,7 +127,7 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 return .emojiPicker(roomID: roomID, itemID: itemID)
             case (.dismissEmojiPicker, .emojiPicker(let roomID, _)):
                 return .room(roomID: roomID)
-            
+
             default:
                 return nil
             }
@@ -179,6 +184,11 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 presentEmojiPicker(for: itemID)
             case (.emojiPicker, .dismissEmojiPicker, .room):
                 break
+
+            case (.room, .presentRoomMemberDetails, .roomMemberDetails(_, let member)):
+                presentRoomMemberDetails(member: member.value)
+            case (.roomMemberDetails, .dismissRoomMemberDetails, .room):
+                break
                 
             default:
                 fatalError("Unknown transition: \(context)")
@@ -256,6 +266,8 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                     stateMachine.tryEvent(.presentMediaUploadPreview(fileURL: url))
                 case .presentEmojiPicker(let itemID):
                     stateMachine.tryEvent(.presentEmojiPicker(itemID: itemID))
+                case .presentRoomMemberDetails(member: let member):
+                    stateMachine.tryEvent(.presentRoomMemberDetails(member: .init(value: member)))
                 }
             }
             .store(in: &cancellables)
@@ -460,12 +472,33 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
         }
     }
 
+    private func presentRoomMemberDetails(member: RoomMemberProxyProtocol) {
+        let params = RoomMemberDetailsScreenCoordinatorParameters(roomMemberProxy: member, mediaProvider: userSession.mediaProvider)
+        let coordinator = RoomMemberDetailsScreenCoordinator(parameters: params)
+
+        navigationStackCoordinator.push(coordinator) { [weak self] in
+            self?.stateMachine.tryEvent(.dismissRoomMemberDetails)
+        }
+    }
+
     private func showSuccess(label: String) {
         ServiceLocator.shared.userIndicatorController.submitIndicator(UserIndicator(title: label, iconName: "checkmark"))
     }
 }
 
 private extension RoomFlowCoordinator {
+    struct HashableRoomMemberWrapper: Hashable {
+        let value: RoomMemberProxyProtocol
+
+        static func == (lhs: HashableRoomMemberWrapper, rhs: HashableRoomMemberWrapper) -> Bool {
+            lhs.value.userID == rhs.value.userID
+        }
+
+        func hash(into hasher: inout Hasher) {
+            hasher.combine(value.userID)
+        }
+    }
+
     enum State: StateType {
         case initial
         case room(roomID: String)
@@ -475,6 +508,7 @@ private extension RoomFlowCoordinator {
         case mediaUploadPicker(roomID: String, source: MediaPickerScreenSource)
         case mediaUploadPreview(roomID: String, fileURL: URL)
         case emojiPicker(roomID: String, itemID: String)
+        case roomMemberDetails(roomID: String, member: HashableRoomMemberWrapper)
     }
     
     struct EventUserInfo {
@@ -502,5 +536,8 @@ private extension RoomFlowCoordinator {
         
         case presentEmojiPicker(itemID: String)
         case dismissEmojiPicker
+
+        case presentRoomMemberDetails(member: HashableRoomMemberWrapper)
+        case dismissRoomMemberDetails
     }
 }

ElementX/Sources/Generated/Strings.swift

@@ -638,6 +638,8 @@ public enum L10n {
   public static var screenRoomDetailsUpdatingRoom: String { return L10n.tr("Localizable", "screen_room_details_updating_room") }
   /// Failed processing media to upload, please try again.
   public static var screenRoomErrorFailedProcessingMedia: String { return L10n.tr("Localizable", "screen_room_error_failed_processing_media") }
+  /// Could not retrieve user details
+  public static var screenRoomErrorFailedRetrievingUserDetails: String { return L10n.tr("Localizable", "screen_room_error_failed_retrieving_user_details") }
   /// Block
   public static var screenRoomMemberDetailsBlockAlertAction: String { return L10n.tr("Localizable", "screen_room_member_details_block_alert_action") }
   /// Blocked users will not be able to send you messages and all message by them will be hidden. You can reverse this action anytime.

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -4,8 +4,9 @@
 // swiftlint:disable all
 import Combine
 import Foundation
-import MatrixRustSDK
+import SwiftUI
 import AnalyticsEvents
+import MatrixRustSDK
 class AnalyticsClientMock: AnalyticsClientProtocol {
     var isRunning: Bool {
         get { return underlyingIsRunning }
@@ -813,6 +814,27 @@ class RoomProxyMock: RoomProxyProtocol {
         updateMembersCallsCount += 1
         await updateMembersClosure?()
     }
+    //MARK: - getMember
+
+    var getMemberUserIDCallsCount = 0
+    var getMemberUserIDCalled: Bool {
+        return getMemberUserIDCallsCount > 0
+    }
+    var getMemberUserIDReceivedUserID: String?
+    var getMemberUserIDReceivedInvocations: [String] = []
+    var getMemberUserIDReturnValue: Result<RoomMemberProxyProtocol, RoomProxyError>!
+    var getMemberUserIDClosure: ((String) async -> Result<RoomMemberProxyProtocol, RoomProxyError>)?
+
+    func getMember(userID: String) async -> Result<RoomMemberProxyProtocol, RoomProxyError> {
+        getMemberUserIDCallsCount += 1
+        getMemberUserIDReceivedUserID = userID
+        getMemberUserIDReceivedInvocations.append(userID)
+        if let getMemberUserIDClosure = getMemberUserIDClosure {
+            return await getMemberUserIDClosure(userID)
+        } else {
+            return getMemberUserIDReturnValue
+        }
+    }
     //MARK: - inviter
 
     var inviterCallsCount = 0
@@ -1121,4 +1143,93 @@ class UserDiscoveryServiceMock: UserDiscoveryServiceProtocol {
         }
     }
 }
+class UserIndicatorControllerMock: UserIndicatorControllerProtocol {
+    var alertInfo: AlertInfo<UUID>?
+
+    //MARK: - submitIndicator
+
+    var submitIndicatorCallsCount = 0
+    var submitIndicatorCalled: Bool {
+        return submitIndicatorCallsCount > 0
+    }
+    var submitIndicatorReceivedIndicator: UserIndicator?
+    var submitIndicatorReceivedInvocations: [UserIndicator] = []
+    var submitIndicatorClosure: ((UserIndicator) -> Void)?
+
+    func submitIndicator(_ indicator: UserIndicator) {
+        submitIndicatorCallsCount += 1
+        submitIndicatorReceivedIndicator = indicator
+        submitIndicatorReceivedInvocations.append(indicator)
+        submitIndicatorClosure?(indicator)
+    }
+    //MARK: - retractIndicatorWithId
+
+    var retractIndicatorWithIdCallsCount = 0
+    var retractIndicatorWithIdCalled: Bool {
+        return retractIndicatorWithIdCallsCount > 0
+    }
+    var retractIndicatorWithIdReceivedId: String?
+    var retractIndicatorWithIdReceivedInvocations: [String] = []
+    var retractIndicatorWithIdClosure: ((String) -> Void)?
+
+    func retractIndicatorWithId(_ id: String) {
+        retractIndicatorWithIdCallsCount += 1
+        retractIndicatorWithIdReceivedId = id
+        retractIndicatorWithIdReceivedInvocations.append(id)
+        retractIndicatorWithIdClosure?(id)
+    }
+    //MARK: - retractAllIndicators
+
+    var retractAllIndicatorsCallsCount = 0
+    var retractAllIndicatorsCalled: Bool {
+        return retractAllIndicatorsCallsCount > 0
+    }
+    var retractAllIndicatorsClosure: (() -> Void)?
+
+    func retractAllIndicators() {
+        retractAllIndicatorsCallsCount += 1
+        retractAllIndicatorsClosure?()
+    }
+    //MARK: - start
+
+    var startCallsCount = 0
+    var startCalled: Bool {
+        return startCallsCount > 0
+    }
+    var startClosure: (() -> Void)?
+
+    func start() {
+        startCallsCount += 1
+        startClosure?()
+    }
+    //MARK: - stop
+
+    var stopCallsCount = 0
+    var stopCalled: Bool {
+        return stopCallsCount > 0
+    }
+    var stopClosure: (() -> Void)?
+
+    func stop() {
+        stopCallsCount += 1
+        stopClosure?()
+    }
+    //MARK: - toPresentable
+
+    var toPresentableCallsCount = 0
+    var toPresentableCalled: Bool {
+        return toPresentableCallsCount > 0
+    }
+    var toPresentableReturnValue: AnyView!
+    var toPresentableClosure: (() -> AnyView)?
+
+    func toPresentable() -> AnyView {
+        toPresentableCallsCount += 1
+        if let toPresentableClosure = toPresentableClosure {
+            return toPresentableClosure()
+        } else {
+            return toPresentableReturnValue
+        }
+    }
+}
 // swiftlint:enable all

ElementX/Sources/Mocks/UserIndicatorControllerMock.swift

@@ -1,5 +1,5 @@
 //
-// Copyright 2022 New Vector Ltd
+// Copyright 2023 New Vector Ltd
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,18 +17,12 @@
 import Combine
 import Foundation
 
-class MockUserIndicatorController: UserIndicatorControllerProtocol {
-    func submitIndicator(_ indicator: UserIndicator) { }
-    
-    func retractIndicatorWithId(_ id: String) { }
-    
-    func retractAllIndicators() { }
-    
-    var alertInfo: AlertInfo<UUID>? {
-        didSet {
-            alertInfoPublisher.send(alertInfo)
-        }
+extension UserIndicatorControllerMock {
+    static var `default`: UserIndicatorControllerMock {
+        let mock = UserIndicatorControllerMock()
+        mock.submitIndicatorClosure = { _ in }
+        mock.retractIndicatorWithIdClosure = { _ in }
+        mock.retractAllIndicatorsClosure = { }
+        return mock
     }
-    
-    let alertInfoPublisher: PassthroughSubject<AlertInfo<UUID>?, Never> = .init()
 }

ElementX/Sources/Other/UserIndicator/UserIndicatorControllerProtocol.swift

@@ -16,9 +16,21 @@
 
 import Foundation
 
+// sourcery: AutoMockable
 protocol UserIndicatorControllerProtocol: CoordinatorProtocol {
     func submitIndicator(_ indicator: UserIndicator)
     func retractIndicatorWithId(_ id: String)
     func retractAllIndicators()
     var alertInfo: AlertInfo<UUID>? { get set }
 }
+
+extension UserIndicatorControllerProtocol {
+    /// Allows to submit a delayed indicator, this returns a Task so that it's also possible to cancel the action
+    func submitIndicator(_ indicator: UserIndicator, delay: Duration) -> Task<Void, Never> {
+        Task {
+            try? await Task.sleep(for: delay)
+            guard !Task.isCancelled else { return }
+            submitIndicator(indicator)
+        }
+    }
+}

ElementX/Sources/Screens/MediaUploadPreviewScreen/View/MediaUploadPreviewScreen.swift

@@ -102,7 +102,7 @@ private class PreviewItem: NSObject, QLPreviewItem {
 // MARK: - Previews
 
 struct MediaUploadPreviewScreen_Previews: PreviewProvider {
-    static let viewModel = MediaUploadPreviewScreenViewModel(userIndicatorController: MockUserIndicatorController(),
+    static let viewModel = MediaUploadPreviewScreenViewModel(userIndicatorController: UserIndicatorControllerMock.default,
                                                              roomProxy: RoomProxyMock(),
                                                              mediaUploadingPreprocessor: MediaUploadingPreprocessor(),
                                                              title: nil,

ElementX/Sources/Screens/RoomDetailsEditScreen/View/RoomDetailsEditScreen.swift

@@ -165,7 +165,7 @@ struct RoomDetailsEditScreen_Previews: PreviewProvider {
     static let viewModel = RoomDetailsEditScreenViewModel(accountOwner: RoomMemberProxyMock.mockAlice,
                                                           mediaProvider: MockMediaProvider(),
                                                           roomProxy: RoomProxyMock(with: .init(name: "Room", displayName: "Room")),
-                                                          userIndicatorController: MockUserIndicatorController())
+                                                          userIndicatorController: UserIndicatorControllerMock.default)
     
     static var previews: some View {
         NavigationStack {

ElementX/Sources/Screens/RoomScreen/RoomScreenCoordinator.swift

@@ -31,6 +31,7 @@ enum RoomScreenCoordinatorAction {
     case presentMediaUploadPreviewScreen(URL)
     case presentRoomDetails
     case presentEmojiPicker(itemID: String)
+    case presentRoomMemberDetails(member: RoomMemberProxyProtocol)
 }
 
 final class RoomScreenCoordinator: CoordinatorProtocol {
@@ -74,6 +75,8 @@ final class RoomScreenCoordinator: CoordinatorProtocol {
                 actionsSubject.send(.presentMediaUploadPicker(.documents))
             case .displayMediaUploadPreviewScreen(let url):
                 actionsSubject.send(.presentMediaUploadPreviewScreen(url))
+            case .displayRoomMemberDetails(let member):
+                actionsSubject.send(.presentRoomMemberDetails(member: member))
             }
         }
     }

ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift

@@ -27,6 +27,7 @@ enum RoomScreenViewModelAction {
     case displayMediaPicker
     case displayDocumentPicker
     case displayMediaUploadPreviewScreen(url: URL)
+    case displayRoomMemberDetails(member: RoomMemberProxyProtocol)
 }
 
 enum RoomScreenComposerMode: Equatable {
@@ -65,6 +66,7 @@ enum RoomScreenViewAction {
     case displayDocumentPicker
     
     case handlePasteOrDrop(provider: NSItemProvider)
+    case tappedOnUser(userID: String)
 }
 
 struct RoomScreenViewState: BindableState {

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -29,12 +29,16 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
 
     private let roomProxy: RoomProxyProtocol
     private let timelineController: RoomTimelineControllerProtocol
+    private unowned let userIndicatorController: UserIndicatorControllerProtocol
+    private var loadingTask: Task<Void, Never>?
     
     init(timelineController: RoomTimelineControllerProtocol,
          mediaProvider: MediaProviderProtocol,
-         roomProxy: RoomProxyProtocol) {
+         roomProxy: RoomProxyProtocol,
+         userIndicatorController: UserIndicatorControllerProtocol = ServiceLocator.shared.userIndicatorController) {
         self.roomProxy = roomProxy
         self.timelineController = timelineController
+        self.userIndicatorController = userIndicatorController
         
         super.init(initialViewState: RoomScreenViewState(roomId: timelineController.roomID,
                                                          roomTitle: roomProxy.roomTitle,
@@ -130,6 +134,8 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
             callback?(.displayDocumentPicker)
         case .handlePasteOrDrop(let provider):
             handlePasteOrDrop(provider)
+        case .tappedOnUser(userID: let userID):
+            Task { await handleTappedUser(userID: userID) }
         }
     }
     
@@ -246,10 +252,10 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                                                  title: L10n.commonError,
                                                  message: message)
         case .toast(let message):
-            ServiceLocator.shared.userIndicatorController.submitIndicator(UserIndicator(id: Constants.toastErrorID,
-                                                                                        type: .toast,
-                                                                                        title: message,
-                                                                                        iconName: "xmark"))
+            userIndicatorController.submitIndicator(UserIndicator(id: Constants.toastErrorID,
+                                                                  type: .toast,
+                                                                  title: message,
+                                                                  iconName: "xmark"))
         }
     }
     
@@ -376,9 +382,9 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         _ = provider.loadDataRepresentation(for: contentType) { data, error in
             Task { @MainActor in
                 let loadingIndicatorIdentifier = UUID().uuidString
-                ServiceLocator.shared.userIndicatorController.submitIndicator(UserIndicator(id: loadingIndicatorIdentifier, type: .modal, title: L10n.commonLoading, persistent: true))
+                self.userIndicatorController.submitIndicator(UserIndicator(id: loadingIndicatorIdentifier, type: .modal, title: L10n.commonLoading, persistent: true))
                 defer {
-                    ServiceLocator.shared.userIndicatorController.retractIndicatorWithId(loadingIndicatorIdentifier)
+                    self.userIndicatorController.retractIndicatorWithId(loadingIndicatorIdentifier)
                 }
 
                 if let error {
@@ -421,6 +427,37 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         
         return messageItem.contentType
     }
+
+    private func handleTappedUser(userID: String) async {
+        // This is generally fast but it could take some time for rooms with thousands of users on first load
+        // Show a loader only if it takes more than 0.1 seconds
+        loadingTask = showLoadingIndicator(with: .milliseconds(100))
+        let result = await roomProxy.getMember(userID: userID)
+        loadingTask?.cancel()
+        hideLoadingIndicator()
+        
+        switch result {
+        case .success(let member):
+            callback?(.displayRoomMemberDetails(member: member))
+        case .failure(let error):
+            displayError(.alert(L10n.screenRoomErrorFailedRetrievingUserDetails))
+            MXLog.error("Failed retrieving the user given the following id \(userID) with error: \(error)")
+        }
+    }
+
+    private static let loadingIndicatorIdentifier = "RoomScreenLoadingIndicator"
+
+    private func showLoadingIndicator(with delay: Duration) -> Task<Void, Never> {
+        userIndicatorController.submitIndicator(UserIndicator(id: Self.loadingIndicatorIdentifier,
+                                                              type: .modal(interactiveDismissDisabled: true),
+                                                              title: L10n.commonLoading,
+                                                              persistent: true),
+                                                delay: delay)
+    }
+
+    private func hideLoadingIndicator() {
+        userIndicatorController.retractIndicatorWithId(Self.loadingIndicatorIdentifier)
+    }
 }
 
 // MARK: - Mocks

ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemBubbledStylerView.swift

@@ -68,6 +68,9 @@ struct TimelineItemBubbledStylerView<Content: View>: View {
                         .padding(.vertical, senderNameVerticalPadding)
                 }
                 .accessibilityElement(children: .combine)
+                .onTapGesture {
+                    context.send(viewAction: .tappedOnUser(userID: timelineItem.sender.id))
+                }
             }
         }
     }

ElementX/Sources/Screens/RoomScreen/View/Style/TimelineItemPlainStylerView.swift

@@ -70,12 +70,17 @@ struct TimelineItemPlainStylerView<Content: View>: View {
     private var header: some View {
         if shouldShowSenderDetails {
             HStack {
-                TimelineSenderAvatarView(timelineItem: timelineItem)
-                Text(timelineItem.sender.displayName ?? timelineItem.sender.id)
-                    .font(.subheadline)
-                    .foregroundColor(.element.primaryContent)
-                    .fontWeight(.semibold)
-                    .lineLimit(1)
+                HStack {
+                    TimelineSenderAvatarView(timelineItem: timelineItem)
+                    Text(timelineItem.sender.displayName ?? timelineItem.sender.id)
+                        .font(.subheadline)
+                        .foregroundColor(.element.primaryContent)
+                        .fontWeight(.semibold)
+                        .lineLimit(1)
+                }
+                .onTapGesture {
+                    context.send(viewAction: .tappedOnUser(userID: timelineItem.sender.id))
+                }
                 Spacer()
                 Text(timelineItem.timestamp)
                     .foregroundColor(Color.element.tertiaryContent)

ElementX/Sources/Services/Room/RoomMember/RoomMemberProxyProtocol.swift

@@ -23,7 +23,7 @@ enum RoomMemberProxyError: Error {
 }
 
 // sourcery: AutoMockable
-protocol RoomMemberProxyProtocol {
+protocol RoomMemberProxyProtocol: AnyObject {
     var userID: String { get }
     var displayName: String? { get }
     var avatarURL: URL? { get }

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -389,6 +389,22 @@ class RoomProxy: RoomProxyProtocol {
             return
         }
     }
+
+    func getMember(userID: String) async -> Result<RoomMemberProxyProtocol, RoomProxyError> {
+        sendMessageBackgroundTask = backgroundTaskService.startBackgroundTask(withName: backgroundTaskName, isReusable: true)
+        defer {
+            sendMessageBackgroundTask?.stop()
+        }
+
+        return await Task.dispatch(on: userInitiatedDispatchQueue) {
+            do {
+                let member = try self.room.member(userId: userID)
+                return .success(RoomMemberProxy(member: member, backgroundTaskService: self.backgroundTaskService))
+            } catch {
+                return .failure(.failedRetrievingMember)
+            }
+        }
+    }
     
     func ignoreUser(_ userID: String) async -> Result<Void, RoomProxyError> {
         sendMessageBackgroundTask = backgroundTaskService.startBackgroundTask(withName: backgroundTaskName, isReusable: true)

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -33,6 +33,7 @@ enum RoomProxyError: Error {
     case failedReportingContent
     case failedAddingTimelineListener
     case failedRetrievingMembers
+    case failedRetrievingMember
     case failedLeavingRoom
     case failedAcceptingInvite
     case failedRejectingInvite
@@ -113,7 +114,9 @@ protocol RoomProxyProtocol {
     func leaveRoom() async -> Result<Void, RoomProxyError>
     
     func updateMembers() async
-    
+
+    func getMember(userID: String) async -> Result<RoomMemberProxyProtocol, RoomProxyError>
+
     func inviter() async -> RoomMemberProxyProtocol?
     
     func rejectInvitation() async -> Result<Void, RoomProxyError>

ElementX/Sources/UITests/UITestsAppCoordinator.swift

@@ -30,7 +30,7 @@ class UITestsAppCoordinator: AppCoordinatorProtocol {
 
         navigationRootCoordinator = NavigationRootCoordinator()
         
-        ServiceLocator.shared.register(userIndicatorController: MockUserIndicatorController())
+        ServiceLocator.shared.register(userIndicatorController: UserIndicatorControllerMock.default)
         
         AppSettings.configureWithSuiteName("io.element.elementx.uitests")
         AppSettings.reset()
@@ -93,13 +93,13 @@ class MockScreen: Identifiable {
         case .serverSelection:
             let navigationStackCoordinator = NavigationStackCoordinator()
             let coordinator = ServerSelectionScreenCoordinator(parameters: .init(authenticationService: MockAuthenticationServiceProxy(),
-                                                                                 userIndicatorController: MockUserIndicatorController(),
+                                                                                 userIndicatorController: UserIndicatorControllerMock.default,
                                                                                  isModallyPresented: true))
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator
         case .serverSelectionNonModal:
             return ServerSelectionScreenCoordinator(parameters: .init(authenticationService: MockAuthenticationServiceProxy(),
-                                                                      userIndicatorController: MockUserIndicatorController(),
+                                                                      userIndicatorController: UserIndicatorControllerMock.default,
                                                                       isModallyPresented: false))
         case .analyticsPrompt:
             return AnalyticsPromptScreenCoordinator()
@@ -361,7 +361,7 @@ class MockScreen: Identifiable {
                                                                                  mediaProvider: MockMediaProvider(),
                                                                                  navigationStackCoordinator: navigationStackCoordinator,
                                                                                  roomProxy: roomProxy,
-                                                                                 userIndicatorController: MockUserIndicatorController()))
+                                                                                 userIndicatorController: UserIndicatorControllerMock.default))
             navigationStackCoordinator.setRootCoordinator(coordinator)
             return navigationStackCoordinator
         case .roomMembersListScreen:
@@ -477,7 +477,7 @@ class MockScreen: Identifiable {
             let mediaProvider = MockMediaProvider()
             let usersSubject = CurrentValueSubject<[UserProfileProxy], Never>([])
             let members: [RoomMemberProxyMock] = id == .inviteUsersInRoomExistingMembers ? [.mockInvitedAlice, .mockBob] : []
-            let roomType: InviteUsersScreenRoomType = id == .inviteUsers ? .draft : .room(members: members, userIndicatorController: MockUserIndicatorController())
+            let roomType: InviteUsersScreenRoomType = id == .inviteUsers ? .draft : .room(members: members, userIndicatorController: UserIndicatorControllerMock.default)
             let coordinator = InviteUsersScreenCoordinator(parameters: .init(selectedUsers: usersSubject.asCurrentValuePublisher(), roomType: roomType, mediaProvider: mediaProvider, userDiscoveryService: userDiscoveryMock))
             coordinator.actions.sink { action in
                 switch action {

ElementX/Sources/UnitTests/UnitTestsAppCoordinator.swift

@@ -20,7 +20,7 @@ class UnitTestsAppCoordinator: AppCoordinatorProtocol {
     let notificationManager: NotificationManagerProtocol = NotificationManagerMock()
     
     init() {
-        ServiceLocator.shared.register(userIndicatorController: MockUserIndicatorController())
+        ServiceLocator.shared.register(userIndicatorController: UserIndicatorControllerMock.default)
         
         AppSettings.configureWithSuiteName("io.element.elementx.unittests")
         AppSettings.reset()