Render state items in the timeline and as the last message on the home screen. (#473)

* State events in the timeline WIP * Implement membership change strings. * Add other state event types and use in RoomSummaryProvider. Co-authored-by: Stefan Ceriu <stefanc@matrix.org>
2026-11-03 06:55:59 +00:00 · 2023-01-20 13:37:39 +00:00
parent 5b0a42ad0f
commit f05fa630c1
32 changed files with 536 additions and 75 deletions
@@ -24,6 +24,48 @@ extension ElementL10n {
  public static let loginMobileDevice = ElementL10n.tr("Untranslated", "login_mobile_device")
  /// Tablet
  public static let loginTabletDevice = ElementL10n.tr("Untranslated", "login_tablet_device")
+  /// %1$@ accepted the invite
+  public static func noticeRoomInviteAccepted(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomInviteAccepted", String(describing: p1))
+  }
+  /// You accepted the invite
+  public static let noticeRoomInviteAcceptedByYou = ElementL10n.tr("Untranslated", "noticeRoomInviteAcceptedByYou")
+  /// %1$@ requested to join
+  public static func noticeRoomKnock(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnock", String(describing: p1))
+  }
+  /// %1$@ allowed %2$@ to join
+  public static func noticeRoomKnockAccepted(_ p1: Any, _ p2: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockAccepted", String(describing: p1), String(describing: p2))
+  }
+  /// %1$@ allowed you to join
+  public static func noticeRoomKnockAcceptedByYou(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockAcceptedByYou", String(describing: p1))
+  }
+  /// You requested to join
+  public static let noticeRoomKnockByYou = ElementL10n.tr("Untranslated", "noticeRoomKnockByYou")
+  /// %1$@ rejected %2$@'s request to join
+  public static func noticeRoomKnockDenied(_ p1: Any, _ p2: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockDenied", String(describing: p1), String(describing: p2))
+  }
+  /// You rejected %1$@'s request to join
+  public static func noticeRoomKnockDeniedByYou(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockDeniedByYou", String(describing: p1))
+  }
+  /// %1$@ rejected your request to join
+  public static func noticeRoomKnockDeniedYou(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockDeniedYou", String(describing: p1))
+  }
+  /// %1$@ is no longer interested in joining
+  public static func noticeRoomKnockRetracted(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomKnockRetracted", String(describing: p1))
+  }
+  /// You cancelled your request to join
+  public static let noticeRoomKnockRetractedByYou = ElementL10n.tr("Untranslated", "noticeRoomKnockRetractedByYou")
+  /// %1$@ made an unknown change to their membership
+  public static func noticeRoomUnknownMembershipChange(_ p1: Any) -> String {
+    return ElementL10n.tr("Untranslated", "noticeRoomUnknownMembershipChange", String(describing: p1))
+  }
  /// Notification
  public static let notification = ElementL10n.tr("Untranslated", "Notification")
  /// About
@@ -213,7 +213,7 @@ struct HomeScreen_Previews: PreviewProvider {
    }
    
    static func body(_ state: MockRoomSummaryProviderState) -> some View {
-        let userSession = MockUserSession(clientProxy: MockClientProxy(userIdentifier: "John Doe",
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "John Doe",
                                                                       roomSummaryProvider: MockRoomSummaryProvider(state: state)),
                                          mediaProvider: MockMediaProvider())
        
@@ -121,7 +121,7 @@ struct HomeScreenRoomCell_Previews: PreviewProvider {
    static var body: some View {
        let summaryProvider = MockRoomSummaryProvider(state: .loaded)

-        let userSession = MockUserSession(clientProxy: MockClientProxy(userIdentifier: "John Doe", roomSummaryProvider: summaryProvider),
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "John Doe", roomSummaryProvider: summaryProvider),
                                          mediaProvider: MockMediaProvider())

        let viewModel = HomeScreenViewModel(userSession: userSession,
@@ -0,0 +1,43 @@
+//
+// 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.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import SwiftUI
+
+struct StateRoomTimelineView: View {
+    let timelineItem: StateRoomTimelineItem
+    
+    var body: some View {
+        Text(timelineItem.text)
+            .font(.element.caption1Bold)
+            .multilineTextAlignment(.center)
+            .foregroundColor(.element.secondaryContent)
+            .frame(maxWidth: .infinity, alignment: .center)
+            .padding(.horizontal, 16)
+            .padding(.vertical, 4)
+    }
+}
+
+struct StateRoomTimelineView_Previews: PreviewProvider {
+    static var previews: some View {
+        body
+        body.timelineStyle(.plain)
+    }
+    
+    static var body: some View {
+        let item = StateRoomTimelineItem(id: UUID().uuidString, text: "Alice joined", timestamp: "Now", groupState: .beginning, isOutgoing: false, isEditable: false, sender: .init(id: ""))
+        return StateRoomTimelineView(timelineItem: item)
+    }
+}
@@ -200,7 +200,7 @@ extension TimelineStyle: CustomStringConvertible {

 struct Settings_Previews: PreviewProvider {
    static var previews: some View {
-        let userSession = MockUserSession(clientProxy: MockClientProxy(userIdentifier: "@userid:example.com"),
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: "@userid:example.com"),
                                          mediaProvider: MockMediaProvider())
        let viewModel = SettingsViewModel(withUserSession: userSession)
        
@@ -52,7 +52,7 @@ class MockAuthenticationServiceProxy: AuthenticationServiceProxyProtocol {
            return .failure(.invalidCredentials)
        }
        
-        let userSession = MockUserSession(clientProxy: MockClientProxy(userIdentifier: username),
+        let userSession = MockUserSession(clientProxy: MockClientProxy(userID: username),
                                          mediaProvider: MockMediaProvider())
        return .success(userSession)
    }
@@ -93,7 +93,7 @@ class ClientProxy: ClientProxyProtocol {
        configureSlidingSync()
    }
    
-    var userIdentifier: String {
+    var userID: String {
        do {
            return try client.userId()
        } catch {
@@ -291,7 +291,9 @@ class ClientProxy: ClientProxyProtocol {
    private func buildAndConfigureVisibleRoomsSlidingSyncView(slidingSync: SlidingSyncProtocol, visibleRoomsView: SlidingSyncView) {
        let visibleRoomsViewProxy = SlidingSyncViewProxy(slidingSync: slidingSync, slidingSyncView: visibleRoomsView)
        
-        visibleRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: visibleRoomsViewProxy)
+        visibleRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: visibleRoomsViewProxy,
+                                                          eventStringBuilder: RoomEventStringBuilder(userID: userID,
+                                                                                                     roomStateStringBuilder: RoomStateStringBuilder(userID: userID)))
        
        visibleRoomsSlidingSyncView = visibleRoomsView
        
@@ -327,7 +329,9 @@ class ClientProxy: ClientProxyProtocol {
            
            let allRoomsViewProxy = SlidingSyncViewProxy(slidingSync: slidingSync, slidingSyncView: allRoomsView)
            
-            allRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: allRoomsViewProxy)
+            allRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: allRoomsViewProxy,
+                                                          eventStringBuilder: RoomEventStringBuilder(userID: userID,
+                                                                                                     roomStateStringBuilder: RoomStateStringBuilder(userID: userID)))
            
            allRoomsSlidingSyncView = allRoomsView
            
@@ -61,7 +61,7 @@ enum PushFormat {
 protocol ClientProxyProtocol: AnyObject, MediaProxyProtocol {
    var callbacks: PassthroughSubject<ClientProxyCallback, Never> { get }
    
-    var userIdentifier: String { get }
+    var userID: String { get }

    var isSoftLogout: Bool { get }

@@ -21,7 +21,7 @@ import MatrixRustSDK
 class MockClientProxy: ClientProxyProtocol {
    let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
    
-    let userIdentifier: String
+    let userID: String
    let isSoftLogout = false
    let deviceId: String? = nil
    let homeserver = ""
@@ -31,8 +31,8 @@ class MockClientProxy: ClientProxyProtocol {
    
    var allRoomsSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()
    
-    internal init(userIdentifier: String, roomSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()) {
-        self.userIdentifier = userIdentifier
+    internal init(userID: String, roomSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()) {
+        self.userID = userID
        visibleRoomsSummaryProvider = roomSummaryProvider
    }
    
@@ -0,0 +1,84 @@
+//
+// 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.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+struct RoomEventStringBuilder {
+    private let roomStateStringBuilder: RoomStateStringBuilder
+    
+    /// The Matrix ID of the current user.
+    private let userID: String
+    
+    init(userID: String, roomStateStringBuilder: RoomStateStringBuilder) {
+        self.userID = userID
+        self.roomStateStringBuilder = roomStateStringBuilder
+    }
+    
+    // swiftlint:disable:next cyclomatic_complexity
+    func buildAttributedString(for eventItemProxy: EventTimelineItemProxy) -> AttributedString? {
+        let sender = eventItemProxy.sender
+        let isOutgoing = eventItemProxy.isOwn
+        
+        switch eventItemProxy.content.kind() {
+        case .unableToDecrypt:
+            return prefix(ElementL10n.encryptionInformationDecryptionError, with: sender)
+        case .redactedMessage:
+            return prefix(ElementL10n.eventRedacted, with: sender)
+        case .sticker:
+            return prefix(ElementL10n.sendASticker, with: sender)
+        case .failedToParseMessageLike, .failedToParseState:
+            return prefix(ElementL10n.roomTimelineItemUnsupported, with: sender)
+        case .message:
+            guard let messageContent = eventItemProxy.content.asMessage() else { fatalError("Invalid message timeline item: \(eventItemProxy)") }
+            
+            let message: String
+            switch messageContent.msgtype() {
+            // Message types that don't need a prefix.
+            case .emote(content: let content):
+                let senderDisplayName = sender.displayName ?? sender.id
+                return AttributedString("* \(senderDisplayName) \(content.body)")
+            // Message types that should be prefixed with the sender's name.
+            case .image:
+                message = ElementL10n.sentAnImage
+            case .video:
+                message = ElementL10n.sentAVideo
+            case .file:
+                message = ElementL10n.sentAFile
+            default:
+                message = messageContent.body()
+            }
+            return prefix(message, with: sender)
+        case .state(let stateKey, let state):
+            return roomStateStringBuilder
+                .buildString(for: state, stateKey: stateKey, sender: sender, isOutgoing: isOutgoing)
+                .map(AttributedString.init)
+        case .roomMembership(userId: let userID, change: let change):
+            return roomStateStringBuilder
+                .buildString(for: change, member: userID, sender: sender, isOutgoing: isOutgoing)
+                .map(AttributedString.init)
+        }
+    }
+    
+    func prefix(_ eventSummary: String, with sender: TimelineItemSender) -> AttributedString {
+        if let senderDisplayName = sender.displayName,
+           let attributedSenderDisplayName = try? AttributedString(markdown: "**\(senderDisplayName)**") {
+            // Don't include the message body in the markdown otherwise it makes tappable links.
+            return attributedSenderDisplayName + ": " + AttributedString(eventSummary)
+        } else {
+            return AttributedString(eventSummary)
+        }
+    }
+}
@@ -21,6 +21,7 @@ import MatrixRustSDK
 class RoomSummaryProvider: RoomSummaryProviderProtocol {
    private let slidingSyncViewProxy: SlidingSyncViewProxy
    private let serialDispatchQueue: DispatchQueue
+    private let eventStringBuilder: RoomEventStringBuilder
    
    private var cancellables = Set<AnyCancellable>()
    
@@ -34,9 +35,10 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
        }
    }
    
-    init(slidingSyncViewProxy: SlidingSyncViewProxy) {
+    init(slidingSyncViewProxy: SlidingSyncViewProxy, eventStringBuilder: RoomEventStringBuilder) {
        self.slidingSyncViewProxy = slidingSyncViewProxy
        serialDispatchQueue = DispatchQueue(label: "io.element.elementx.roomsummaryprovider")
+        self.eventStringBuilder = eventStringBuilder
        
        rooms = slidingSyncViewProxy.currentRoomsList().map { roomListEntry in
            buildSummaryForRoomListEntry(roomListEntry)
@@ -151,16 +153,8 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
        DispatchQueue.global(qos: .default).sync {
            if let latestRoomMessage = room.latestRoomMessage() {
                let lastMessage = EventTimelineItemProxy(item: latestRoomMessage)
-                
                lastMessageTimestamp = lastMessage.timestamp
-                
-                if let senderDisplayName = lastMessage.sender.displayName,
-                   let attributedSenderDisplayName = try? AttributedString(markdown: "**\(senderDisplayName)**") {
-                    // Don't include the message body in the markdown otherwise it makes tappable links.
-                    attributedLastMessage = attributedSenderDisplayName + ": " + AttributedString(lastMessage.body ?? "")
-                } else if let body = lastMessage.body {
-                    attributedLastMessage = AttributedString(body)
-                }
+                attributedLastMessage = eventStringBuilder.buildAttributedString(for: lastMessage)
            }
        }
        
@@ -19,7 +19,7 @@ import Combine
 struct MockUserSession: UserSessionProtocol {
    let callbacks = PassthroughSubject<UserSessionCallback, Never>()
    let sessionVerificationController: SessionVerificationControllerProxyProtocol? = nil
-    var userID: String { clientProxy.userIdentifier }
+    var userID: String { clientProxy.userID }
    var isSoftLogout: Bool { clientProxy.isSoftLogout }
    var deviceId: String? { clientProxy.deviceId }
    var homeserver: String { clientProxy.homeserver }
@@ -23,7 +23,7 @@ class UserSession: UserSessionProtocol {
    private var authErrorCancellable: AnyCancellable?
    private var restoreTokenUpdateCancellable: AnyCancellable?
    
-    var userID: String { clientProxy.userIdentifier }
+    var userID: String { clientProxy.userID }
    var isSoftLogout: Bool { clientProxy.isSoftLogout }
    var deviceId: String? { clientProxy.deviceId }
    var homeserver: String { clientProxy.homeserver }
@@ -259,9 +259,10 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
            let groupState = computeGroupState(for: itemProxy, previousItemProxy: previousItemProxy, nextItemProxy: nextItemProxy)
            
            switch itemProxy {
-            case .event(let eventItem):
-                newTimelineItems.append(timelineItemFactory.buildTimelineItemFor(eventItemProxy: eventItem,
-                                                                                 groupState: groupState))
+            case .event(let eventItemProxy):
+                if let timelineItem = timelineItemFactory.buildTimelineItemFor(eventItemProxy: eventItemProxy, groupState: groupState) {
+                    newTimelineItems.append(timelineItem)
+                }
            case .virtual(let virtualItem):
                switch virtualItem {
                case .dayDivider(let year, let month, let day):
@@ -0,0 +1,30 @@
+//
+// 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.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import UIKit
+
+struct StateRoomTimelineItem: EventBasedTimelineItemProtocol, Identifiable, Hashable {
+    let id: String
+    let text: String
+    let timestamp: String
+    let groupState: TimelineItemGroupState
+    let isOutgoing: Bool
+    let isEditable: Bool
+    
+    var sender: TimelineItemSender
+    
+    var properties = RoomTimelineItemProperties()
+}
@@ -0,0 +1,200 @@
+//
+// 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.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import MatrixRustSDK
+import UIKit
+
+struct RoomStateStringBuilder {
+    let userID: String
+    
+    // swiftlint:disable:next cyclomatic_complexity function_body_length
+    func buildString(for change: MembershipChange, member: String, sender: TimelineItemSender, isOutgoing: Bool) -> String? {
+        let senderName = sender.displayName ?? sender.id
+        let senderIsYou = isOutgoing
+        let memberIsYou = member == userID
+        
+        switch change {
+        case .joined:
+            return memberIsYou ? ElementL10n.noticeRoomJoinByYou : ElementL10n.noticeRoomJoin(member)
+        case .left:
+            return memberIsYou ? ElementL10n.noticeRoomLeaveByYou : ElementL10n.noticeRoomLeave(member)
+        case .banned, .kickedAndBanned:
+            return senderIsYou ? ElementL10n.noticeRoomBanByYou(member) : ElementL10n.noticeRoomBan(senderName, member)
+        case .unbanned:
+            return senderIsYou ? ElementL10n.noticeRoomUnbanByYou(member) : ElementL10n.noticeRoomUnban(senderName, member)
+        case .kicked:
+            return senderIsYou ? ElementL10n.noticeRoomRemoveByYou(member) : ElementL10n.noticeRoomRemove(senderName, member)
+        case .invited:
+            if senderIsYou {
+                return ElementL10n.noticeRoomInviteByYou(member)
+            } else if memberIsYou {
+                return ElementL10n.noticeRoomInviteYou(senderName)
+            } else {
+                return ElementL10n.noticeRoomInvite(senderName, member)
+            }
+        case .invitationAccepted:
+            return memberIsYou ? ElementL10n.noticeRoomInviteAcceptedByYou : ElementL10n.noticeRoomInviteAccepted(member)
+        case .invitationRejected:
+            return memberIsYou ? ElementL10n.noticeRoomRejectByYou : ElementL10n.noticeRoomReject(member)
+        case .invitationRevoked:
+            return senderIsYou ? ElementL10n.noticeRoomThirdPartyRevokedInviteByYou(member) : ElementL10n.noticeRoomThirdPartyRevokedInvite(sender, member)
+        case .knocked:
+            return memberIsYou ? ElementL10n.noticeRoomKnockByYou : ElementL10n.noticeRoomKnock(member)
+        case .knockAccepted:
+            return senderIsYou ? ElementL10n.noticeRoomKnockAcceptedByYou(senderName) : ElementL10n.noticeRoomKnockAccepted(senderName, member)
+        case .knockRetracted:
+            return memberIsYou ? ElementL10n.noticeRoomKnockRetractedByYou : ElementL10n.noticeRoomKnockRetracted(member)
+        case .knockDenied:
+            if senderIsYou {
+                return ElementL10n.noticeRoomKnockDeniedByYou(member)
+            } else if memberIsYou {
+                return ElementL10n.noticeRoomKnockDeniedYou(senderName)
+            } else {
+                return ElementL10n.noticeRoomKnockDenied(senderName, member)
+            }
+        case .profileChanged(let displayName, let previousDisplayName, let avatarURLString, let previousAvatarURLString):
+            return profileChangedString(displayName: displayName, previousDisplayName: previousDisplayName,
+                                        avatarURLString: avatarURLString, previousAvatarURLString: previousAvatarURLString,
+                                        member: member, memberIsYou: memberIsYou,
+                                        sender: sender, senderIsYou: senderIsYou)
+        case .none, .error, .notImplemented, .unknown: // Not useful information for the user.
+            MXLog.verbose("Filtering timeline item for membership change: \(change)")
+            return nil
+        }
+    }
+    
+    // swiftlint:disable:next cyclomatic_complexity function_parameter_count
+    private func profileChangedString(displayName: String?, previousDisplayName: String?,
+                                      avatarURLString: String?, previousAvatarURLString: String?,
+                                      member: String, memberIsYou: Bool,
+                                      sender: TimelineItemSender, senderIsYou: Bool) -> String {
+        let displayNameChanged = displayName != previousDisplayName
+        let avatarChanged = avatarURLString != previousAvatarURLString
+        
+        switch (displayNameChanged, avatarChanged, memberIsYou) {
+        case (true, false, false):
+            if let displayName, let previousDisplayName {
+                return ElementL10n.noticeDisplayNameChangedFrom(member, displayName, previousDisplayName)
+            } else if let displayName {
+                return ElementL10n.noticeDisplayNameSet(member, displayName)
+            } else if let previousDisplayName {
+                return ElementL10n.noticeDisplayNameRemoved(member, previousDisplayName)
+            } else {
+                MXLog.error("The display name changed from nil to nil, shouldn't be possible.")
+                return ElementL10n.noticeMemberNoChanges(member)
+            }
+        case (false, true, false):
+            return ElementL10n.noticeAvatarUrlChanged(displayName ?? member)
+        case (true, false, true):
+            if let displayName, let previousDisplayName {
+                return ElementL10n.noticeDisplayNameChangedFromByYou(displayName, previousDisplayName)
+            } else if let displayName {
+                return ElementL10n.noticeDisplayNameSetByYou(displayName)
+            } else if let previousDisplayName {
+                return ElementL10n.noticeDisplayNameRemovedByYou(previousDisplayName)
+            } else {
+                MXLog.error("The display name changed from nil to nil, shouldn't be possible.")
+                return ElementL10n.noticeMemberNoChangesByYou
+            }
+        case (false, true, true):
+            return ElementL10n.noticeAvatarUrlChangedByYou
+        case (true, true, _):
+            // When both have changed, get the string for the display name and tack on that the avatar changed too.
+            return profileChangedString(displayName: displayName, previousDisplayName: previousDisplayName,
+                                        avatarURLString: nil, previousAvatarURLString: nil,
+                                        member: member, memberIsYou: memberIsYou,
+                                        sender: sender, senderIsYou: senderIsYou) + "\n" + ElementL10n.noticeAvatarChangedToo
+        case (false, false, _):
+            MXLog.error("Nothing changed, shouldn't be possible.")
+            return ElementL10n.noticeMemberNoChangesByYou
+        }
+    }
+    
+    // swiftlint:disable:next cyclomatic_complexity function_body_length
+    func buildString(for state: OtherState, stateKey: String?, sender: TimelineItemSender, isOutgoing: Bool) -> String? {
+        let senderName = sender.displayName ?? sender.id
+        
+        switch state {
+        case .roomAvatar(let url):
+            switch (url, isOutgoing) {
+            case (.some, false):
+                return ElementL10n.noticeRoomAvatarChanged(senderName)
+            case (nil, false):
+                return ElementL10n.noticeRoomAvatarRemoved(senderName)
+            case (.some, true):
+                return ElementL10n.noticeRoomAvatarRemovedByYou
+            case (nil, true):
+                return ElementL10n.noticeRoomAvatarRemovedByYou
+            }
+        case .roomCreate:
+            return isOutgoing ? ElementL10n.noticeRoomCreatedByYou : ElementL10n.noticeRoomCreated(senderName)
+        case .roomEncryption:
+            return ElementL10n.encryptionEnabled
+        case .roomName(let name):
+            switch (name, isOutgoing) {
+            case (.some(let name), false):
+                return ElementL10n.noticeRoomNameChanged(senderName, name)
+            case (nil, false):
+                return ElementL10n.noticeRoomNameRemoved(senderName)
+            case (.some(let name), true):
+                return ElementL10n.noticeRoomNameChangedByYou(name)
+            case (nil, true):
+                return ElementL10n.noticeRoomNameRemovedByYou
+            }
+        case .roomThirdPartyInvite(let displayName):
+            guard let displayName else {
+                MXLog.error("roomThirdPartyInvite undisplayable due to missing name.")
+                return nil
+            }
+            
+            if isOutgoing {
+                return ElementL10n.noticeRoomThirdPartyInviteByYou(displayName)
+            } else {
+                return ElementL10n.noticeRoomThirdPartyInvite(senderName, displayName)
+            }
+        case .roomTopic(let topic):
+            switch (topic, isOutgoing) {
+            case (.some(let topic), false):
+                return ElementL10n.noticeRoomTopicChanged(senderName, topic)
+            case (nil, false):
+                return ElementL10n.noticeRoomTopicRemoved(senderName)
+            case (.some(let name), true):
+                return ElementL10n.noticeRoomTopicChangedByYou(name)
+            case (nil, true):
+                return ElementL10n.noticeRoomTopicRemovedByYou
+            }
+        case .policyRuleRoom, .policyRuleServer, .policyRuleUser: // No strings available.
+            break
+        case .roomAliases, .roomCanonicalAlias: // Doesn't provide the alias.
+            break
+        case .roomGuestAccess, .roomHistoryVisibility: // Doesn't provide information about the change.
+            break
+        case .roomJoinRules: // Doesn't provide information about the change.
+            break
+        case .roomPinnedEvents, .roomPowerLevels, .roomServerAcl: // Doesn't provide information about the change.
+            break
+        case .roomTombstone: // Handle as a virtual timeline item with a link to the upgraded room.
+            break
+        case .spaceChild, .spaceParent: // Users shouldn't see the timeline of a Space.
+            break
+        case .custom: // Won't provide actionable information to the user.
+            break
+        }
+        
+        MXLog.verbose("Filtering timeline item for state: \(state)")
+        return nil
+    }
+}
@@ -20,21 +20,24 @@ import UIKit
 struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
    private let mediaProvider: MediaProviderProtocol
    private let attributedStringBuilder: AttributedStringBuilderProtocol
+    private let roomStateStringBuilder: RoomStateStringBuilder
    
    /// The Matrix ID of the current user.
    private let userID: String
    
    init(userID: String,
         mediaProvider: MediaProviderProtocol,
-         attributedStringBuilder: AttributedStringBuilderProtocol) {
+         attributedStringBuilder: AttributedStringBuilderProtocol,
+         roomStateStringBuilder: RoomStateStringBuilder) {
        self.userID = userID
        self.mediaProvider = mediaProvider
        self.attributedStringBuilder = attributedStringBuilder
+        self.roomStateStringBuilder = roomStateStringBuilder
    }
    
    // swiftlint:disable:next cyclomatic_complexity
    func buildTimelineItemFor(eventItemProxy: EventTimelineItemProxy,
-                              groupState: TimelineItemGroupState) -> RoomTimelineItemProtocol {
+                              groupState: TimelineItemGroupState) -> RoomTimelineItemProtocol? {
        var sender = eventItemProxy.sender
        if let senderAvatarURL = eventItemProxy.sender.avatarURL,
           let image = mediaProvider.imageFromURL(senderAvatarURL, avatarSize: .user(on: .timeline)) {
@@ -79,14 +82,14 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
            case .none:
                return buildFallbackTimelineItem(eventItemProxy, sender, isOutgoing, groupState)
            }
-        case .state:
-            return buildFallbackTimelineItem(eventItemProxy, sender, isOutgoing, groupState)
-        case .roomMembership:
-            return buildFallbackTimelineItem(eventItemProxy, sender, isOutgoing, groupState)
+        case .state(let stateKey, let content):
+            return buildStateTimelineItemFor(eventItemProxy: eventItemProxy, state: content, stateKey: stateKey, sender: sender, isOutgoing: isOutgoing)
+        case .roomMembership(userId: let userID, change: let change):
+            return buildStateMembershipChangeTimelineItemFor(eventItemProxy: eventItemProxy, member: userID, membershipChange: change, sender: sender, isOutgoing: isOutgoing)
        }
    }
    
-    // MARK: - Private
+    // MARK: - Message Events
    
    // swiftlint:disable:next function_parameter_count
    private func buildUnsupportedTimelineItem(_ eventItemProxy: EventTimelineItemProxy,
@@ -359,4 +362,34 @@ struct RoomTimelineItemFactory: RoomTimelineItemFactoryProtocol {
            return AggregatedReaction(key: reaction.key, count: Int(reaction.count), isHighlighted: isHighlighted)
        }
    }
+    
+    // MARK: - State Events
+    
+    private func buildStateTimelineItemFor(eventItemProxy: EventTimelineItemProxy,
+                                           state: OtherState,
+                                           stateKey: String,
+                                           sender: TimelineItemSender,
+                                           isOutgoing: Bool) -> RoomTimelineItemProtocol? {
+        guard let text = roomStateStringBuilder.buildString(for: state, stateKey: stateKey, sender: sender, isOutgoing: isOutgoing) else { return nil }
+        return buildStateTimelineItem(eventItemProxy: eventItemProxy, text: text, sender: sender, isOutgoing: isOutgoing)
+    }
+    
+    private func buildStateMembershipChangeTimelineItemFor(eventItemProxy: EventTimelineItemProxy,
+                                                           member: String,
+                                                           membershipChange: MembershipChange,
+                                                           sender: TimelineItemSender,
+                                                           isOutgoing: Bool) -> RoomTimelineItemProtocol? {
+        guard let text = roomStateStringBuilder.buildString(for: membershipChange, member: member, sender: eventItemProxy.sender, isOutgoing: isOutgoing) else { return nil }
+        return buildStateTimelineItem(eventItemProxy: eventItemProxy, text: text, sender: sender, isOutgoing: isOutgoing)
+    }
+    
+    private func buildStateTimelineItem(eventItemProxy: EventTimelineItemProxy, text: String, sender: TimelineItemSender, isOutgoing: Bool) -> RoomTimelineItemProtocol {
+        StateRoomTimelineItem(id: eventItemProxy.id,
+                              text: text,
+                              timestamp: eventItemProxy.timestamp.formatted(date: .omitted, time: .shortened),
+                              groupState: .single,
+                              isOutgoing: isOutgoing,
+                              isEditable: false,
+                              sender: sender)
+    }
 }
@@ -19,5 +19,5 @@ import Foundation
@MainActor
 protocol RoomTimelineItemFactoryProtocol {
    func buildTimelineItemFor(eventItemProxy: EventTimelineItemProxy,
-                              groupState: TimelineItemGroupState) -> RoomTimelineItemProtocol
+                              groupState: TimelineItemGroupState) -> RoomTimelineItemProtocol?
 }
@@ -48,6 +48,8 @@ struct RoomTimelineViewFactory: RoomTimelineViewFactoryProtocol {
            return .unsupported(item)
        case let item as TimelineStartRoomTimelineItem:
            return .timelineStart(item)
+        case let item as StateRoomTimelineItem:
+            return .state(item)
        default:
            fatalError("Unknown timeline item")
        }
@@ -32,6 +32,7 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
    case sticker(StickerRoomTimelineItem)
    case unsupported(UnsupportedRoomTimelineItem)
    case timelineStart(TimelineStartRoomTimelineItem)
+    case state(StateRoomTimelineItem)
    
    var id: String {
        switch self {
@@ -63,6 +64,8 @@ enum RoomTimelineViewProvider: Identifiable, Hashable {
            return item.id
        case .timelineStart(let item):
            return item.id
+        case .state(let item):
+            return item.id
        }
    }
 }
@@ -98,6 +101,8 @@ extension RoomTimelineViewProvider: View {
            UnsupportedRoomTimelineView(timelineItem: item)
        case .timelineStart(let item):
            TimelineStartRoomTimelineView(timelineItem: item)
+        case .state(let item):
+            StateRoomTimelineView(timelineItem: item)
        }
    }
 }
@@ -149,11 +149,12 @@ class UserSessionFlowCoordinator: CoordinatorProtocol {
                MXLog.error("Invalid room identifier: \(roomIdentifier)")
                return
            }
-            let userId = userSession.clientProxy.userIdentifier
+            let userId = userSession.clientProxy.userID

            let timelineItemFactory = RoomTimelineItemFactory(userID: userId,
                                                              mediaProvider: userSession.mediaProvider,
-                                                              attributedStringBuilder: AttributedStringBuilder())
+                                                              attributedStringBuilder: AttributedStringBuilder(),
+                                                              roomStateStringBuilder: RoomStateStringBuilder(userID: userId))
            
            let timelineController = roomTimelineControllerFactory.buildRoomTimelineController(userId: userId,
                                                                                               roomProxy: roomProxy,
@@ -78,13 +78,13 @@ class UserSessionStore: UserSessionStoreProtocol {
            return .failure(.failedRefreshingRestoreToken)
        }

-        keychainController.setRestorationToken(restorationToken, forUsername: userSession.clientProxy.userIdentifier)
+        keychainController.setRestorationToken(restorationToken, forUsername: userSession.clientProxy.userID)

        return .success(())
    }
    
    func logout(userSession: UserSessionProtocol) {
-        let userID = userSession.clientProxy.userIdentifier
+        let userID = userSession.clientProxy.userID
        keychainController.removeRestorationTokenForUsername(userID)
        deleteSessionDirectory(for: userID)
    }
@@ -85,7 +85,7 @@ class MockScreen: Identifiable {
                                                                userNotificationController: MockUserNotificationController(),
                                                                isModallyPresented: false))
        case .analyticsPrompt:
-            return AnalyticsPromptCoordinator(parameters: .init(userSession: MockUserSession(clientProxy: MockClientProxy(userIdentifier: "@mock:client.com"),
+            return AnalyticsPromptCoordinator(parameters: .init(userSession: MockUserSession(clientProxy: MockClientProxy(userID: "@mock:client.com"),
                                                                                             mediaProvider: MockMediaProvider())))
        case .authenticationFlow:
            let navigationStackCoordinator = NavigationStackCoordinator()
@@ -108,7 +108,7 @@ class MockScreen: Identifiable {
            return TemplateCoordinator(parameters: .init(promptType: .upgrade))
        case .home:
            let navigationStackCoordinator = NavigationStackCoordinator()
-            let session = MockUserSession(clientProxy: MockClientProxy(userIdentifier: "@mock:matrix.org"),
+            let session = MockUserSession(clientProxy: MockClientProxy(userID: "@mock:matrix.org"),
                                          mediaProvider: MockMediaProvider())
            let coordinator = HomeScreenCoordinator(parameters: .init(userSession: session,
                                                                      attributedStringBuilder: AttributedStringBuilder(),
@@ -120,7 +120,7 @@ class MockScreen: Identifiable {
            let navigationStackCoordinator = NavigationStackCoordinator()
            let coordinator = SettingsCoordinator(parameters: .init(navigationStackCoordinator: navigationStackCoordinator,
                                                                    userNotificationController: MockUserNotificationController(),
-                                                                    userSession: MockUserSession(clientProxy: MockClientProxy(userIdentifier: "@mock:client.com"),
+                                                                    userSession: MockUserSession(clientProxy: MockClientProxy(userID: "@mock:client.com"),
                                                                                                 mediaProvider: MockMediaProvider()),
                                                                    bugReportService: MockBugReportService()))
            navigationStackCoordinator.setRootCoordinator(coordinator)
@@ -260,7 +260,7 @@ class MockScreen: Identifiable {
        case .userSessionScreen:
            let navigationSplitCoordinator = NavigationSplitCoordinator(placeholderCoordinator: SplashScreenCoordinator())
            
-            let clientProxy = MockClientProxy(userIdentifier: "@mock:client.com", roomSummaryProvider: MockRoomSummaryProvider(state: .loaded))
+            let clientProxy = MockClientProxy(userID: "@mock:client.com", roomSummaryProvider: MockRoomSummaryProvider(state: .loaded))
            
            let coordinator = UserSessionFlowCoordinator(userSession: MockUserSession(clientProxy: clientProxy, mediaProvider: MockMediaProvider()),
                                                         navigationSplitCoordinator: navigationSplitCoordinator,