Fixes #2486 - Implement blocked users management in the app settings

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -38,6 +38,9 @@ class ClientProxy: ClientProxyProtocol {
     // periphery: ignore - only for retain
     private var syncServiceStateUpdateTaskHandle: TaskHandle?
     
+    // periphery:ignore - required for instance retention in the rust codebase
+    private var ignoredUsersListenerTaskHandle: TaskHandle?
+    
     private var delegateHandle: TaskHandle?
     
     // These following summary providers both operate on the same allRooms() list but
@@ -69,15 +72,21 @@ class ClientProxy: ClientProxyProtocol {
 
     private var loadCachedAvatarURLTask: Task<Void, Never>?
     private let userAvatarURLSubject = CurrentValueSubject<URL?, Never>(nil)
-    var userAvatarURL: CurrentValuePublisher<URL?, Never> {
+    var userAvatarURLPublisher: CurrentValuePublisher<URL?, Never> {
         userAvatarURLSubject.asCurrentValuePublisher()
     }
     
     private let userDisplayNameSubject = CurrentValueSubject<String?, Never>(nil)
-    var userDisplayName: CurrentValuePublisher<String?, Never> {
+    var userDisplayNamePublisher: CurrentValuePublisher<String?, Never> {
         userDisplayNameSubject.asCurrentValuePublisher()
     }
     
+    private let ignoredUsersSubject = CurrentValueSubject<[String]?, Never>(nil)
+    var ignoredUsersPublisher: CurrentValuePublisher<[String]?, Never> {
+        ignoredUsersSubject
+            .asCurrentValuePublisher()
+    }
+    
     private var cancellables = Set<AnyCancellable>()
     
     /// Will be `true` whilst the app cleans up and forces a logout. Prevents the sync service from restarting
@@ -92,7 +101,10 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
     
-    let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
+    private let actionsSubject = PassthroughSubject<ClientProxyAction, Never>()
+    var actionsPublisher: AnyPublisher<ClientProxyAction, Never> {
+        actionsSubject.eraseToAnyPublisher()
+    }
     
     private let loadingStateSubject = CurrentValueSubject<ClientProxyLoadingState, Never>(.notLoading)
     var loadingStatePublisher: CurrentValuePublisher<ClientProxyLoadingState, Never> {
@@ -119,7 +131,7 @@ class ClientProxy: ClientProxyProtocol {
 
         delegateHandle = client.setDelegate(delegate: ClientDelegateWrapper { [weak self] isSoftLogout in
             self?.hasEncounteredAuthError = true
-            self?.callbacks.send(.receivedAuthError(isSoftLogout: isSoftLogout))
+            self?.actionsSubject.send(.receivedAuthError(isSoftLogout: isSoftLogout))
         })
         
         networkMonitor.reachabilityPublisher
@@ -135,6 +147,10 @@ class ClientProxy: ClientProxyProtocol {
         await configureAppService()
 
         loadUserAvatarURLFromCache()
+        
+        ignoredUsersListenerTaskHandle = client.subscribeToIgnoredUsers(listener: IgnoredUsersListenerProxy { [weak self] ignoredUsers in
+            self?.ignoredUsersSubject.send(ignoredUsers)
+        })
     }
     
     var userID: String {
@@ -472,6 +488,28 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
     
+    // MARK: - Ignored users
+    
+    func ignoreUser(_ userID: String) async -> Result<Void, ClientProxyError> {
+        do {
+            try await client.ignoreUser(userId: userID)
+            return .success(())
+        } catch {
+            MXLog.error("Failed ignoring user with error: \(error)")
+            return .failure(.failedIgnoringUser)
+        }
+    }
+    
+    func unignoreUser(_ userID: String) async -> Result<Void, ClientProxyError> {
+        do {
+            try await client.unignoreUser(userId: userID)
+            return .success(())
+        } catch {
+            MXLog.error("Failed unignoring user with error: \(error)")
+            return .failure(.failedUnignoringUser)
+        }
+    }
+    
     // MARK: Private
 
     private func loadUserAvatarURLFromCache() {
@@ -570,7 +608,11 @@ class ClientProxy: ClientProxyProtocol {
             }
             
             // Hide the sync spinner as soon as we get any update back
-            callbacks.send(.receivedSyncUpdate)
+            actionsSubject.send(.receivedSyncUpdate)
+            
+            if ignoredUsersSubject.value == nil {
+                updateIgnoredUsers()
+            }
         })
     }
     
@@ -620,6 +662,17 @@ class ClientProxy: ClientProxyProtocol {
             return (nil, nil)
         }
     }
+    
+    private func updateIgnoredUsers() {
+        Task {
+            do {
+                let ignoredUsers = try await client.ignoredUsers()
+                ignoredUsersSubject.send(ignoredUsers)
+            } catch {
+                MXLog.error("Failed fetching ignored users with error: \(error)")
+            }
+        }
+    }
 }
 
 extension ClientProxy: MediaLoaderProtocol {
@@ -690,3 +743,15 @@ private class ClientDelegateWrapper: ClientDelegate {
         MXLog.info("Delegating session updates to the ClientSessionDelegate.")
     }
 }
+
+private class IgnoredUsersListenerProxy: IgnoredUsersListener {
+    private let onUpdateClosure: ([String]) -> Void
+
+    init(onUpdateClosure: @escaping ([String]) -> Void) {
+        self.onUpdateClosure = onUpdateClosure
+    }
+    
+    func call(ignoredUserIds: [String]) {
+        onUpdateClosure(ignoredUserIds)
+    }
+}

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -18,7 +18,7 @@ import Combine
 import Foundation
 import MatrixRustSDK
 
-enum ClientProxyCallback {
+enum ClientProxyAction {
     case receivedSyncUpdate
     case receivedAuthError(isSoftLogout: Bool)
     
@@ -50,6 +50,8 @@ enum ClientProxyError: Error {
     case failedGettingUserProfile
     case failedSettingUserAvatar
     case failedCheckingIsLastDevice(Error?)
+    case failedIgnoringUser
+    case failedUnignoringUser
 }
 
 enum SlidingSyncConstants {
@@ -70,7 +72,7 @@ struct PusherConfiguration {
 }
 
 protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
-    var callbacks: PassthroughSubject<ClientProxyCallback, Never> { get }
+    var actionsPublisher: AnyPublisher<ClientProxyAction, Never> { get }
     
     var loadingStatePublisher: CurrentValuePublisher<ClientProxyLoadingState, Never> { get }
     
@@ -80,9 +82,12 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
 
     var homeserver: String { get }
         
-    var userDisplayName: CurrentValuePublisher<String?, Never> { get }
+    var userDisplayNamePublisher: CurrentValuePublisher<String?, Never> { get }
 
-    var userAvatarURL: CurrentValuePublisher<URL?, Never> { get }
+    var userAvatarURLPublisher: CurrentValuePublisher<URL?, Never> { get }
+
+    /// We delay fetching this until after the first sync. Nil until then
+    var ignoredUsersPublisher: CurrentValuePublisher<[String]?, Never> { get }
     
     var pusherNotificationClientIdentifier: String? { get }
     
@@ -134,4 +139,10 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
     func searchUsers(searchTerm: String, limit: UInt) async -> Result<SearchUsersResultsProxy, ClientProxyError>
     
     func profile(for userID: String) async -> Result<UserProfileProxy, ClientProxyError>
+    
+    // MARK: - Ignored users
+    
+    func ignoreUser(_ userID: String) async -> Result<Void, ClientProxyError>
+    
+    func unignoreUser(_ userID: String) async -> Result<Void, ClientProxyError>
 }

ElementX/Sources/Services/Client/MockClientProxy.swift

@@ -19,7 +19,10 @@ import Foundation
 import MatrixRustSDK
 
 class MockClientProxy: ClientProxyProtocol {
-    let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
+    let actionsSubject = PassthroughSubject<ClientProxyAction, Never>()
+    var actionsPublisher: AnyPublisher<ClientProxyAction, Never> {
+        actionsSubject.eraseToAnyPublisher()
+    }
     
     let loadingStatePublisher = CurrentValuePublisher<ClientProxyLoadingState, Never>(.notLoading)
     
@@ -34,9 +37,14 @@ class MockClientProxy: ClientProxyProtocol {
     
     var inviteSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()
 
-    var userAvatarURL: CurrentValuePublisher<URL?, Never> { CurrentValueSubject<URL?, Never>(nil).asCurrentValuePublisher() }
+    var userAvatarURLPublisher: CurrentValuePublisher<URL?, Never> { CurrentValueSubject<URL?, Never>(nil).asCurrentValuePublisher() }
     
-    var userDisplayName: CurrentValuePublisher<String?, Never> { CurrentValueSubject<String?, Never>("User display name").asCurrentValuePublisher() }
+    var userDisplayNamePublisher: CurrentValuePublisher<String?, Never> { CurrentValueSubject<String?, Never>("User display name").asCurrentValuePublisher() }
+    
+    var ignoredUsersPublisher: CurrentValuePublisher<[String]?, Never> {
+        let ignoredUsers = [RoomMemberProxyMock].allMembers.map(\.userID)
+        return CurrentValueSubject<[String]?, Never>(ignoredUsers).asCurrentValuePublisher()
+    }
     
     var notificationSettings: NotificationSettingsProxyProtocol = NotificationSettingsProxyMock(with: .init())
     
@@ -166,4 +174,12 @@ class MockClientProxy: ClientProxyProtocol {
         getProfileCalled = true
         return getProfileResult
     }
+    
+    func ignoreUser(_ userID: String) async -> Result<Void, ClientProxyError> {
+        .failure(.failedIgnoringUser)
+    }
+    
+    func unignoreUser(_ userID: String) async -> Result<Void, ClientProxyError> {
+        .failure(.failedUnignoringUser)
+    }
 }

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -39,17 +39,17 @@ class RoomProxy: RoomProxyProtocol {
     private var subscribedForUpdates = false
 
     private let membersSubject = CurrentValueSubject<[RoomMemberProxyProtocol], Never>([])
-    var members: CurrentValuePublisher<[RoomMemberProxyProtocol], Never> {
+    var membersPublisher: CurrentValuePublisher<[RoomMemberProxyProtocol], Never> {
         membersSubject.asCurrentValuePublisher()
     }
     
     private let typingMembersSubject = CurrentValueSubject<[String], Never>([])
-    var typingMembers: CurrentValuePublisher<[String], Never> {
+    var typingMembersPublisher: CurrentValuePublisher<[String], Never> {
         typingMembersSubject.asCurrentValuePublisher()
     }
         
     private let actionsSubject = PassthroughSubject<RoomProxyAction, Never>()
-    var actions: AnyPublisher<RoomProxyAction, Never> {
+    var actionsPublisher: AnyPublisher<RoomProxyAction, Never> {
         actionsSubject.eraseToAnyPublisher()
     }
     
@@ -217,7 +217,7 @@ class RoomProxy: RoomProxyProtocol {
     }
 
     func getMember(userID: String) async -> Result<RoomMemberProxyProtocol, RoomProxyError> {
-        if let member = members.value.filter({ $0.userID == userID }).first {
+        if let member = membersPublisher.value.filter({ $0.userID == userID }).first {
             return .success(member)
         }
         
@@ -473,23 +473,21 @@ class RoomProxy: RoomProxyProtocol {
     }
     
     private func subscribeToTypingNotifications() {
-        Task {
-            typingNotificationObservationToken = await room.subscribeToTypingNotifications(listener: RoomTypingNotificationUpdateListener { [weak self] typingUserIDs in
-                guard let self else { return }
-                
-                MXLog.info("Received typing notification update, typingUsers: \(typingUserIDs)")
-                
-                let typingMembers = typingUserIDs.compactMap { userID in
-                    if let member = self.members.value.filter({ $0.userID == userID }).first {
-                        return member.displayName ?? member.userID
-                    } else {
-                        return userID
-                    }
+        typingNotificationObservationToken = room.subscribeToTypingNotifications(listener: RoomTypingNotificationUpdateListener { [weak self] typingUserIDs in
+            guard let self else { return }
+            
+            MXLog.info("Received typing notification update, typingUsers: \(typingUserIDs)")
+            
+            let typingMembers = typingUserIDs.compactMap { userID in
+                if let member = self.membersPublisher.value.filter({ $0.userID == userID }).first {
+                    return member.displayName ?? member.userID
+                } else {
+                    return userID
                 }
-                
-                typingMembersSubject.send(typingMembers)
-            })
-        }
+            }
+            
+            typingMembersSubject.send(typingMembers)
+        })
     }
 }
 

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -62,15 +62,15 @@ protocol RoomProxyProtocol {
     
     var avatarURL: URL? { get }
 
-    var members: CurrentValuePublisher<[RoomMemberProxyProtocol], Never> { get }
+    var membersPublisher: CurrentValuePublisher<[RoomMemberProxyProtocol], Never> { get }
     
-    var typingMembers: CurrentValuePublisher<[String], Never> { get }
+    var typingMembersPublisher: CurrentValuePublisher<[String], Never> { get }
         
     var joinedMembersCount: Int { get }
     
     var activeMembersCount: Int { get }
     
-    var actions: AnyPublisher<RoomProxyAction, Never> { get }
+    var actionsPublisher: AnyPublisher<RoomProxyAction, Never> { get }
     
     var timeline: TimelineProxyProtocol { get }
     
@@ -167,6 +167,6 @@ extension RoomProxyProtocol {
 
     func members() async -> [RoomMemberProxyProtocol]? {
         await updateMembers()
-        return members.value
+        return membersPublisher.value
     }
 }

ElementX/Sources/Services/Session/UserSession.swift

@@ -60,7 +60,7 @@ class UserSession: UserSessionProtocol {
         self.mediaProvider = mediaProvider
         self.voiceMessageMediaManager = voiceMessageMediaManager
         
-        clientProxy.callbacks
+        clientProxy.actionsPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] callback in
                 if callback.isSyncUpdate {
@@ -69,7 +69,7 @@ class UserSession: UserSessionProtocol {
             }
             .store(in: &cancellables)
         
-        authErrorCancellable = clientProxy.callbacks
+        authErrorCancellable = clientProxy.actionsPublisher
             .receive(on: DispatchQueue.main)
             .sink { [weak self] callback in
                 guard let self else { return }