Local Notification Settings Event

changelog.d/7281.wip

@@ -0,0 +1 @@
+Links "Enable Notifications for this session" setting to enabled value in pusher

changelog.d/7300.wip

@@ -0,0 +1 @@
+Implements client-side of local notification settings event

library/ui-strings/src/main/res/values/strings.xml

@@ -1663,6 +1663,7 @@
     <string name="create_new_room">Create New Room</string>
     <string name="create_new_space">Create New Space</string>
     <string name="error_no_network">No network. Please check your Internet connection.</string>
+    <string name="error_check_network">Something went wrong. Please check your network connection and try again.</string>
     <string name="change_room_directory_network">"Change network"</string>
     <string name="please_wait">"Please wait…"</string>
     <string name="updating_your_data">Updating your data…</string>

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/account/LocalNotificationSettingsContent.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 The Matrix.org Foundation C.I.C.
+ *
+ * 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 org.matrix.android.sdk.api.account
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+data class LocalNotificationSettingsContent(
+        @Json(name = "is_silenced") val isSilenced: Boolean = false
+)

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/accountdata/UserAccountDataTypes.kt

@@ -28,4 +28,5 @@ object UserAccountDataTypes {
     const val TYPE_IDENTITY_SERVER = "m.identity_server"
     const val TYPE_ACCEPTED_TERMS = "m.accepted_terms"
     const val TYPE_OVERRIDE_COLORS = "im.vector.setting.override_colors"
+    const val TYPE_LOCAL_NOTIFICATION_SETTINGS = "m.local_notification_settings"
 }

vector/src/main/java/im/vector/app/core/pushers/PushersManager.kt

@@ -23,6 +23,7 @@ import im.vector.app.core.resources.AppNameProvider
 import im.vector.app.core.resources.LocaleProvider
 import im.vector.app.core.resources.StringProvider
 import org.matrix.android.sdk.api.session.pushers.HttpPusher
+import org.matrix.android.sdk.api.session.pushers.Pusher
 import java.util.UUID
 import javax.inject.Inject
 import kotlin.math.abs
@@ -90,6 +91,18 @@ class PushersManager @Inject constructor(
         )
     }
 
+    fun getPusherForCurrentSession(): Pusher? {
+        val session = activeSessionHolder.getSafeActiveSession() ?: return null
+        val deviceId = session.sessionParams.deviceId
+        return session.pushersService().getPushers().firstOrNull { it.deviceId == deviceId }
+    }
+
+    suspend fun togglePusherForCurrentSession(enable: Boolean) {
+        val session = activeSessionHolder.getSafeActiveSession() ?: return
+        val pusher = getPusherForCurrentSession() ?: return
+        session.pushersService().togglePusher(pusher, enable)
+    }
+
     suspend fun unregisterEmailPusher(email: String) {
         val currentSession = activeSessionHolder.getSafeActiveSession() ?: return
         currentSession.pushersService().removeEmailPusher(email)

vector/src/main/java/im/vector/app/features/home/HomeActivity.kt

@@ -215,6 +215,7 @@ class HomeActivity :
                 )
             }
         }
+
         sharedActionViewModel = viewModelProvider[HomeSharedActionViewModel::class.java]
         roomListSharedActionViewModel = viewModelProvider[RoomListSharedActionViewModel::class.java]
         views.drawerLayout.addDrawerListener(drawerListener)
@@ -406,6 +407,14 @@ class HomeActivity :
     }
 
     private fun renderState(state: HomeActivityViewState) {
+        lifecycleScope.launch {
+            if (state.areNotificationsSilenced) {
+                unifiedPushHelper.unregister(pushersManager)
+            } else {
+                unifiedPushHelper.register(this@HomeActivity)
+            }
+        }
+
         when (val status = state.syncRequestState) {
             is SyncRequestState.InitialSyncProgressing -> {
                 val initSyncStepStr = initSyncStepFormatter.format(status.initialSyncStep)

vector/src/main/java/im/vector/app/features/home/HomeActivityViewModel.kt

@@ -16,6 +16,7 @@
 
 package im.vector.app.features.home
 
+import androidx.lifecycle.asFlow
 import com.airbnb.mvrx.Mavericks
 import com.airbnb.mvrx.MavericksViewModelFactory
 import com.airbnb.mvrx.ViewModelContext
@@ -45,10 +46,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.takeWhile
 import kotlinx.coroutines.launch
+import org.matrix.android.sdk.api.account.LocalNotificationSettingsContent
 import org.matrix.android.sdk.api.auth.UIABaseAuth
 import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
 import org.matrix.android.sdk.api.auth.UserPasswordAuth
@@ -57,9 +60,11 @@ import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
 import org.matrix.android.sdk.api.auth.registration.nextUncompletedStage
 import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.raw.RawService
+import org.matrix.android.sdk.api.session.accountdata.UserAccountDataTypes
 import org.matrix.android.sdk.api.session.crypto.crosssigning.CrossSigningService
 import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
 import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.api.session.getUserOrDefault
 import org.matrix.android.sdk.api.session.pushrules.RuleIds
 import org.matrix.android.sdk.api.session.room.model.Membership
@@ -115,6 +120,7 @@ class HomeActivityViewModel @AssistedInject constructor(
         observeCrossSigningReset()
         observeAnalytics()
         observeReleaseNotes()
+        observeLocalNotificationsSilenced()
         initThreadsMigration()
     }
 
@@ -136,6 +142,17 @@ class HomeActivityViewModel @AssistedInject constructor(
         }
     }
 
+    fun observeLocalNotificationsSilenced() {
+        val currentSession = activeSessionHolder.getActiveSession()
+        viewModelScope.launch {
+            currentSession.accountDataService()
+                    .getLiveUserAccountDataEvent(UserAccountDataTypes.TYPE_LOCAL_NOTIFICATION_SETTINGS)
+                    .asFlow()
+                    .map { it.getOrNull()?.content?.toModel<LocalNotificationSettingsContent>()?.isSilenced ?: false }
+                    .onEach { setState { copy(areNotificationsSilenced = it) } }
+        }
+    }
+
     private fun observeAnalytics() {
         if (analyticsConfig.isEnabled) {
             analyticsStore.didAskUserConsentFlow

vector/src/main/java/im/vector/app/features/home/HomeActivityViewState.kt

@@ -22,5 +22,6 @@ import org.matrix.android.sdk.api.session.sync.SyncRequestState
 
 data class HomeActivityViewState(
         val syncRequestState: SyncRequestState = SyncRequestState.Idle,
-        val authenticationDescription: AuthenticationDescription? = null
+        val authenticationDescription: AuthenticationDescription? = null,
+        val areNotificationsSilenced: Boolean = false,
 ) : MavericksState

vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsNotificationPreferenceFragment.kt

@@ -54,6 +54,7 @@ import im.vector.app.features.settings.VectorPreferences
 import im.vector.app.features.settings.VectorSettingsBaseFragment
 import im.vector.app.features.settings.VectorSettingsFragmentInteractionListener
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.session.Session
@@ -104,6 +105,10 @@ class VectorSettingsNotificationPreferenceFragment :
         }
 
         findPreference<SwitchPreference>(VectorPreferences.SETTINGS_ENABLE_THIS_DEVICE_PREFERENCE_KEY)?.let {
+            pushersManager.getPusherForCurrentSession()?.let { pusher ->
+                it.isChecked = pusher.enabled
+            }
+
             it.setTransactionalSwitchChangeListener(lifecycleScope) { isChecked ->
                 if (isChecked) {
                     unifiedPushHelper.register(requireActivity()) {
@@ -117,6 +122,16 @@ class VectorSettingsNotificationPreferenceFragment :
                         }
                         findPreference<VectorPreference>(VectorPreferences.SETTINGS_NOTIFICATION_METHOD_KEY)
                                 ?.summary = unifiedPushHelper.getCurrentDistributorName()
+                        lifecycleScope.launch {
+                            val result = runCatching {
+                                pushersManager.togglePusherForCurrentSession(true)
+                            }
+
+                            result.exceptionOrNull()?.let { _ ->
+                                Toast.makeText(context, R.string.error_check_network, Toast.LENGTH_SHORT).show()
+                                it.isChecked = false
+                            }
+                        }
                     }
                 } else {
                     unifiedPushHelper.unregister(pushersManager)

vector/src/test/java/im/vector/app/core/pushers/PushersManagerTest.kt

@@ -24,8 +24,12 @@ import im.vector.app.test.fakes.FakeLocaleProvider
 import im.vector.app.test.fakes.FakePushersService
 import im.vector.app.test.fakes.FakeSession
 import im.vector.app.test.fakes.FakeStringProvider
+import im.vector.app.test.fixtures.CredentialsFixture
 import im.vector.app.test.fixtures.CryptoDeviceInfoFixture.aCryptoDeviceInfo
+import im.vector.app.test.fixtures.PusherFixture
+import im.vector.app.test.fixtures.SessionParamsFixture
 import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
 import org.amshove.kluent.shouldBeEqualTo
 import org.junit.Test
 import org.matrix.android.sdk.api.session.crypto.model.UnsignedDeviceInfo
@@ -82,4 +86,34 @@ class PushersManagerTest {
         val httpPusher = pushersService.verifyEnqueueAddHttpPusher()
         httpPusher shouldBeEqualTo expectedHttpPusher
     }
+
+    @Test
+    fun `when getPusherForCurrentSession, then return pusher`() {
+        val deviceId = "device_id"
+        val sessionParams = SessionParamsFixture.aSessionParams(
+                credentials = CredentialsFixture.aCredentials(deviceId = deviceId)
+        )
+        session.givenSessionParams(sessionParams)
+        val expectedPusher = PusherFixture.aPusher(deviceId = deviceId)
+        pushersService.givenGetPushers(listOf(expectedPusher))
+
+        val pusher = pushersManager.getPusherForCurrentSession()
+
+        pusher shouldBeEqualTo expectedPusher
+    }
+
+    @Test
+    fun `when togglePusherForCurrentSession, then do service toggle pusher`() = runTest {
+        val deviceId = "device_id"
+        val sessionParams = SessionParamsFixture.aSessionParams(
+                credentials = CredentialsFixture.aCredentials(deviceId = deviceId)
+        )
+        session.givenSessionParams(sessionParams)
+        val pusher = PusherFixture.aPusher(deviceId = deviceId)
+        pushersService.givenGetPushers(listOf(pusher))
+
+        pushersManager.togglePusherForCurrentSession(true)
+
+        pushersService.verifyOnlyGetPushersAndTogglePusherCalled(pusher, true)
+    }
 }

vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt

@@ -21,6 +21,7 @@ import androidx.arch.core.executor.testing.InstantTaskExecutorRule
 import com.airbnb.mvrx.Loading
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.test.MavericksTestRule
+import im.vector.app.R
 import im.vector.app.features.settings.devices.v2.DeviceFullInfo
 import im.vector.app.features.settings.devices.v2.RefreshDevicesUseCase
 import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
@@ -55,8 +56,10 @@ import org.junit.Test
 import org.matrix.android.sdk.api.auth.UIABaseAuth
 import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
 import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
+import org.matrix.android.sdk.api.failure.Failure
 import org.matrix.android.sdk.api.session.crypto.model.RoomEncryptionTrustLevel
 import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
+import javax.net.ssl.HttpsURLConnection
 import kotlin.coroutines.Continuation
 
 private const val A_SESSION_ID_1 = "session-id-1"
@@ -203,6 +206,113 @@ class SessionOverviewViewModelTest {
                 .finish()
     }
 
+    @Test
+    fun `given another session and no reAuth is needed when handling signout action then signout process is performed`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        givenSignoutSuccess(A_SESSION_ID_1)
+        every { refreshDevicesUseCase.execute() } just runs
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+                pushers = Loading(),
+        )
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(signoutAction)
+
+        // Then
+        viewModelTest
+                .assertStatesChanges(
+                        expectedViewState,
+                        { copy(isLoading = true) },
+                        { copy(isLoading = false) }
+                )
+                .assertEvent { it is SessionOverviewViewEvent.SignoutSuccess }
+                .finish()
+        verify {
+            refreshDevicesUseCase.execute()
+        }
+    }
+
+    @Test
+    fun `given another session and server error during signout when handling signout action then signout process is performed`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val serverError = Failure.OtherServerError(errorBody = "", httpCode = HttpsURLConnection.HTTP_UNAUTHORIZED)
+        givenSignoutError(A_SESSION_ID_1, serverError)
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+                pushers = Loading(),
+        )
+        fakeStringProvider.given(R.string.authentication_error, AUTH_ERROR_MESSAGE)
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(signoutAction)
+
+        // Then
+        viewModelTest
+                .assertStatesChanges(
+                        expectedViewState,
+                        { copy(isLoading = true) },
+                        { copy(isLoading = false) }
+                )
+                .assertEvent { it is SessionOverviewViewEvent.SignoutError && it.error.message == AUTH_ERROR_MESSAGE }
+                .finish()
+    }
+
+    @Test
+    fun `given another session and unexpected error during signout when handling signout action then signout process is performed`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val error = Exception()
+        givenSignoutError(A_SESSION_ID_1, error)
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+                pushers = Loading(),
+        )
+        fakeStringProvider.given(R.string.matrix_error, AN_ERROR_MESSAGE)
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(signoutAction)
+
+        // Then
+        viewModelTest
+                .assertStatesChanges(
+                        expectedViewState,
+                        { copy(isLoading = true) },
+                        { copy(isLoading = false) }
+                )
+                .assertEvent { it is SessionOverviewViewEvent.SignoutError && it.error.message == AN_ERROR_MESSAGE }
+                .finish()
+    }
+
     @Test
     fun `given another session and reAuth is needed during signout when handling signout action then requestReAuth is sent and pending auth is stored`() {
         // Given

vector/src/test/java/im/vector/app/test/fakes/FakePushersService.kt

@@ -29,10 +29,21 @@ import org.matrix.android.sdk.api.session.pushers.PushersService
 
 class FakePushersService : PushersService by mockk(relaxed = true) {
 
+    fun givenGetPushers(pushers: List<Pusher>) {
+        every { getPushers() } returns pushers
+    }
+
     fun givenPushersLive(pushers: List<Pusher>) {
         every { getPushersLive() } returns liveData { emit(pushers) }
     }
 
+    fun verifyOnlyGetPushersAndTogglePusherCalled(pusher: Pusher, enable: Boolean) {
+        coVerify(ordering = Ordering.ALL) {
+            getPushers()
+            togglePusher(pusher, enable)
+        }
+    }
+
     fun verifyOnlyTogglePusherCalled(pusher: Pusher, enable: Boolean) {
         coVerify(ordering = Ordering.ALL) {
             getPushersLive() // verifies only getPushersLive and the following togglePusher was called