Pinned items timeline implementation for the banner

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -8320,7 +8320,7 @@ class RoomProxyMock: RoomProxyProtocol {
  return pinnedEventIDsCallsCount > 0
  }
 
- var pinnedEventIDs: [String] {
+ var pinnedEventIDs: Set<String> {
  get async {
  pinnedEventIDsCallsCount += 1
  if let pinnedEventIDsClosure = pinnedEventIDsClosure {
@@ -8330,8 +8330,8 @@ class RoomProxyMock: RoomProxyProtocol {
  }
  }
  }
- var underlyingPinnedEventIDs: [String]!
- var pinnedEventIDsClosure: (() async -> [String])?
+ var underlyingPinnedEventIDs: Set<String>!
+ var pinnedEventIDsClosure: (() async -> Set<String>)?
  var membership: Membership {
  get { return underlyingMembership }
  set(value) { underlyingMembership = value }
@@ -8403,6 +8403,23 @@ class RoomProxyMock: RoomProxyProtocol {
  set(value) { underlyingTimeline = value }
  }
  var underlyingTimeline: TimelineProxyProtocol!
+ var pinnedEventsTimelineCallsCount = 0
+ var pinnedEventsTimelineCalled: Bool {
+ return pinnedEventsTimelineCallsCount > 0
+ }
+
+ var pinnedEventsTimeline: TimelineProxyProtocol? {
+ get async {
+ pinnedEventsTimelineCallsCount += 1
+ if let pinnedEventsTimelineClosure = pinnedEventsTimelineClosure {
+ return await pinnedEventsTimelineClosure()
+ } else {
+ return underlyingPinnedEventsTimeline
+ }
+ }
+ }
+ var underlyingPinnedEventsTimeline: TimelineProxyProtocol?
+ var pinnedEventsTimelineClosure: (() async -> TimelineProxyProtocol?)?
 
  //MARK: - subscribeForUpdates
 

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -10989,6 +10989,42 @@ open class RoomSDKMock: MatrixRustSDK.Room {
  try await clearComposerDraftClosure?()
  }
 
+ //MARK: - clearPinnedEventsCache
+
+ var clearPinnedEventsCacheUnderlyingCallsCount = 0
+ open var clearPinnedEventsCacheCallsCount: Int {
+ get {
+ if Thread.isMainThread {
+ return clearPinnedEventsCacheUnderlyingCallsCount
+ } else {
+ var returnValue: Int? = nil
+ DispatchQueue.main.sync {
+ returnValue = clearPinnedEventsCacheUnderlyingCallsCount
+ }
+
+ return returnValue!
+ }
+ }
+ set {
+ if Thread.isMainThread {
+ clearPinnedEventsCacheUnderlyingCallsCount = newValue
+ } else {
+ DispatchQueue.main.sync {
+ clearPinnedEventsCacheUnderlyingCallsCount = newValue
+ }
+ }
+ }
+ }
+ open var clearPinnedEventsCacheCalled: Bool {
+ return clearPinnedEventsCacheCallsCount > 0
+ }
+ open var clearPinnedEventsCacheClosure: (() async -> Void)?
+
+ open override func clearPinnedEventsCache() async {
+ clearPinnedEventsCacheCallsCount += 1
+ await clearPinnedEventsCacheClosure?()
+ }
+
  //MARK: - discardRoomKey
 
  open var discardRoomKeyThrowableError: Error?
@@ -13005,6 +13041,81 @@ open class RoomSDKMock: MatrixRustSDK.Room {
  }
  }
 
+ //MARK: - pinnedEventsTimeline
+
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadThrowableError: Error?
+ var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingCallsCount = 0
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadCallsCount: Int {
+ get {
+ if Thread.isMainThread {
+ return pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingCallsCount
+ } else {
+ var returnValue: Int? = nil
+ DispatchQueue.main.sync {
+ returnValue = pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingCallsCount
+ }
+
+ return returnValue!
+ }
+ }
+ set {
+ if Thread.isMainThread {
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingCallsCount = newValue
+ } else {
+ DispatchQueue.main.sync {
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingCallsCount = newValue
+ }
+ }
+ }
+ }
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadCalled: Bool {
+ return pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadCallsCount > 0
+ }
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReceivedArguments: (internalIdPrefix: String?, maxEventsToLoad: UInt16)?
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReceivedInvocations: [(internalIdPrefix: String?, maxEventsToLoad: UInt16)] = []
+
+ var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingReturnValue: Timeline!
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReturnValue: Timeline! {
+ get {
+ if Thread.isMainThread {
+ return pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingReturnValue
+ } else {
+ var returnValue: Timeline? = nil
+ DispatchQueue.main.sync {
+ returnValue = pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingReturnValue
+ }
+
+ return returnValue!
+ }
+ }
+ set {
+ if Thread.isMainThread {
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingReturnValue = newValue
+ } else {
+ DispatchQueue.main.sync {
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadUnderlyingReturnValue = newValue
+ }
+ }
+ }
+ }
+ open var pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadClosure: ((String?, UInt16) async throws -> Timeline)?
+
+ open override func pinnedEventsTimeline(internalIdPrefix: String?, maxEventsToLoad: UInt16) async throws -> Timeline {
+ if let error = pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadThrowableError {
+ throw error
+ }
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadCallsCount += 1
+ pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReceivedArguments = (internalIdPrefix: internalIdPrefix, maxEventsToLoad: maxEventsToLoad)
+ DispatchQueue.main.async {
+ self.pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReceivedInvocations.append((internalIdPrefix: internalIdPrefix, maxEventsToLoad: maxEventsToLoad))
+ }
+ if let pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadClosure = pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadClosure {
+ return try await pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadClosure(internalIdPrefix, maxEventsToLoad)
+ } else {
+ return pinnedEventsTimelineInternalIdPrefixMaxEventsToLoadReturnValue
+ }
+ }
+
  //MARK: - rawName
 
  var rawNameUnderlyingCallsCount = 0

ElementX/Sources/Mocks/RoomProxyMock.swift

@@ -29,7 +29,7 @@ struct RoomProxyMockConfiguration {
  var isEncrypted = true
  var hasOngoingCall = true
  var canonicalAlias: String?
- var pinnedEventIDs: [String] = []
+ var pinnedEventIDs: Set<String> = []
 
  var timelineStartReached = false
 

ElementX/Sources/Other/Extensions/AttributedString.swift

@@ -17,6 +17,11 @@
 import Foundation
 
 extension AttributedString {
+ // faster than doing `String(characters)`: https://forums.swift.org/t/attributedstring-to-string/61667
+ var string: String {
+ String(characters[...])
+ }
+
  var formattedComponents: [AttributedStringBuilderComponent] {
  runs[\.blockquote].map { value, range in
  var attributedString = AttributedString(self[range])

ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift

@@ -139,7 +139,7 @@ enum RoomScreenViewAction {
  case hasSwitchedTimeline
 
  case hasScrolled(direction: ScrollDirection)
- case tappedPinBanner
+ case tappedPinnedEventsBanner
  case viewAllPins
 }
 
@@ -172,10 +172,14 @@ struct RoomScreenViewState: BindableState {
  var isPinningEnabled = false
  var lastScrollDirection: ScrollDirection?
 
+ // The `pinnedEventIDs` are used only to determine if an item is already pinned or not.
+ // It's updated from the room info, so it's faster than using the timeline
+ var pinnedEventIDs: Set<String> = []
+ // This is used to control the banner
  var pinnedEventsState = PinnedEventsState()
 
- var shouldShowPinBanner: Bool {
- isPinningEnabled && !pinnedEventsState.pinnedEventIDs.isEmpty && lastScrollDirection != .top
+ var shouldShowPinnedEventsBanner: Bool {
+ isPinningEnabled && !pinnedEventsState.pinnedEventContents.isEmpty && lastScrollDirection != .top
  }
 
  var canJoinCall = false
@@ -296,39 +300,53 @@ enum ScrollDirection: Equatable {
 }
 
 struct PinnedEventsState: Equatable {
- // For now these will only contain and show the event IDs, but in the future they will also contain the content
- var pinnedEventIDs: OrderedSet<String> = [] {
+ var pinnedEventContents: OrderedDictionary<String, AttributedString> = [:] {
  didSet {
- if selectedPinEventID == nil, !pinnedEventIDs.isEmpty {
- selectedPinEventID = pinnedEventIDs.first
- } else if pinnedEventIDs.isEmpty {
+ if selectedPinEventID == nil, !pinnedEventContents.keys.isEmpty {
+ selectedPinEventID = pinnedEventContents.keys.last
+ } else if pinnedEventContents.isEmpty {
  selectedPinEventID = nil
- } else if let selectedPinEventID, !pinnedEventIDs.contains(selectedPinEventID) {
- self.selectedPinEventID = pinnedEventIDs.first
+ } else if let selectedPinEventID, !pinnedEventContents.keys.set.contains(selectedPinEventID) {
+ self.selectedPinEventID = pinnedEventContents.firstNonNil { $0.key }
  }
  }
  }
 
- var selectedPinEventID: String?
+ private(set) var selectedPinEventID: String?
 
  var selectedPinIndex: Int {
+ let defaultValue = pinnedEventContents.isEmpty ? 0 : pinnedEventContents.count - 1
  guard let selectedPinEventID else {
- return 0
+ return defaultValue
  }
- return pinnedEventIDs.firstIndex(of: selectedPinEventID) ?? 0
+ return pinnedEventContents.keys.firstIndex(of: selectedPinEventID) ?? defaultValue
  }
 
- // For now we show the event ID as the content, but is just until we have a way to get the real content
  var selectedPinContent: AttributedString {
- .init(selectedPinEventID ?? "")
+ guard let selectedPinEventID,
+ var content = pinnedEventContents[selectedPinEventID] else {
+ return AttributedString()
+ }
+ content.font = .compound.bodyMD
+ return content
+ }
+
+ var bannerIndicatorDescription: AttributedString {
+ let index = selectedPinIndex + 1
+ let boldPlaceholder = "{bold}"
+ var finalString = AttributedString(L10n.screenRoomPinnedBannerIndicatorDescription(boldPlaceholder))
+ var boldString = AttributedString(L10n.screenRoomPinnedBannerIndicator(index, pinnedEventContents.count))
+ boldString.bold()
+ finalString.replace(boldPlaceholder, with: boldString)
+ return finalString
  }
 
  mutating func nextPin() {
- guard !pinnedEventIDs.isEmpty else {
+ guard !pinnedEventContents.isEmpty else {
  return
  }
  let currentIndex = selectedPinIndex
- let nextIndex = (currentIndex + 1) % pinnedEventIDs.count
- selectedPinEventID = pinnedEventIDs[nextIndex]
+ let nextIndex = (currentIndex + 1) % pinnedEventContents.count
+ selectedPinEventID = pinnedEventContents.keys[nextIndex]
  }
 }

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -36,6 +36,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
  private let appMediator: AppMediatorProtocol
  private let appSettings: AppSettings
  private let analyticsService: AnalyticsService
+ private let pinnedEventStringBuilder: RoomEventStringBuilder
 
  private let roomScreenInteractionHandler: RoomScreenInteractionHandler
 
@@ -66,6 +67,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
  self.analyticsService = analyticsService
  self.userIndicatorController = userIndicatorController
  self.appMediator = appMediator
+ pinnedEventStringBuilder = .pinnedEventStringBuilder(userID: roomProxy.ownUserID)
 
  let voiceMessageRecorder = VoiceMessageRecorder(audioRecorder: AudioRecorder(), mediaPlayerProvider: mediaPlayerProvider)
 
@@ -124,6 +126,23 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
  state.canJoinCall = permission
  }
  }
+
+ Task {
+ guard let pinnedEventsTimelineProvider = await roomProxy.pinnedEventsTimeline?.timelineProvider else {
+ return
+ }
+
+ buildPinnedEventContent(timelineItems: pinnedEventsTimelineProvider.itemProxies)
+
+ pinnedEventsTimelineProvider.updatePublisher
+ // When pinning or unpinning an item, the timeline might return empty for a short while, so we need to debounce it to prevent weird UI behaviours like the banner disappearing
+ .debounce(for: .milliseconds(100), scheduler: DispatchQueue.main)
+ .sink { [weak self] updatedItems, _ in
+ guard let self else { return }
+ buildPinnedEventContent(timelineItems: updatedItems)
+ }
+ .store(in: &cancellables)
+ }
  }
 
  // MARK: - Public
@@ -196,7 +215,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
  Task { state.timelineViewState.isSwitchingTimelines = false }
  case let .hasScrolled(direction):
  state.lastScrollDirection = direction
- case .tappedPinBanner:
+ case .tappedPinnedEventsBanner:
  if let eventID = state.pinnedEventsState.selectedPinEventID {
  Task { await focusOnEvent(eventID: eventID) }
  }
@@ -423,12 +442,12 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
  return
  }
  // 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.
- await state.pinnedEventsState.pinnedEventIDs = .init(roomProxy.pinnedEventIDs)
+ await state.pinnedEventIDs = roomProxy.pinnedEventIDs
  for await _ in roomInfoSubscription.receive(on: DispatchQueue.main).values {
  guard !Task.isCancelled else {
  return
  }
- await state.pinnedEventsState.pinnedEventIDs = .init(roomProxy.pinnedEventIDs)
+ await state.pinnedEventIDs = roomProxy.pinnedEventIDs
  }
  }
  .store(in: &cancellables)
@@ -635,6 +654,21 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
 
  // MARK: - Timeline Item Building
 
+ private func buildPinnedEventContent(timelineItems: [TimelineItemProxy]) {
+ var pinnedEventContents = OrderedDictionary<String, AttributedString>()
+
+ for item in timelineItems {
+ // Only remote events are pinned
+ if case let .event(event) = item,
+ let eventID = event.id.eventID {
+ pinnedEventContents.updateValue(pinnedEventStringBuilder.buildAttributedString(for: event) ?? AttributedString(L10n.commonUnsupportedEvent),
+ forKey: eventID)
+ }
+ }
+
+ state.pinnedEventsState.pinnedEventContents = pinnedEventContents
+ }
+
  private func buildTimelineViews(timelineItems: [RoomTimelineItemProtocol], isSwitchingTimelines: Bool = false) {
  var timelineItemsDictionary = OrderedDictionary<String, RoomTimelineItemViewState>()