Merge branch 'release/0.4.10' into main

Author: bmarty

.github/workflows/gradle-wrapper-validation.yml

@@ -12,4 +12,4 @@ jobs:
     # No concurrency required, this is a prerequisite to other actions and should run every time.
     steps:
       - uses: actions/checkout@v4
-      - uses: gradle/wrapper-validation-action@v2
+      - uses: gradle/wrapper-validation-action@v3

CHANGES.md

@@ -1,3 +1,20 @@
+Changes in Element X v0.4.10 (2024-04-17)
+=========================================
+
+Matrix Rust SDK 0.2.14
+
+Features ✨
+----------
+ - Rework room navigation to handle unknown room and prepare work on permalink. ([#2695](https://github.com/element-hq/element-x-android/issues/2695))
+
+Other changes
+-------------
+ - Encrypt new session data with a passphrase ([#2703](https://github.com/element-hq/element-x-android/issues/2703))
+ - Use sdk API to build permalinks ([#2708](https://github.com/element-hq/element-x-android/issues/2708))
+ - Parse permalink using parseMatrixEntityFrom from the SDK ([#2709](https://github.com/element-hq/element-x-android/issues/2709))
+ - Fix compile for forks that use the `noop` analytics module ([#2698](https://github.com/element-hq/element-x-android/issues/2698))
+
+
 Changes in Element X v0.4.9 (2024-04-12)
 ========================================
 

appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt

@@ -42,18 +42,20 @@ import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.appnav.loggedin.LoggedInNode
 import io.element.android.appnav.room.RoomFlowNode
-import io.element.android.appnav.room.RoomLoadedFlowNode
+import io.element.android.appnav.room.RoomNavigationTarget
+import io.element.android.appnav.room.joined.JoinedRoomLoadedFlowNode
 import io.element.android.features.createroom.api.CreateRoomEntryPoint
 import io.element.android.features.ftue.api.FtueEntryPoint
 import io.element.android.features.ftue.api.state.FtueService
 import io.element.android.features.ftue.api.state.FtueState
-import io.element.android.features.invitelist.api.InviteListEntryPoint
+import io.element.android.features.invite.api.InviteListEntryPoint
 import io.element.android.features.lockscreen.api.LockScreenEntryPoint
 import io.element.android.features.lockscreen.api.LockScreenLockState
 import io.element.android.features.lockscreen.api.LockScreenService
 import io.element.android.features.networkmonitor.api.NetworkMonitor
 import io.element.android.features.networkmonitor.api.NetworkStatus
 import io.element.android.features.preferences.api.PreferencesEntryPoint
+import io.element.android.features.roomdirectory.api.RoomDescription
 import io.element.android.features.roomdirectory.api.RoomDirectoryEntryPoint
 import io.element.android.features.roomlist.api.RoomListEntryPoint
 import io.element.android.features.securebackup.api.SecureBackupEntryPoint
@@ -82,6 +84,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.parcelize.Parcelize
 import timber.log.Timber
+import java.util.Optional
 
 @ContributesNode(SessionScope::class)
 class LoggedInFlowNode @AssistedInject constructor(
@@ -213,7 +216,8 @@ class LoggedInFlowNode @AssistedInject constructor(
         @Parcelize
         data class Room(
             val roomId: RoomId,
-            val initialElement: RoomLoadedFlowNode.NavTarget = RoomLoadedFlowNode.NavTarget.Messages
+            val roomDescription: RoomDescription? = null,
+            val initialElement: RoomNavigationTarget = RoomNavigationTarget.Messages
         ) : NavTarget
 
         @Parcelize
@@ -273,7 +277,7 @@ class LoggedInFlowNode @AssistedInject constructor(
                     }
 
                     override fun onRoomSettingsClicked(roomId: RoomId) {
-                        backstack.push(NavTarget.Room(roomId, initialElement = RoomLoadedFlowNode.NavTarget.RoomDetails))
+                        backstack.push(NavTarget.Room(roomId, initialElement = RoomNavigationTarget.Details))
                     }
 
                     override fun onReportBugClicked() {
@@ -290,7 +294,7 @@ class LoggedInFlowNode @AssistedInject constructor(
                     .build()
             }
             is NavTarget.Room -> {
-                val callback = object : RoomLoadedFlowNode.Callback {
+                val callback = object : JoinedRoomLoadedFlowNode.Callback {
                     override fun onOpenRoom(roomId: RoomId) {
                         backstack.push(NavTarget.Room(roomId))
                     }
@@ -303,7 +307,11 @@ class LoggedInFlowNode @AssistedInject constructor(
                         backstack.push(NavTarget.Settings(PreferencesEntryPoint.InitialTarget.NotificationSettings))
                     }
                 }
-                val inputs = RoomFlowNode.Inputs(roomId = navTarget.roomId, initialElement = navTarget.initialElement)
+                val inputs = RoomFlowNode.Inputs(
+                    roomId = navTarget.roomId,
+                    roomDescription = Optional.ofNullable(navTarget.roomDescription),
+                    initialElement = navTarget.initialElement
+                )
                 createNode<RoomFlowNode>(buildContext, plugins = listOf(inputs, callback))
             }
             is NavTarget.Settings -> {
@@ -317,7 +325,7 @@ class LoggedInFlowNode @AssistedInject constructor(
                     }
 
                     override fun onOpenRoomNotificationSettings(roomId: RoomId) {
-                        backstack.push(NavTarget.Room(roomId, initialElement = RoomLoadedFlowNode.NavTarget.RoomNotificationSettings))
+                        backstack.push(NavTarget.Room(roomId, initialElement = RoomNavigationTarget.NotificationSettings))
                     }
                 }
                 val inputs = PreferencesEntryPoint.Params(navTarget.initialElement)
@@ -349,6 +357,10 @@ class LoggedInFlowNode @AssistedInject constructor(
                         backstack.pop()
                     }
 
+                    override fun onInviteClicked(roomId: RoomId) {
+                        backstack.push(NavTarget.Room(roomId))
+                    }
+
                     override fun onInviteAccepted(roomId: RoomId) {
                         backstack.push(NavTarget.Room(roomId))
                     }
@@ -370,8 +382,12 @@ class LoggedInFlowNode @AssistedInject constructor(
             NavTarget.RoomDirectorySearch -> {
                 roomDirectoryEntryPoint.nodeBuilder(this, buildContext)
                     .callback(object : RoomDirectoryEntryPoint.Callback {
-                        override fun onOpenRoom(roomId: RoomId) {
-                            coroutineScope.launch { attachRoom(roomId) }
+                        override fun onRoomJoined(roomId: RoomId) {
+                            backstack.push(NavTarget.Room(roomId))
+                        }
+
+                        override fun onResultClicked(roomDescription: RoomDescription) {
+                            backstack.push(NavTarget.Room(roomDescription.roomId, roomDescription))
                         }
                     })
                     .build()

appnav/src/main/kotlin/io/element/android/appnav/room/RoomFlowNode.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 New Vector Ltd
+ * Copyright (c) 2024 New Vector Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,13 @@
  * limitations under the License.
  */
 
-@file:OptIn(ExperimentalMaterial3Api::class)
-
 package io.element.android.appnav.room
 
 import android.os.Parcelable
-import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.lifecycle.lifecycleScope
 import com.bumble.appyx.core.modality.BuildContext
@@ -36,102 +34,109 @@ import com.bumble.appyx.navmodel.backstack.operation.newRoot
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
-import io.element.android.features.networkmonitor.api.NetworkMonitor
-import io.element.android.features.networkmonitor.api.NetworkStatus
+import io.element.android.appnav.room.joined.JoinedRoomFlowNode
+import io.element.android.appnav.room.joined.JoinedRoomLoadedFlowNode
+import io.element.android.features.joinroom.api.JoinRoomEntryPoint
+import io.element.android.features.roomdirectory.api.RoomDescription
 import io.element.android.libraries.architecture.BackstackView
 import io.element.android.libraries.architecture.BaseFlowNode
 import io.element.android.libraries.architecture.NodeInputs
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
 import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
-import kotlinx.coroutines.flow.distinctUntilChanged
+import io.element.android.libraries.matrix.api.room.CurrentUserMembership
+import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
 
 @ContributesNode(SessionScope::class)
 class RoomFlowNode @AssistedInject constructor(
     @Assisted val buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    loadingRoomStateFlowFactory: LoadingRoomStateFlowFactory,
-    private val networkMonitor: NetworkMonitor,
-) :
-    BaseFlowNode<RoomFlowNode.NavTarget>(
-        backstack = BackStack(
-            initialElement = NavTarget.Loading,
-            savedStateMap = buildContext.savedStateMap,
-        ),
-        buildContext = buildContext,
-        plugins = plugins
-    ) {
+    private val client: MatrixClient,
+    private val roomMembershipObserver: RoomMembershipObserver,
+    private val joinRoomEntryPoint: JoinRoomEntryPoint,
+) : BaseFlowNode<RoomFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.Loading,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins
+) {
     data class Inputs(
         val roomId: RoomId,
-        val initialElement: RoomLoadedFlowNode.NavTarget = RoomLoadedFlowNode.NavTarget.Messages,
+        val roomDescription: Optional<RoomDescription>,
+        val initialElement: RoomNavigationTarget = RoomNavigationTarget.Messages,
     ) : NodeInputs
 
     private val inputs: Inputs = inputs()
-    private val loadingRoomStateStateFlow = loadingRoomStateFlowFactory.create(lifecycleScope, inputs.roomId)
 
     sealed interface NavTarget : Parcelable {
         @Parcelize
         data object Loading : NavTarget
 
         @Parcelize
-        data object Loaded : NavTarget
+        data object JoinRoom : NavTarget
+
+        @Parcelize
+        data object JoinedRoom : NavTarget
     }
 
     override fun onBuilt() {
         super.onBuilt()
-        loadingRoomStateStateFlow
-            .map {
-                it is LoadingRoomState.Loaded
+        client.getRoomInfoFlow(
+            inputs.roomId
+        ).onEach { roomInfo ->
+            Timber.d("Room membership: ${roomInfo.map { it.currentUserMembership }}")
+            if (roomInfo.getOrNull()?.currentUserMembership == CurrentUserMembership.JOINED) {
+                backstack.newRoot(NavTarget.JoinedRoom)
+            } else {
+                backstack.newRoot(NavTarget.JoinRoom)
             }
-            .distinctUntilChanged()
-            .onEach { isLoaded ->
-                if (isLoaded) {
-                    backstack.newRoot(NavTarget.Loaded)
-                } else {
-                    backstack.newRoot(NavTarget.Loading)
-                }
+        }
+            .launchIn(lifecycleScope)
+
+        // When leaving the room from this session only, navigate up.
+        roomMembershipObserver.updates
+            .filter { update -> update.roomId == inputs.roomId && !update.isUserInRoom }
+            .onEach {
+                navigateUp()
             }
             .launchIn(lifecycleScope)
     }
 
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
         return when (navTarget) {
-            NavTarget.Loaded -> {
-                val roomFlowNodeCallback = plugins<RoomLoadedFlowNode.Callback>()
-                val awaitRoomState = loadingRoomStateStateFlow.value
-                if (awaitRoomState is LoadingRoomState.Loaded) {
-                    val inputs = RoomLoadedFlowNode.Inputs(awaitRoomState.room, initialElement = inputs.initialElement)
-                    createNode<RoomLoadedFlowNode>(buildContext, plugins = listOf(inputs) + roomFlowNodeCallback)
-                } else {
-                    loadingNode(buildContext, this::navigateUp)
-                }
+            NavTarget.Loading -> loadingNode(buildContext)
+            NavTarget.JoinRoom -> {
+                val inputs = JoinRoomEntryPoint.Inputs(inputs.roomId, roomDescription = inputs.roomDescription)
+                joinRoomEntryPoint.createNode(this, buildContext, inputs)
             }
-            NavTarget.Loading -> {
-                loadingNode(buildContext, this::navigateUp)
+            NavTarget.JoinedRoom -> {
+                val roomFlowNodeCallback = plugins<JoinedRoomLoadedFlowNode.Callback>()
+                val inputs = JoinedRoomFlowNode.Inputs(inputs.roomId, initialElement = inputs.initialElement)
+                createNode<JoinedRoomFlowNode>(buildContext, plugins = listOf(inputs) + roomFlowNodeCallback)
             }
         }
     }
 
-    private fun loadingNode(buildContext: BuildContext, onBackClicked: () -> Unit) = node(buildContext) { modifier ->
-        val loadingRoomState by loadingRoomStateStateFlow.collectAsState()
-        val networkStatus by networkMonitor.connectivity.collectAsState()
-        LoadingRoomNodeView(
-            state = loadingRoomState,
-            hasNetworkConnection = networkStatus == NetworkStatus.Online,
-            modifier = modifier,
-            onBackClicked = onBackClicked
-        )
+    private fun loadingNode(buildContext: BuildContext) = node(buildContext) {
+        Box(modifier = it.fillMaxSize(), contentAlignment = Alignment.Center) {
+            CircularProgressIndicator()
+        }
     }
 
     @Composable
     override fun View(modifier: Modifier) {
-        BackstackView(
-            transitionHandler = JumpToEndTransitionHandler(),
-        )
+        BackstackView(transitionHandler = JumpToEndTransitionHandler())
     }
 }

appnav/src/main/kotlin/io/element/android/appnav/room/RoomNavigationTarget.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.appnav.room
+
+enum class RoomNavigationTarget {
+    Messages,
+    Details,
+    NotificationSettings,
+}