Let MatrixClient exposes val instead of fun for the services.

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/MatrixClient.kt

@@ -49,9 +49,18 @@ interface MatrixClient {
     val userProfile: StateFlow<MatrixUser>
     val roomListService: RoomListService
     val spaceService: SpaceService
+    val syncService: SyncService
+    val sessionVerificationService: SessionVerificationService
+    val pushersService: PushersService
+    val notificationService: NotificationService
+    val notificationSettingsService: NotificationSettingsService
+    val encryptionService: EncryptionService
+    val roomDirectoryService: RoomDirectoryService
+    val mediaPreviewService: MediaPreviewService
     val mediaLoader: MatrixMediaLoader
     val sessionCoroutineScope: CoroutineScope
     val ignoredUsersFlow: StateFlow<ImmutableList<UserId>>
+    val roomMembershipObserver: RoomMembershipObserver
     suspend fun getJoinedRoom(roomId: RoomId): JoinedRoom?
     suspend fun getRoom(roomId: RoomId): BaseRoom?
     suspend fun findDM(userId: UserId): Result<RoomId?>
@@ -68,14 +77,6 @@ interface MatrixClient {
     suspend fun joinRoom(roomId: RoomId): Result<RoomInfo?>
     suspend fun joinRoomByIdOrAlias(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>): Result<RoomInfo?>
     suspend fun knockRoom(roomIdOrAlias: RoomIdOrAlias, message: String, serverNames: List<String>): Result<RoomInfo?>
-    fun syncService(): SyncService
-    fun sessionVerificationService(): SessionVerificationService
-    fun pushersService(): PushersService
-    fun notificationService(): NotificationService
-    fun notificationSettingsService(): NotificationSettingsService
-    fun encryptionService(): EncryptionService
-    fun roomDirectoryService(): RoomDirectoryService
-    fun mediaPreviewService(): MediaPreviewService
     suspend fun getCacheSize(): Long
 
     /**
@@ -97,7 +98,6 @@ interface MatrixClient {
     suspend fun getUserProfile(): Result<MatrixUser>
     suspend fun getAccountManagementUrl(action: AccountManagementAction?): Result<String?>
     suspend fun uploadMedia(mimeType: String, data: ByteArray): Result<String>
-    fun roomMembershipObserver(): RoomMembershipObserver
 
     /**
      * Get a room info flow for a given room ID.

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -23,13 +23,8 @@ import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
 import io.element.android.libraries.matrix.api.createroom.RoomPreset
-import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
-import io.element.android.libraries.matrix.api.media.MediaPreviewService
-import io.element.android.libraries.matrix.api.notification.NotificationService
-import io.element.android.libraries.matrix.api.notificationsettings.NotificationSettingsService
 import io.element.android.libraries.matrix.api.oidc.AccountManagementAction
-import io.element.android.libraries.matrix.api.pusher.PushersService
 import io.element.android.libraries.matrix.api.room.BaseRoom
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.JoinedRoom
@@ -39,16 +34,13 @@ import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import io.element.android.libraries.matrix.api.room.join.JoinRule
-import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryService
 import io.element.android.libraries.matrix.api.roomdirectory.RoomVisibility
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.api.spaces.SpaceService
 import io.element.android.libraries.matrix.api.sync.SlidingSyncVersion
-import io.element.android.libraries.matrix.api.sync.SyncService
 import io.element.android.libraries.matrix.api.sync.SyncState
 import io.element.android.libraries.matrix.api.user.MatrixSearchUserResults
 import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.api.verification.SessionVerificationService
 import io.element.android.libraries.matrix.impl.encryption.RustEncryptionService
 import io.element.android.libraries.matrix.impl.exception.mapClientException
 import io.element.android.libraries.matrix.impl.mapper.map
@@ -147,29 +139,29 @@ class RustMatrixClient(
     private val innerRoomListService = innerSyncService.roomListService()
     private val innerSpaceService = innerClient.spaceService()
 
-    private val roomMembershipObserver = RoomMembershipObserver()
+    override val roomMembershipObserver = RoomMembershipObserver()
 
-    private val rustSyncService = RustSyncService(
+    override val syncService = RustSyncService(
         inner = innerSyncService,
         dispatcher = sessionDispatcher,
         sessionCoroutineScope = sessionCoroutineScope
     )
-    private val pushersService = RustPushersService(
+    override val pushersService = RustPushersService(
         client = innerClient,
         dispatchers = dispatchers,
     )
     private val notificationProcessSetup = NotificationProcessSetup.SingleProcess(innerSyncService)
     private val innerNotificationClient = runBlocking { innerClient.notificationClient(notificationProcessSetup) }
-    private val notificationService = RustNotificationService(sessionId, innerNotificationClient, dispatchers, clock)
-    private val notificationSettingsService = RustNotificationSettingsService(innerClient, sessionCoroutineScope, dispatchers)
-    private val encryptionService = RustEncryptionService(
+    override val notificationService = RustNotificationService(sessionId, innerNotificationClient, dispatchers, clock)
+    override val notificationSettingsService = RustNotificationSettingsService(innerClient, sessionCoroutineScope, dispatchers)
+    override val encryptionService = RustEncryptionService(
         client = innerClient,
-        syncService = rustSyncService,
+        syncService = syncService,
         sessionCoroutineScope = sessionCoroutineScope,
         dispatchers = dispatchers,
     )
 
-    private val roomDirectoryService = RustRoomDirectoryService(
+    override val roomDirectoryService = RustRoomDirectoryService(
         client = innerClient,
         sessionDispatcher = sessionDispatcher,
     )
@@ -196,9 +188,9 @@ class RustMatrixClient(
         sessionDispatcher = sessionDispatcher,
     )
 
-    private val verificationService = RustSessionVerificationService(
+    override val sessionVerificationService = RustSessionVerificationService(
         client = innerClient,
-        isSyncServiceReady = rustSyncService.syncState.map { it == SyncState.Running },
+        isSyncServiceReady = syncService.syncState.map { it == SyncState.Running },
         sessionCoroutineScope = sessionCoroutineScope,
     )
 
@@ -227,7 +219,7 @@ class RustMatrixClient(
         innerClient = innerClient,
     )
 
-    private val mediaPreviewService = RustMediaPreviewService(
+    override val mediaPreviewService = RustMediaPreviewService(
         sessionCoroutineScope = sessionCoroutineScope,
         innerClient = innerClient,
         sessionDispatcher = sessionDispatcher,
@@ -538,33 +530,17 @@ class RustMatrixClient(
         }.mapFailure { it.mapClientException() }
     }
 
-    override fun syncService(): SyncService = rustSyncService
-
-    override fun sessionVerificationService(): SessionVerificationService = verificationService
-
-    override fun pushersService(): PushersService = pushersService
-
-    override fun notificationService(): NotificationService = notificationService
-
-    override fun encryptionService(): EncryptionService = encryptionService
-
-    override fun notificationSettingsService(): NotificationSettingsService = notificationSettingsService
-
-    override fun roomDirectoryService(): RoomDirectoryService = roomDirectoryService
-
-    override fun mediaPreviewService(): MediaPreviewService = mediaPreviewService
-
     internal suspend fun destroy() {
         innerNotificationClient.close()
 
         roomFactory.destroy()
-        rustSyncService.destroy()
+        syncService.destroy()
         notificationSettingsService.destroy()
         notificationProcessSetup.destroy()
 
         sessionCoroutineScope.cancel()
         clientDelegateTaskHandle?.cancelAndDestroy()
-        verificationService.destroy()
+        sessionVerificationService.destroy()
 
         sessionDelegate.clearCurrentClient()
         innerRoomListService.close()
@@ -674,8 +650,6 @@ class RustMatrixClient(
         }
     }
 
-    override fun roomMembershipObserver(): RoomMembershipObserver = roomMembershipObserver
-
     override fun getRoomInfoFlow(roomId: RoomId): Flow<Optional<RoomInfo>> {
         return mxCallbackFlow {
             val roomNotFound = innerRoomListService.roomOrNull(roomId.value).use { it == null }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/di/SessionMatrixModule.kt

@@ -21,6 +21,7 @@ import io.element.android.libraries.matrix.api.notificationsettings.Notification
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryService
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
+import io.element.android.libraries.matrix.api.spaces.SpaceService
 import io.element.android.libraries.matrix.api.sync.SyncService
 import io.element.android.libraries.matrix.api.verification.SessionVerificationService
 import kotlinx.coroutines.CoroutineScope
@@ -35,17 +36,17 @@ object SessionMatrixModule {
 
     @Provides
     fun providesSessionVerificationService(matrixClient: MatrixClient): SessionVerificationService {
-        return matrixClient.sessionVerificationService()
+        return matrixClient.sessionVerificationService
     }
 
     @Provides
     fun providesNotificationSettingsService(matrixClient: MatrixClient): NotificationSettingsService {
-        return matrixClient.notificationSettingsService()
+        return matrixClient.notificationSettingsService
     }
 
     @Provides
     fun provideRoomMembershipObserver(matrixClient: MatrixClient): RoomMembershipObserver {
-        return matrixClient.roomMembershipObserver()
+        return matrixClient.roomMembershipObserver
     }
 
     @Provides
@@ -55,12 +56,12 @@ object SessionMatrixModule {
 
     @Provides
     fun providesSyncService(matrixClient: MatrixClient): SyncService {
-        return matrixClient.syncService()
+        return matrixClient.syncService
     }
 
     @Provides
     fun providesEncryptionService(matrixClient: MatrixClient): EncryptionService {
-        return matrixClient.encryptionService()
+        return matrixClient.encryptionService
     }
 
     @Provides
@@ -76,11 +77,16 @@ object SessionMatrixModule {
 
     @Provides
     fun providesRoomDirectoryService(matrixClient: MatrixClient): RoomDirectoryService {
-        return matrixClient.roomDirectoryService()
+        return matrixClient.roomDirectoryService
     }
 
     @Provides
     fun providesMediaPreviewService(matrixClient: MatrixClient): MediaPreviewService {
-        return matrixClient.mediaPreviewService()
+        return matrixClient.mediaPreviewService
+    }
+
+    @Provides
+    fun providesSpaceService(matrixClient: MatrixClient): SpaceService {
+        return matrixClient.spaceService
     }
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/encryption/RustEncryptionService.kt

@@ -46,7 +46,7 @@ import org.matrix.rustcomponents.sdk.BackupUploadState as RustBackupUploadState
 import org.matrix.rustcomponents.sdk.EnableRecoveryProgress as RustEnableRecoveryProgress
 import org.matrix.rustcomponents.sdk.SteadyStateException as RustSteadyStateException
 
-internal class RustEncryptionService(
+class RustEncryptionService(
     client: Client,
     syncService: RustSyncService,
     sessionCoroutineScope: CoroutineScope,

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt

@@ -15,13 +15,9 @@ import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
-import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
 import io.element.android.libraries.matrix.api.media.MediaPreviewService
-import io.element.android.libraries.matrix.api.notification.NotificationService
-import io.element.android.libraries.matrix.api.notificationsettings.NotificationSettingsService
 import io.element.android.libraries.matrix.api.oidc.AccountManagementAction
-import io.element.android.libraries.matrix.api.pusher.PushersService
 import io.element.android.libraries.matrix.api.room.BaseRoom
 import io.element.android.libraries.matrix.api.room.JoinedRoom
 import io.element.android.libraries.matrix.api.room.NotJoinedRoom
@@ -34,7 +30,6 @@ import io.element.android.libraries.matrix.api.spaces.SpaceService
 import io.element.android.libraries.matrix.api.sync.SlidingSyncVersion
 import io.element.android.libraries.matrix.api.user.MatrixSearchUserResults
 import io.element.android.libraries.matrix.api.user.MatrixUser
-import io.element.android.libraries.matrix.api.verification.SessionVerificationService
 import io.element.android.libraries.matrix.test.encryption.FakeEncryptionService
 import io.element.android.libraries.matrix.test.media.FakeMatrixMediaLoader
 import io.element.android.libraries.matrix.test.media.FakeMediaPreviewService
@@ -69,14 +64,15 @@ class FakeMatrixClient(
     override val roomListService: RoomListService = FakeRoomListService(),
     override val spaceService: SpaceService = FakeSpaceService(),
     override val mediaLoader: MatrixMediaLoader = FakeMatrixMediaLoader(),
-    private val sessionVerificationService: FakeSessionVerificationService = FakeSessionVerificationService(),
-    private val pushersService: FakePushersService = FakePushersService(),
-    private val notificationService: FakeNotificationService = FakeNotificationService(),
-    private val notificationSettingsService: FakeNotificationSettingsService = FakeNotificationSettingsService(),
-    private val syncService: FakeSyncService = FakeSyncService(),
-    private val encryptionService: FakeEncryptionService = FakeEncryptionService(),
-    private val roomDirectoryService: RoomDirectoryService = FakeRoomDirectoryService(),
-    private val mediaPreviewService: MediaPreviewService = FakeMediaPreviewService(),
+    override val sessionVerificationService: FakeSessionVerificationService = FakeSessionVerificationService(),
+    override val pushersService: FakePushersService = FakePushersService(),
+    override val notificationService: FakeNotificationService = FakeNotificationService(),
+    override val notificationSettingsService: FakeNotificationSettingsService = FakeNotificationSettingsService(),
+    override val syncService: FakeSyncService = FakeSyncService(),
+    override val encryptionService: FakeEncryptionService = FakeEncryptionService(),
+    override val roomDirectoryService: RoomDirectoryService = FakeRoomDirectoryService(),
+    override val mediaPreviewService: MediaPreviewService = FakeMediaPreviewService(),
+    override val roomMembershipObserver: RoomMembershipObserver = RoomMembershipObserver(),
     private val accountManagementUrlResult: (AccountManagementAction?) -> Result<String?> = { lambdaError() },
     private val resolveRoomAliasResult: (RoomAlias) -> Result<Optional<ResolvedRoomAlias>> = {
         Result.success(
@@ -174,10 +170,6 @@ class FakeMatrixClient(
         return searchUserResults[searchTerm] ?: Result.failure(IllegalStateException("No response defined for $searchTerm"))
     }
 
-    override fun syncService() = syncService
-
-    override fun roomDirectoryService() = roomDirectoryService
-
     override suspend fun getCacheSize(): Long {
         return 0
     }
@@ -238,19 +230,6 @@ class FakeMatrixClient(
         return knockRoomLambda(roomIdOrAlias, message, serverNames)
     }
 
-    override fun sessionVerificationService(): SessionVerificationService = sessionVerificationService
-
-    override fun pushersService(): PushersService = pushersService
-
-    override fun notificationService(): NotificationService = notificationService
-    override fun notificationSettingsService(): NotificationSettingsService = notificationSettingsService
-    override fun encryptionService(): EncryptionService = encryptionService
-    override fun mediaPreviewService(): MediaPreviewService = mediaPreviewService
-
-    override fun roomMembershipObserver(): RoomMembershipObserver {
-        return RoomMembershipObserver()
-    }
-
     // Mocks
 
     fun givenCreateRoomResult(result: Result<RoomId>) {

libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/safety/Avatars.kt

@@ -17,7 +17,7 @@ import io.element.android.libraries.matrix.api.MatrixClient
 @Composable
 fun MatrixClient.rememberHideInvitesAvatar(): State<Boolean> {
     return remember {
-        mediaPreviewService()
+        mediaPreviewService
             .mediaPreviewConfigFlow
             .mapState { config -> config.hideInviteAvatar }
     }.collectAsState()

libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/DefaultPusherSubscriber.kt

@@ -50,7 +50,7 @@ class DefaultPusherSubscriber(
             Timber.tag(loggerTag.value)
                 .d("Unnecessary to register again the same pusher, but do it in case the pusher has been removed from the server")
         }
-        return matrixClient.pushersService()
+        return matrixClient.pushersService
             .setHttpPusher(
                 createHttpPusher(pushKey, gateway, matrixClient.sessionId)
             )
@@ -100,7 +100,7 @@ class DefaultPusherSubscriber(
         gateway: String,
     ): Result<Unit> {
         val userDataStore = userPushStoreFactory.getOrCreate(matrixClient.sessionId)
-        return matrixClient.pushersService()
+        return matrixClient.pushersService
             .unsetHttpPusher(
                 unsetHttpPusherData = UnsetHttpPusherData(
                     pushKey = pushKey,

libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt

@@ -98,7 +98,7 @@ class DefaultNotifiableEventResolver(
         val ids = notificationEventRequests.groupBy { it.roomId }.mapValues { (_, value) -> value.map { it.eventId } }
 
         // TODO this notificationData is not always valid at the moment, sometimes the Rust SDK can't fetch the matching event
-        val notificationsResult = client.notificationService().getNotifications(ids)
+        val notificationsResult = client.notificationService.getNotifications(ids)
 
         if (notificationsResult.isFailure) {
             val exception = notificationsResult.exceptionOrNull()
@@ -131,7 +131,7 @@ class DefaultNotifiableEventResolver(
     ): Result<ResolvedPushEvent> = runCatchingExceptions {
         when (val content = this.content) {
             is NotificationContent.MessageLike.RoomMessage -> {
-                val showMediaPreview = client.mediaPreviewService().getMediaPreviewValue() == MediaPreviewValue.On
+                val showMediaPreview = client.mediaPreviewService.getMediaPreviewValue() == MediaPreviewValue.On
                 val senderDisambiguatedDisplayName = getDisambiguatedDisplayName(content.senderId)
                 val messageBody = descriptionFromMessageContent(content, senderDisambiguatedDisplayName)
                 val notifiableMessageEvent = buildNotifiableMessageEvent(

libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandler.kt

@@ -30,7 +30,7 @@ class DefaultOnMissedCallNotificationHandler(
     ) {
         // Resolve the event and add a notification for it, at this point it should no longer be a ringing one
         val notificationData = matrixClientProvider.getOrRestore(sessionId).getOrNull()
-            ?.notificationService()
+            ?.notificationService
             ?.getNotifications(mapOf(roomId to listOf(eventId)))
             ?.getOrNull()
             ?.get(eventId)