Removing dead code part 3 (#2264)

ElementX/Sources/Services/Timeline/RoomTimelineProvider.swift

@@ -32,10 +32,10 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
         itemProxiesSubject.value
     }
 
-    var updatePublisher: AnyPublisher<TimelineProviderUpdate, Never> {
+    var updatePublisher: AnyPublisher<Void, Never> {
         itemProxiesSubject
             .combineLatest(backPaginationStateSubject)
-            .map(TimelineProviderUpdate.init)
+            .map { _, _ in () }
             .eraseToAnyPublisher()
     }
 

ElementX/Sources/Services/Timeline/RoomTimelineProviderProtocol.swift

@@ -19,15 +19,10 @@ import Foundation
 
 import MatrixRustSDK
 
-struct TimelineProviderUpdate {
-    let items: [TimelineItemProxy]
-    let backPaginationState: BackPaginationStatus
-}
-
 @MainActor
 // sourcery: AutoMockable
 protocol RoomTimelineProviderProtocol {
-    var updatePublisher: AnyPublisher<TimelineProviderUpdate, Never> { get }
+    var updatePublisher: AnyPublisher<Void, Never> { get }
     var itemProxies: [TimelineItemProxy] { get }
     var backPaginationState: BackPaginationStatus { get }
 }

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineController.swift

@@ -27,11 +27,6 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
     private let serialDispatchQueue: DispatchQueue
     
     private var cancellables = Set<AnyCancellable>()
-    private var timelineItemsUpdateTask: Task<Void, Never>? {
-        willSet {
-            timelineItemsUpdateTask?.cancel()
-        }
-    }
     
     let callbacks = PassthroughSubject<RoomTimelineControllerCallback, Never>()
     
@@ -257,13 +252,9 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         for (index, collapsibleChunk) in collapsibleChunks.enumerated() {
             let isLastItem = index == collapsibleChunks.indices.last
             
-            // Try building a stable identifier for items that don't have one
-            // We need to avoid duplicates otherwise the diffable datasource will crash
-            let reversedIndex = collapsibleChunks.count - index
-            
             let items = collapsibleChunk.compactMap { itemProxy in
                 
-                let timelineItem = buildTimelineItem(for: itemProxy, chunkIndex: reversedIndex)
+                let timelineItem = buildTimelineItem(for: itemProxy)
                 
                 if timelineItem is EncryptedHistoryRoomTimelineItem {
                     canBackPaginate = false
@@ -319,7 +310,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         callbacks.send(.isBackPaginating(isBackPaginating))
     }
     
-    private func buildTimelineItem(for itemProxy: TimelineItemProxy, chunkIndex: Int) -> RoomTimelineItemProtocol? {
+    private func buildTimelineItem(for itemProxy: TimelineItemProxy) -> RoomTimelineItemProtocol? {
         switch itemProxy {
         case .event(let eventTimelineItem):
             let timelineItem = timelineItemFactory.buildTimelineItem(for: eventTimelineItem)

ElementX/Sources/Services/Timeline/TimelineItemProxy.swift

@@ -89,9 +89,7 @@ class EventTimelineItemProxy {
     }()
     
     lazy var canBeRepliedTo = item.canBeRepliedTo()
-        
-    lazy var isRoomState = content.kind().isRoomState
-    
+            
     lazy var content = item.content()
 
     lazy var isOwn = item.isOwn()
@@ -125,17 +123,6 @@ class EventTimelineItemProxy {
     lazy var readReceipts = item.readReceipts()
 }
 
-extension TimelineItemContentKind {
-    var isRoomState: Bool {
-        switch self {
-        case .state, .roomMembership:
-            return true
-        default:
-            return false
-        }
-    }
-}
-
 struct TimelineItemDebugInfo: Identifiable, CustomStringConvertible {
     let id = UUID()
     let model: String

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemFactory.swift

@@ -19,24 +19,18 @@ import UIKit
 import UniformTypeIdentifiers
 
 struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
-    private let mediaProvider: MediaProviderProtocol
     private let attributedStringBuilder: AttributedStringBuilderProtocol
     private let stateEventStringBuilder: RoomStateEventStringBuilder
-    private let appSettings: AppSettings
     
     /// The Matrix ID of the current user.
     private let userID: String
     
     init(userID: String,
-         mediaProvider: MediaProviderProtocol,
          attributedStringBuilder: AttributedStringBuilderProtocol,
-         stateEventStringBuilder: RoomStateEventStringBuilder,
-         appSettings: AppSettings) {
+         stateEventStringBuilder: RoomStateEventStringBuilder) {
         self.userID = userID
-        self.mediaProvider = mediaProvider
         self.attributedStringBuilder = attributedStringBuilder
         self.stateEventStringBuilder = stateEventStringBuilder
-        self.appSettings = appSettings
     }
     
     func buildTimelineItem(for eventItemProxy: EventTimelineItemProxy) -> RoomTimelineItemProtocol? {
@@ -61,7 +55,7 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
         case .message:
             return buildMessageTimelineItem(eventItemProxy, isOutgoing)
         case .state(let stateKey, let content):
-            return buildStateTimelineItem(for: eventItemProxy, state: content, stateKey: stateKey, isOutgoing: isOutgoing)
+            return buildStateTimelineItem(for: eventItemProxy, state: content, isOutgoing: isOutgoing)
         case .roomMembership(userId: let userID, change: let change):
             return buildStateMembershipChangeTimelineItem(for: eventItemProxy, member: userID, membershipChange: change, isOutgoing: isOutgoing)
         case .profileChange(let displayName, let prevDisplayName, let avatarUrl, let prevAvatarUrl):
@@ -564,7 +558,6 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
     
     private func buildStateTimelineItem(for eventItemProxy: EventTimelineItemProxy,
                                         state: OtherState,
-                                        stateKey: String,
                                         isOutgoing: Bool) -> RoomTimelineItemProtocol? {
         guard let text = stateEventStringBuilder.buildString(for: state, sender: eventItemProxy.sender, isOutgoing: isOutgoing) else { return nil }
         return buildStateTimelineItem(for: eventItemProxy, text: text, isOutgoing: isOutgoing)

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemView.swift

@@ -78,8 +78,4 @@ struct RoomTimelineItemView: View {
             VoiceMessageRoomTimelineView(timelineItem: item, playerState: context.viewState.audioPlayerStateProvider?(item.id) ?? AudioPlayerState(id: .timelineItemIdentifier(item.id), duration: 0))
         }
     }
-
-    var timelineGroupStyle: TimelineGroupStyle {
-        viewState.groupStyle
-    }
 }

ElementX/Sources/Services/Timeline/TimelineItems/RoomTimelineItemViewState.swift

@@ -34,10 +34,6 @@ final class RoomTimelineItemViewState: Identifiable, Equatable, ObservableObject
         identifier.timelineID
     }
 
-    var isReactable: Bool {
-        type.isReactable
-    }
-
     init(type: RoomTimelineItemType, groupStyle: TimelineGroupStyle) {
         self.type = type
         self.groupStyle = groupStyle
@@ -146,18 +142,4 @@ enum RoomTimelineItemType: Equatable {
             return item.id
         }
     }
-
-    /// Whether or not it is possible to send a reaction to this timeline item.
-    var isReactable: Bool {
-        switch self {
-        case .text, .image, .video, .audio, .file, .emote, .notice, .sticker, .location, .poll, .voice:
-            return true
-        case .redacted, .encrypted, .unsupported, .state: // Event based items that aren't reactable
-            return false
-        case .timelineStart, .encryptedHistory, .separator, .readMarker, .paginationIndicator: // Virtual items are never reactable
-            return false
-        case .group:
-            return false
-        }
-    }
 }

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -30,6 +30,8 @@ final class TimelineProxy: TimelineProxyProtocol {
     
     private var backPaginationStateObservationToken: TaskHandle?
     private var roomTimelineObservationToken: TaskHandle?
+    
+    // periphery:ignore - retaining purpose
     private var timelineListener: RoomTimelineListener?
    
     private let backPaginationStateSubject = PassthroughSubject<BackPaginationStatus, Never>()
@@ -47,10 +49,6 @@ final class TimelineProxy: TimelineProxyProtocol {
         innerTimelineProvider
     }
     
-    var hasPendingUpdatesSubscription: Bool {
-        innerTimelineProvider != nil
-    }
-    
     deinit {
         backPaginationStateObservationToken?.cancel()
         roomTimelineObservationToken?.cancel()

ElementX/Sources/Services/Timeline/TimelineProxyProtocol.swift

@@ -125,14 +125,3 @@ protocol TimelineProxyProtocol {
     
     func sendPollResponse(pollStartID: String, answers: [String]) async -> Result<Void, TimelineProxyError>
 }
-
-extension TimelineProxyProtocol {
-    func sendMessage(_ message: String,
-                     html: String,
-                     intentionalMentions: IntentionalMentions) async -> Result<Void, TimelineProxyError> {
-        await sendMessage(message,
-                          html: html,
-                          inReplyTo: nil,
-                          intentionalMentions: intentionalMentions)
-    }
-}