Sulkta-OSS/element-x-ada
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #5466 from element-hq/feature/bma/replaceFunByVal

Browse source 
Replace fun by val in MatrixClient
This commit is contained in:
Benoit Marty 2025-10-06 22:34:39 +02:00 • committed by GitHub
commit 69c86232c4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
38 changed files with 170 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -49,9 +49,18 @@ interface MatrixClient {
val userProfile: StateFlow<MatrixUser>
val roomListService: RoomListService
val spaceService: SpaceService
val mediaLoader: MatrixMediaLoader
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 matrixMediaLoader: 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.

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

@ -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
@ -128,11 +120,10 @@ import org.matrix.rustcomponents.sdk.SyncService as ClientSyncService
class RustMatrixClient(
private val innerClient: Client,
private val baseDirectory: File,
private val sessionStore: SessionStore,
private val appCoroutineScope: CoroutineScope,
private val sessionDelegate: RustClientSessionDelegate,
private val innerSyncService: ClientSyncService,
appCoroutineScope: CoroutineScope,
dispatchers: CoroutineDispatchers,
baseCacheDirectory: File,
clock: SystemClock,
@ -147,29 +138,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 +187,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,
)
@ -221,13 +212,13 @@ class RustMatrixClient(
featureFlagService = featureFlagService,
)
override val mediaLoader: MatrixMediaLoader = RustMediaLoader(
override val matrixMediaLoader: MatrixMediaLoader = RustMediaLoader(
baseCacheDirectory = baseCacheDirectory,
dispatchers = dispatchers,
innerClient = innerClient,
)
private val mediaPreviewService = RustMediaPreviewService(
override val mediaPreviewService = RustMediaPreviewService(
sessionCoroutineScope = sessionCoroutineScope,
innerClient = innerClient,
sessionDispatcher = sessionDispatcher,
@ -538,33 +529,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()
@ -575,7 +550,7 @@ class RustMatrixClient(
}
override suspend fun getCacheSize(): Long {
return baseDirectory.getCacheSize()
return getCacheSize(includeCryptoDb = false)
}
override suspend fun clearCache() {
@ -674,8 +649,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 }
@ -740,7 +713,7 @@ class RustMatrixClient(
}
}
private suspend fun File.getCacheSize(
private suspend fun getCacheSize(
includeCryptoDb: Boolean = false,
): Long = withContext(sessionDispatcher) {
val sessionDirectory = sessionPathsProvider.provides(sessionId) ?: return@withContext 0L

19
libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientFactory.kt
View file

@ -9,7 +9,6 @@ package io.element.android.libraries.matrix.impl
import dev.zacsweers.metro.Inject
import io.element.android.libraries.core.coroutine.CoroutineDispatchers
import io.element.android.libraries.di.BaseDirectory
import io.element.android.libraries.di.CacheDirectory
import io.element.android.libraries.di.annotations.AppCoroutineScope
import io.element.android.libraries.featureflag.api.FeatureFlagService
@ -43,7 +42,6 @@ import java.io.File
@Inject
class RustMatrixClientFactory(
@BaseDirectory private val baseDirectory: File,
@CacheDirectory private val cacheDirectory: File,
@AppCoroutineScope
private val appCoroutineScope: CoroutineScope,
@ -87,7 +85,6 @@ class RustMatrixClientFactory(
return RustMatrixClient(
innerClient = client,
baseDirectory = baseDirectory,
sessionStore = sessionStore,
appCoroutineScope = appCoroutineScope,
sessionDelegate = sessionDelegate,
@ -136,13 +133,15 @@ class RustMatrixClientFactory(
)
.enableShareHistoryOnInvite(featureFlagService.isFeatureEnabled(FeatureFlags.EnableKeyShareOnInvite))
.threadsEnabled(featureFlagService.isFeatureEnabled(FeatureFlags.Threads), threadSubscriptions = false)
.requestConfig(RequestConfig(
timeout = 30_000uL,
retryLimit = 0u,
// Use default values for the rest
maxConcurrentRequests = null,
maxRetryTime = null,
))
.requestConfig(
RequestConfig(
timeout = 30_000uL,
retryLimit = 0u,
// Use default values for the rest
maxConcurrentRequests = null,
maxRetryTime = null,
)
)
.run {
// Apply sliding sync version settings
when (slidingSyncType) {

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

@ -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,32 +56,37 @@ 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
fun provideMediaLoader(matrixClient: MatrixClient): MatrixMediaLoader {
return matrixClient.mediaLoader
fun providesMatrixMediaLoader(matrixClient: MatrixClient): MatrixMediaLoader {
return matrixClient.matrixMediaLoader
}
@SessionCoroutineScope
@Provides
fun provideSessionCoroutineScope(matrixClient: MatrixClient): CoroutineScope {
fun providesSessionCoroutineScope(matrixClient: MatrixClient): CoroutineScope {
return matrixClient.sessionCoroutineScope
}
@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
}
}

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

@ -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,

2
libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientFactoryTest.kt
View file

@ -36,14 +36,12 @@ class RustMatrixClientFactoryTest {
}
fun TestScope.createRustMatrixClientFactory(
baseDirectory: File = File("/base"),
cacheDirectory: File = File("/cache"),
sessionStore: SessionStore = InMemorySessionStore(
updateUserProfileResult = { _, _, _ -> },
),
clientBuilderProvider: ClientBuilderProvider = FakeClientBuilderProvider(),
) = RustMatrixClientFactory(
baseDirectory = baseDirectory,
cacheDirectory = cacheDirectory,
appCoroutineScope = backgroundScope,
coroutineDispatchers = testCoroutineDispatchers(),

1
libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClientTest.kt
View file

@ -102,7 +102,6 @@ class RustMatrixClientTest {
),
) = RustMatrixClient(
innerClient = client,
baseDirectory = File(""),
sessionStore = sessionStore,
appCoroutineScope = backgroundScope,
sessionDelegate = aRustClientSessionDelegate(

1
libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/auth/RustMatrixAuthenticationServiceTest.kt
View file

@ -53,7 +53,6 @@ class RustMatrixAuthenticationServiceTest {
val baseDirectory = File("/base")
val cacheDirectory = File("/cache")
val rustMatrixClientFactory = createRustMatrixClientFactory(
baseDirectory = baseDirectory,
cacheDirectory = cacheDirectory,
sessionStore = sessionStore,
clientBuilderProvider = clientBuilderProvider,

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

@ -32,6 +32,7 @@ import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryServic
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.user.MatrixSearchUserResults
import io.element.android.libraries.matrix.api.user.MatrixUser
import io.element.android.libraries.matrix.api.verification.SessionVerificationService
@ -68,15 +69,16 @@ class FakeMatrixClient(
private val userAvatarUrl: String? = AN_AVATAR_URL,
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 matrixMediaLoader: MatrixMediaLoader = FakeMatrixMediaLoader(),
override val sessionVerificationService: SessionVerificationService = FakeSessionVerificationService(),
override val pushersService: PushersService = FakePushersService(),
override val notificationService: NotificationService = FakeNotificationService(),
override val notificationSettingsService: NotificationSettingsService = FakeNotificationSettingsService(),
override val syncService: SyncService = FakeSyncService(),
override val encryptionService: EncryptionService = 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 +176,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 +236,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>) {

6
libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/media/AvatarDataFetcherFactory.kt
View file

@ -11,10 +11,10 @@ import coil3.ImageLoader
import coil3.fetch.Fetcher
import coil3.request.Options
import io.element.android.libraries.designsystem.components.avatar.AvatarData
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
internal class AvatarDataFetcherFactory(
private val client: MatrixClient
private val matrixMediaLoader: MatrixMediaLoader
) : Fetcher.Factory<AvatarData> {
override fun create(
data: AvatarData,
@ -22,7 +22,7 @@ internal class AvatarDataFetcherFactory(
imageLoader: ImageLoader
): Fetcher {
return CoilMediaFetcher(
mediaLoader = client.mediaLoader,
mediaLoader = matrixMediaLoader,
mediaData = data.toMediaRequestData(),
)
}

10
libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/media/ImageLoaderFactories.kt
View file

@ -18,11 +18,11 @@ import dev.zacsweers.metro.ContributesBinding
import dev.zacsweers.metro.Inject
import dev.zacsweers.metro.Provider
import io.element.android.libraries.di.annotations.ApplicationContext
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
import okhttp3.OkHttpClient
interface LoggedInImageLoaderFactory {
fun newImageLoader(matrixClient: MatrixClient): ImageLoader
fun newImageLoader(matrixMediaLoader: MatrixMediaLoader): ImageLoader
}
@ContributesBinding(AppScope::class)
@ -31,7 +31,7 @@ class DefaultLoggedInImageLoaderFactory(
@ApplicationContext private val context: Context,
private val okHttpClient: Provider<OkHttpClient>,
) : LoggedInImageLoaderFactory {
override fun newImageLoader(matrixClient: MatrixClient): ImageLoader {
override fun newImageLoader(matrixMediaLoader: MatrixMediaLoader): ImageLoader {
return ImageLoader.Builder(context)
.components {
add(
@ -50,8 +50,8 @@ class DefaultLoggedInImageLoaderFactory(
}
add(AvatarDataKeyer())
add(MediaRequestDataKeyer())
add(AvatarDataFetcherFactory(matrixClient))
add(MediaRequestDataFetcherFactory(matrixClient))
add(AvatarDataFetcherFactory(matrixMediaLoader))
add(MediaRequestDataFetcherFactory(matrixMediaLoader))
}
.build()
}

2
libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/media/ImageLoaderHolder.kt
View file

@ -49,7 +49,7 @@ class DefaultImageLoaderHolder(
return synchronized(map) {
map.getOrPut(client.sessionId) {
loggedInImageLoaderFactory
.newImageLoader(client)
.newImageLoader(client.matrixMediaLoader)
}
}
}

6
libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/media/MediaRequestDataFetcherFactory.kt
View file

@ -10,10 +10,10 @@ package io.element.android.libraries.matrix.ui.media
import coil3.ImageLoader
import coil3.fetch.Fetcher
import coil3.request.Options
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
internal class MediaRequestDataFetcherFactory(
private val client: MatrixClient
private val matrixMediaLoader: MatrixMediaLoader,
) : Fetcher.Factory<MediaRequestData> {
override fun create(
data: MediaRequestData,
@ -21,7 +21,7 @@ internal class MediaRequestDataFetcherFactory(
imageLoader: ImageLoader
): Fetcher {
return CoilMediaFetcher(
mediaLoader = client.mediaLoader,
mediaLoader = matrixMediaLoader,
mediaData = data,
)
}

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

@ -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()

10
libraries/matrixui/src/test/kotlin/io/element/android/libraries/matrix/ui/media/DefaultImageLoaderHolderTest.kt
View file

@ -10,7 +10,7 @@ package io.element.android.libraries.matrix.ui.media
import androidx.test.platform.app.InstrumentationRegistry
import coil3.ImageLoader
import com.google.common.truth.Truth.assertThat
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
import io.element.android.libraries.matrix.test.A_SESSION_ID
import io.element.android.libraries.matrix.test.FakeMatrixClient
import io.element.android.libraries.sessionstorage.test.observer.FakeSessionObserver
@ -27,7 +27,7 @@ class DefaultImageLoaderHolderTest {
@Test
fun `get - returns the same ImageLoader for the same client`() {
val context = InstrumentationRegistry.getInstrumentation().context
val lambda = lambdaRecorder<MatrixClient, ImageLoader> { ImageLoader.Builder(context).build() }
val lambda = lambdaRecorder<MatrixMediaLoader, ImageLoader> { ImageLoader.Builder(context).build() }
val holder = DefaultImageLoaderHolder(
loggedInImageLoaderFactory = FakeLoggedInImageLoaderFactory(lambda),
@ -39,14 +39,14 @@ class DefaultImageLoaderHolderTest {
assert(imageLoader1 === imageLoader2)
lambda.assertions()
.isCalledOnce()
.with(value(client))
.with(value(client.matrixMediaLoader))
}
@Test
fun `when session is deleted, the image loader is deleted`() = runTest {
val context = InstrumentationRegistry.getInstrumentation().context
val lambda =
lambdaRecorder<MatrixClient, ImageLoader> { ImageLoader.Builder(context).build() }
lambdaRecorder<MatrixMediaLoader, ImageLoader> { ImageLoader.Builder(context).build() }
val sessionObserver = FakeSessionObserver()
val holder = DefaultImageLoaderHolder(
loggedInImageLoaderFactory = FakeLoggedInImageLoaderFactory(lambda),
@ -65,7 +65,7 @@ class DefaultImageLoaderHolderTest {
fun `when session is created, nothing happen`() = runTest {
val context = InstrumentationRegistry.getInstrumentation().context
val lambda =
lambdaRecorder<MatrixClient, ImageLoader> { ImageLoader.Builder(context).build() }
lambdaRecorder<MatrixMediaLoader, ImageLoader> { ImageLoader.Builder(context).build() }
val sessionObserver = FakeSessionObserver()
DefaultImageLoaderHolder(
loggedInImageLoaderFactory = FakeLoggedInImageLoaderFactory(lambda),

8
libraries/matrixui/src/test/kotlin/io/element/android/libraries/matrix/ui/media/FakeLoggedInImageLoaderFactory.kt
View file

@ -8,12 +8,12 @@
package io.element.android.libraries.matrix.ui.media
import coil3.ImageLoader
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.media.MatrixMediaLoader
class FakeLoggedInImageLoaderFactory(
private val newImageLoaderLambda: (MatrixClient) -> ImageLoader
private val newImageLoaderLambda: (MatrixMediaLoader) -> ImageLoader
) : LoggedInImageLoaderFactory {
override fun newImageLoader(matrixClient: MatrixClient): ImageLoader {
return newImageLoaderLambda(matrixClient)
override fun newImageLoader(matrixMediaLoader: MatrixMediaLoader): ImageLoader {
return newImageLoaderLambda(matrixMediaLoader)
}
}

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

@ -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,

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

@ -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(

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

@ -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)

2
libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationMediaRepo.kt
View file

@ -72,7 +72,7 @@ class DefaultNotificationMediaRepo(
): DefaultNotificationMediaRepo
}
private val matrixMediaLoader = client.mediaLoader
private val matrixMediaLoader = client.matrixMediaLoader
override suspend fun getMediaFile(
mediaSource: MediaSource,