ehealthsolutions/element-x-ios
3
0
Fork 0
mirror of https://github.com/Novaloop-AG/element-x-ios.git synced 2026-11-05 03:48:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Room list service (#1138)

Browse Source 
* Adopt the new RoomListService

* Use client.roomListWithEncryption

* Store the roomList so that it doesn't get dropped and create problems on the rust side

* Use roomListService instead of old roomList client method

* Added back documentation removed by mistake

* Tweaks following code review, SDK bump
This commit is contained in:
Stefan Ceriu
2023-06-22 19:59:32 +03:00
committed by GitHub
parent 6018221e1e
commit 652fd3cf76
12 changed files with 109 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ElementX/Sources/Services/Client/ClientProxy.swift
+15 -13
View File
@@ -26,7 +26,7 @@ class ClientProxy: ClientProxyProtocol {
private let mediaLoader: MediaLoaderProtocol
private let clientQueue: DispatchQueue
private var roomListService: RoomList?
private var roomListService: RoomListService?
private var roomListStateUpdateTaskHandle: TaskHandle?
var roomSummaryProvider: RoomSummaryProviderProtocol?
@@ -227,8 +227,8 @@ class ClientProxy: ClientProxyProtocol {
return nil
}
if roomSummaryProvider.statePublisher.value != .fullyLoaded {
_ = await roomSummaryProvider.statePublisher.values.first(where: { $0 == .fullyLoaded })
if !roomSummaryProvider.statePublisher.value.isLoaded {
_ = await roomSummaryProvider.statePublisher.values.first(where: { $0.isLoaded })
}
(roomListItem, room) = await Task.dispatch(on: clientQueue) {
@@ -366,7 +366,7 @@ class ClientProxy: ClientProxyProtocol {
}
do {
let roomListService = try client.roomList()
let roomListService = try client.roomListServiceWithEncryption()
roomListStateUpdateTaskHandle = roomListService.state(listener: RoomListStateListenerProxy { [weak self] state in
guard let self else { return }
MXLog.info("Received room list update: \(state)")
@@ -379,9 +379,12 @@ class ClientProxy: ClientProxyProtocol {
// The invites are available only when entering `running`
if state == .running {
Task {
// Subscribe to invites later as the underlying SlidingSync list is only added when entering AllRooms
await self.inviteSummaryProvider?.subscribeIfNecessary(entriesFunction: roomListService.invites(listener:),
entriesLoadingStateFunction: nil)
do {
// Subscribe to invites later as the underlying SlidingSync list is only added when entering AllRooms
try await self.inviteSummaryProvider?.setRoomList(roomListService.invites())
} catch {
MXLog.error("Failed configuring invites room list with error: \(error)")
}
}
}
@@ -397,8 +400,7 @@ class ClientProxy: ClientProxyProtocol {
eventStringBuilder: RoomEventStringBuilder(stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID)),
name: "AllRooms")
await roomSummaryProvider?.subscribeIfNecessary(entriesFunction: roomListService.entries(listener:),
entriesLoadingStateFunction: roomListService.entriesLoadingState(listener:))
try await roomSummaryProvider?.setRoomList(roomListService.allRooms())
inviteSummaryProvider = RoomSummaryProvider(roomListService: roomListService,
eventStringBuilder: RoomEventStringBuilder(stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID)),
@@ -437,14 +439,14 @@ extension ClientProxy: MediaLoaderProtocol {
}
}
private class RoomListStateListenerProxy: RoomListStateListener {
private let onUpdateClosure: (RoomListState) -> Void
private class RoomListStateListenerProxy: RoomListServiceStateListener {
private let onUpdateClosure: (RoomListServiceState) -> Void
init(_ onUpdateClosure: @escaping (RoomListState) -> Void) {
init(_ onUpdateClosure: @escaping (RoomListServiceState) -> Void) {
self.onUpdateClosure = onUpdateClosure
}
func onUpdate(state: RoomListState) {
func onUpdate(state: RoomListServiceState) {
onUpdateClosure(state)
}
}
ElementX/Sources/Services/Room/RoomSummary/MockRoomSummaryProvider.swift
+2 -3
View File
@@ -38,12 +38,11 @@ class MockRoomSummaryProvider: RoomSummaryProviderProtocol {
statePublisher = .init(.notLoaded)
case .loaded(let rooms):
roomListPublisher = .init(rooms)
statePublisher = .init(.fullyLoaded)
statePublisher = .init(.loaded(totalNumberOfRooms: UInt(rooms.count)))
}
}
func subscribeIfNecessary(entriesFunction: EntriesFunction,
entriesLoadingStateFunction: LoadingStateFunction?) async { }
func setRoomList(_ roomList: RoomList) { }
func updateVisibleRange(_ range: Range<Int>) { }
}
ElementX/Sources/Services/Room/RoomSummary/RoomSummaryProvider.swift
+27 -31
View File
@@ -19,12 +19,14 @@ import Foundation
import MatrixRustSDK
class RoomSummaryProvider: RoomSummaryProviderProtocol {
private let roomListService: RoomListProtocol
private let roomListService: RoomListServiceProtocol
private let eventStringBuilder: RoomEventStringBuilder
private let name: String
private let serialDispatchQueue: DispatchQueue
private var roomList: RoomListProtocol?
private var cancellables = Set<AnyCancellable>()
private var listUpdatesTaskHandle: TaskHandle?
private var stateUpdatesTaskHandle: TaskHandle?
@@ -49,7 +51,7 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
}
}
init(roomListService: RoomListProtocol,
init(roomListService: RoomListServiceProtocol,
eventStringBuilder: RoomEventStringBuilder,
name: String) {
self.roomListService = roomListService
@@ -63,37 +65,35 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
.store(in: &cancellables)
}
func subscribeIfNecessary(entriesFunction: EntriesFunction,
entriesLoadingStateFunction: LoadingStateFunction?) async {
func setRoomList(_ roomList: RoomList) {
guard listUpdatesTaskHandle == nil, stateUpdatesTaskHandle == nil else {
return
}
self.roomList = roomList
do {
let listUpdatesSubscriptionResult = try await entriesFunction(RoomListEntriesListenerProxy { [weak self] update in
let listUpdatesSubscriptionResult = try roomList.entries(listener: RoomListEntriesListenerProxy { [weak self] update in
guard let self else { return }
MXLog.verbose("\(name): Received list update")
diffPublisher.send(update)
})
listUpdatesTaskHandle = listUpdatesSubscriptionResult.entriesStream
rooms = listUpdatesSubscriptionResult.entries.map { roomListEntry in
buildSummaryForRoomListEntry(roomListEntry)
}
if let entriesLoadingStateFunction {
let stateUpdatesSubscriptionResult = try await entriesLoadingStateFunction(RoomListStateObserver { [weak self] state in
guard let self else { return }
MXLog.info("\(name): Received state update: \(state)")
stateSubject.send(RoomSummaryProviderState(slidingSyncState: state))
})
stateSubject.send(RoomSummaryProviderState(slidingSyncState: stateUpdatesSubscriptionResult.entriesLoadingState))
stateUpdatesTaskHandle = stateUpdatesSubscriptionResult.entriesLoadingStateStream
}
let stateUpdatesSubscriptionResult = try roomList.loadingState(listener: RoomListStateObserver { [weak self] state in
guard let self else { return }
MXLog.info("\(name): Received state update: \(state)")
stateSubject.send(RoomSummaryProviderState(roomListState: state))
})
stateUpdatesTaskHandle = stateUpdatesSubscriptionResult.stateStream
stateSubject.send(RoomSummaryProviderState(roomListState: stateUpdatesSubscriptionResult.state))
} catch {
MXLog.error("Failed setting up room list entry listener with error: \(error)")
}
@@ -266,16 +266,12 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
}
extension RoomSummaryProviderState {
init(slidingSyncState: SlidingSyncListLoadingState) {
switch slidingSyncState {
init(roomListState: RoomListLoadingState) {
switch roomListState {
case .notLoaded:
self = .notLoaded
case .preloaded:
self = .preloaded
case .partiallyLoaded:
self = .partiallyLoaded
case .fullyLoaded:
self = .fullyLoaded
case .loaded(let maximumNumberOfRooms):
self = .loaded(totalNumberOfRooms: UInt(maximumNumberOfRooms ?? 0))
}
}
}
@@ -314,14 +310,14 @@ private class RoomListEntriesListenerProxy: RoomListEntriesListener {
}
}
private class RoomListStateObserver: SlidingSyncListStateObserver {
private let onUpdateClosure: (SlidingSyncListLoadingState) -> Void
private class RoomListStateObserver: RoomListLoadingStateListener {
private let onUpdateClosure: (RoomListLoadingState) -> Void
init(_ onUpdateClosure: @escaping (SlidingSyncListLoadingState) -> Void) {
init(_ onUpdateClosure: @escaping (RoomListLoadingState) -> Void) {
self.onUpdateClosure = onUpdateClosure
}
func didReceiveUpdate(newState: SlidingSyncListLoadingState) {
onUpdateClosure(newState)
func onUpdate(state: RoomListLoadingState) {
onUpdateClosure(state)
}
}
ElementX/Sources/Services/Room/RoomSummary/RoomSummaryProviderProtocol.swift
+21 -9
View File
@@ -20,9 +20,25 @@ import MatrixRustSDK
enum RoomSummaryProviderState {
case notLoaded
case preloaded
case partiallyLoaded
case fullyLoaded
case loaded(totalNumberOfRooms: UInt)
var isLoaded: Bool {
switch self {
case .loaded:
return true
default:
return false
}
}
var totalNumberOfRooms: UInt? {
switch self {
case .loaded(let totalNumberOfRooms):
return totalNumberOfRooms
default:
return nil
}
}
}
enum RoomSummary: CustomStringConvertible {
@@ -61,19 +77,15 @@ enum RoomSummary: CustomStringConvertible {
}
protocol RoomSummaryProviderProtocol {
typealias EntriesFunction = (RoomListEntriesListener) async throws -> RoomListEntriesResult
typealias LoadingStateFunction = (SlidingSyncListStateObserver) async throws -> RoomListEntriesLoadingStateResult
/// Publishes the currently available room summaries
var roomListPublisher: CurrentValuePublisher<[RoomSummary], Never> { get }
/// Publishes the current state the summary provider is finding itself in
var statePublisher: CurrentValuePublisher<RoomSummaryProviderState, Never> { get }
/// A separate subscription method is needed instead of running this in the constructor because the invites list is added later on the Rust side.
/// This is outside of the constructor because the invites list is added later on the Rust side.
/// Wanted to be able to build the InvitesSummaryProvider directly instead of having to inform the HomeScreenViewModel about it later
func subscribeIfNecessary(entriesFunction: EntriesFunction,
entriesLoadingStateFunction: LoadingStateFunction?) async
func setRoomList(_ roomList: RoomList)
func updateVisibleRange(_ range: Range<Int>)
}