RoomScreenViewModel refactor part 2 (#3169)

ElementX/Sources/Screens/Timeline/TimelineInteractionHandler.swift

@@ -503,10 +503,6 @@ class TimelineInteractionHandler {
         actionsSubject.send(.displayEmojiPicker(itemID: itemID, selectedEmojis: selectedEmojis))
     }
     
-    func displayRoomMemberDetails(userID: String) async {
-        actionsSubject.send(.displayRoomMemberDetails(userID: userID))
-    }
-    
     func processItemTap(_ itemID: TimelineItemIdentifier) async -> RoomTimelineControllerAction {
         guard let timelineItem = timelineController.timelineItems.firstUsingStableID(itemID) else {
             return .none

ElementX/Sources/Screens/Timeline/TimelineModels.swift

@@ -19,7 +19,6 @@ import OrderedCollections
 import SwiftUI
 
 enum TimelineViewModelAction {
-    case displayRoomDetails
     case displayEmojiPicker(itemID: TimelineItemIdentifier, selectedEmojis: Set<String>)
     case displayReportContent(itemID: TimelineItemIdentifier, senderID: String)
     case displayCameraPicker
@@ -28,11 +27,10 @@ enum TimelineViewModelAction {
     case displayLocationPicker
     case displayPollForm(mode: PollFormMode)
     case displayMediaUploadPreviewScreen(url: URL)
-    case displayRoomMemberDetails(userID: String)
+    case tappedOnSenderDetails(userID: String)
     case displayMessageForwarding(forwardingItem: MessageForwardingItem)
     case displayLocation(body: String, geoURI: GeoURI, description: String?)
     case composer(action: TimelineComposerAction)
-    case displayCallScreen
     case hasScrolled(direction: ScrollDirection)
 }
 
@@ -48,41 +46,39 @@ enum TimelineAudioPlayerAction {
 }
 
 enum TimelineViewAction {
-    case itemAppeared(itemID: TimelineItemIdentifier) // t
-    case itemDisappeared(itemID: TimelineItemIdentifier) // t
+    case itemAppeared(itemID: TimelineItemIdentifier)
+    case itemDisappeared(itemID: TimelineItemIdentifier)
     
-    case itemTapped(itemID: TimelineItemIdentifier) // t
-    case itemSendInfoTapped(itemID: TimelineItemIdentifier) // t
-    case toggleReaction(key: String, itemID: TimelineItemIdentifier) // t
-    case sendReadReceiptIfNeeded(TimelineItemIdentifier) // t
-    case paginateBackwards // t
-    case paginateForwards // t
-    case scrollToBottom // t
+    case itemTapped(itemID: TimelineItemIdentifier)
+    case itemSendInfoTapped(itemID: TimelineItemIdentifier)
+    case toggleReaction(key: String, itemID: TimelineItemIdentifier)
+    case sendReadReceiptIfNeeded(TimelineItemIdentifier)
+    case paginateBackwards
+    case paginateForwards
+    case scrollToBottom
     
-    case displayTimelineItemMenu(itemID: TimelineItemIdentifier) // t
-    case handleTimelineItemMenuAction(itemID: TimelineItemIdentifier, action: TimelineItemMenuAction) // not t
+    case displayTimelineItemMenu(itemID: TimelineItemIdentifier)
+    case handleTimelineItemMenuAction(itemID: TimelineItemIdentifier, action: TimelineItemMenuAction)
     
-    case displayRoomDetails // not t
-    case displayRoomMemberDetails(userID: String) // t -> change name
-    case displayReactionSummary(itemID: TimelineItemIdentifier, key: String) // t -> handle externally
-    case displayEmojiPicker(itemID: TimelineItemIdentifier) // t -> handle externally
-    case displayReadReceipts(itemID: TimelineItemIdentifier) // t -> handle externally
-    case displayCall // not t
+    case tappedOnSenderDetails(userID: String)
+    case displayReactionSummary(itemID: TimelineItemIdentifier, key: String)
+    case displayEmojiPicker(itemID: TimelineItemIdentifier)
+    case displayReadReceipts(itemID: TimelineItemIdentifier)
     
-    case handlePasteOrDrop(provider: NSItemProvider) // not t
-    case handlePollAction(TimelineViewPollAction) // t
-    case handleAudioPlayerAction(TimelineAudioPlayerAction) // t
+    case handlePasteOrDrop(provider: NSItemProvider)
+    case handlePollAction(TimelineViewPollAction)
+    case handleAudioPlayerAction(TimelineAudioPlayerAction)
     
     /// Focus the timeline onto the specified event ID (switching to a detached timeline if needed).
-    case focusOnEventID(String) // t
+    case focusOnEventID(String)
     /// Switch back to a live timeline (from a detached one).
-    case focusLive // t
+    case focusLive
     /// The timeline scrolled to reveal the focussed item.
-    case scrolledToFocussedItem // t
+    case scrolledToFocussedItem
     /// The table view has loaded the first items for a new timeline.
-    case hasSwitchedTimeline // t
+    case hasSwitchedTimeline
     
-    case hasScrolled(direction: ScrollDirection) // t
+    case hasScrolled(direction: ScrollDirection)
 }
 
 enum TimelineComposerAction {
@@ -94,8 +90,6 @@ enum TimelineComposerAction {
 
 struct TimelineViewState: BindableState {
     var roomID: String
-    var roomTitle = ""
-    var roomAvatar: RoomAvatar
     var members: [String: RoomMemberState] = [:]
     var typingMembers: [String] = []
     var showLoading = false
@@ -113,9 +107,6 @@ struct TimelineViewState: BindableState {
     // It's updated from the room info, so it's faster than using the timeline
     var pinnedEventIDs: Set<String> = []
     
-    var canJoinCall = false
-    var hasOngoingCall = false
-    
     var bindings: TimelineViewStateBindings
     
     /// A closure providing the associated audio player state for an item in the timeline.

ElementX/Sources/Screens/Timeline/TimelineViewModel.swift

@@ -81,13 +81,10 @@ class TimelineViewModel: TimelineViewModelType, TimelineViewModelProtocol {
                                                                 analyticsService: analyticsService)
         
         super.init(initialViewState: TimelineViewState(roomID: roomProxy.id,
-                                                       roomTitle: roomProxy.roomTitle,
-                                                       roomAvatar: roomProxy.avatar,
                                                        isEncryptedOneToOneRoom: roomProxy.isEncryptedOneToOneRoom,
                                                        timelineViewState: TimelineState(focussedEvent: focussedEventID.map { .init(eventID: $0, appearance: .immediate) }),
                                                        ownUserID: roomProxy.ownUserID,
                                                        isViewSourceEnabled: appSettings.viewSourceEnabled,
-                                                       hasOngoingCall: roomProxy.hasOngoingCall,
                                                        bindings: .init(reactionsCollapsed: [:])),
                    imageProvider: mediaProvider)
         
@@ -117,13 +114,6 @@ class TimelineViewModel: TimelineViewModelType, TimelineViewModelProtocol {
         // Note: beware if we get to e.g. restore a reply / edit,
         // maybe we are tracking a non-needed first initial state
         trackComposerMode(.default)
-        
-        Task {
-            let userID = roomProxy.ownUserID
-            if case let .success(permission) = await roomProxy.canUserJoinCall(userID: userID) {
-                state.canJoinCall = permission
-            }
-        }
     }
     
     // MARK: - Public
@@ -157,19 +147,14 @@ class TimelineViewModel: TimelineViewModelType, TimelineViewModelProtocol {
             timelineInteractionHandler.displayTimelineItemActionMenu(for: itemID)
         case .handleTimelineItemMenuAction(let itemID, let action):
             timelineInteractionHandler.handleTimelineItemMenuAction(action, itemID: itemID)
-        case .displayRoomDetails:
-            actionsSubject.send(.displayRoomDetails)
-        case .displayRoomMemberDetails(userID: let userID):
-            Task { await timelineInteractionHandler.displayRoomMemberDetails(userID: userID) }
+        case .tappedOnSenderDetails(userID: let userID):
+            actionsSubject.send(.tappedOnSenderDetails(userID: userID))
         case .displayEmojiPicker(let itemID):
             timelineInteractionHandler.displayEmojiPicker(for: itemID)
         case .displayReactionSummary(let itemID, let key):
             displayReactionSummary(for: itemID, selectedKey: key)
         case .displayReadReceipts(itemID: let itemID):
             displayReadReceipts(for: itemID)
-        case .displayCall:
-            actionsSubject.send(.displayCallScreen)
-            analyticsService.trackInteraction(name: .MobileRoomCallButton)
         case .handlePasteOrDrop(let provider):
             timelineInteractionHandler.handlePasteOrDrop(provider)
         case .handlePollAction(let pollAction):
@@ -389,17 +374,6 @@ class TimelineViewModel: TimelineViewModelType, TimelineViewModelProtocol {
         let roomInfoSubscription = roomProxy
             .actionsPublisher
             .filter { $0 == .roomInfoUpdate }
-        
-        roomInfoSubscription
-            .throttle(for: .seconds(1), scheduler: DispatchQueue.main, latest: true)
-            .sink { [weak self] _ in
-                guard let self else { return }
-                state.roomTitle = roomProxy.roomTitle
-                state.roomAvatar = roomProxy.avatar
-                state.hasOngoingCall = roomProxy.hasOngoingCall
-            }
-            .store(in: &cancellables)
-        
         Task { [weak self] in
             // Don't guard let self here, otherwise the for await will strongify the self reference creating a strong reference cycle.
             // If the subscription has sent a value before the Task has started it might be lost, so before entering the loop we always do an update.
@@ -449,7 +423,7 @@ class TimelineViewModel: TimelineViewModelType, TimelineViewModelProtocol {
                 case .displayMediaUploadPreviewScreen(let url):
                     actionsSubject.send(.displayMediaUploadPreviewScreen(url: url))
                 case .displayRoomMemberDetails(userID: let userID):
-                    actionsSubject.send(.displayRoomMemberDetails(userID: userID))
+                    actionsSubject.send(.tappedOnSenderDetails(userID: userID))
                 case .showActionMenu(let actionMenuInfo):
                     Task {
                         await self.updatePermissions()

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

@@ -97,7 +97,7 @@ struct TimelineItemBubbledStylerView<Content: View>: View {
             // sender info are read inside the `TimelineAccessibilityModifier`
             .accessibilityHidden(true)
             .onTapGesture {
-                context.send(viewAction: .displayRoomMemberDetails(userID: timelineItem.sender.id))
+                context.send(viewAction: .tappedOnSenderDetails(userID: timelineItem.sender.id))
             }
             .padding(.top, 8)
         }

ElementX/Sources/Screens/Timeline/View/TimelineItemViews/HighlightedTimelineItemModifier.swift

@@ -93,9 +93,10 @@ struct HighlightedTimelineItemModifier_Previews: PreviewProvider, TestablePrevie
 
 /// A preview that allows quick testing of the highlight appearance across various timeline scenarios.
 struct HighlightedTimelineItemTimeline_Previews: PreviewProvider {
-    static let roomViewModel = RoomScreenViewModel.mock()
+    static let roomProxyMock = RoomProxyMock(.init(name: "Preview room"))
+    static let roomViewModel = RoomScreenViewModel.mock(roomProxyMock: roomProxyMock)
     static let focussedEventID = "RoomTimelineItemFixtures.default.5"
-    static let timelineViewModel = TimelineViewModel(roomProxy: RoomProxyMock(.init(name: "Preview room")),
+    static let timelineViewModel = TimelineViewModel(roomProxy: roomProxyMock,
                                                      focussedEventID: focussedEventID,
                                                      timelineController: MockRoomTimelineController(),
                                                      mediaProvider: MockMediaProvider(),

ElementX/Sources/Screens/Timeline/View/TimelineView.swift

@@ -79,9 +79,10 @@ struct TimelineView: UIViewControllerRepresentable {
 // MARK: - Previews
 
 struct TimelineView_Previews: PreviewProvider, TestablePreview {
-    static let roomViewModel = RoomScreenViewModel.mock()
-    static let timelineViewModel = TimelineViewModel(roomProxy: RoomProxyMock(.init(id: "stable_id",
-                                                                                    name: "Preview room")),
+    static let roomProxyMock = RoomProxyMock(.init(id: "stable_id",
+                                                   name: "Preview room"))
+    static let roomViewModel = RoomScreenViewModel.mock(roomProxyMock: roomProxyMock)
+    static let timelineViewModel = TimelineViewModel(roomProxy: roomProxyMock,
                                                      timelineController: MockRoomTimelineController(),
                                                      mediaProvider: MockMediaProvider(),
                                                      mediaPlayerProvider: MediaPlayerProviderMock(),