Sliding Sync + New Timeline API (#189)

* Begin adopting new Timeline API.

* Add edited indicator and reactions.

* vector-im/element-x-ios/issues/65 - Sliding sync support
* Fix missing room display name, wrong placeholder avatar text color and various other warnings that would fail the build on the CI

* Various tweaks:
* using release version of the demo branch of the sdk
* enabled home screen last room messages
* switched debug mode rust logging to warn
* enabled redactions
* enabled new logout flows and soft logout
* enabled replies

* Fix room member display name and avatar crashes / race condition, fix unit tests
* Make the ClientProxy and the UserSession MainActors
* Remove unused MatrixRustSDK imports, we should strive to keep these only in top level services and proxies
* Don't start either of the syncs while in soft logout

* #181: Style the session verification banner to match Figma.
* #181: Update verification modal.
* #181: Update snapshot tests.

* Make session verification state machine less pedantic
* Remove unnecessary weak selfs
* Various tweaks following code review:
* add start and stop sync client proxy methods
* move ss proxy url the build settings
* made media provider load results discardable
* added publishers for the roomSummaryProvider's total number of rooms and state

* Fix when sender details are shown
* Disable sync v2, causes duplicates in the timeline (as expected)
* Move ClientProxy media loading off the main queue and into a detached task
* Another attempt at moving image loading off the main queue
* Moved home screen diffing and latest room fetching to the background
* Prevent the timeline composer from becoming the first responder when not needed

* Bump to a newer version of the RustSDK

* Fixes vector-im/element-x-ios/issues/107 - New home screen design
* Implement thumbnail loading instead of full image avatars.
* Revert "Disable sync v2, causes duplicates in the timeline (as expected)"
* Add support for local echoes, dispatching detached tasks to a concurrenc GCD queue
* Move the session verification banner to a List Section to avoid UI glitches
* Optimise room mapping after sliding sync updates and thumbnail fetching
* Replace home screen List with a LazyVStack in an attempt to fix performance. Moved move summary provider room updating to a background thread

* Fixes vector-im/element-x-ios/issues/177 - New Bubbles Design
* Define in group state for timeline items
* Add replies into the bubble
* Add timeline width environment value
* Add `RoundedCorner` shape with specific corners rounding
* Add in group state for previews
* Implement bubble grouping logic
* Timeline avatar layout changes
* Fix placeholder avatars for dark mode
* New bubbles design
* Update mock timeline items
* Update timeline separator design
* Update room screen reference screenshots
* Add changelog
* Formatting fixes
* Add some space before single or beginning outgoing items

* Redesign the message composer

* Handle the msgtype enum.

* Update room name label line limit and incoming bubble background. Disabled syncv2, ss withCommonExtensions and session verification controller checking

* Increase default back pagination limit.
* Stop parsing links and tidy up composer button.
* Also fix the frame of an image whilst loading.
* Bump SDK package version.

* Remove app states about settings
* Add strings
* Use colors on placeholder avatars
* Tiny changes for placeholder avatars
* Update settings screen design
* Provide a user display name from the mock client
* Settings screen presentation logic
* Add changelog
* Update reference screenshots

Co-authored-by: Doug <douglase@element.io>
Co-authored-by: ismailgulek <ismailgulek@users.noreply.github.com>
Co-authored-by: ismailgulek <ismailg@matrix.org>

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -19,64 +19,91 @@ import Foundation
 import MatrixRustSDK
 import UIKit
 
-private class WeakClientProxyWrapper: ClientDelegate {
+private class WeakClientProxyWrapper: ClientDelegate, SlidingSyncObserver {
     private weak var clientProxy: ClientProxy?
     
     init(clientProxy: ClientProxy) {
         self.clientProxy = clientProxy
     }
     
-    func didReceiveSyncUpdate() {
-        clientProxy?.didReceiveSyncUpdate()
-    }
+    // MARK: - ClientDelegate
+    
+    func didReceiveSyncUpdate() { }
 
     func didReceiveAuthError(isSoftLogout: Bool) {
-        clientProxy?.didReceiveAuthError(isSoftLogout: isSoftLogout)
+        Task {
+            await clientProxy?.didReceiveAuthError(isSoftLogout: isSoftLogout)
+        }
     }
 
     func didUpdateRestoreToken() {
-        clientProxy?.didUpdateRestoreToken()
+        Task {
+            await clientProxy?.didUpdateRestoreToken()
+        }
+    }
+    
+    // MARK: - SlidingSyncDelegate
+    
+    func didReceiveSyncUpdate(summary: UpdateSummary) {
+        Task {
+            await self.clientProxy?.didReceiveSlidingSyncUpdate(summary: summary)
+        }
     }
 }
 
 class ClientProxy: ClientProxyProtocol {
     /// The maximum number of timeline events required during a sync request.
-    static let syncLimit: UInt16 = 20
+    static let syncLimit: UInt16 = 50
     
-    private let client: Client
+    private let client: ClientProtocol
     private let backgroundTaskService: BackgroundTaskServiceProtocol
     private var sessionVerificationControllerProxy: SessionVerificationControllerProxy?
     
-    private(set) var rooms: [RoomProxy] = [] {
-        didSet {
-            callbacks.send(.updatedRoomsList)
-        }
-    }
+    private var slidingSyncObserverToken: StoppableSpawn?
+    private let slidingSync: SlidingSync
+    
+    private var roomProxies = [String: RoomProxyProtocol]()
+    
+    let roomSummaryProvider: RoomSummaryProviderProtocol
     
     deinit {
+        // These need to be inlined instead of using stopSync()
+        // as we can't call async methods safely from deinit
         client.setDelegate(delegate: nil)
+        slidingSyncObserverToken?.cancel()
+        slidingSync.setObserver(observer: nil)
     }
     
     let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
     
-    init(client: Client,
+    init(client: ClientProtocol,
          backgroundTaskService: BackgroundTaskServiceProtocol) {
         self.client = client
         self.backgroundTaskService = backgroundTaskService
         
+        do {
+            let slidingSyncBuilder = try client.slidingSync().homeserver(url: BuildSettings.slidingSyncProxyBaseURL.absoluteString)
+            
+            let slidingSyncView = try SlidingSyncViewBuilder()
+                .timelineLimit(limit: 10)
+                .requiredState(requiredState: [RequiredState(key: "m.room.avatar", value: "")])
+                .name(name: "HomeScreenView")
+                .syncMode(mode: .fullSync)
+                .build()
+            
+            slidingSync = try slidingSyncBuilder
+                .addView(view: slidingSyncView)
+//                .withCommonExtensions()
+                .build()
+            
+            roomSummaryProvider = RoomSummaryProvider(slidingSyncController: slidingSync,
+                                                      slidingSyncView: slidingSyncView,
+                                                      roomMessageFactory: RoomMessageFactory())
+        } catch {
+            fatalError("Failed configuring sliding sync")
+        }
+        
         client.setDelegate(delegate: WeakClientProxyWrapper(clientProxy: self))
-
-        #warning("Use isSoftLogout() api on next SDK release.")
-        Benchmark.startTrackingForIdentifier("ClientSync", message: "Started sync.")
-        client.startSync(timelineLimit: ClientProxy.syncLimit)
-
-        Task { await updateRooms() }
-//        if !client.isSoftLogout() {
-//            Benchmark.startTrackingForIdentifier("ClientSync", message: "Started sync.")
-//            client.startSync(timelineLimit: ClientProxy.syncLimit)
-//
-//            Task { await updateRooms() }
-//        }
     }
     
     var userIdentifier: String {
@@ -89,9 +116,7 @@ class ClientProxy: ClientProxyProtocol {
     }
 
     var isSoftLogout: Bool {
-        #warning("Use isSoftLogout() api on next SDK release.")
-        return false
-//        client.isSoftLogout()
+        client.isSoftLogout()
     }
 
     var deviceId: String? {
@@ -116,6 +141,46 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
     
+    func startSync() {
+        guard !client.isSoftLogout() else {
+            return
+        }
+        
+        slidingSync.setObserver(observer: WeakClientProxyWrapper(clientProxy: self))
+        slidingSyncObserverToken = slidingSync.sync()
+    }
+    
+    func stopSync() {
+        client.setDelegate(delegate: nil)
+        
+        slidingSyncObserverToken?.cancel()
+        slidingSync.setObserver(observer: nil)
+    }
+    
+    func roomForIdentifier(_ identifier: String) -> RoomProxyProtocol? {
+        if let roomProxy = roomProxies[identifier] {
+            return roomProxy
+        }
+        
+        do {
+            guard let slidingSyncRoom = try slidingSync.getRoom(roomId: identifier),
+                  let room = slidingSyncRoom.fullRoom() else {
+                MXLog.error("Failed retrieving room with identifier: \(identifier)")
+                return nil
+            }
+            
+            let roomProxy = RoomProxy(slidingSyncRoom: slidingSyncRoom,
+                                      room: room,
+                                      backgroundTaskService: backgroundTaskService)
+            roomProxies[identifier] = roomProxy
+            
+            return roomProxy
+        } catch {
+            MXLog.error("Failed retrieving room with identifier: \(identifier)")
+            return nil
+        }
+    }
+        
     func loadUserDisplayName() async -> Result<String, ClientProxyError> {
         await Task.detached {
             do {
@@ -152,9 +217,18 @@ class ClientProxy: ClientProxyProtocol {
         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)
+    func loadMediaContentForSource(_ source: MatrixRustSDK.MediaSource) async throws -> Data {
+        try await Task.detached {
+            let bytes = try self.client.getMediaContent(source: source)
+            return Data(bytes: bytes, count: bytes.count)
+        }.value
+    }
+    
+    func loadMediaThumbnailForSource(_ source: MatrixRustSDK.MediaSource, width: UInt, height: UInt) async throws -> Data {
+        try await Task.detached {
+            let bytes = try self.client.getMediaThumbnail(source: source, width: UInt64(width), height: UInt64(height))
+            return Data(bytes: bytes, count: bytes.count)
+        }.value
     }
     
     func sessionVerificationControllerProxy() async -> Result<SessionVerificationControllerProxyProtocol, ClientProxyError> {
@@ -171,8 +245,7 @@ class ClientProxy: ClientProxyProtocol {
 
     func logout() async {
         do {
-            #warning("Use logout() api on next SDK release.")
-//            try client.logout()
+            try client.logout()
         } catch {
             MXLog.error("Failed logging out with error: \(error)")
         }
@@ -180,16 +253,6 @@ class ClientProxy: ClientProxyProtocol {
     
     // MARK: Private
     
-    fileprivate func didReceiveSyncUpdate() {
-        Benchmark.logElapsedDurationForIdentifier("ClientSync", message: "Received sync update")
-        
-        callbacks.send(.receivedSyncUpdate)
-        
-        Task.detached {
-            await self.updateRooms()
-        }
-    }
-
     fileprivate func didReceiveAuthError(isSoftLogout: Bool) {
         callbacks.send(.receivedAuthError(isSoftLogout: isSoftLogout))
     }
@@ -198,32 +261,9 @@ class ClientProxy: ClientProxyProtocol {
         callbacks.send(.updatedRestoreToken)
     }
     
-    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")
+    fileprivate func didReceiveSlidingSyncUpdate(summary: UpdateSummary) {
+        roomSummaryProvider.updateRoomsWithIdentifiers(summary.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(),
-                                              backgroundTaskService: backgroundTaskService))
-            case .remove(_, let id, _):
-                currentRooms.removeAll { $0.id == id }
-            }
-        }
-        
-        Benchmark.endTrackingForIdentifier("ProcessingRooms", message: "Finished processing \(sdkRooms.count) rooms")
-        
-        rooms = currentRooms
+//        callbacks.send(.receivedSyncUpdate)
     }
 }