Merge pull request #1610 from vector-im/dla/feature/custom_room_notif…

…ication_settings_list

Custom room notification settings list

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

@@ -197,7 +197,9 @@ class LoggedInFlowNode @AssistedInject constructor(
         ) : NavTarget
 
         @Parcelize
-        data object Settings : NavTarget
+        data class Settings(
+            val initialElement: PreferencesEntryPoint.InitialTarget = PreferencesEntryPoint.InitialTarget.Root
+        ) : NavTarget
 
         @Parcelize
         data object CreateRoom : NavTarget
@@ -227,7 +229,7 @@ class LoggedInFlowNode @AssistedInject constructor(
                     }
 
                     override fun onSettingsClicked() {
-                        backstack.push(NavTarget.Settings)
+                        backstack.push(NavTarget.Settings())
                     }
 
                     override fun onCreateRoomClicked() {
@@ -260,11 +262,15 @@ class LoggedInFlowNode @AssistedInject constructor(
                     override fun onForwardedToSingleRoom(roomId: RoomId) {
                         coroutineScope.launch { attachRoom(roomId) }
                     }
+
+                    override fun onOpenGlobalNotificationSettings() {
+                        backstack.push(NavTarget.Settings(PreferencesEntryPoint.InitialTarget.NotificationSettings))
+                    }
                 }
                 val inputs = RoomFlowNode.Inputs(roomId = navTarget.roomId, initialElement = navTarget.initialElement)
                 createNode<RoomFlowNode>(buildContext, plugins = listOf(inputs, callback))
             }
-            NavTarget.Settings -> {
+            is NavTarget.Settings -> {
                 val callback = object : PreferencesEntryPoint.Callback {
                     override fun onOpenBugReport() {
                         plugins<Callback>().forEach { it.onOpenBugReport() }
@@ -273,8 +279,14 @@ class LoggedInFlowNode @AssistedInject constructor(
                     override fun onVerifyClicked() {
                         backstack.push(NavTarget.VerifySession)
                     }
+
+                    override fun onOpenRoomNotificationSettings(roomId: RoomId) {
+                        backstack.push(NavTarget.Room(roomId, initialElement = RoomLoadedFlowNode.NavTarget.RoomNotificationSettings))
+                    }
                 }
-                preferencesEntryPoint.nodeBuilder(this, buildContext)
+                val inputs = PreferencesEntryPoint.Params(navTarget.initialElement)
+                return preferencesEntryPoint.nodeBuilder(this, buildContext)
+                    .params(inputs)
                     .callback(callback)
                     .build()
             }

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

@@ -75,6 +75,7 @@ class RoomLoadedFlowNode @AssistedInject constructor(
 
     interface Callback : Plugin {
         fun onForwardedToSingleRoom(roomId: RoomId)
+        fun onOpenGlobalNotificationSettings()
     }
 
     data class Inputs(
@@ -128,6 +129,18 @@ class RoomLoadedFlowNode @AssistedInject constructor(
             }
     }
 
+    private fun createRoomDetailsNode(buildContext: BuildContext, initialTarget: RoomDetailsEntryPoint.InitialTarget): Node {
+        val callback = object : RoomDetailsEntryPoint.Callback {
+            override fun onOpenGlobalNotificationSettings() {
+                callbacks.forEach { it.onOpenGlobalNotificationSettings() }
+            }
+        }
+        return roomDetailsEntryPoint.nodeBuilder(this, buildContext)
+            .params(RoomDetailsEntryPoint.Params(initialTarget))
+            .callback(callback)
+            .build()
+    }
+
     override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
         return when (navTarget) {
             NavTarget.Messages -> {
@@ -147,12 +160,13 @@ class RoomLoadedFlowNode @AssistedInject constructor(
                 messagesEntryPoint.createNode(this, buildContext, callback)
             }
             NavTarget.RoomDetails -> {
-                val inputs = RoomDetailsEntryPoint.Inputs(RoomDetailsEntryPoint.InitialTarget.RoomDetails)
-                roomDetailsEntryPoint.createNode(this, buildContext, inputs, emptyList())
+                createRoomDetailsNode(buildContext, RoomDetailsEntryPoint.InitialTarget.RoomDetails)
             }
             is NavTarget.RoomMemberDetails -> {
-                val inputs = RoomDetailsEntryPoint.Inputs(RoomDetailsEntryPoint.InitialTarget.RoomMemberDetails(navTarget.userId))
-                roomDetailsEntryPoint.createNode(this, buildContext, inputs, emptyList())
+                createRoomDetailsNode(buildContext, RoomDetailsEntryPoint.InitialTarget.RoomMemberDetails(navTarget.userId))
+            }
+            NavTarget.RoomNotificationSettings -> {
+                createRoomDetailsNode(buildContext, RoomDetailsEntryPoint.InitialTarget.RoomNotificationSettings)
             }
         }
     }
@@ -166,6 +180,9 @@ class RoomLoadedFlowNode @AssistedInject constructor(
 
         @Parcelize
         data class RoomMemberDetails(val userId: UserId) : NavTarget
+
+        @Parcelize
+        data object RoomNotificationSettings : NavTarget
     }
 
     @Composable

appnav/src/test/kotlin/io/element/android/appnav/RoomFlowNodeTest.kt

@@ -71,14 +71,22 @@ class RoomFlowNodeTest {
 
         var nodeId: String? = null
 
-        override fun createNode(
-            parentNode: Node,
-            buildContext: BuildContext,
-            inputs: RoomDetailsEntryPoint.Inputs,
-            plugins: List<Plugin>
-        ): Node {
-            return node(buildContext) {}.also {
-                nodeId = it.id
+        override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): RoomDetailsEntryPoint.NodeBuilder {
+            return object : RoomDetailsEntryPoint.NodeBuilder {
+
+                override fun params(params: RoomDetailsEntryPoint.Params): RoomDetailsEntryPoint.NodeBuilder {
+                    return this
+                }
+
+                override fun callback(callback: RoomDetailsEntryPoint.Callback): RoomDetailsEntryPoint.NodeBuilder {
+                    return this
+                }
+
+                override fun build(): Node {
+                    return  node(buildContext) {}.also {
+                        nodeId = it.id
+                    }
+                }
             }
         }
     }

features/preferences/api/build.gradle.kts

@@ -15,6 +15,7 @@
  */
 plugins {
     id("io.element.android-library")
+    id("kotlin-parcelize")
 }
 
 android {

features/preferences/api/src/main/kotlin/io/element/android/features/preferences/api/PreferencesEntryPoint.kt

@@ -16,22 +16,37 @@
 
 package io.element.android.features.preferences.api
 
+import android.os.Parcelable
 import com.bumble.appyx.core.modality.BuildContext
 import com.bumble.appyx.core.node.Node
 import com.bumble.appyx.core.plugin.Plugin
 import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.matrix.api.core.RoomId
+import kotlinx.parcelize.Parcelize
 
 interface PreferencesEntryPoint : FeatureEntryPoint {
 
+    sealed interface InitialTarget : Parcelable {
+        @Parcelize
+        data object Root : InitialTarget
+        @Parcelize
+        data object NotificationSettings : InitialTarget
+    }
+
+    data class Params(val initialElement: InitialTarget) : NodeInputs
     fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
 
     interface NodeBuilder {
+
+        fun params(params: Params): NodeBuilder
         fun callback(callback: Callback): NodeBuilder
         fun build(): Node
     }
 
     interface Callback : Plugin {
         fun onOpenBugReport()
         fun onVerifyClicked()
+        fun onOpenRoomNotificationSettings(roomId: RoomId)
     }
 }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/DefaultPreferencesEntryPoint.kt

@@ -31,6 +31,11 @@ class DefaultPreferencesEntryPoint @Inject constructor() : PreferencesEntryPoint
         return object : PreferencesEntryPoint.NodeBuilder {
             val plugins = ArrayList<Plugin>()
 
+            override fun params(params: PreferencesEntryPoint.Params): PreferencesEntryPoint.NodeBuilder {
+                plugins += params
+                return this
+            }
+
             override fun callback(callback: PreferencesEntryPoint.Callback): PreferencesEntryPoint.NodeBuilder {
                 plugins += callback
                 return this
@@ -42,3 +47,8 @@ class DefaultPreferencesEntryPoint @Inject constructor() : PreferencesEntryPoint
         }
     }
 }
+
+internal fun PreferencesEntryPoint.InitialTarget.toNavTarget() = when (this) {
+    is PreferencesEntryPoint.InitialTarget.Root -> PreferencesFlowNode.NavTarget.Root
+    is PreferencesEntryPoint.InitialTarget.NotificationSettings -> PreferencesFlowNode.NavTarget.NotificationSettings
+}

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/PreferencesFlowNode.kt

@@ -43,6 +43,7 @@ import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import kotlinx.parcelize.Parcelize
 
@@ -52,7 +53,7 @@ class PreferencesFlowNode @AssistedInject constructor(
     @Assisted plugins: List<Plugin>,
 ) : BackstackNode<PreferencesFlowNode.NavTarget>(
     backstack = BackStack(
-        initialElement = NavTarget.Root,
+        initialElement = plugins.filterIsInstance<PreferencesEntryPoint.Params>().first().initialElement.toNavTarget(),
         savedStateMap = buildContext.savedStateMap,
     ),
     buildContext = buildContext,
@@ -152,8 +153,13 @@ class PreferencesFlowNode @AssistedInject constructor(
                 createNode<NotificationSettingsNode>(buildContext, listOf(notificationSettingsCallback))
             }
             is NavTarget.EditDefaultNotificationSetting -> {
+                val callback = object : EditDefaultNotificationSettingNode.Callback {
+                    override fun openRoomNotificationSettings(roomId: RoomId) {
+                        plugins<PreferencesEntryPoint.Callback>().forEach { it.onOpenRoomNotificationSettings(roomId) }
+                    }
+                }
                 val input = EditDefaultNotificationSettingNode.Inputs(navTarget.isOneToOne)
-                createNode<EditDefaultNotificationSettingNode>(buildContext, plugins = listOf(input))
+                createNode<EditDefaultNotificationSettingNode>(buildContext, plugins = listOf(input, callback))
             }
             NavTarget.AdvancedSettings -> {
                 createNode<AdvancedSettingsNode>(buildContext)

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/notifications/NotificationSettingsEvents.kt

@@ -24,4 +24,5 @@ sealed interface NotificationSettingsEvents {
     data class SetCallNotificationsEnabled(val enabled: Boolean) : NotificationSettingsEvents
     data object FixConfigurationMismatch : NotificationSettingsEvents
     data object ClearConfigurationMismatchError : NotificationSettingsEvents
+    data object ClearNotificationChangeError : NotificationSettingsEvents
 }

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/notifications/NotificationSettingsPresenter.kt

@@ -23,7 +23,9 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.notificationsettings.NotificationSettingsService
 import io.element.android.libraries.matrix.api.room.RoomNotificationMode
@@ -50,6 +52,7 @@ class NotificationSettingsPresenter @Inject constructor(
         val systemNotificationsEnabled: MutableState<Boolean> = remember {
             mutableStateOf(systemNotificationsEnabledProvider.notificationsEnabled())
         }
+        val changeNotificationSettingAction: MutableState<Async<Unit>> = remember { mutableStateOf(Async.Uninitialized) }
 
         val localCoroutineScope = rememberCoroutineScope()
         val appNotificationsEnabled = userPushStore
@@ -67,8 +70,12 @@ class NotificationSettingsPresenter @Inject constructor(
 
         fun handleEvents(event: NotificationSettingsEvents) {
             when (event) {
-                is NotificationSettingsEvents.SetAtRoomNotificationsEnabled -> localCoroutineScope.setAtRoomNotificationsEnabled(event.enabled)
-                is NotificationSettingsEvents.SetCallNotificationsEnabled -> localCoroutineScope.setCallNotificationsEnabled(event.enabled)
+                is NotificationSettingsEvents.SetAtRoomNotificationsEnabled -> {
+                    localCoroutineScope.setAtRoomNotificationsEnabled(event.enabled, changeNotificationSettingAction)
+                }
+                is NotificationSettingsEvents.SetCallNotificationsEnabled -> {
+                    localCoroutineScope.setCallNotificationsEnabled(event.enabled, changeNotificationSettingAction)
+                }
                 is NotificationSettingsEvents.SetNotificationsEnabled -> localCoroutineScope.setNotificationsEnabled(userPushStore, event.enabled)
                 NotificationSettingsEvents.ClearConfigurationMismatchError -> {
                     matrixSettings.value = NotificationSettingsState.MatrixSettings.Invalid(fixFailed = false)
@@ -77,6 +84,7 @@ class NotificationSettingsPresenter @Inject constructor(
                 NotificationSettingsEvents.RefreshSystemNotificationsEnabled -> {
                     systemNotificationsEnabled.value = systemNotificationsEnabledProvider.notificationsEnabled()
                 }
+                NotificationSettingsEvents.ClearNotificationChangeError -> changeNotificationSettingAction.value = Async.Uninitialized
             }
         }
 
@@ -86,6 +94,7 @@ class NotificationSettingsPresenter @Inject constructor(
                 systemNotificationsEnabled = systemNotificationsEnabled.value,
                 appNotificationsEnabled = appNotificationsEnabled.value
             ),
+            changeNotificationSettingAction = changeNotificationSettingAction.value,
             eventSink = ::handleEvents
         )
     }
@@ -154,12 +163,16 @@ class NotificationSettingsPresenter @Inject constructor(
         )
     }
 
-    private fun CoroutineScope.setAtRoomNotificationsEnabled(enabled: Boolean) = launch {
-        notificationSettingsService.setRoomMentionEnabled(enabled)
+    private fun CoroutineScope.setAtRoomNotificationsEnabled(enabled: Boolean, action: MutableState<Async<Unit>>) = launch {
+        suspend {
+            notificationSettingsService.setRoomMentionEnabled(enabled).getOrThrow()
+        }.runCatchingUpdatingState(action)
     }
 
-    private fun CoroutineScope.setCallNotificationsEnabled(enabled: Boolean) = launch {
-        notificationSettingsService.setCallEnabled(enabled)
+    private fun CoroutineScope.setCallNotificationsEnabled(enabled: Boolean, action: MutableState<Async<Unit>>) = launch {
+        suspend {
+            notificationSettingsService.setCallEnabled(enabled).getOrThrow()
+        }.runCatchingUpdatingState(action)
     }
 
     private fun CoroutineScope.setNotificationsEnabled(userPushStore: UserPushStore, enabled: Boolean) = launch {

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/notifications/NotificationSettingsState.kt

@@ -17,12 +17,14 @@
 package io.element.android.features.preferences.impl.notifications
 
 import androidx.compose.runtime.Immutable
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.room.RoomNotificationMode
 
 @Immutable
 data class NotificationSettingsState(
     val matrixSettings: MatrixSettings,
     val appSettings: AppSettings,
+    val changeNotificationSettingAction: Async<Unit>,
     val eventSink: (NotificationSettingsEvents) -> Unit,
 ) {
     sealed interface MatrixSettings {

features/preferences/impl/src/main/kotlin/io/element/android/features/preferences/impl/notifications/NotificationSettingsStateProvider.kt

@@ -17,16 +17,21 @@
 package io.element.android.features.preferences.impl.notifications
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.matrix.api.room.RoomNotificationMode
 
 open class NotificationSettingsStateProvider : PreviewParameterProvider<NotificationSettingsState> {
     override val values: Sequence<NotificationSettingsState>
         get() = sequenceOf(
             aNotificationSettingsState(),
+            aNotificationSettingsState(changeNotificationSettingAction = Async.Loading(Unit)),
+            aNotificationSettingsState(changeNotificationSettingAction = Async.Failure(Throwable("error"))),
         )
 }
 
-fun aNotificationSettingsState() = NotificationSettingsState(
+fun aNotificationSettingsState(
+    changeNotificationSettingAction: Async<Unit> = Async.Uninitialized,
+) = NotificationSettingsState(
     matrixSettings = NotificationSettingsState.MatrixSettings.Valid(
         atRoomNotificationsEnabled = true,
         callNotificationsEnabled = true,
@@ -37,5 +42,6 @@ fun aNotificationSettingsState() = NotificationSettingsState(
         systemNotificationsEnabled = false,
         appNotificationsEnabled = true,
     ),
+    changeNotificationSettingAction = changeNotificationSettingAction,
     eventSink = {}
 )