vector-im/element-x-ios/issues/53 - Converted most callback based methods to async/await

ElementX/Sources/Screens/HomeScreen/HomeScreenCoordinator.swift

@@ -70,7 +70,10 @@ final class HomeScreenCoordinator: Coordinator, Presentable {
             }
         }
         
-        parameters.userSession.callbacks.sink { [weak self] result in
+        parameters.userSession
+            .callbacks
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] result in
                 switch result {
                 case .updatedRoomsList:
                     self?.updateRoomsList()
@@ -79,19 +82,19 @@ final class HomeScreenCoordinator: Coordinator, Presentable {
         
         updateRoomsList()
         
-        parameters.userSession.userAvatarURL { [weak self] result in
+        Task {
-            if case let .success(avatarURL) = result {
+            if case let .success(userAvatarURL) = await parameters.userSession.loadUserAvatarURL() {
-                self?.parameters.mediaProvider.loadImageFromURL(avatarURL) { result in
+                if case let .success(avatar) = await parameters.mediaProvider.loadImageFromURL(userAvatarURL) {
-                    if case let .success(avatar) = result {
+                    await MainActor.run {
-                        self?.viewModel.updateWithUserAvatar(avatar)
+                        self.viewModel.updateWithUserAvatar(avatar)
-                    }
                     }
                 }
             }
             
-        parameters.userSession.userDisplayName { [weak self] result in
+            if case let .success(userDisplayName) = await parameters.userSession.loadUserDisplayName() {
-            if case let .success(displayName) = result {
+                await MainActor.run {
-                self?.viewModel.updateWithUserDisplayName(displayName)
+                    self.viewModel.updateWithUserDisplayName(userDisplayName)
+                }
             }
         }
     }

ElementX/Sources/Screens/HomeScreen/HomeScreenViewModel.swift

@@ -65,7 +65,9 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         roomUpdateListeners.removeAll()
         
         roomList.forEach({ roomSummary  in
-            roomSummary.callbacks.sink { [weak self] callback in
+            roomSummary.callbacks
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self] callback in
                     guard let self = self else {
                         return
                     }
@@ -98,7 +100,9 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
             return
         }
         
-        roomSummary.loadData()
+        Task {
+            await roomSummary.loadDetails()
+        }
     }
     
     private func buildOrUpdateRoomFromSummary(_ roomSummary: RoomSummaryProtocol) -> HomeScreenRoom {

ElementX/Sources/Screens/HomeScreen/View/HomeScreen.swift

@@ -152,7 +152,7 @@ struct RoomCell: View {
             }
             .animation(.easeInOut, value: room)
             .frame(minHeight: 60.0)
-            .onAppear {
+            .task {
                 context.send(viewAction: .loadRoomData(roomIdentifier: room.id))
             }
         }

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -38,7 +38,9 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         
         super.init(initialViewState: RoomScreenViewState(roomTitle: roomName ?? "Unknown room 💥", bindings: RoomScreenViewStateBindings(composerText: "")))
         
-        timelineController.callbacks.sink { [weak self] callback in
+        timelineController.callbacks
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] callback in
             guard let self = self else { return }
             
             switch callback {
@@ -62,16 +64,24 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
     // MARK: - Public
     
     override func process(viewAction: RoomScreenViewAction) {
+        Task {
             switch viewAction {
             case .loadPreviousPage:
+                await MainActor.run {
                     state.isBackPaginating = true
-            timelineController.paginateBackwards(Constants.backPaginationPageSize) { [weak self] _ in
-                self?.state.isBackPaginating = false
                 }
+                
+                switch await timelineController.paginateBackwards(Constants.backPaginationPageSize) {
+                default:
+                    await MainActor.run {
+                        state.isBackPaginating = false
+                    }
+                }
+                
             case .itemAppeared(let id):
-            timelineController.processItemAppearance(id)
+                await timelineController.processItemAppearance(id)
             case .itemDisappeared(let id):
-            timelineController.processItemDisappearance(id)
+                await timelineController.processItemDisappearance(id)
             case .linkClicked(let url):
                 MXLog.warning("Link clicked: \(url)")
             case .sendMessage:
@@ -79,10 +89,14 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                     return
                 }
                 
-            timelineController.sendMessage(state.bindings.composerText)
+                await timelineController.sendMessage(state.bindings.composerText)
+                
+                await MainActor.run {
                     state.bindings.composerText = ""
                 }
             }
+        }
+    }
     
     // MARK: - Private
     

ElementX/Sources/Services/Authentication/UserSession.swift

@@ -28,16 +28,13 @@ private class WeakUserSessionWrapper: ClientDelegate {
     }
     
     func didReceiveSyncUpdate() {
-        DispatchQueue.main.async {
         self.userSession?.didReceiveSyncUpdate()
     }
-    }
 }
 
 class UserSession: ClientDelegate {
     
     private let client: Client
-    private let processingQueue: DispatchQueue
     
     private(set) var rooms: [RoomProxy] = [] {
         didSet {
@@ -55,7 +52,6 @@ class UserSession: ClientDelegate {
     
     init(client: Client) {
         self.client = client
-        self.processingQueue = DispatchQueue(label: "UserSessionProcessingQueue")
         self.mediaProvider = MediaProvider(client: client, imageCache: ImageCache.default)
         
         client.setDelegate(delegate: WeakUserSessionWrapper(userSession: self))
@@ -63,7 +59,9 @@ class UserSession: ClientDelegate {
         Benchmark.startTrackingForIdentifier("ClientSync", message: "Started sync.")
         client.startSync()
         
-        updateRooms()
+        Task {
+            await updateRooms()
+        }
     }
     
     var userIdentifier: String {
@@ -75,34 +73,25 @@ class UserSession: ClientDelegate {
         }
     }
     
-    func userDisplayName(_ completion: @escaping (Result<String, UserSessionError>) -> Void) {
+    func loadUserDisplayName() async -> Result<String, UserSessionError> {
-        processingQueue.async {
+        await withCheckedContinuation { continuation in
             do {
                 let displayName = try self.client.displayName()
-                
+                continuation.resume(returning: .success(displayName))
-                DispatchQueue.main.async {
-                    completion(.success(displayName))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedRetrievingDisplayName))
-                    completion(.failure(UserSessionError.failedRetrievingDisplayName))
-                }
             }
+            
         }
     }
         
-    func userAvatarURL(_ completion: @escaping (Result<String, UserSessionError>) -> Void) {
+    func loadUserAvatarURL() async -> Result<String, UserSessionError> {
-        processingQueue.async {
+        await withCheckedContinuation { continuation in
             do {
-                let displayName = try self.client.avatarUrl()
+                let avatarURL = try self.client.avatarUrl()
-                
+                continuation.resume(returning: .success(avatarURL))
-                DispatchQueue.main.async {
-                    completion(.success(displayName))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedRetrievingDisplayName))
-                    completion(.failure(UserSessionError.failedRetrievingDisplayName))
-                }
             }
         }
     }
@@ -111,18 +100,16 @@ class UserSession: ClientDelegate {
     
     func didReceiveSyncUpdate() {
         Benchmark.logElapsedDurationForIdentifier("ClientSync", message: "Received sync update")
-        updateRooms()
+        
+        Task {
+            await updateRooms()
+        }
     }
     
     // MARK: Private
     
-    func updateRooms() {
+    private func updateRooms() async {
         var currentRooms = self.rooms
-        self.processingQueue.async { [weak self] in
-            guard let self = self else {
-                return
-            }
-            
         Benchmark.startTrackingForIdentifier("ClientRooms", message: "Fetching available rooms")
         let sdkRooms = self.client.rooms()
         Benchmark.endTrackingForIdentifier("ClientRooms", message: "Retrieved \(sdkRooms.count) rooms")
@@ -145,9 +132,6 @@ class UserSession: ClientDelegate {
         
         Benchmark.endTrackingForIdentifier("ProcessingRooms", message: "Finished processing \(sdkRooms.count) rooms")
         
-            DispatchQueue.main.async {
         self.rooms = currentRooms
     }
-        }
-    }
 }

ElementX/Sources/Services/Media/MediaProvider.swift

@@ -29,16 +29,28 @@ struct MediaProvider: MediaProviderProtocol {
         return imageCache.retrieveImageInMemoryCache(forKey: source.underlyingSource.url(), options: nil)
     }
     
-    func loadImageFromSource(_ source: MediaSource, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void) {
+    func imageFromURL(_ url: String?) -> UIImage? {
-        if let image = imageFromSource(source) {
+        guard let url = url else {
-            completion(.success(image))
+            return nil
-            return
         }
         
+        return imageFromSource(MediaSource(source: mediaSourceFromUrl(url: url)))
+    }
+    
+    func loadImageFromURL(_ url: String) async -> Result<UIImage, MediaProviderError> {
+        await loadImageFromSource(MediaSource(source: mediaSourceFromUrl(url: url)))
+    }
+        
+    func loadImageFromSource(_ source: MediaSource) async -> Result<UIImage, MediaProviderError> {
+        if let image = imageFromSource(source) {
+            return .success(image)
+        }
+        
+        return await withCheckedContinuation { continuation in
             imageCache.retrieveImage(forKey: source.underlyingSource.url()) { result in
                 if case let .success(cacheResult) = result,
                    let image = cacheResult.image {
-                completion(.success(image))
+                    continuation.resume(returning: .success(image))
                     return
                 }
                 
@@ -48,36 +60,19 @@ struct MediaProvider: MediaProviderProtocol {
                         
                         guard let image = UIImage(data: Data(bytes: imageData, count: imageData.count)) else {
                             MXLog.error("Invalid image data")
-                        DispatchQueue.main.async {
+                            continuation.resume(returning: .failure(.invalidImageData))
-                            completion(.failure(.invalidImageData))
-                        }
                             return
                         }
                         
                         imageCache.store(image, forKey: source.underlyingSource.url())
                         
-                    DispatchQueue.main.async {
+                        continuation.resume(returning: .success(image))
-                        completion(.success(image))
-                    }
                     } catch {
                         MXLog.error("Failed retrieving image with error: \(error)")
-                    DispatchQueue.main.async {
+                        continuation.resume(returning: .failure(.failedRetrievingImage))
-                        completion(.failure(.failedRetrievingImage))
                     }
                 }
             }
         }
     }
-    
-    func imageFromURL(_ url: String?) -> UIImage? {
-        guard let url = url else {
-            return nil
-        }
-        
-        return imageFromSource(MediaSource(source: mediaSourceFromUrl(url: url)))
-    }
-    
-    func loadImageFromURL(_ url: String, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void) {
-        return loadImageFromSource(MediaSource(source: mediaSourceFromUrl(url: url)), completion)
-    }
 }

ElementX/Sources/Services/Media/MediaProviderProtocol.swift

@@ -17,9 +17,9 @@ enum MediaProviderError: Error {
 protocol MediaProviderProtocol {
     func imageFromSource(_ source: MediaSource?) -> UIImage?
     
-    func loadImageFromSource(_ source: MediaSource, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void)
+    func loadImageFromSource(_ source: MediaSource) async -> Result<UIImage, MediaProviderError>
     
     func imageFromURL(_ url: String?) -> UIImage?
     
-    func loadImageFromURL(_ url: String, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void)
+    func loadImageFromURL(_ url: String) async -> Result<UIImage, MediaProviderError>
 }

ElementX/Sources/Services/Media/MockMediaProvider.swift

@@ -19,8 +19,8 @@ struct MockMediaProvider: MediaProviderProtocol {
         return nil
     }
     
-    func loadImageFromSource(_ source: MediaSource, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void) {
+    func loadImageFromSource(_ source: MediaSource) async -> Result<UIImage, MediaProviderError> {
-        
+        return .failure(.failedRetrievingImage)
     }
     
     func imageFromURL(_ url: String?) -> UIImage? {
@@ -30,4 +30,8 @@ struct MockMediaProvider: MediaProviderProtocol {
     func loadImageFromURL(_ url: String, _ completion: @escaping (Result<UIImage, MediaProviderError>) -> Void) {
         
     }
+    
+    func loadImageFromURL(_ url: String) async -> Result<UIImage, MediaProviderError> {
+        return .failure(.failedRetrievingImage)
+    }
 }

ElementX/Sources/Services/Room/Members/MemberDetailsProvider.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 class MemberDetailProvider: MemberDetailProviderProtocol {
-    private let roomProxy: RoomProxyProtocol?
+    private let roomProxy: RoomProxyProtocol
     private var memberAvatars = [String: String]()
     private var memberDisplayNames = [String: String]()
     
@@ -18,58 +18,38 @@ class MemberDetailProvider: MemberDetailProviderProtocol {
     }
     
     func avatarURLForUserId(_ userId: String) -> String? {
-        self.memberAvatars[userId]
+        memberAvatars[userId]
-    }
-    
-    func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, MemberDetailProviderError>) -> Void) {
-        guard let roomProxy = roomProxy else {
-            return
     }
     
+    func loadAvatarURLForUserId(_ userId: String) async -> Result<String?, MemberDetailProviderError> {
         if let avatarURL = avatarURLForUserId(userId) {
-            completion(.success(avatarURL))
+            return .success(avatarURL)
         }
         
-        roomProxy.avatarURLForUserId(userId, completion: { [weak self] result in
+        switch await roomProxy.loadAvatarURLForUserId(userId) {
-            guard let self = self else {
-                return
-            }
-            
-            switch result {
         case .success(let avatarURL):
-                self.memberAvatars[userId] = avatarURL
+            memberAvatars[userId] = avatarURL
-                completion(.success(avatarURL))
+            return .success(avatarURL)
         case .failure:
-                completion(.failure(.failedRetrievingUserAvatarURL))
+            return .failure(.failedRetrievingUserAvatarURL)
         }
-        })
     }
         
     func displayNameForUserId(_ userId: String) -> String? {
-        self.memberDisplayNames[userId]
+        memberDisplayNames[userId]
     }
     
-    func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, MemberDetailProviderError>) -> Void) {
+    func loadDisplayNameForUserId(_ userId: String) async -> Result<String?, MemberDetailProviderError> {
-        guard let roomProxy = roomProxy else {
+        if let displayName = displayNameForUserId(userId) {
-            return
+            return .success(displayName)
         }
         
-        if let avatarURL = displayNameForUserId(userId) {
+        switch await roomProxy.loadDisplayNameForUserId(userId) {
-            completion(.success(avatarURL))
-        }
-        
-        roomProxy.displayNameForUserId(userId, completion: { [weak self] result in
-            guard let self = self else {
-                return
-            }
-            
-            switch result {
         case .success(let displayName):
-                self.memberDisplayNames[userId] = displayName
+            memberDisplayNames[userId] = displayName
-                completion(.success(displayName))
+            return .success(displayName)
         case .failure:
-                completion(.failure(.failedRetrievingUserDisplayName))
+            return .failure(.failedRetrievingUserDisplayName)
         }
-        })
     }
 }

ElementX/Sources/Services/Room/Members/MemberDetailsProviderProtocol.swift

@@ -16,8 +16,8 @@ enum MemberDetailProviderError: Error {
 
 protocol MemberDetailProviderProtocol {
     func avatarURLForUserId(_ userId: String) -> String?
-    func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, MemberDetailProviderError>) -> Void)
+    func loadAvatarURLForUserId(_ userId: String) async -> Result<String?, MemberDetailProviderError>
     
     func displayNameForUserId(_ userId: String) -> String?
-    func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, MemberDetailProviderError>) -> Void)
+    func loadDisplayNameForUserId(_ userId: String) async -> Result<String?, MemberDetailProviderError>
 }

ElementX/Sources/Services/Room/MockRoomProxy.swift

@@ -27,27 +27,27 @@ struct MockRoomProxy: RoomProxyProtocol {
     
     var callbacks = PassthroughSubject<RoomProxyCallback, Never>()
     
-    func displayName(_ completion: @escaping (Result<String, RoomProxyError>) -> Void) {
+    func loadDisplayNameForUserId(_ userId: String) async -> Result<String?, RoomProxyError> {
-        completion(.success("Room display name"))
+        return .failure(.failedRetrievingMemberDisplayName)
+    }
+    
+    func loadAvatarURLForUserId(_ userId: String) async -> Result<String?, RoomProxyError> {
+        return .failure(.failedRetrievingMemberAvatarURL)
+    }
+    
+    func loadDisplayName() async -> Result<String, RoomProxyError> {
+        return .failure(.failedRetrievingDisplayName)
     }
     
     func startLiveEventListener() {
         
     }
     
-    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
+    func paginateBackwards(count: UInt) async -> Result<Void, RoomProxyError> {
-        
+        return .failure(.backwardStreamNotAvailable)
     }
         
-    func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
+    func sendMessage(_ message: String) async -> Result<Void, RoomProxyError> {
-        
+        return .failure(.failedSendingMessage)
-    }
-    
-    func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
-        
-    }
-    
-    func sendMessage(_ message: String, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
-        
     }
 }

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -21,19 +21,14 @@ private class WeakRoomProxyWrapper: RoomDelegate {
     // MARK: - RoomDelegate
     
     func didReceiveMessage(message: AnyMessage) {
-        DispatchQueue.main.async {
         self.roomProxy?.appendMessage(message)
     }
-    }
 }
 
 class RoomProxy: RoomProxyProtocol {
     private let room: Room
     private let messageFactory: RoomMessageFactory
     
-    private let generalProcessingQueue: DispatchQueue
-    private let messageProcessingQueue: DispatchQueue
-    
     private var backwardStream: BackwardsStreamProtocol?
     
     private(set) var displayName: String?
@@ -45,18 +40,13 @@ class RoomProxy: RoomProxyProtocol {
     init(room: Room, messageFactory: RoomMessageFactory) {
         self.room = room
         self.messageFactory = messageFactory
-        generalProcessingQueue = DispatchQueue(label: "RoomProxyGeneralProcessingQueue")
-        messageProcessingQueue = DispatchQueue(label: "RoomProxyMessageProcessingQueue")
         messages = []
         
-        messageProcessingQueue.async {
-            let backwardStream = room.startLiveEventListener()
-            DispatchQueue.main.async {
-                self.backwardStream = backwardStream
-            }
-        }
-        
         room.setDelegate(delegate: WeakRoomProxyWrapper(roomProxy: self))
+        
+        Task {
+            backwardStream = room.startLiveEventListener()
+        }
     }
     
     var id: String {
@@ -95,66 +85,50 @@ class RoomProxy: RoomProxyProtocol {
         room.avatarUrl()
     }
     
-    func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
+    func loadAvatarURLForUserId(_ userId: String) async -> Result<String?, RoomProxyError> {
-        generalProcessingQueue.async {
+        await withCheckedContinuation({ continuation in
             do {
                 let avatarURL = try self.room.memberAvatarUrl(userId: userId)
-                
+                continuation.resume(returning: .success(avatarURL))
-                DispatchQueue.main.async {
-                    completion(.success(avatarURL))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedRetrievingMemberAvatarURL))
-                    completion(.failure(RoomProxyError.failedRetrievingMemberAvatarURL))
-                }
-            }
             }
+        })
     }
     
-    func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
+    func loadDisplayNameForUserId(_ userId: String) async -> Result<String?, RoomProxyError> {
-        generalProcessingQueue.async {
+        await withCheckedContinuation({ continuation in
             do {
                 let displayName = try self.room.memberDisplayName(userId: userId)
-
+                continuation.resume(returning: .success(displayName))
-                DispatchQueue.main.async {
-                    completion(.success(displayName))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedRetrievingMemberDisplayName))
-                    completion(.failure(RoomProxyError.failedRetrievingMemberDisplayName))
-                }
-            }
             }
+        })
     }
         
-    func displayName(_ completion: @escaping (Result<String, RoomProxyError>) -> Void) {
+    func loadDisplayName() async -> Result<String, RoomProxyError> {
+        await withCheckedContinuation({ continuation in
             if let displayName = displayName {
-            completion(.success(displayName))
+                continuation.resume(returning: .success(displayName))
                 return
             }
             
-        generalProcessingQueue.async {
             do {
                 let displayName = try self.room.displayName()
                 self.displayName = displayName
                 
-                DispatchQueue.main.async {
+                continuation.resume(returning: .success(displayName))
-                    completion(.success(displayName))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedRetrievingDisplayName))
-                    completion(.failure(.failedRetrievingDisplayName))
-                }
-            }
             }
+        })
     }
     
-    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
+    func paginateBackwards(count: UInt) async -> Result<Void, RoomProxyError> {
-        messageProcessingQueue.async {
+        await withCheckedContinuation { continuation in
             guard let backwardStream = self.backwardStream else {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.backwardStreamNotAvailable))
-                    callback?(.failure(.backwardStreamNotAvailable))
-                }
                 return
             }
             
@@ -166,28 +140,22 @@ class RoomProxy: RoomProxyProtocol {
                 self.messageFactory.buildRoomMessageFrom(message)
             }.reversed()
             
-            DispatchQueue.main.async {
             self.messages.insert(contentsOf: messages, at: 0)
-                callback?(.success(()))
+            
-            }
+            continuation.resume(returning: .success(()))
         }
     }
     
-    func sendMessage(_ message: String, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
+    func sendMessage(_ message: String) async -> Result<Void, RoomProxyError> {
         let messageContent = messageEventContentFromMarkdown(md: message)
         let transactionId = genTransactionId()
         
-        messageProcessingQueue.async {
+        return await withCheckedContinuation { continuation in
             do {
                 try self.room.send(msg: messageContent, txnId: transactionId)
-                
+                continuation.resume(returning: .success(()))
-                DispatchQueue.main.async {
-                    callback?(.success(()))
-                }
             } catch {
-                DispatchQueue.main.async {
+                continuation.resume(returning: .failure(.failedSendingMessage))
-                    callback?(.failure(.failedSendingMessage))
-                }
             }
         }
     }

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -37,15 +37,15 @@ protocol RoomProxyProtocol {
     
     var avatarURL: String? { get }
     
-    func displayName(_ completion: @escaping (Result<String, RoomProxyError>) -> Void)
+    func loadAvatarURLForUserId(_ userId: String) async -> Result<String?, RoomProxyError>
     
-    func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void)
+    func loadDisplayNameForUserId(_ userId: String) async -> Result<String?, RoomProxyError>
     
-    func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void)
+    func loadDisplayName() async -> Result<String, RoomProxyError>
     
-    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?)
+    func paginateBackwards(count: UInt) async -> Result<Void, RoomProxyError>
     
-    func sendMessage(_ message: String, callback: ((Result<Void, RoomProxyError>) -> Void)?)
+    func sendMessage(_ message: String) async -> Result<Void, RoomProxyError>
     
     var callbacks: PassthroughSubject<RoomProxyCallback, Never> { get }
 }

ElementX/Sources/Services/Room/RoomSummary/EventBriefFactory.swift

@@ -16,21 +16,20 @@ struct EventBriefFactory: EventBriefFactoryProtocol {
         self.memberDetailProvider = memberDetailProvider
     }
     
-    func eventBriefForMessage(_ message: RoomMessageProtocol?, completion: @escaping ((EventBrief?) -> Void)) {
+    func eventBriefForMessage(_ message: RoomMessageProtocol?) async -> EventBrief? {
         guard let message = message else {
-            completion(nil)
+            return nil
-            return
         }
         
         switch message {
         case is ImageRoomMessage:
-            completion(nil)
+            return nil
         case let message as TextRoomMessage:
-            buildEventBrief(message: message, htmlBody: message.htmlBody, completion: completion)
+            return await buildEventBrief(message: message, htmlBody: message.htmlBody)
         case let message as NoticeRoomMessage:
-            buildEventBrief(message: message, htmlBody: message.htmlBody, completion: completion)
+            return await buildEventBrief(message: message, htmlBody: message.htmlBody)
         case let message as EmoteRoomMessage:
-            buildEventBrief(message: message, htmlBody: message.htmlBody, completion: completion)
+            return await buildEventBrief(message: message, htmlBody: message.htmlBody)
         default:
             fatalError("Unknown room message.")
         }
@@ -38,26 +37,24 @@ struct EventBriefFactory: EventBriefFactoryProtocol {
     
     // MARK: - Private
     
-    private func buildEventBrief(message: RoomMessageProtocol, htmlBody: String?, completion: @escaping ((EventBrief?) -> Void)) {
+    private func buildEventBrief(message: RoomMessageProtocol, htmlBody: String?) async ->  EventBrief? {
-        memberDetailProvider.displayNameForUserId(message.sender) { result in
+        switch await memberDetailProvider.loadDisplayNameForUserId(message.sender) {
-            switch result {
         case .success(let displayName):
-                completion(EventBrief(eventId: message.id,
+            return EventBrief(eventId: message.id,
                               senderId: message.sender,
                               senderDisplayName: displayName,
                               body: message.body,
                               htmlBody: htmlBody,
-                                      date: message.originServerTs))
+                              date: message.originServerTs)
         case .failure(let error):
             MXLog.error("Failed fetching sender display name with error: \(error)")
             
-                completion(EventBrief(eventId: message.id,
+            return EventBrief(eventId: message.id,
                               senderId: message.sender,
                               senderDisplayName: nil,
                               body: message.body,
                               htmlBody: htmlBody,
-                                      date: message.originServerTs))
+                              date: message.originServerTs)
-            }
         }
     }
 }

ElementX/Sources/Services/Room/RoomSummary/EventBriefFactoryProtocol.swift

@@ -9,5 +9,5 @@
 import Foundation
 
 protocol EventBriefFactoryProtocol {
-    func eventBriefForMessage(_ message: RoomMessageProtocol?, completion: @escaping ((EventBrief?) -> Void))
+    func eventBriefForMessage(_ message: RoomMessageProtocol?) async -> EventBrief?
 }

ElementX/Sources/Services/Room/RoomSummary/MockRoomSummary.swift

@@ -30,7 +30,7 @@ struct MockRoomSummary: RoomSummaryProtocol {
     
     var avatar: UIImage?
     
-    func loadData() {
+    func loadDetails() {
         
     }
     

ElementX/Sources/Services/Room/RoomSummary/RoomSummary.swift

@@ -71,81 +71,81 @@ class RoomSummary: RoomSummaryProtocol {
         self.mediaProvider = mediaProvider
         self.eventBriefFactory = eventBriefFactory
         
-        eventBriefFactory.eventBriefForMessage(roomProxy.messages.last) { [weak self] result in
+        Task {
-            self?.lastMessage = result
+            lastMessage = await eventBriefFactory.eventBriefForMessage(roomProxy.messages.last)
         }
         
-        roomProxy.callbacks.sink { [weak self] callback in
+        roomProxy.callbacks
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] callback in
                 guard let self = self else {
                     return
                 }
                 
                 switch callback {
                 case .updatedMessages:
-                self.eventBriefFactory.eventBriefForMessage(self.roomProxy.messages.last) { [weak self] result in
+                    Task {
-                    self?.lastMessage = result
+                        self.lastMessage = await eventBriefFactory.eventBriefForMessage(roomProxy.messages.last)
                     }
                 }
             }
             .store(in: &roomUpdateListeners)
     }
     
-    func loadData() {
+    func loadDetails() async {
         if hasLoadedData {
             return
         }
         
-        loadDisplayName()
+        await withTaskGroup(of: Void.self) { group in
-        loadLastMessage()
+            group.addTask {
-        loadAvatar()
+                await self.loadDisplayName()
+            }
+            group.addTask {
+                await self.loadAvatar()
+            }
+            group.addTask {
+                await self.loadLastMessage()
+            }
+        }
         
         hasLoadedData = true
     }
     
     // MARK: - Private
     
-    private func loadDisplayName() {
+    private func loadDisplayName() async {
-        roomProxy.displayName { [weak self] result in
+        switch await roomProxy.loadDisplayName() {
-            guard let self = self else { return }
-            
-            switch result {
         case .success(let displayName):
             self.displayName = displayName
         case .failure(let error):
             MXLog.error("Failed fetching room display name with error: \(error)")
         }
     }
+    
+    private func loadAvatar() async {
+        guard let avatarURL = roomProxy.avatarURL else {
+            return
         }
         
-    private func loadLastMessage() {
+        switch await mediaProvider.loadImageFromURL(avatarURL) {
-        if roomProxy.messages.last == nil {
+        case .success(let avatar):
-            roomProxy.paginateBackwards(count: 1) { [weak self] result in
+            self.avatar = avatar
-                guard let self = self else { return }
-                
-                switch result {
-                case .success:
-                    self.eventBriefFactory.eventBriefForMessage(self.roomProxy.messages.last) { [weak self] result in
-                        self?.lastMessage = result
-                    }
-                case .failure(let error):
-                    MXLog.error("Failed back paginating with error: \(error)")
-                }
-            }
-        }
-    }
-    
-    private func loadAvatar() {
-        if let avatarURL = roomProxy.avatarURL {
-            mediaProvider.loadImageFromURL(avatarURL) { [weak self] result in
-                guard let self = self else { return }
-                
-                switch result {
-                case .success(let image):
-                    self.avatar = image
         case .failure(let error):
             MXLog.error("Failed fetching room avatar with error: \(error)")
         }
     }
+    
+    private func loadLastMessage() async {
+        guard roomProxy.messages.last == nil else {
+            return
+        }
+        
+        switch await roomProxy.paginateBackwards(count: 1) {
+        case .success:
+            self.lastMessage = await self.eventBriefFactory.eventBriefForMessage(self.roomProxy.messages.last)
+        case .failure(let error):
+            MXLog.error("Failed back paginating with error: \(error)")
         }
     }
 }

ElementX/Sources/Services/Room/RoomSummary/RoomSummaryProtocol.swift

@@ -28,5 +28,5 @@ protocol RoomSummaryProtocol {
     
     var callbacks: PassthroughSubject<RoomSummaryCallback, Never> { get }
     
-    func loadData()
+    func loadDetails() async
 }

ElementX/Sources/Services/Timeline/MockRoomTimelineController.swift

@@ -19,19 +19,19 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
                                                      SeparatorRoomTimelineItem(id: UUID().uuidString, text: "Today"),
                                                      TextRoomTimelineItem(id: UUID().uuidString, text: "You too!", timestamp: "5 PM", shouldShowSenderDetails: true, senderId: "Bob")]
     
-    func paginateBackwards(_ count: UInt, callback: ((Result<Void, RoomTimelineControllerError>) -> Void)) {
+    func paginateBackwards(_ count: UInt) async -> Result<Void, RoomTimelineControllerError> {
-        callbacks.send(.updatedTimelineItems)
+        return .failure(.generic)
     }
     
-    func processItemAppearance(_ itemId: String) {
+    func processItemAppearance(_ itemId: String) async {
         
     }
     
-    func processItemDisappearance(_ itemId: String) {
+    func processItemDisappearance(_ itemId: String) async {
         
     }
     
-    func sendMessage(_ message: String) {
+    func sendMessage(_ message: String) async {
         
     }
 }

ElementX/Sources/Services/Timeline/RoomTimelineController.swift

@@ -45,31 +45,29 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         NotificationCenter.default.addObserver(self, selector: #selector(contentSizeCategoryDidChange), name: UIContentSizeCategory.didChangeNotification, object: nil)
     }
     
-    func paginateBackwards(_ count: UInt, callback: @escaping ((Result<Void, RoomTimelineControllerError>) -> Void)) {
+    func paginateBackwards(_ count: UInt) async -> Result<Void, RoomTimelineControllerError> {
-        timelineProvider.paginateBackwards(count) { [weak self] result in
+        switch await timelineProvider.paginateBackwards(count) {
-            switch result {
         case .success:
-                callback(.success(()))
+            updateTimelineItems()
-                self?.updateTimelineItems()
+            return .success(())
         case .failure:
-                callback(.failure(.generic))
+            return .failure(.generic)
-            }
         }
     }
     
-    func processItemAppearance(_ itemId: String) {
+    func processItemAppearance(_ itemId: String) async {
         guard let timelineItem = self.timelineItems.filter({ $0.id == itemId}).first else {
             return
         }
         
         if let item = timelineItem as? EventBasedTimelineItemProtocol {
-            loadUserAvatarForTimelineItem(item)
+            await loadUserAvatarForTimelineItem(item)
-            loadUserDisplayNameForTimelineItem(item)
+            await loadUserDisplayNameForTimelineItem(item)
         }
                 
         switch timelineItem {
         case let item as ImageRoomTimelineItem:
-            loadImageForTimelineItem(item)
+            await loadImageForTimelineItem(item)
         default:
             break
         }
@@ -79,8 +77,13 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         
     }
     
-    func sendMessage(_ message: String) {
+    func sendMessage(_ message: String) async {
-        timelineProvider.sendMessage(message)
+        switch await timelineProvider.sendMessage(message) {
+        case .success:
+            break
+        case .failure:
+            break
+        }
     }
     
     // MARK: - Private
@@ -124,7 +127,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         return Calendar.current.isDate(lhs.originServerTs, inSameDayAs: rhs.originServerTs)
     }
     
-    private func loadImageForTimelineItem(_ timelineItem: ImageRoomTimelineItem) {
+    private func loadImageForTimelineItem(_ timelineItem: ImageRoomTimelineItem) async {
         if timelineItem.image != nil {
             return
         }
@@ -133,12 +136,8 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             return
         }
         
-        mediaProvider.loadImageFromSource(source) { [weak self] result in
+        switch await mediaProvider.loadImageFromSource(source) {
-            guard let self = self else {
+        case .success(let image):
-                return
-            }
-            
-            if case let .success(image) = result {
             guard let index = self.timelineItems.firstIndex(where: { $0.id == timelineItem.id }),
                   var item = self.timelineItems[index] as? ImageRoomTimelineItem else {
                 return
@@ -147,43 +146,50 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             item.image = image
             self.timelineItems[index] = item
             self.callbacks.send(.updatedTimelineItem(timelineItem.id))
-            }
+        case .failure:
+            break
         }
     }
     
-    private func loadUserAvatarForTimelineItem(_ timelineItem: EventBasedTimelineItemProtocol) {
+    private func loadUserAvatarForTimelineItem(_ timelineItem: EventBasedTimelineItemProtocol) async {
         if timelineItem.shouldShowSenderDetails == false {
             return
         }
         
-        memberDetailProvider.avatarURLForUserId(timelineItem.senderId) { result in
+        switch await memberDetailProvider.loadAvatarURLForUserId(timelineItem.senderId) {
-            if case let .success(avatarURL) = result,
+        case .success(let avatarURL):
-               let avatarURL = avatarURL {
+            guard let avatarURL = avatarURL else {
-                self.mediaProvider.loadImageFromURL(avatarURL) { result in
+                return
-                    if case let .success(image) = result {
+            }
+            
+            switch await mediaProvider.loadImageFromURL(avatarURL) {
+            case .success(let avatar):
                 guard let index = self.timelineItems.firstIndex(where: { $0.id == timelineItem.id }),
                       var item = self.timelineItems[index] as? EventBasedTimelineItemProtocol else {
                     return
                 }
                 
-                        item.senderAvatar = image
+                item.senderAvatar = avatar
                 self.timelineItems[index] = item
                 self.callbacks.send(.updatedTimelineItem(timelineItem.id))
+            case .failure:
+                break
             }
-                }
+            
-            }
+        case .failure:
+            break
         }
     }
     
-    private func loadUserDisplayNameForTimelineItem(_ timelineItem: EventBasedTimelineItemProtocol) {
+    private func loadUserDisplayNameForTimelineItem(_ timelineItem: EventBasedTimelineItemProtocol) async {
         if timelineItem.shouldShowSenderDetails == false {
             return
         }
         
-        memberDetailProvider.displayNameForUserId(timelineItem.senderId) { result in
+        switch await memberDetailProvider.loadDisplayNameForUserId(timelineItem.senderId) {
-            if case let .success(displayName) = result,
+        case .success(let displayName):
-               let displayName = displayName {
+            guard let displayName = displayName,
-                guard let index = self.timelineItems.firstIndex(where: { $0.id == timelineItem.id }),
+                  let index = self.timelineItems.firstIndex(where: { $0.id == timelineItem.id }),
                   var item = self.timelineItems[index] as? EventBasedTimelineItemProtocol else {
                 return
             }
@@ -191,7 +197,8 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             item.senderDisplayName = displayName
             self.timelineItems[index] = item
             self.callbacks.send(.updatedTimelineItem(timelineItem.id))
-            }
+        case .failure:
+            break
         }
     }
 }

ElementX/Sources/Services/Timeline/RoomTimelineControllerProtocol.swift

@@ -22,11 +22,11 @@ protocol RoomTimelineControllerProtocol {
     var timelineItems: [RoomTimelineItemProtocol] { get }
     var callbacks: PassthroughSubject<RoomTimelineControllerCallback, Never> { get }
     
-    func paginateBackwards(_ count: UInt, callback: @escaping ((Result<Void, RoomTimelineControllerError>) -> Void))
+    func processItemAppearance(_ itemId: String) async
     
-    func processItemAppearance(_ itemId: String)
+    func processItemDisappearance(_ itemId: String) async
     
-    func processItemDisappearance(_ itemId: String)
+    func paginateBackwards(_ count: UInt) async -> Result<Void, RoomTimelineControllerError>
     
-    func sendMessage(_ message: String)
+    func sendMessage(_ message: String) async
 }

ElementX/Sources/Services/Timeline/RoomTimelineProvider.swift

@@ -13,7 +13,7 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
     private let roomProxy: RoomProxyProtocol
     private var cancellables = Set<AnyCancellable>()
     
-    let callbacks = PassthroughSubject<RoomTimelineCallback, Never>()
+    let callbacks = PassthroughSubject<RoomTimelineProviderCallback, Never>()
     
     init(roomProxy: RoomProxyProtocol) {
         self.roomProxy = roomProxy
@@ -32,25 +32,21 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
         roomProxy.messages
     }
     
-    func paginateBackwards(_ count: UInt, callback: ((Result<Void, RoomTimelineError>) -> Void)?) {
+    func paginateBackwards(_ count: UInt) async -> Result<Void, RoomTimelineProviderError> {
-        self.roomProxy.paginateBackwards(count: count) { result in
+        switch await roomProxy.paginateBackwards(count: count) {
-            switch result {
         case .success:
-                callback?(.success(()))
+            return .success(())
         case .failure:
-                callback?(.failure(.generic))
+            return .failure(.generic)
-            }
         }
     }
     
-    func sendMessage(_ message: String) {
+    func sendMessage(_ message: String) async -> Result<Void, RoomTimelineProviderError> {
-        roomProxy.sendMessage(message) { result in
+        switch await roomProxy.sendMessage(message) {
-            switch result {
         case .success:
-                break
+            return .success(())
-            case .failure(let error):
+        case .failure:
-                MXLog.error("Failed sending message with error: \(error)")
+            return .failure(.failedSendingMessage)
-            }
         }
     }
 }

ElementX/Sources/Services/Timeline/RoomTimelineProviderProtocol.swift

@@ -9,20 +9,21 @@
 import Foundation
 import Combine
 
-enum RoomTimelineCallback {
+enum RoomTimelineProviderCallback {
     case updatedMessages
 }
 
-enum RoomTimelineError: Error {
+enum RoomTimelineProviderError: Error {
+    case failedSendingMessage
     case generic
 }
 
 protocol RoomTimelineProviderProtocol {
-    var callbacks: PassthroughSubject<RoomTimelineCallback, Never> { get }
+    var callbacks: PassthroughSubject<RoomTimelineProviderCallback, Never> { get }
     
     var messages: [RoomMessageProtocol] { get }
     
-    func paginateBackwards(_ count: UInt, callback: ((Result<Void, RoomTimelineError>) -> Void)?)
+    func paginateBackwards(_ count: UInt) async -> Result<Void, RoomTimelineProviderError>
     
-    func sendMessage(_ message: String)
+    func sendMessage(_ message: String) async ->  Result<Void, RoomTimelineProviderError>
 }