Merge branch 'develop' into feature/fga/fix_left_room_membership_change

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

@@ -120,10 +120,6 @@ class RustClientSessionDelegate(
         }
     }
 
-    override fun didRefreshTokens() {
-        // This is done in `saveSessionInKeychain(Session)` instead.
-    }
-
     override fun retrieveSessionFromKeychain(userId: String): Session {
         // This should never be called, as it's only used for multi-process setups
         error("retrieveSessionFromKeychain should never be called for Android")

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

@@ -152,7 +152,7 @@ class RustMatrixClient(
     )
     private val notificationProcessSetup = NotificationProcessSetup.SingleProcess(innerSyncService)
     private val innerNotificationClient = runBlocking { innerClient.notificationClient(notificationProcessSetup) }
-    private val notificationService = RustNotificationService(innerNotificationClient, dispatchers, clock)
+    private val notificationService = RustNotificationService(sessionId, innerNotificationClient, dispatchers, clock)
     private val notificationSettingsService = RustNotificationSettingsService(innerClient, sessionCoroutineScope, dispatchers)
     private val encryptionService = RustEncryptionService(
         client = innerClient,
@@ -189,7 +189,6 @@ class RustMatrixClient(
 
     private val roomMembershipObserver = RoomMembershipObserver()
     private val roomFactory = RustRoomFactory(
-        innerClient = innerClient,
         roomListService = roomListService,
         innerRoomListService = innerRoomListService,
         sessionId = sessionId,

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

@@ -72,8 +72,9 @@ class RustMatrixClientFactory @Inject constructor(
     suspend fun create(client: Client): RustMatrixClient {
         val (anonymizedAccessToken, anonymizedRefreshToken) = client.session().anonymizedTokens()
 
+        client.setUtdDelegate(UtdTracker(analyticsService))
+
         val syncService = client.syncService()
-            .withUtdHook(UtdTracker(analyticsService))
             .withOfflineMode()
             .finish()
 

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

@@ -10,6 +10,7 @@ package io.element.android.libraries.matrix.impl.notification
 import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
+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.notification.NotificationContent
 import io.element.android.libraries.matrix.api.notification.NotificationData
@@ -25,6 +26,7 @@ class NotificationMapper(
     private val notificationContentMapper = NotificationContentMapper()
 
     fun map(
+        sessionId: SessionId,
         eventId: EventId,
         roomId: RoomId,
         notificationItem: NotificationItem
@@ -35,6 +37,7 @@ class NotificationMapper(
                 activeMembersCount = item.roomInfo.joinedMembersCount.toInt(),
             )
             NotificationData(
+                sessionId = sessionId,
                 eventId = eventId,
                 // FIXME once the `NotificationItem` in the SDK returns the thread id
                 threadId = null,

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

@@ -10,28 +10,45 @@ package io.element.android.libraries.matrix.impl.notification
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.notification.NotificationData
 import io.element.android.libraries.matrix.api.notification.NotificationService
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.NotificationClient
-import org.matrix.rustcomponents.sdk.use
+import org.matrix.rustcomponents.sdk.NotificationItemsRequest
+import timber.log.Timber
 
 class RustNotificationService(
+    private val sessionId: SessionId,
     private val notificationClient: NotificationClient,
     private val dispatchers: CoroutineDispatchers,
     clock: SystemClock,
 ) : NotificationService {
     private val notificationMapper: NotificationMapper = NotificationMapper(clock)
 
-    override suspend fun getNotification(
-        roomId: RoomId,
-        eventId: EventId,
-    ): Result<NotificationData?> = withContext(dispatchers.io) {
+    override suspend fun getNotifications(
+        ids: Map<RoomId, List<EventId>>
+    ): Result<Map<EventId, NotificationData>> = withContext(dispatchers.io) {
         runCatching {
-            val item = notificationClient.getNotification(roomId.value, eventId.value)
-            item?.use {
-                notificationMapper.map(eventId, roomId, it)
+            val requests = ids.map { (roomId, eventIds) ->
+                NotificationItemsRequest(
+                    roomId = roomId.value,
+                    eventIds = eventIds.map { it.value }
+                )
+            }
+            val items = notificationClient.getNotifications(requests)
+            buildMap {
+                val eventIds = requests.flatMap { it.eventIds }
+                for (eventId in eventIds) {
+                    val item = items[eventId]
+                    if (item != null) {
+                        val roomId = RoomId(requests.find { it.eventIds.contains(eventId) }?.roomId!!)
+                        put(EventId(eventId), notificationMapper.map(sessionId, EventId(eventId), roomId, item))
+                    } else {
+                        Timber.e("Could not retrieve event for notification with $eventId")
+                    }
+                }
             }
         }
     }

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

@@ -8,7 +8,9 @@
 package io.element.android.libraries.matrix.impl.proxy
 
 import android.content.Context
+import android.net.ConnectivityManager
 import android.provider.Settings
+import androidx.core.content.getSystemService
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.ApplicationContext
@@ -32,6 +34,13 @@ class DefaultProxyProvider @Inject constructor(
     private val context: Context
 ) : ProxyProvider {
     override fun provides(): String? {
+        val defaultProxy = context.getSystemService<ConnectivityManager>()?.defaultProxy
+        if (defaultProxy == null) {
+            // Note: can be tested by running:
+            // adb shell settings put global http_proxy :0
+            Timber.d("No default proxy")
+            return null
+        }
         return Settings.Global.getString(context.contentResolver, Settings.Global.HTTP_PROXY)
             ?.also {
                 Timber.d("Using global proxy")

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

@@ -212,6 +212,7 @@ class JoinedRustRoom(
                     internalIdPrefix = internalIdPrefix,
                     dateDividerMode = dateDividerMode,
                     trackReadReceipts = trackReadReceipts,
+                    reportUtds = true,
                 )
             ).let { innerTimeline ->
                 val mode = when (createTimelineParams) {
@@ -416,7 +417,6 @@ class JoinedRustRoom(
             RustWidgetDriver(
                 widgetSettings = widgetSettings,
                 room = innerRoom,
-                joinedRustRoom = this,
                 widgetCapabilitiesProvider = object : WidgetCapabilitiesProvider {
                     override fun acquireCapabilities(capabilities: WidgetCapabilities): WidgetCapabilities {
                         return getElementCallRequiredPermissions(sessionId.value, baseRoom.deviceId.value)

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

@@ -11,7 +11,6 @@ import io.element.android.libraries.core.coroutine.parallelMap
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.room.ForwardEventException
-import io.element.android.libraries.matrix.impl.roomlist.fullRoomWithTimeline
 import io.element.android.libraries.matrix.impl.roomlist.roomOrNull
 import io.element.android.libraries.matrix.impl.timeline.runWithTimelineListenerRegistered
 import kotlinx.coroutines.CancellationException
@@ -49,10 +48,7 @@ class RoomContentForwarder(
         val content = (messageLikeContent.kind as? MsgLikeKind.Message)?.content
             ?: throw ForwardEventException(toRoomIds)
 
-        val targetSlidingSyncRooms = toRoomIds.mapNotNull { roomId -> roomListService.roomOrNull(roomId.value) }
-        val targetRooms = targetSlidingSyncRooms.map { slidingSyncRoom ->
-            slidingSyncRoom.use { it.fullRoomWithTimeline(null) }
-        }
+        val targetRooms = toRoomIds.mapNotNull { roomId -> roomListService.roomOrNull(roomId.value) }
         val failedForwardingTo = mutableSetOf<RoomId>()
         targetRooms.parallelMap { room ->
             room.use { targetRoom ->

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

@@ -20,7 +20,6 @@ import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.api.roomlist.awaitLoaded
 import io.element.android.libraries.matrix.impl.room.preview.RoomPreviewInfoMapper
-import io.element.android.libraries.matrix.impl.roomlist.fullRoomWithTimeline
 import io.element.android.libraries.matrix.impl.roomlist.roomOrNull
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CoroutineScope
@@ -28,10 +27,12 @@ import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import org.matrix.rustcomponents.sdk.Client
+import org.matrix.rustcomponents.sdk.DateDividerMode
 import org.matrix.rustcomponents.sdk.Membership
 import org.matrix.rustcomponents.sdk.Room
-import org.matrix.rustcomponents.sdk.RoomListItem
+import org.matrix.rustcomponents.sdk.TimelineConfiguration
+import org.matrix.rustcomponents.sdk.TimelineFilter
+import org.matrix.rustcomponents.sdk.TimelineFocus
 import timber.log.Timber
 import java.util.concurrent.atomic.AtomicBoolean
 import org.matrix.rustcomponents.sdk.RoomListService as InnerRoomListService
@@ -39,7 +40,6 @@ import org.matrix.rustcomponents.sdk.RoomListService as InnerRoomListService
 class RustRoomFactory(
     private val sessionId: SessionId,
     private val deviceId: DeviceId,
-    private val innerClient: Client,
     private val notificationSettingsService: NotificationSettingsService,
     private val sessionCoroutineScope: CoroutineScope,
     private val dispatchers: CoroutineDispatchers,
@@ -79,16 +79,11 @@ class RustRoomFactory(
                 Timber.d("Room factory is destroyed, returning null for $roomId")
                 return@withContext null
             }
-            val roomListItem = awaitRoomListItem(roomId) ?: return@withContext null
-            getBaseRoom(roomListItem)
+            val room = awaitRoomInRoomList(roomId) ?: return@withContext null
+            getBaseRoom(room)
         }
     }
 
-    private suspend fun getBaseRoom(roomListItem: RoomListItem): RustBaseRoom? {
-        val sdkRoom = innerClient.getRoom(roomListItem.id()) ?: return null
-        return getBaseRoom(sdkRoom)
-    }
-
     private suspend fun getBaseRoom(sdkRoom: Room): RustBaseRoom {
         val initialRoomInfo = sdkRoom.roomInfo()
         return RustBaseRoom(
@@ -110,18 +105,27 @@ class RustRoomFactory(
                 Timber.d("Room factory is destroyed, returning null for $roomId")
                 return@withContext null
             }
-            val roomListItem = awaitRoomListItem(roomId) ?: return@withContext null
+            val sdkRoom = awaitRoomInRoomList(roomId) ?: return@withContext null
 
-            if (roomListItem.membership() == Membership.JOINED) {
-                // Init the live timeline in the SDK from the RoomListItem
-                val sdkRoom = roomListItem.fullRoomWithTimeline(eventFilters)
+            if (sdkRoom.membership() == Membership.JOINED) {
+                // Init the live timeline in the SDK from the Room
+                val timeline = sdkRoom.timelineWithConfiguration(
+                    TimelineConfiguration(
+                        focus = TimelineFocus.Live,
+                        filter = eventFilters?.let(TimelineFilter::EventTypeFilter) ?: TimelineFilter.All,
+                        internalIdPrefix = "live",
+                        dateDividerMode = DateDividerMode.DAILY,
+                        trackReadReceipts = true,
+                        reportUtds = true,
+                    )
+                )
 
                 GetRoomResult.Joined(
                     JoinedRustRoom(
                         baseRoom = getBaseRoom(sdkRoom),
                         notificationSettingsService = notificationSettingsService,
                         roomContentForwarder = roomContentForwarder,
-                        liveInnerTimeline = sdkRoom.timeline(),
+                        liveInnerTimeline = timeline,
                         coroutineDispatchers = dispatchers,
                         systemClock = systemClock,
                         featureFlagService = featureFlagService,
@@ -129,7 +133,7 @@ class RustRoomFactory(
                 )
             } else {
                 val preview = try {
-                    roomListItem.previewRoom(via = emptyList())
+                    sdkRoom.previewRoom(via = emptyList())
                 } catch (e: Exception) {
                     Timber.e(e, "Failed to get room preview for $roomId")
                     return@withContext null
@@ -138,7 +142,7 @@ class RustRoomFactory(
                 GetRoomResult.NotJoined(
                     NotJoinedRustRoom(
                         sessionId = sessionId,
-                        localRoom = getBaseRoom(roomListItem),
+                        localRoom = getBaseRoom(sdkRoom),
                         previewInfo = RoomPreviewInfoMapper.map(preview.info()),
                     )
                 )
@@ -147,22 +151,22 @@ class RustRoomFactory(
     }
 
     /**
-     * Get the Rust room list item for a room, retrying after the room list is loaded if necessary.
+     * Get the Rust room for a room, retrying after the room list is loaded if necessary.
      */
-    private suspend fun awaitRoomListItem(roomId: RoomId): RoomListItem? {
-        var roomListItem = innerRoomListService.roomOrNull(roomId.value)
-        if (roomListItem == null) {
+    private suspend fun awaitRoomInRoomList(roomId: RoomId): Room? {
+        var sdkRoom = innerRoomListService.roomOrNull(roomId.value)
+        if (sdkRoom == null) {
             // ... otherwise, lets wait for the SS to load all rooms and check again.
             roomListService.allRooms.awaitLoaded()
-            roomListItem = innerRoomListService.roomOrNull(roomId.value)
+            sdkRoom = innerRoomListService.roomOrNull(roomId.value)
         }
 
-        if (roomListItem == null) {
+        if (sdkRoom == null) {
             Timber.d("Room not found for $roomId")
             return null
         }
 
-        return roomListItem
+        return sdkRoom
     }
 }
 

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

@@ -19,11 +19,11 @@ import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.RoomListEntriesDynamicFilterKind
 import org.matrix.rustcomponents.sdk.RoomListEntriesListener
 import org.matrix.rustcomponents.sdk.RoomListEntriesUpdate
 import org.matrix.rustcomponents.sdk.RoomListInterface
-import org.matrix.rustcomponents.sdk.RoomListItem
 import org.matrix.rustcomponents.sdk.RoomListLoadingState
 import org.matrix.rustcomponents.sdk.RoomListLoadingStateListener
 import org.matrix.rustcomponents.sdk.RoomListServiceInterface
@@ -114,7 +114,7 @@ internal fun RoomListServiceInterface.syncIndicator(): Flow<RoomListServiceSyncI
         )
     }.buffer(Channel.UNLIMITED)
 
-internal fun RoomListServiceInterface.roomOrNull(roomId: String): RoomListItem? {
+internal fun RoomListServiceInterface.roomOrNull(roomId: String): Room? {
     return tryOrNull(
         onError = { Timber.e(it, "Failed finding room with id=$roomId.") }
     ) {

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

@@ -1,20 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.libraries.matrix.impl.roomlist
-
-import org.matrix.rustcomponents.sdk.Room
-import org.matrix.rustcomponents.sdk.RoomListItem
-import org.matrix.rustcomponents.sdk.TimelineEventTypeFilter
-
-/** Returns a `Room` with an initialized timeline using the given [filter]. */
-suspend fun RoomListItem.fullRoomWithTimeline(filter: TimelineEventTypeFilter? = null): Room {
-    if (!isTimelineInitialized()) {
-        initTimeline(filter, "live")
-    }
-    return fullRoom()
-}

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

@@ -10,16 +10,16 @@ package io.element.android.libraries.matrix.impl.roomlist
 import io.element.android.libraries.matrix.api.roomlist.RoomSummary
 import io.element.android.libraries.matrix.impl.room.RoomInfoMapper
 import io.element.android.libraries.matrix.impl.room.message.RoomMessageFactory
-import org.matrix.rustcomponents.sdk.RoomListItem
+import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.use
 
 class RoomSummaryFactory(
     private val roomMessageFactory: RoomMessageFactory = RoomMessageFactory(),
     private val roomInfoMapper: RoomInfoMapper = RoomInfoMapper(),
 ) {
-    suspend fun create(roomListItem: RoomListItem): RoomSummary {
-        val roomInfo = roomListItem.roomInfo().let(roomInfoMapper::map)
-        val latestRoomMessage = roomListItem.latestEvent().use { event ->
+    suspend fun create(room: Room): RoomSummary {
+        val roomInfo = room.roomInfo().let(roomInfoMapper::map)
+        val latestRoomMessage = room.latestEvent().use { event ->
             roomMessageFactory.create(event)
         }
         return RoomSummary(

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

@@ -12,8 +12,8 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
+import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.RoomListEntriesUpdate
-import org.matrix.rustcomponents.sdk.RoomListItem
 import org.matrix.rustcomponents.sdk.RoomListServiceInterface
 import org.matrix.rustcomponents.sdk.use
 import timber.log.Timber
@@ -95,20 +95,16 @@ class RoomSummaryListProcessor(
         }
     }
 
-    private suspend fun buildSummaryForRoomListEntry(entry: RoomListItem): RoomSummary {
-        return buildRoomSummaryForRoomListItem(entry)
+    private suspend fun buildSummaryForRoomListEntry(entry: Room): RoomSummary {
+        return entry.use { roomSummaryDetailsFactory.create(room = it) }
     }
 
     private suspend fun buildRoomSummaryForIdentifier(identifier: String): RoomSummary? {
-        return roomListService.roomOrNull(identifier)?.use { roomListItem ->
-            buildRoomSummaryForRoomListItem(roomListItem)
+        return roomListService.roomOrNull(identifier)?.let { room ->
+            buildSummaryForRoomListEntry(room)
         }
     }
 
-    private suspend fun buildRoomSummaryForRoomListItem(roomListItem: RoomListItem): RoomSummary {
-        return roomSummaryDetailsFactory.create(roomListItem = roomListItem)
-    }
-
     private suspend fun updateRoomSummaries(block: suspend MutableList<RoomSummary>.() -> Unit) = withContext(coroutineContext) {
         mutex.withLock {
             val current = roomSummaries.replayCache.lastOrNull()

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

@@ -53,4 +53,5 @@ fun TracingConfiguration.map(): org.matrix.rustcomponents.sdk.TracingConfigurati
     extraTargets = extraTargets,
     traceLogPacks = traceLogPacks.map(),
     writeToFiles = writesToFilesConfiguration.toTracingFileConfiguration(),
+    sentryDsn = null,
 )

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

@@ -9,7 +9,6 @@ package io.element.android.libraries.matrix.impl.widget
 
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetSettings
-import io.element.android.libraries.matrix.impl.room.JoinedRustRoom
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -25,7 +24,6 @@ import kotlin.coroutines.coroutineContext
 class RustWidgetDriver(
     widgetSettings: MatrixWidgetSettings,
     private val room: Room,
-    private val joinedRustRoom: JoinedRustRoom,
     private val widgetCapabilitiesProvider: WidgetCapabilitiesProvider,
 ) : MatrixWidgetDriver {
     // It's important to have extra capacity here to make sure we don't drop any messages
@@ -71,6 +69,5 @@ class RustWidgetDriver(
     override fun close() {
         receiveMessageJob?.cancel()
         driverAndHandle.driver.close()
-        joinedRustRoom.destroy()
     }
 }