#53 - Refactored various components:

- updated the authentication coordinator to use async await - replaced the UserSession with a ClientProxy (similar to the RoomProxy) - renamed `completion` to `callback` on the coordinators and view models - renamed `viewModelResult` to `viewModelAction` - introduced back UserSession as a user specific service container
2026-11-02 12:07:55 +00:00 · 2022-05-26 16:04:48 +03:00
parent edf765b7cd
commit 1b4d3a650e
33 changed files with 312 additions and 214 deletions
@@ -0,0 +1,131 @@
+//
+//  ClientProxy.swift
+//  ElementX
+//
+//  Created by Stefan Ceriu on 14.02.2022.
+//
+
+import Foundation
+import MatrixRustSDK
+import Combine
+import UIKit
+
+private class WeakClientProxyWrapper: ClientDelegate {
+    private weak var clientProxy: ClientProxy?
+    
+    init(clientProxy: ClientProxy) {
+        self.clientProxy = clientProxy
+    }
+    
+    func didReceiveSyncUpdate() {
+        clientProxy?.didReceiveSyncUpdate()
+    }
+}
+
+class ClientProxy: ClientProxyProtocol {
+    
+    private let client: Client
+    
+    private(set) var rooms: [RoomProxy] = [] {
+        didSet {
+            callbacks.send(.updatedRoomsList)
+        }
+    }
+    
+    deinit {
+        client.setDelegate(delegate: nil)
+    }
+    
+    let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
+    
+    init(client: Client) {
+        self.client = client
+        
+        client.setDelegate(delegate: WeakClientProxyWrapper(clientProxy: self))
+        
+        Benchmark.startTrackingForIdentifier("ClientSync", message: "Started sync.")
+        client.startSync()
+        
+        Task { await updateRooms() }
+    }
+    
+    var userIdentifier: String {
+        do {
+            return try client.userId()
+        } catch {
+            MXLog.error("Failed retrieving room info with error: \(error)")
+            return "Unknown user identifier"
+        }
+    }
+    
+    func loadUserDisplayName() async -> Result<String, ClientProxyError> {
+        await Task.detached { () -> Result<String, ClientProxyError> in
+            do {
+                let displayName = try self.client.displayName()
+                return .success(displayName)
+            } catch {
+                return .failure(.failedRetrievingDisplayName)
+            }
+            
+        }
+        .value
+    }
+        
+    func loadUserAvatarURLString() async -> Result<String, ClientProxyError> {
+        await Task.detached { () -> Result<String, ClientProxyError> in
+            do {
+                let avatarURL = try self.client.avatarUrl()
+                return .success(avatarURL)
+            } catch {
+                return .failure(.failedRetrievingDisplayName)
+            }
+        }
+        .value
+    }
+    
+    func mediaSourceForURLString(_ urlString: String) -> MatrixRustSDK.MediaSource {
+        MatrixRustSDK.mediaSourceFromUrl(url: urlString)
+    }
+    
+    func loadMediaContentForSource(_ source: MatrixRustSDK.MediaSource) throws -> Data {
+        let bytes = try client.getMediaContent(source: source)
+        return Data(bytes: bytes, count: bytes.count)
+    }
+    
+    // MARK: Private
+    
+    fileprivate func didReceiveSyncUpdate() {
+        Benchmark.logElapsedDurationForIdentifier("ClientSync", message: "Received sync update")
+        
+        Task.detached {
+            await self.updateRooms()
+        }
+    }
+    
+    private func updateRooms() async {
+        var currentRooms = rooms
+        Benchmark.startTrackingForIdentifier("ClientRooms", message: "Fetching available rooms")
+        let sdkRooms = client.rooms()
+        Benchmark.endTrackingForIdentifier("ClientRooms", message: "Retrieved \(sdkRooms.count) rooms")
+        
+        Benchmark.startTrackingForIdentifier("ProcessingRooms", message: "Started processing \(sdkRooms.count) rooms")
+        let diff = sdkRooms.map({ $0.id() }).difference(from: currentRooms.map(\.id))
+        
+        for change in diff {
+            switch change {
+            case .insert(_, let id, _):
+                guard let sdkRoom = sdkRooms.first(where: { $0.id() == id }) else {
+                    MXLog.error("Failed retrieving sdk room with id: \(id)")
+                    break
+                }
+                currentRooms.append(RoomProxy(room: sdkRoom, roomMessageFactory: RoomMessageFactory()))
+            case .remove(_, let id, _):
+                currentRooms.removeAll { $0.id == id }
+            }
+        }
+        
+        Benchmark.endTrackingForIdentifier("ProcessingRooms", message: "Finished processing \(sdkRooms.count) rooms")
+        
+        rooms = currentRooms
+    }
+}