From 320e9eac390d6c35561f494b45dd989a5670ae29 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Wed, 21 Sep 2022 11:53:28 +0200
Subject: [PATCH 01/17] Adding changelog entry

---
 changelog.d/7190.wip | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 changelog.d/7190.wip

diff --git a/changelog.d/7190.wip b/changelog.d/7190.wip
new file mode 100644
index 0000000000..3c70666d91
--- /dev/null
+++ b/changelog.d/7190.wip
@@ -0,0 +1 @@
+[Device management] Sign out a session

From 5380c3078042e48b8609333ff2b28e57db32aeb0 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Thu, 22 Sep 2022 17:26:04 +0200
Subject: [PATCH 02/17] Adding signout action and corresponding use cases

---
 .../v2/overview/SessionOverviewAction.kt      |  1 +
 .../v2/overview/SessionOverviewViewEvent.kt   |  5 ++
 .../v2/overview/SessionOverviewViewModel.kt   | 33 +++++++++++
 .../InterceptSignoutFlowResponseUseCase.kt    | 59 +++++++++++++++++++
 .../v2/signout/SignoutSessionResult.kt        | 32 ++++++++++
 .../v2/signout/SignoutSessionUseCase.kt       | 40 +++++++++++++
 6 files changed, 170 insertions(+)
 create mode 100644 vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
 create mode 100644 vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionResult.kt
 create mode 100644 vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
index 1118c5dc5b..cea0281570 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
@@ -20,4 +20,5 @@ import im.vector.app.core.platform.VectorViewModelAction
 
 sealed class SessionOverviewAction : VectorViewModelAction {
     object VerifySession : SessionOverviewAction()
+    object SignoutSession : SessionOverviewAction()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
index 8508b395ad..ac64e3dfe6 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
@@ -17,9 +17,14 @@
 package im.vector.app.features.settings.devices.v2.overview
 
 import im.vector.app.core.platform.VectorViewEvents
+import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
 
 sealed class SessionOverviewViewEvent : VectorViewEvents {
     object ShowVerifyCurrentSession : SessionOverviewViewEvent()
     data class ShowVerifyOtherSession(val deviceId: String) : SessionOverviewViewEvent()
     object PromptResetSecrets : SessionOverviewViewEvent()
+    data class RequestReAuth(
+            val registrationFlowResponse: RegistrationFlowResponse,
+            val lastErrorCode: String?
+    ) : SessionOverviewViewEvent()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 69556e039e..2f3116f40f 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -25,14 +25,22 @@ import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.di.MavericksAssistedViewModelFactory
 import im.vector.app.core.di.hiltMavericksViewModelFactory
 import im.vector.app.core.platform.VectorViewModel
+import im.vector.app.features.auth.PendingAuthHandler
 import im.vector.app.features.settings.devices.v2.IsCurrentSessionUseCase
+import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
+import im.vector.app.features.settings.devices.v2.signout.SignoutSessionUseCase
 import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+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.session.crypto.model.RoomEncryptionTrustLevel
+import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
+import kotlin.coroutines.Continuation
 
 class SessionOverviewViewModel @AssistedInject constructor(
         @Assisted val initialState: SessionOverviewViewState,
@@ -40,6 +48,9 @@ class SessionOverviewViewModel @AssistedInject constructor(
         private val isCurrentSessionUseCase: IsCurrentSessionUseCase,
         private val getDeviceFullInfoUseCase: GetDeviceFullInfoUseCase,
         private val checkIfCurrentSessionCanBeVerifiedUseCase: CheckIfCurrentSessionCanBeVerifiedUseCase,
+        private val signoutSessionUseCase: SignoutSessionUseCase,
+        private val interceptSignoutFlowResponseUseCase: InterceptSignoutFlowResponseUseCase,
+        private val pendingAuthHandler: PendingAuthHandler,
 ) : VectorViewModel<SessionOverviewViewState, SessionOverviewAction, SessionOverviewViewEvent>(initialState) {
 
     companion object : MavericksViewModelFactory<SessionOverviewViewModel, SessionOverviewViewState> by hiltMavericksViewModelFactory()
@@ -83,6 +94,7 @@ class SessionOverviewViewModel @AssistedInject constructor(
     override fun handle(action: SessionOverviewAction) {
         when (action) {
             is SessionOverviewAction.VerifySession -> handleVerifySessionAction()
+            SessionOverviewAction.SignoutSession -> handleSignoutSession()
         }
     }
 
@@ -108,4 +120,25 @@ class SessionOverviewViewModel @AssistedInject constructor(
     private fun handleVerifyOtherSession(deviceId: String) {
         _viewEvents.post(SessionOverviewViewEvent.ShowVerifyOtherSession(deviceId))
     }
+
+    // TODO add unit tests
+    private fun handleSignoutSession() = withState { state ->
+        // TODO should we do something different when it is current session?
+        viewModelScope.launch {
+            signoutSessionUseCase.execute(state.deviceId, object : UserInteractiveAuthInterceptor {
+                override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation<UIABaseAuth>) {
+                    when (val result = interceptSignoutFlowResponseUseCase.execute(flowResponse, errCode, promise)) {
+                        is SignoutSessionResult.ReAuthNeeded -> onReAuthNeeded(result)
+                        is SignoutSessionResult.Completed -> Unit // TODO refresh devices list? + post event to close the associated screen
+                    }
+                }
+            })
+        }
+    }
+
+    private fun onReAuthNeeded(reAuthNeeded: SignoutSessionResult.ReAuthNeeded) {
+        pendingAuthHandler.pendingAuth = DefaultBaseAuth(session = reAuthNeeded.flowResponse.session)
+        pendingAuthHandler.uiaContinuation = reAuthNeeded.uiaContinuation
+        _viewEvents.post(SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode))
+    }
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
new file mode 100644
index 0000000000..4e69452ab3
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2.signout
+
+import im.vector.app.core.di.ActiveSessionHolder
+import im.vector.app.features.login.ReAuthHelper
+import org.matrix.android.sdk.api.auth.UIABaseAuth
+import org.matrix.android.sdk.api.auth.UserPasswordAuth
+import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
+import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
+import org.matrix.android.sdk.api.auth.registration.nextUncompletedStage
+import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
+import javax.inject.Inject
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+
+// TODO add unit tests
+class InterceptSignoutFlowResponseUseCase @Inject constructor(
+        private val reAuthHelper: ReAuthHelper,
+        private val activeSessionHolder: ActiveSessionHolder,
+) {
+
+    fun execute(
+            flowResponse: RegistrationFlowResponse,
+            errCode: String?,
+            promise: Continuation<UIABaseAuth>
+    ): SignoutSessionResult {
+        return if (flowResponse.nextUncompletedStage() == LoginFlowTypes.PASSWORD && reAuthHelper.data != null && errCode == null) {
+            UserPasswordAuth(
+                    session = null,
+                    user = activeSessionHolder.getActiveSession().myUserId,
+                    password = reAuthHelper.data
+            ).let { promise.resume(it) }
+
+            SignoutSessionResult.Completed
+        } else {
+            SignoutSessionResult.ReAuthNeeded(
+                    pendingAuth = DefaultBaseAuth(session = flowResponse.session),
+                    uiaContinuation = promise,
+                    flowResponse = flowResponse,
+                    errCode = errCode
+            )
+        }
+    }
+}
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionResult.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionResult.kt
new file mode 100644
index 0000000000..fa1fb31b66
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionResult.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2.signout
+
+import org.matrix.android.sdk.api.auth.UIABaseAuth
+import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
+import kotlin.coroutines.Continuation
+
+sealed class SignoutSessionResult {
+    data class ReAuthNeeded(
+            val pendingAuth: UIABaseAuth,
+            val uiaContinuation: Continuation<UIABaseAuth>,
+            val flowResponse: RegistrationFlowResponse,
+            val errCode: String?
+    ) : SignoutSessionResult()
+
+    object Completed : SignoutSessionResult()
+}
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt
new file mode 100644
index 0000000000..b86dab13cd
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2.signout
+
+import im.vector.app.core.di.ActiveSessionHolder
+import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
+import org.matrix.android.sdk.api.util.awaitCallback
+import javax.inject.Inject
+
+// TODO add unit tests
+class SignoutSessionUseCase @Inject constructor(
+        private val activeSessionHolder: ActiveSessionHolder,
+) {
+
+    suspend fun execute(deviceId: String, userInteractiveAuthInterceptor: UserInteractiveAuthInterceptor): Result<Unit> {
+        return deleteDevice(deviceId, userInteractiveAuthInterceptor)
+    }
+
+    private suspend fun deleteDevice(deviceId: String, userInteractiveAuthInterceptor: UserInteractiveAuthInterceptor) = runCatching {
+        awaitCallback<Unit> { matrixCallback ->
+            activeSessionHolder.getActiveSession()
+                    .cryptoService()
+                    .deleteDevice(deviceId, userInteractiveAuthInterceptor, matrixCallback)
+        }
+    }
+}

From 7e81aa6193bbf7ad05dff06b325259d17f2fc21c Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Fri, 23 Sep 2022 10:13:48 +0200
Subject: [PATCH 03/17] ReAuth process

---
 .../v2/overview/SessionOverviewAction.kt      |  5 ++-
 .../v2/overview/SessionOverviewFragment.kt    | 38 +++++++++++++++++++
 .../v2/overview/SessionOverviewViewModel.kt   | 25 +++++++++++-
 3 files changed, 66 insertions(+), 2 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
index cea0281570..c0d428b951 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 New Vector Ltd
+ * Copyright (c) 2022 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.
@@ -21,4 +21,7 @@ import im.vector.app.core.platform.VectorViewModelAction
 sealed class SessionOverviewAction : VectorViewModelAction {
     object VerifySession : SessionOverviewAction()
     object SignoutSession : SessionOverviewAction()
+    object SsoAuthDone : SessionOverviewAction()
+    data class PasswordAuthDone(val password: String) : SessionOverviewAction()
+    object ReAuthCancelled : SessionOverviewAction()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index ccf68a18bc..c369065292 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -16,6 +16,7 @@
 
 package im.vector.app.features.settings.devices.v2.overview
 
+import android.app.Activity
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.MenuItem
@@ -30,13 +31,16 @@ import com.airbnb.mvrx.withState
 import dagger.hilt.android.AndroidEntryPoint
 import im.vector.app.R
 import im.vector.app.core.date.VectorDateFormatter
+import im.vector.app.core.extensions.registerStartForActivityResult
 import im.vector.app.core.platform.VectorBaseFragment
 import im.vector.app.core.platform.VectorMenuProvider
 import im.vector.app.core.resources.ColorProvider
 import im.vector.app.core.resources.DrawableProvider
 import im.vector.app.databinding.FragmentSessionOverviewBinding
+import im.vector.app.features.auth.ReAuthActivity
 import im.vector.app.features.crypto.recover.SetupMode
 import im.vector.app.features.settings.devices.v2.list.SessionInfoViewState
+import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
 import javax.inject.Inject
 
 /**
@@ -92,6 +96,7 @@ class SessionOverviewFragment :
                 is SessionOverviewViewEvent.PromptResetSecrets -> {
                     navigator.open4SSetup(requireActivity(), SetupMode.PASSPHRASE_AND_NEEDED_SECRETS_RESET)
                 }
+                is SessionOverviewViewEvent.RequestReAuth -> askForReAuthentication(it)
             }
         }
     }
@@ -157,4 +162,37 @@ class SessionOverviewFragment :
             views.sessionOverviewInfo.isVisible = false
         }
     }
+
+    private val reAuthActivityResultLauncher = registerStartForActivityResult { activityResult ->
+        if (activityResult.resultCode == Activity.RESULT_OK) {
+            when (activityResult.data?.extras?.getString(ReAuthActivity.RESULT_FLOW_TYPE)) {
+                LoginFlowTypes.SSO -> {
+                    viewModel.handle(SessionOverviewAction.SsoAuthDone)
+                }
+                LoginFlowTypes.PASSWORD -> {
+                    val password = activityResult.data?.extras?.getString(ReAuthActivity.RESULT_VALUE) ?: ""
+                    viewModel.handle(SessionOverviewAction.PasswordAuthDone(password))
+                }
+                else -> {
+                    viewModel.handle(SessionOverviewAction.ReAuthCancelled)
+                }
+            }
+        } else {
+            viewModel.handle(SessionOverviewAction.ReAuthCancelled)
+        }
+    }
+
+    /**
+     * Launch the re auth activity to get credentials.
+     */
+    private fun askForReAuthentication(reAuthReq: SessionOverviewViewEvent.RequestReAuth) {
+        ReAuthActivity.newIntent(
+                requireContext(),
+                reAuthReq.registrationFlowResponse,
+                reAuthReq.lastErrorCode,
+                getString(R.string.devices_delete_dialog_title)
+        ).let { intent ->
+            reAuthActivityResultLauncher.launch(intent)
+        }
+    }
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 2f3116f40f..7dab404167 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -28,6 +28,7 @@ import im.vector.app.core.platform.VectorViewModel
 import im.vector.app.features.auth.PendingAuthHandler
 import im.vector.app.features.settings.devices.v2.IsCurrentSessionUseCase
 import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
+import im.vector.app.features.settings.devices.v2.signout.SignoutSessionResult
 import im.vector.app.features.settings.devices.v2.signout.SignoutSessionUseCase
 import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
 import kotlinx.coroutines.flow.distinctUntilChanged
@@ -40,6 +41,7 @@ import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
 import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
 import org.matrix.android.sdk.api.session.crypto.model.RoomEncryptionTrustLevel
 import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
+import timber.log.Timber
 import kotlin.coroutines.Continuation
 
 class SessionOverviewViewModel @AssistedInject constructor(
@@ -91,10 +93,14 @@ class SessionOverviewViewModel @AssistedInject constructor(
                 }
     }
 
+    // TODO add unit tests
     override fun handle(action: SessionOverviewAction) {
         when (action) {
             is SessionOverviewAction.VerifySession -> handleVerifySessionAction()
             SessionOverviewAction.SignoutSession -> handleSignoutSession()
+            SessionOverviewAction.SsoAuthDone -> handleSsoAuthDone()
+            is SessionOverviewAction.PasswordAuthDone -> handlePasswordAuthDone(action)
+            SessionOverviewAction.ReAuthCancelled -> handleReAuthCancelled()
         }
     }
 
@@ -129,7 +135,11 @@ class SessionOverviewViewModel @AssistedInject constructor(
                 override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation<UIABaseAuth>) {
                     when (val result = interceptSignoutFlowResponseUseCase.execute(flowResponse, errCode, promise)) {
                         is SignoutSessionResult.ReAuthNeeded -> onReAuthNeeded(result)
-                        is SignoutSessionResult.Completed -> Unit // TODO refresh devices list? + post event to close the associated screen
+                        is SignoutSessionResult.Completed -> {
+                            Timber.d("signout completed")
+                            // TODO check if it is called after a reAuth
+                            // TODO refresh devices list? + post event to close the associated screen
+                        }
                     }
                 }
             })
@@ -137,8 +147,21 @@ class SessionOverviewViewModel @AssistedInject constructor(
     }
 
     private fun onReAuthNeeded(reAuthNeeded: SignoutSessionResult.ReAuthNeeded) {
+        Timber.d("onReAuthNeeded")
         pendingAuthHandler.pendingAuth = DefaultBaseAuth(session = reAuthNeeded.flowResponse.session)
         pendingAuthHandler.uiaContinuation = reAuthNeeded.uiaContinuation
         _viewEvents.post(SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode))
     }
+
+    private fun handleSsoAuthDone() {
+        pendingAuthHandler.ssoAuthDone()
+    }
+
+    private fun handlePasswordAuthDone(action: SessionOverviewAction.PasswordAuthDone) {
+        pendingAuthHandler.passwordAuthDone(action.password)
+    }
+
+    private fun handleReAuthCancelled() {
+        pendingAuthHandler.reAuthCancelled()
+    }
 }

From b2b3ee1fe5923d3c2ffacb7ae3d9afa0db519bb7 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Fri, 23 Sep 2022 16:11:55 +0200
Subject: [PATCH 04/17] Adding button to trigger sign out

---
 .../src/main/res/values/strings.xml           |  1 +
 .../src/main/res/values/styles_buttons.xml    |  4 ++
 .../v2/overview/SessionOverviewFragment.kt    | 33 +++++++-----
 .../v2/overview/SessionOverviewViewEvent.kt   |  3 ++
 .../v2/overview/SessionOverviewViewModel.kt   | 51 +++++++++++++++----
 .../overview/SessionOverviewViewNavigator.kt  |  6 +++
 .../res/layout/fragment_session_overview.xml  | 13 +++++
 7 files changed, 89 insertions(+), 22 deletions(-)

diff --git a/library/ui-strings/src/main/res/values/strings.xml b/library/ui-strings/src/main/res/values/strings.xml
index 4d9ea008d5..6e68b09ee7 100644
--- a/library/ui-strings/src/main/res/values/strings.xml
+++ b/library/ui-strings/src/main/res/values/strings.xml
@@ -3290,6 +3290,7 @@
     <string name="device_manager_other_sessions_no_unverified_sessions_found">No unverified sessions found.</string>
     <string name="device_manager_other_sessions_no_inactive_sessions_found">No inactive sessions found.</string>
     <string name="device_manager_other_sessions_clear_filter">Clear Filter</string>
+    <string name="device_manager_session_overview_signout">Sign out of this session</string>
     <string name="device_manager_session_details_title">Session details</string>
     <string name="device_manager_session_details_description">Application, device, and activity information.</string>
     <string name="device_manager_session_details_session_name">Session name</string>
diff --git a/library/ui-styles/src/main/res/values/styles_buttons.xml b/library/ui-styles/src/main/res/values/styles_buttons.xml
index 702f427cc0..db78fcf338 100644
--- a/library/ui-styles/src/main/res/values/styles_buttons.xml
+++ b/library/ui-styles/src/main/res/values/styles_buttons.xml
@@ -41,6 +41,10 @@
         <item name="lineHeight">24sp</item>
     </style>
 
+    <style name="Widget.Vector.Button.Text.Destructive">
+        <item name="materialThemeOverlay">@style/VectorMaterialThemeOverlayDestructive</item>
+    </style>
+
     <style name="Widget.Vector.Button.Text.OnPrimary">
         <item name="colorControlHighlight">?colorOnPrimary</item>
         <item name="materialThemeOverlay">@style/VectorMaterialThemeOverlayOnPrimary</item>
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index c369065292..3bcd65111f 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -70,18 +70,7 @@ class SessionOverviewFragment :
         observeViewEvents()
         initSessionInfoView()
         initVerifyButton()
-    }
-
-    private fun initSessionInfoView() {
-        views.sessionOverviewInfo.onLearnMoreClickListener = {
-            Toast.makeText(context, "Learn more verification status", Toast.LENGTH_LONG).show()
-        }
-    }
-
-    private fun initVerifyButton() {
-        views.sessionOverviewInfo.viewVerifyButton.debouncedClicks {
-            viewModel.handle(SessionOverviewAction.VerifySession)
-        }
+        initSignoutButton()
     }
 
     private fun observeViewEvents() {
@@ -97,10 +86,30 @@ class SessionOverviewFragment :
                     navigator.open4SSetup(requireActivity(), SetupMode.PASSPHRASE_AND_NEEDED_SECRETS_RESET)
                 }
                 is SessionOverviewViewEvent.RequestReAuth -> askForReAuthentication(it)
+                SessionOverviewViewEvent.SignoutSuccess -> viewNavigator.goBack(requireActivity())
+                is SessionOverviewViewEvent.SignoutError -> showFailure(it.error)
             }
         }
     }
 
+    private fun initSessionInfoView() {
+        views.sessionOverviewInfo.onLearnMoreClickListener = {
+            Toast.makeText(context, "Learn more verification status", Toast.LENGTH_LONG).show()
+        }
+    }
+
+    private fun initVerifyButton() {
+        views.sessionOverviewInfo.viewVerifyButton.debouncedClicks {
+            viewModel.handle(SessionOverviewAction.VerifySession)
+        }
+    }
+
+    private fun initSignoutButton() {
+        views.sessionOverviewSignout.debouncedClicks {
+            viewModel.handle(SessionOverviewAction.SignoutSession)
+        }
+    }
+
     override fun onDestroyView() {
         cleanUpSessionInfoView()
         super.onDestroyView()
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
index ac64e3dfe6..4ff31d1a81 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
@@ -27,4 +27,7 @@ sealed class SessionOverviewViewEvent : VectorViewEvents {
             val registrationFlowResponse: RegistrationFlowResponse,
             val lastErrorCode: String?
     ) : SessionOverviewViewEvent()
+
+    object SignoutSuccess : SessionOverviewViewEvent()
+    data class SignoutError(val error: Throwable) : SessionOverviewViewEvent()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 7dab404167..7e08e1ccf5 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -21,12 +21,15 @@ import com.airbnb.mvrx.Success
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
+import im.vector.app.R
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.di.MavericksAssistedViewModelFactory
 import im.vector.app.core.di.hiltMavericksViewModelFactory
-import im.vector.app.core.platform.VectorViewModel
+import im.vector.app.core.resources.StringProvider
 import im.vector.app.features.auth.PendingAuthHandler
 import im.vector.app.features.settings.devices.v2.IsCurrentSessionUseCase
+import im.vector.app.features.settings.devices.v2.RefreshDevicesUseCase
+import im.vector.app.features.settings.devices.v2.VectorSessionsListViewModel
 import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
 import im.vector.app.features.settings.devices.v2.signout.SignoutSessionResult
 import im.vector.app.features.settings.devices.v2.signout.SignoutSessionUseCase
@@ -39,21 +42,27 @@ import kotlinx.coroutines.launch
 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 timber.log.Timber
+import javax.net.ssl.HttpsURLConnection
 import kotlin.coroutines.Continuation
 
 class SessionOverviewViewModel @AssistedInject constructor(
         @Assisted val initialState: SessionOverviewViewState,
-        private val activeSessionHolder: ActiveSessionHolder,
         private val isCurrentSessionUseCase: IsCurrentSessionUseCase,
+        private val stringProvider: StringProvider,
         private val getDeviceFullInfoUseCase: GetDeviceFullInfoUseCase,
         private val checkIfCurrentSessionCanBeVerifiedUseCase: CheckIfCurrentSessionCanBeVerifiedUseCase,
         private val signoutSessionUseCase: SignoutSessionUseCase,
         private val interceptSignoutFlowResponseUseCase: InterceptSignoutFlowResponseUseCase,
         private val pendingAuthHandler: PendingAuthHandler,
-) : VectorViewModel<SessionOverviewViewState, SessionOverviewAction, SessionOverviewViewEvent>(initialState) {
+        activeSessionHolder: ActiveSessionHolder,
+        refreshDevicesUseCase: RefreshDevicesUseCase,
+) : VectorSessionsListViewModel<SessionOverviewViewState, SessionOverviewAction, SessionOverviewViewEvent>(
+        initialState, activeSessionHolder, refreshDevicesUseCase
+) {
 
     companion object : MavericksViewModelFactory<SessionOverviewViewModel, SessionOverviewViewState> by hiltMavericksViewModelFactory()
 
@@ -129,20 +138,26 @@ class SessionOverviewViewModel @AssistedInject constructor(
 
     // TODO add unit tests
     private fun handleSignoutSession() = withState { state ->
-        // TODO should we do something different when it is current session?
+        // TODO for current session: do the same process as sign out button in the general settings
+        // TODO add a loading viewState or ViewEvent
         viewModelScope.launch {
-            signoutSessionUseCase.execute(state.deviceId, object : UserInteractiveAuthInterceptor {
+            val signoutResult = signoutSessionUseCase.execute(state.deviceId, object : UserInteractiveAuthInterceptor {
                 override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation<UIABaseAuth>) {
                     when (val result = interceptSignoutFlowResponseUseCase.execute(flowResponse, errCode, promise)) {
                         is SignoutSessionResult.ReAuthNeeded -> onReAuthNeeded(result)
-                        is SignoutSessionResult.Completed -> {
-                            Timber.d("signout completed")
-                            // TODO check if it is called after a reAuth
-                            // TODO refresh devices list? + post event to close the associated screen
-                        }
+                        is SignoutSessionResult.Completed -> Unit
                     }
                 }
             })
+
+            if (signoutResult.isSuccess) {
+                onSignoutSuccess()
+            } else {
+                when (val failure = signoutResult.exceptionOrNull()) {
+                    null -> onSignoutSuccess()
+                    else -> onSignoutFailure(failure)
+                }
+            }
         }
     }
 
@@ -153,6 +168,22 @@ class SessionOverviewViewModel @AssistedInject constructor(
         _viewEvents.post(SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode))
     }
 
+    private fun onSignoutSuccess() {
+        Timber.d("signout success")
+        refreshDeviceList()
+        _viewEvents.post(SessionOverviewViewEvent.SignoutSuccess)
+    }
+
+    private fun onSignoutFailure(failure: Throwable) {
+        Timber.e("signout failure", failure)
+        val failureMessage = if (failure is Failure.OtherServerError && failure.httpCode == HttpsURLConnection.HTTP_UNAUTHORIZED) {
+            stringProvider.getString(R.string.authentication_error)
+        } else {
+            stringProvider.getString(R.string.matrix_error)
+        }
+        _viewEvents.post(SessionOverviewViewEvent.SignoutError(Exception(failureMessage)))
+    }
+
     private fun handleSsoAuthDone() {
         pendingAuthHandler.ssoAuthDone()
     }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
index 8c4d0345dc..ba5c3181d2 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
@@ -17,6 +17,7 @@
 package im.vector.app.features.settings.devices.v2.overview
 
 import android.content.Context
+import androidx.fragment.app.FragmentActivity
 import im.vector.app.features.settings.devices.v2.details.SessionDetailsActivity
 import im.vector.app.features.settings.devices.v2.rename.RenameSessionActivity
 import javax.inject.Inject
@@ -30,4 +31,9 @@ class SessionOverviewViewNavigator @Inject constructor() {
     fun goToRenameSession(context: Context, deviceId: String) {
         context.startActivity(RenameSessionActivity.newIntent(context, deviceId))
     }
+
+    // TODO add unit test
+    fun goBack(fragmentActivity: FragmentActivity) {
+        fragmentActivity.finish()
+    }
 }
diff --git a/vector/src/main/res/layout/fragment_session_overview.xml b/vector/src/main/res/layout/fragment_session_overview.xml
index f4573ef85e..0a9dd61fe0 100644
--- a/vector/src/main/res/layout/fragment_session_overview.xml
+++ b/vector/src/main/res/layout/fragment_session_overview.xml
@@ -31,6 +31,19 @@
             app:sessionOverviewEntryDescription="@string/device_manager_session_details_description"
             app:sessionOverviewEntryTitle="@string/device_manager_session_details_title" />
 
+        <Button
+            android:id="@+id/sessionOverviewSignout"
+            style="@style/Widget.Vector.Button.Text.Destructive"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="8dp"
+            android:text="@string/device_manager_session_overview_signout"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintHorizontal_bias="0"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toBottomOf="@id/sessionOverviewEntryDetails"
+            app:layout_constraintWidth="wrap_content" />
+
     </androidx.constraintlayout.widget.ConstraintLayout>
 
 </ScrollView>

From d6bb6efb1d23dd056b110eff962f5c2a29b1b2af Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Fri, 23 Sep 2022 16:35:28 +0200
Subject: [PATCH 05/17] Loading dialog during signout process

---
 .../v2/overview/SessionOverviewFragment.kt    |  9 +++++++
 .../v2/overview/SessionOverviewViewModel.kt   | 25 ++++++++++++-------
 .../v2/overview/SessionOverviewViewState.kt   |  1 +
 3 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index 3bcd65111f..eed7c1fead 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -139,6 +139,7 @@ class SessionOverviewFragment :
         updateToolbar(state.isCurrentSession)
         updateEntryDetails(state.deviceId)
         updateSessionInfo(state)
+        updateLoading(state.isLoading)
     }
 
     private fun updateToolbar(isCurrentSession: Boolean) {
@@ -172,6 +173,14 @@ class SessionOverviewFragment :
         }
     }
 
+    private fun updateLoading(isLoading: Boolean) {
+        if (isLoading) {
+            showLoading(null)
+        } else {
+            dismissLoadingDialog()
+        }
+    }
+
     private val reAuthActivityResultLauncher = registerStartForActivityResult { activityResult ->
         if (activityResult.resultCode == Activity.RESULT_OK) {
             when (activityResult.data?.extras?.getString(ReAuthActivity.RESULT_FLOW_TYPE)) {
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 7e08e1ccf5..9a6043e194 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -139,16 +139,10 @@ class SessionOverviewViewModel @AssistedInject constructor(
     // TODO add unit tests
     private fun handleSignoutSession() = withState { state ->
         // TODO for current session: do the same process as sign out button in the general settings
-        // TODO add a loading viewState or ViewEvent
         viewModelScope.launch {
-            val signoutResult = signoutSessionUseCase.execute(state.deviceId, object : UserInteractiveAuthInterceptor {
-                override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation<UIABaseAuth>) {
-                    when (val result = interceptSignoutFlowResponseUseCase.execute(flowResponse, errCode, promise)) {
-                        is SignoutSessionResult.ReAuthNeeded -> onReAuthNeeded(result)
-                        is SignoutSessionResult.Completed -> Unit
-                    }
-                }
-            })
+            setLoading(true)
+            val signoutResult = signout(state.deviceId)
+            setLoading(false)
 
             if (signoutResult.isSuccess) {
                 onSignoutSuccess()
@@ -161,6 +155,15 @@ class SessionOverviewViewModel @AssistedInject constructor(
         }
     }
 
+    private suspend fun signout(deviceId: String) = signoutSessionUseCase.execute(deviceId, object : UserInteractiveAuthInterceptor {
+        override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation<UIABaseAuth>) {
+            when (val result = interceptSignoutFlowResponseUseCase.execute(flowResponse, errCode, promise)) {
+                is SignoutSessionResult.ReAuthNeeded -> onReAuthNeeded(result)
+                is SignoutSessionResult.Completed -> Unit
+            }
+        }
+    })
+
     private fun onReAuthNeeded(reAuthNeeded: SignoutSessionResult.ReAuthNeeded) {
         Timber.d("onReAuthNeeded")
         pendingAuthHandler.pendingAuth = DefaultBaseAuth(session = reAuthNeeded.flowResponse.session)
@@ -168,6 +171,10 @@ class SessionOverviewViewModel @AssistedInject constructor(
         _viewEvents.post(SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode))
     }
 
+    private fun setLoading(isLoading: Boolean) {
+        setState { copy(isLoading = isLoading) }
+    }
+
     private fun onSignoutSuccess() {
         Timber.d("signout success")
         refreshDeviceList()
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
index 1cb455dd5c..8a0b41c55d 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
@@ -26,6 +26,7 @@ data class SessionOverviewViewState(
         val isCurrentSession: Boolean = false,
         val isCurrentSessionTrusted: Boolean = false,
         val deviceInfo: Async<DeviceFullInfo> = Uninitialized,
+        val isLoading: Boolean = false,
 ) : MavericksState {
     constructor(args: SessionOverviewArgs) : this(
             deviceId = args.deviceId

From 0c708c0ad4c7350d36c974f1e55a2353bc4fe9fb Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Fri, 23 Sep 2022 17:04:21 +0200
Subject: [PATCH 06/17] Fix after rebase property qualifier

---
 .../settings/devices/v2/overview/SessionOverviewViewModel.kt    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 9a6043e194..1eacb61bbc 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -58,7 +58,7 @@ class SessionOverviewViewModel @AssistedInject constructor(
         private val signoutSessionUseCase: SignoutSessionUseCase,
         private val interceptSignoutFlowResponseUseCase: InterceptSignoutFlowResponseUseCase,
         private val pendingAuthHandler: PendingAuthHandler,
-        activeSessionHolder: ActiveSessionHolder,
+        private val activeSessionHolder: ActiveSessionHolder,
         refreshDevicesUseCase: RefreshDevicesUseCase,
 ) : VectorSessionsListViewModel<SessionOverviewViewState, SessionOverviewAction, SessionOverviewViewEvent>(
         initialState, activeSessionHolder, refreshDevicesUseCase

From bf42220422f747f00c570221e0897bad7a15dcec Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 10:08:59 +0200
Subject: [PATCH 07/17] Unit tests for view navigator

---
 .../overview/SessionOverviewViewNavigator.kt   |  1 -
 .../SessionOverviewViewNavigatorTest.kt        | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
index ba5c3181d2..0cb95bae7d 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigator.kt
@@ -32,7 +32,6 @@ class SessionOverviewViewNavigator @Inject constructor() {
         context.startActivity(RenameSessionActivity.newIntent(context, deviceId))
     }
 
-    // TODO add unit test
     fun goBack(fragmentActivity: FragmentActivity) {
         fragmentActivity.finish()
     }
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigatorTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigatorTest.kt
index 3d38f3b3bf..e309c05042 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigatorTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewNavigatorTest.kt
@@ -17,12 +17,15 @@
 package im.vector.app.features.settings.devices.v2.overview
 
 import android.content.Intent
+import androidx.fragment.app.FragmentActivity
 import im.vector.app.features.settings.devices.v2.details.SessionDetailsActivity
 import im.vector.app.features.settings.devices.v2.rename.RenameSessionActivity
 import im.vector.app.test.fakes.FakeContext
 import io.mockk.every
+import io.mockk.just
 import io.mockk.mockk
 import io.mockk.mockkObject
+import io.mockk.runs
 import io.mockk.unmockkAll
 import io.mockk.verify
 import org.junit.After
@@ -77,6 +80,21 @@ class SessionOverviewViewNavigatorTest {
         }
     }
 
+    @Test
+    fun `given an activity when going back then the activity is finished`() {
+        // Given
+        val fragmentActivity = mockk<FragmentActivity>()
+        every { fragmentActivity.finish() } just runs
+
+        // When
+        sessionOverviewViewNavigator.goBack(fragmentActivity)
+
+        // Then
+        verify {
+            fragmentActivity.finish()
+        }
+    }
+
     private fun givenIntentForSessionDetails(sessionId: String): Intent {
         val intent = mockk<Intent>()
         every { SessionDetailsActivity.newIntent(context.instance, sessionId) } returns intent

From 04ad2daa80f9c7e6bebd22729459c1f00d77b1b6 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 10:34:07 +0200
Subject: [PATCH 08/17] Unit tests for signout use case

---
 .../v2/signout/SignoutSessionUseCase.kt       |  3 +-
 .../v2/signout/SignoutSessionUseCaseTest.kt   | 79 +++++++++++++++++++
 .../app/test/fakes/FakeCryptoService.kt       | 14 ++++
 3 files changed, 94 insertions(+), 2 deletions(-)
 create mode 100644 vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCaseTest.kt

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt
index b86dab13cd..60ca8e91c6 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCase.kt
@@ -21,7 +21,6 @@ import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
 import org.matrix.android.sdk.api.util.awaitCallback
 import javax.inject.Inject
 
-// TODO add unit tests
 class SignoutSessionUseCase @Inject constructor(
         private val activeSessionHolder: ActiveSessionHolder,
 ) {
@@ -31,7 +30,7 @@ class SignoutSessionUseCase @Inject constructor(
     }
 
     private suspend fun deleteDevice(deviceId: String, userInteractiveAuthInterceptor: UserInteractiveAuthInterceptor) = runCatching {
-        awaitCallback<Unit> { matrixCallback ->
+        awaitCallback { matrixCallback ->
             activeSessionHolder.getActiveSession()
                     .cryptoService()
                     .deleteDevice(deviceId, userInteractiveAuthInterceptor, matrixCallback)
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCaseTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCaseTest.kt
new file mode 100644
index 0000000000..5af91c16ce
--- /dev/null
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/SignoutSessionUseCaseTest.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2.signout
+
+import im.vector.app.test.fakes.FakeActiveSessionHolder
+import io.mockk.every
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.amshove.kluent.shouldBe
+import org.junit.Test
+import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor
+
+private const val A_DEVICE_ID = "device-id"
+
+class SignoutSessionUseCaseTest {
+
+    private val fakeActiveSessionHolder = FakeActiveSessionHolder()
+
+    private val signoutSessionUseCase = SignoutSessionUseCase(
+            activeSessionHolder = fakeActiveSessionHolder.instance
+    )
+
+    @Test
+    fun `given a device id when signing out with success then success result is returned`() = runTest {
+        // Given
+        val interceptor = givenAuthInterceptor()
+        fakeActiveSessionHolder.fakeSession
+                .fakeCryptoService
+                .givenDeleteDeviceSucceeds(A_DEVICE_ID)
+
+        // When
+        val result = signoutSessionUseCase.execute(A_DEVICE_ID, interceptor)
+
+        // Then
+        result.isSuccess shouldBe true
+        every {
+            fakeActiveSessionHolder.fakeSession
+                    .fakeCryptoService
+                    .deleteDevice(A_DEVICE_ID, interceptor, any())
+        }
+    }
+
+    @Test
+    fun `given a device id when signing out with error then failure result is returned`() = runTest {
+        // Given
+        val interceptor = givenAuthInterceptor()
+        val error = mockk<Exception>()
+        fakeActiveSessionHolder.fakeSession
+                .fakeCryptoService
+                .givenDeleteDeviceFailsWithError(A_DEVICE_ID, error)
+
+        // When
+        val result = signoutSessionUseCase.execute(A_DEVICE_ID, interceptor)
+
+        // Then
+        result.isFailure shouldBe true
+        every {
+            fakeActiveSessionHolder.fakeSession
+                    .fakeCryptoService
+                    .deleteDevice(A_DEVICE_ID, interceptor, any())
+        }
+    }
+
+    private fun givenAuthInterceptor() = mockk<UserInteractiveAuthInterceptor>()
+}
diff --git a/vector/src/test/java/im/vector/app/test/fakes/FakeCryptoService.kt b/vector/src/test/java/im/vector/app/test/fakes/FakeCryptoService.kt
index a83da8cb9d..3b1b4df7d1 100644
--- a/vector/src/test/java/im/vector/app/test/fakes/FakeCryptoService.kt
+++ b/vector/src/test/java/im/vector/app/test/fakes/FakeCryptoService.kt
@@ -67,4 +67,18 @@ class FakeCryptoService(
             thirdArg<MatrixCallback<Unit>>().onFailure(error)
         }
     }
+
+    fun givenDeleteDeviceSucceeds(deviceId: String) {
+        val matrixCallback = slot<MatrixCallback<Unit>>()
+        every { deleteDevice(deviceId, any(), capture(matrixCallback)) } answers {
+            thirdArg<MatrixCallback<Unit>>().onSuccess(Unit)
+        }
+    }
+
+    fun givenDeleteDeviceFailsWithError(deviceId: String, error: Exception) {
+        val matrixCallback = slot<MatrixCallback<Unit>>()
+        every { deleteDevice(deviceId, any(), capture(matrixCallback)) } answers {
+            thirdArg<MatrixCallback<Unit>>().onFailure(error)
+        }
+    }
 }

From 8d870b8220691ed0f9d69f52a0dd70980a35238c Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 14:26:22 +0200
Subject: [PATCH 09/17] Replace IsCurrentSessionUseCase by using DeviceFullInfo
 field

---
 .../devices/v2/IsCurrentSessionUseCase.kt     | 30 --------
 .../v2/overview/SessionOverviewFragment.kt    | 20 +++--
 .../v2/overview/SessionOverviewViewModel.kt   | 12 +--
 .../v2/overview/SessionOverviewViewState.kt   |  1 -
 .../devices/v2/IsCurrentSessionUseCaseTest.kt | 77 -------------------
 5 files changed, 14 insertions(+), 126 deletions(-)
 delete mode 100644 vector/src/main/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCase.kt
 delete mode 100644 vector/src/test/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCaseTest.kt

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCase.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCase.kt
deleted file mode 100644
index 885908120a..0000000000
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCase.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2
-
-import im.vector.app.core.di.ActiveSessionHolder
-import javax.inject.Inject
-
-class IsCurrentSessionUseCase @Inject constructor(
-        private val activeSessionHolder: ActiveSessionHolder,
-) {
-
-    fun execute(deviceId: String): Boolean {
-        val currentDeviceId = activeSessionHolder.getSafeActiveSession()?.sessionParams?.deviceId.orEmpty()
-        return deviceId.isNotEmpty() && deviceId == currentDeviceId
-    }
-}
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index eed7c1fead..3bd128ae42 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -136,17 +136,20 @@ class SessionOverviewFragment :
     }
 
     override fun invalidate() = withState(viewModel) { state ->
-        updateToolbar(state.isCurrentSession)
+        updateToolbar(state)
         updateEntryDetails(state.deviceId)
         updateSessionInfo(state)
         updateLoading(state.isLoading)
     }
 
-    private fun updateToolbar(isCurrentSession: Boolean) {
-        val titleResId = if (isCurrentSession) R.string.device_manager_current_session_title else R.string.device_manager_session_title
-        (activity as? AppCompatActivity)
-                ?.supportActionBar
-                ?.setTitle(titleResId)
+    private fun updateToolbar(viewState: SessionOverviewViewState) {
+        if (viewState.deviceInfo is Success) {
+            val titleResId =
+                    if (viewState.deviceInfo.invoke().isCurrentDevice) R.string.device_manager_current_session_title else R.string.device_manager_session_title
+            (activity as? AppCompatActivity)
+                    ?.supportActionBar
+                    ?.setTitle(titleResId)
+        }
     }
 
     private fun updateEntryDetails(deviceId: String) {
@@ -158,10 +161,11 @@ class SessionOverviewFragment :
     private fun updateSessionInfo(viewState: SessionOverviewViewState) {
         if (viewState.deviceInfo is Success) {
             views.sessionOverviewInfo.isVisible = true
-            val isCurrentSession = viewState.isCurrentSession
+            val deviceInfo = viewState.deviceInfo.invoke()
+            val isCurrentSession = deviceInfo.isCurrentDevice
             val infoViewState = SessionInfoViewState(
                     isCurrentSession = isCurrentSession,
-                    deviceFullInfo = viewState.deviceInfo.invoke(),
+                    deviceFullInfo = deviceInfo,
                     isVerifyButtonVisible = isCurrentSession || viewState.isCurrentSessionTrusted,
                     isDetailsButtonVisible = false,
                     isLearnMoreLinkVisible = true,
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 1eacb61bbc..aaf5c9d2a7 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -27,7 +27,6 @@ import im.vector.app.core.di.MavericksAssistedViewModelFactory
 import im.vector.app.core.di.hiltMavericksViewModelFactory
 import im.vector.app.core.resources.StringProvider
 import im.vector.app.features.auth.PendingAuthHandler
-import im.vector.app.features.settings.devices.v2.IsCurrentSessionUseCase
 import im.vector.app.features.settings.devices.v2.RefreshDevicesUseCase
 import im.vector.app.features.settings.devices.v2.VectorSessionsListViewModel
 import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
@@ -42,6 +41,7 @@ import kotlinx.coroutines.launch
 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.extensions.orFalse
 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
@@ -51,7 +51,6 @@ import kotlin.coroutines.Continuation
 
 class SessionOverviewViewModel @AssistedInject constructor(
         @Assisted val initialState: SessionOverviewViewState,
-        private val isCurrentSessionUseCase: IsCurrentSessionUseCase,
         private val stringProvider: StringProvider,
         private val getDeviceFullInfoUseCase: GetDeviceFullInfoUseCase,
         private val checkIfCurrentSessionCanBeVerifiedUseCase: CheckIfCurrentSessionCanBeVerifiedUseCase,
@@ -72,17 +71,10 @@ class SessionOverviewViewModel @AssistedInject constructor(
     }
 
     init {
-        setState {
-            copy(isCurrentSession = isCurrentSession(deviceId))
-        }
         observeSessionInfo(initialState.deviceId)
         observeCurrentSessionInfo()
     }
 
-    private fun isCurrentSession(deviceId: String): Boolean {
-        return isCurrentSessionUseCase.execute(deviceId)
-    }
-
     private fun observeSessionInfo(deviceId: String) {
         getDeviceFullInfoUseCase.execute(deviceId)
                 .onEach { setState { copy(deviceInfo = Success(it)) } }
@@ -114,7 +106,7 @@ class SessionOverviewViewModel @AssistedInject constructor(
     }
 
     private fun handleVerifySessionAction() = withState { viewState ->
-        if (viewState.isCurrentSession) {
+        if (viewState.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
             handleVerifyCurrentSession()
         } else {
             handleVerifyOtherSession(viewState.deviceId)
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
index 8a0b41c55d..07423888b5 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewState.kt
@@ -23,7 +23,6 @@ import im.vector.app.features.settings.devices.v2.DeviceFullInfo
 
 data class SessionOverviewViewState(
         val deviceId: String,
-        val isCurrentSession: Boolean = false,
         val isCurrentSessionTrusted: Boolean = false,
         val deviceInfo: Async<DeviceFullInfo> = Uninitialized,
         val isLoading: Boolean = false,
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCaseTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCaseTest.kt
deleted file mode 100644
index 09a94ac08b..0000000000
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/IsCurrentSessionUseCaseTest.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2
-
-import im.vector.app.test.fakes.FakeActiveSessionHolder
-import io.mockk.verify
-import org.amshove.kluent.shouldBe
-import org.junit.Test
-import org.matrix.android.sdk.api.auth.data.SessionParams
-
-private const val A_SESSION_ID_1 = "session-id-1"
-private const val A_SESSION_ID_2 = "session-id-2"
-
-class IsCurrentSessionUseCaseTest {
-
-    private val fakeActiveSessionHolder = FakeActiveSessionHolder()
-
-    private val isCurrentSessionUseCase = IsCurrentSessionUseCase(
-            activeSessionHolder = fakeActiveSessionHolder.instance,
-    )
-
-    @Test
-    fun `given the session id of the current session when checking if id is current session then result is true`() {
-        // Given
-        val sessionParams = givenIdForCurrentSession(A_SESSION_ID_1)
-
-        // When
-        val result = isCurrentSessionUseCase.execute(A_SESSION_ID_1)
-
-        // Then
-        result shouldBe true
-        verify { sessionParams.deviceId }
-    }
-
-    @Test
-    fun `given a session id different from the current session id when checking if id is current session then result is false`() {
-        // Given
-        val sessionParams = givenIdForCurrentSession(A_SESSION_ID_1)
-
-        // When
-        val result = isCurrentSessionUseCase.execute(A_SESSION_ID_2)
-
-        // Then
-        result shouldBe false
-        verify { sessionParams.deviceId }
-    }
-
-    @Test
-    fun `given no current active session when checking if id is current session then result is false`() {
-        // Given
-        fakeActiveSessionHolder.givenGetSafeActiveSessionReturns(null)
-
-        // When
-        val result = isCurrentSessionUseCase.execute(A_SESSION_ID_1)
-
-        // Then
-        result shouldBe false
-    }
-
-    private fun givenIdForCurrentSession(sessionId: String): SessionParams {
-        return fakeActiveSessionHolder.fakeSession.givenSessionId(sessionId)
-    }
-}

From 0fe5ee68f2a8e100e88ac63591e29681dfe69ad9 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 14:58:03 +0200
Subject: [PATCH 10/17] Unit tests for interception of signout process result

---
 .../InterceptSignoutFlowResponseUseCase.kt    |   1 -
 ...InterceptSignoutFlowResponseUseCaseTest.kt | 174 ++++++++++++++++++
 .../vector/app/test/fakes/FakeReAuthHelper.kt |  30 +++
 3 files changed, 204 insertions(+), 1 deletion(-)
 create mode 100644 vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCaseTest.kt
 create mode 100644 vector/src/test/java/im/vector/app/test/fakes/FakeReAuthHelper.kt

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
index 4e69452ab3..4316995272 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCase.kt
@@ -28,7 +28,6 @@ import javax.inject.Inject
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 
-// TODO add unit tests
 class InterceptSignoutFlowResponseUseCase @Inject constructor(
         private val reAuthHelper: ReAuthHelper,
         private val activeSessionHolder: ActiveSessionHolder,
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCaseTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCaseTest.kt
new file mode 100644
index 0000000000..35551ba36e
--- /dev/null
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/signout/InterceptSignoutFlowResponseUseCaseTest.kt
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.features.settings.devices.v2.signout
+
+import im.vector.app.test.fakes.FakeActiveSessionHolder
+import im.vector.app.test.fakes.FakeReAuthHelper
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.runs
+import io.mockk.unmockkAll
+import org.amshove.kluent.shouldBeEqualTo
+import org.amshove.kluent.shouldBeInstanceOf
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.matrix.android.sdk.api.auth.UIABaseAuth
+import org.matrix.android.sdk.api.auth.UserPasswordAuth
+import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
+import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse
+import org.matrix.android.sdk.api.auth.registration.nextUncompletedStage
+import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+
+private const val A_PASSWORD = "password"
+private const val A_SESSION_ID = "session-id"
+private const val AN_ERROR_CODE = "error-code"
+
+class InterceptSignoutFlowResponseUseCaseTest {
+
+    private val fakeReAuthHelper = FakeReAuthHelper()
+    private val fakeActiveSessionHolder = FakeActiveSessionHolder()
+
+    private val interceptSignoutFlowResponseUseCase = InterceptSignoutFlowResponseUseCase(
+            reAuthHelper = fakeReAuthHelper.instance,
+            activeSessionHolder = fakeActiveSessionHolder.instance,
+    )
+
+    @Before
+    fun setUp() {
+        mockkStatic("org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponseKt")
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    @Test
+    fun `given no error and a stored password and a next stage as password when intercepting then promise is resumed and success is returned`() {
+        // Given
+        val registrationFlowResponse = givenNextUncompletedStage(LoginFlowTypes.PASSWORD, A_SESSION_ID)
+        fakeReAuthHelper.givenStoredPassword(A_PASSWORD)
+        val errorCode: String? = null
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        every { promise.resume(any()) } just runs
+        val expectedAuth = UserPasswordAuth(
+                session = null,
+                user = fakeActiveSessionHolder.fakeSession.myUserId,
+                password = A_PASSWORD,
+        )
+
+        // When
+        val result = interceptSignoutFlowResponseUseCase.execute(
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode,
+                promise = promise,
+        )
+
+        // Then
+        result shouldBeInstanceOf (SignoutSessionResult.Completed::class)
+        every {
+            promise.resume(expectedAuth)
+        }
+    }
+
+    @Test
+    fun `given an error when intercepting then reAuthNeeded result is returned`() {
+        // Given
+        val registrationFlowResponse = givenNextUncompletedStage(LoginFlowTypes.PASSWORD, A_SESSION_ID)
+        fakeReAuthHelper.givenStoredPassword(A_PASSWORD)
+        val errorCode = AN_ERROR_CODE
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        val expectedResult = SignoutSessionResult.ReAuthNeeded(
+                pendingAuth = DefaultBaseAuth(session = A_SESSION_ID),
+                uiaContinuation = promise,
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode
+        )
+
+        // When
+        val result = interceptSignoutFlowResponseUseCase.execute(
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode,
+                promise = promise,
+        )
+
+        // Then
+        result shouldBeEqualTo expectedResult
+    }
+
+    @Test
+    fun `given next stage is not password when intercepting then reAuthNeeded result is returned`() {
+        // Given
+        val registrationFlowResponse = givenNextUncompletedStage(LoginFlowTypes.SSO, A_SESSION_ID)
+        fakeReAuthHelper.givenStoredPassword(A_PASSWORD)
+        val errorCode: String? = null
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        val expectedResult = SignoutSessionResult.ReAuthNeeded(
+                pendingAuth = DefaultBaseAuth(session = A_SESSION_ID),
+                uiaContinuation = promise,
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode
+        )
+
+        // When
+        val result = interceptSignoutFlowResponseUseCase.execute(
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode,
+                promise = promise,
+        )
+
+        // Then
+        result shouldBeEqualTo expectedResult
+    }
+
+    @Test
+    fun `given no existing stored password when intercepting then reAuthNeeded result is returned`() {
+        // Given
+        val registrationFlowResponse = givenNextUncompletedStage(LoginFlowTypes.PASSWORD, A_SESSION_ID)
+        fakeReAuthHelper.givenStoredPassword(null)
+        val errorCode: String? = null
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        val expectedResult = SignoutSessionResult.ReAuthNeeded(
+                pendingAuth = DefaultBaseAuth(session = A_SESSION_ID),
+                uiaContinuation = promise,
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode
+        )
+
+        // When
+        val result = interceptSignoutFlowResponseUseCase.execute(
+                flowResponse = registrationFlowResponse,
+                errCode = errorCode,
+                promise = promise,
+        )
+
+        // Then
+        result shouldBeEqualTo expectedResult
+    }
+
+    private fun givenNextUncompletedStage(nextStage: String, sessionId: String): RegistrationFlowResponse {
+        val registrationFlowResponse = mockk<RegistrationFlowResponse>()
+        every { registrationFlowResponse.nextUncompletedStage() } returns nextStage
+        every { registrationFlowResponse.session } returns sessionId
+        return registrationFlowResponse
+    }
+}
diff --git a/vector/src/test/java/im/vector/app/test/fakes/FakeReAuthHelper.kt b/vector/src/test/java/im/vector/app/test/fakes/FakeReAuthHelper.kt
new file mode 100644
index 0000000000..96004a4990
--- /dev/null
+++ b/vector/src/test/java/im/vector/app/test/fakes/FakeReAuthHelper.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.test.fakes
+
+import im.vector.app.features.login.ReAuthHelper
+import io.mockk.every
+import io.mockk.mockk
+
+class FakeReAuthHelper {
+
+    val instance = mockk<ReAuthHelper>()
+
+    fun givenStoredPassword(pwd: String?) {
+        every { instance.data } returns pwd
+    }
+}

From 68bee65e972104a3a26584d557e0fb38e2f319f4 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 15:26:09 +0200
Subject: [PATCH 11/17] Confirm signout when it is current session

---
 .../v2/overview/SessionOverviewFragment.kt        |  6 ++++++
 .../v2/overview/SessionOverviewViewEvent.kt       |  1 +
 .../v2/overview/SessionOverviewViewModel.kt       | 15 +++++++++++++--
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index 3bd128ae42..341b0233b7 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -40,6 +40,7 @@ import im.vector.app.databinding.FragmentSessionOverviewBinding
 import im.vector.app.features.auth.ReAuthActivity
 import im.vector.app.features.crypto.recover.SetupMode
 import im.vector.app.features.settings.devices.v2.list.SessionInfoViewState
+import im.vector.app.features.workers.signout.SignOutUiWorker
 import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
 import javax.inject.Inject
 
@@ -86,12 +87,17 @@ class SessionOverviewFragment :
                     navigator.open4SSetup(requireActivity(), SetupMode.PASSPHRASE_AND_NEEDED_SECRETS_RESET)
                 }
                 is SessionOverviewViewEvent.RequestReAuth -> askForReAuthentication(it)
+                SessionOverviewViewEvent.ConfirmSignoutCurrentSession -> confirmSignoutCurrentSession()
                 SessionOverviewViewEvent.SignoutSuccess -> viewNavigator.goBack(requireActivity())
                 is SessionOverviewViewEvent.SignoutError -> showFailure(it.error)
             }
         }
     }
 
+    private fun confirmSignoutCurrentSession() {
+        activity?.let { SignOutUiWorker(it).perform() }
+    }
+
     private fun initSessionInfoView() {
         views.sessionOverviewInfo.onLearnMoreClickListener = {
             Toast.makeText(context, "Learn more verification status", Toast.LENGTH_LONG).show()
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
index 4ff31d1a81..0d8a2ac8af 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
@@ -28,6 +28,7 @@ sealed class SessionOverviewViewEvent : VectorViewEvents {
             val lastErrorCode: String?
     ) : SessionOverviewViewEvent()
 
+    object ConfirmSignoutCurrentSession : SessionOverviewViewEvent()
     object SignoutSuccess : SessionOverviewViewEvent()
     data class SignoutError(val error: Throwable) : SessionOverviewViewEvent()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index aaf5c9d2a7..afdd28096f 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -130,10 +130,21 @@ class SessionOverviewViewModel @AssistedInject constructor(
 
     // TODO add unit tests
     private fun handleSignoutSession() = withState { state ->
-        // TODO for current session: do the same process as sign out button in the general settings
+        if (state.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
+            handleSignoutCurrentSession()
+        } else {
+            handleSignoutOtherSession(state.deviceId)
+        }
+    }
+
+    private fun handleSignoutCurrentSession() {
+        _viewEvents.post(SessionOverviewViewEvent.ConfirmSignoutCurrentSession)
+    }
+
+    private fun handleSignoutOtherSession(deviceId: String) {
         viewModelScope.launch {
             setLoading(true)
-            val signoutResult = signout(state.deviceId)
+            val signoutResult = signout(deviceId)
             setLoading(false)
 
             if (signoutResult.isSuccess) {

From da3d3308b4dd7f1acb06cf03dc5a05491c6bc64d Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 16:26:31 +0200
Subject: [PATCH 12/17] Fix unit tests in ViewModel

---
 .../devices/v2/DevicesViewModelTest.kt        |  4 +-
 .../overview/SessionOverviewViewModelTest.kt  | 45 ++++++++++++++-----
 .../app/test/fakes/FakePendingAuthHandler.kt  | 25 +++++++++++
 .../app/test/fakes/FakeVerificationService.kt | 14 +++++-
 4 files changed, 74 insertions(+), 14 deletions(-)
 create mode 100644 vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt

diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
index 44940dd2c3..a1b6205a77 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
@@ -217,8 +217,8 @@ class DevicesViewModelTest {
                 .fakeSession
                 .fakeCryptoService
                 .fakeVerificationService
-        every { fakeVerificationService.addListener(any()) } just runs
-        every { fakeVerificationService.removeListener(any()) } just runs
+        fakeVerificationService.givenAddListenerSucceeds()
+        fakeVerificationService.givenRemoveListenerSucceeds()
         return fakeVerificationService
     }
 
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index 857fa94ade..b9fc027a63 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -19,9 +19,14 @@ package im.vector.app.features.settings.devices.v2.overview
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.test.MvRxTestRule
 import im.vector.app.features.settings.devices.v2.DeviceFullInfo
-import im.vector.app.features.settings.devices.v2.IsCurrentSessionUseCase
+import im.vector.app.features.settings.devices.v2.RefreshDevicesUseCase
+import im.vector.app.features.settings.devices.v2.signout.InterceptSignoutFlowResponseUseCase
+import im.vector.app.features.settings.devices.v2.signout.SignoutSessionUseCase
 import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
 import im.vector.app.test.fakes.FakeActiveSessionHolder
+import im.vector.app.test.fakes.FakePendingAuthHandler
+import im.vector.app.test.fakes.FakeStringProvider
+import im.vector.app.test.fakes.FakeVerificationService
 import im.vector.app.test.test
 import im.vector.app.test.testDispatcher
 import io.mockk.coEvery
@@ -46,29 +51,35 @@ class SessionOverviewViewModelTest {
             deviceId = A_SESSION_ID_1
     )
     private val fakeActiveSessionHolder = FakeActiveSessionHolder()
-    private val isCurrentSessionUseCase = mockk<IsCurrentSessionUseCase>()
+    private val fakeStringProvider = FakeStringProvider()
     private val getDeviceFullInfoUseCase = mockk<GetDeviceFullInfoUseCase>()
     private val checkIfCurrentSessionCanBeVerifiedUseCase = mockk<CheckIfCurrentSessionCanBeVerifiedUseCase>()
+    private val signoutSessionUseCase = mockk<SignoutSessionUseCase>()
+    private val interceptSignoutFlowResponseUseCase = mockk<InterceptSignoutFlowResponseUseCase>()
+    private val fakePendingAuthHandler = FakePendingAuthHandler()
+    private val refreshDevicesUseCase = mockk<RefreshDevicesUseCase>()
 
     private fun createViewModel() = SessionOverviewViewModel(
             initialState = SessionOverviewViewState(args),
-            activeSessionHolder = fakeActiveSessionHolder.instance,
-            isCurrentSessionUseCase = isCurrentSessionUseCase,
+            stringProvider = fakeStringProvider.instance,
             getDeviceFullInfoUseCase = getDeviceFullInfoUseCase,
             checkIfCurrentSessionCanBeVerifiedUseCase = checkIfCurrentSessionCanBeVerifiedUseCase,
+            signoutSessionUseCase = signoutSessionUseCase,
+            interceptSignoutFlowResponseUseCase = interceptSignoutFlowResponseUseCase,
+            pendingAuthHandler = fakePendingAuthHandler.instance,
+            activeSessionHolder = fakeActiveSessionHolder.instance,
+            refreshDevicesUseCase = refreshDevicesUseCase,
     )
 
     @Test
     fun `given the viewModel has been initialized then viewState is updated with session info and current session verification status`() {
         // Given
+        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
-        val isCurrentSession = true
-        every { isCurrentSessionUseCase.execute(any()) } returns isCurrentSession
         givenCurrentSessionIsTrusted()
         val expectedState = SessionOverviewViewState(
                 deviceId = A_SESSION_ID_1,
-                isCurrentSession = isCurrentSession,
                 deviceInfo = Success(deviceFullInfo),
                 isCurrentSessionTrusted = true,
         )
@@ -81,7 +92,6 @@ class SessionOverviewViewModelTest {
                 .assertLatestState { state -> state == expectedState }
                 .finish()
         verify {
-            isCurrentSessionUseCase.execute(A_SESSION_ID_1)
             getDeviceFullInfoUseCase.execute(A_SESSION_ID_1)
         }
     }
@@ -89,9 +99,10 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given current session can be verified when handling verify current session action then self verification event is posted`() {
         // Given
+        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns true
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
-        every { isCurrentSessionUseCase.execute(any()) } returns true
         val verifySessionAction = SessionOverviewAction.VerifySession
         coEvery { checkIfCurrentSessionCanBeVerifiedUseCase.execute() } returns true
         givenCurrentSessionIsTrusted()
@@ -113,9 +124,10 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given current session cannot be verified when handling verify current session action then reset secrets event is posted`() {
         // Given
+        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns true
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
-        every { isCurrentSessionUseCase.execute(any()) } returns true
         val verifySessionAction = SessionOverviewAction.VerifySession
         coEvery { checkIfCurrentSessionCanBeVerifiedUseCase.execute() } returns false
         givenCurrentSessionIsTrusted()
@@ -137,9 +149,10 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given another session when handling verify session action then verify session event is posted`() {
         // Given
+        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
-        every { isCurrentSessionUseCase.execute(any()) } returns false
         val verifySessionAction = SessionOverviewAction.VerifySession
         givenCurrentSessionIsTrusted()
 
@@ -154,6 +167,16 @@ class SessionOverviewViewModelTest {
                 .finish()
     }
 
+    private fun givenVerificationService(): FakeVerificationService {
+        val fakeVerificationService = fakeActiveSessionHolder
+                .fakeSession
+                .fakeCryptoService
+                .fakeVerificationService
+        fakeVerificationService.givenAddListenerSucceeds()
+        fakeVerificationService.givenRemoveListenerSucceeds()
+        return fakeVerificationService
+    }
+
     private fun givenCurrentSessionIsTrusted() {
         fakeActiveSessionHolder.fakeSession.givenSessionId(A_SESSION_ID_2)
         val deviceFullInfo = mockk<DeviceFullInfo>()
diff --git a/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt b/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt
new file mode 100644
index 0000000000..5d49dc3a77
--- /dev/null
+++ b/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 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 im.vector.app.test.fakes
+
+import im.vector.app.features.auth.PendingAuthHandler
+import io.mockk.mockk
+
+class FakePendingAuthHandler {
+
+    val instance = mockk<PendingAuthHandler>()
+}
diff --git a/vector/src/test/java/im/vector/app/test/fakes/FakeVerificationService.kt b/vector/src/test/java/im/vector/app/test/fakes/FakeVerificationService.kt
index 984a48b2c1..4b2dec9fc2 100644
--- a/vector/src/test/java/im/vector/app/test/fakes/FakeVerificationService.kt
+++ b/vector/src/test/java/im/vector/app/test/fakes/FakeVerificationService.kt
@@ -16,7 +16,19 @@
 
 package im.vector.app.test.fakes
 
+import io.mockk.every
+import io.mockk.just
 import io.mockk.mockk
+import io.mockk.runs
 import org.matrix.android.sdk.api.session.crypto.verification.VerificationService
 
-class FakeVerificationService : VerificationService by mockk()
+class FakeVerificationService : VerificationService by mockk() {
+
+    fun givenAddListenerSucceeds() {
+        every { addListener(any()) } just runs
+    }
+
+    fun givenRemoveListenerSucceeds() {
+        every { removeListener(any()) } just runs
+    }
+}

From 89cf8ee8ec99825b015d48e7642a6956660c00f9 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Mon, 26 Sep 2022 17:11:31 +0200
Subject: [PATCH 13/17] Unit test for signout success

---
 .../devices/v2/DevicesViewModelTest.kt        |  1 +
 .../overview/SessionOverviewViewModelTest.kt  | 99 ++++++++++++++++++-
 2 files changed, 96 insertions(+), 4 deletions(-)

diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
index a1b6205a77..c8cfdc6d8a 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
@@ -70,6 +70,7 @@ class DevicesViewModelTest {
 
     @Before
     fun setup() {
+        // Needed for internal usage of Flow<T>.throttleFirst() inside the ViewModel
         mockkStatic(SystemClock::class)
         every { SystemClock.elapsedRealtime() } returns 1234
     }
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index b9fc027a63..cb84478f19 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -16,11 +16,13 @@
 
 package im.vector.app.features.settings.devices.v2.overview
 
+import android.os.SystemClock
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.test.MvRxTestRule
 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
+import im.vector.app.features.settings.devices.v2.signout.SignoutSessionResult
 import im.vector.app.features.settings.devices.v2.signout.SignoutSessionUseCase
 import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
 import im.vector.app.test.fakes.FakeActiveSessionHolder
@@ -32,12 +34,23 @@ import im.vector.app.test.testDispatcher
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
+import io.mockk.just
 import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.runs
+import io.mockk.slot
+import io.mockk.unmockkAll
 import io.mockk.verify
 import kotlinx.coroutines.flow.flowOf
+import org.junit.After
+import org.junit.Before
 import org.junit.Rule
 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.session.crypto.model.RoomEncryptionTrustLevel
+import kotlin.coroutines.Continuation
 
 private const val A_SESSION_ID_1 = "session-id-1"
 private const val A_SESSION_ID_2 = "session-id-2"
@@ -71,10 +84,23 @@ class SessionOverviewViewModelTest {
             refreshDevicesUseCase = refreshDevicesUseCase,
     )
 
+    @Before
+    fun setup() {
+        // Needed for internal usage of Flow<T>.throttleFirst() inside the ViewModel
+        mockkStatic(SystemClock::class)
+        every { SystemClock.elapsedRealtime() } returns 1234
+
+        givenVerificationService()
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
     @Test
     fun `given the viewModel has been initialized then viewState is updated with session info and current session verification status`() {
         // Given
-        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
         givenCurrentSessionIsTrusted()
@@ -99,7 +125,6 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given current session can be verified when handling verify current session action then self verification event is posted`() {
         // Given
-        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
         every { deviceFullInfo.isCurrentDevice } returns true
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
@@ -124,7 +149,6 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given current session cannot be verified when handling verify current session action then reset secrets event is posted`() {
         // Given
-        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
         every { deviceFullInfo.isCurrentDevice } returns true
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
@@ -149,7 +173,6 @@ class SessionOverviewViewModelTest {
     @Test
     fun `given another session when handling verify session action then verify session event is posted`() {
         // Given
-        givenVerificationService()
         val deviceFullInfo = mockk<DeviceFullInfo>()
         every { deviceFullInfo.isCurrentDevice } returns false
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
@@ -167,6 +190,74 @@ class SessionOverviewViewModelTest {
                 .finish()
     }
 
+    @Test
+    fun `given current session when handling signout action then confirmation event is posted`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns true
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val signoutAction = SessionOverviewAction.SignoutSession
+        givenCurrentSessionIsTrusted()
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(signoutAction)
+
+        // Then
+        viewModelTest
+                .assertEvent { it is SessionOverviewViewEvent.ConfirmSignoutCurrentSession }
+                .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.SignoutSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+        )
+
+        // 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()
+        }
+    }
+
+    private fun givenSignoutSuccess(deviceId: String) {
+        val interceptor = slot<UserInteractiveAuthInterceptor>()
+        val flowResponse = mockk<RegistrationFlowResponse>()
+        val errorCode = "errorCode"
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        every { interceptSignoutFlowResponseUseCase.execute(flowResponse, errorCode, promise) } returns SignoutSessionResult.Completed
+        coEvery { signoutSessionUseCase.execute(deviceId, capture(interceptor)) } coAnswers {
+            secondArg<UserInteractiveAuthInterceptor>().performStage(flowResponse, errorCode, promise)
+            Result.success(Unit)
+        }
+    }
+
     private fun givenVerificationService(): FakeVerificationService {
         val fakeVerificationService = fakeActiveSessionHolder
                 .fakeSession

From dafa98eb77239cfb5c2252142f4f09aa435fc931 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Tue, 27 Sep 2022 09:29:49 +0200
Subject: [PATCH 14/17] Unit tests for signout error cases

---
 .../overview/SessionOverviewViewModelTest.kt  | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index cb84478f19..3e2af32f68 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -19,6 +19,7 @@ package im.vector.app.features.settings.devices.v2.overview
 import android.os.SystemClock
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.test.MvRxTestRule
+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
@@ -49,11 +50,15 @@ 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 javax.net.ssl.HttpsURLConnection
 import kotlin.coroutines.Continuation
 
 private const val A_SESSION_ID_1 = "session-id-1"
 private const val A_SESSION_ID_2 = "session-id-2"
+private const val AUTH_ERROR_MESSAGE = "auth-error-message"
+private const val AN_ERROR_MESSAGE = "error-message"
 
 class SessionOverviewViewModelTest {
 
@@ -246,6 +251,74 @@ class SessionOverviewViewModelTest {
         }
     }
 
+    @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.SignoutSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+        )
+        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.SignoutSession
+        givenCurrentSessionIsTrusted()
+        val expectedViewState = SessionOverviewViewState(
+                deviceId = A_SESSION_ID_1,
+                isCurrentSessionTrusted = true,
+                deviceInfo = Success(deviceFullInfo),
+                isLoading = false,
+        )
+        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()
+    }
+
     private fun givenSignoutSuccess(deviceId: String) {
         val interceptor = slot<UserInteractiveAuthInterceptor>()
         val flowResponse = mockk<RegistrationFlowResponse>()
@@ -258,6 +331,10 @@ class SessionOverviewViewModelTest {
         }
     }
 
+    private fun givenSignoutError(deviceId: String, error: Throwable) {
+        coEvery { signoutSessionUseCase.execute(deviceId, any()) } returns Result.failure(error)
+    }
+
     private fun givenVerificationService(): FakeVerificationService {
         val fakeVerificationService = fakeActiveSessionHolder
                 .fakeSession

From 68d9f672c5f7bd8007ae539d566623c3fac2b0cc Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Tue, 27 Sep 2022 14:24:54 +0200
Subject: [PATCH 15/17] Unit tests for after reAuth

---
 .../overview/SessionOverviewViewModelTest.kt  | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index 3e2af32f68..205e173353 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -42,6 +42,7 @@ import io.mockk.runs
 import io.mockk.slot
 import io.mockk.unmockkAll
 import io.mockk.verify
+import io.mockk.verifyAll
 import kotlinx.coroutines.flow.flowOf
 import org.junit.After
 import org.junit.Before
@@ -59,6 +60,7 @@ private const val A_SESSION_ID_1 = "session-id-1"
 private const val A_SESSION_ID_2 = "session-id-2"
 private const val AUTH_ERROR_MESSAGE = "auth-error-message"
 private const val AN_ERROR_MESSAGE = "error-message"
+private const val A_PASSWORD = "password"
 
 class SessionOverviewViewModelTest {
 
@@ -319,6 +321,72 @@ class SessionOverviewViewModelTest {
                 .finish()
     }
 
+    @Test
+    fun `given SSO auth has been done when handling ssoAuthDone action then corresponding method of pending auth handler is called`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val action = SessionOverviewAction.SsoAuthDone
+        givenCurrentSessionIsTrusted()
+        every { fakePendingAuthHandler.instance.ssoAuthDone() } just runs
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(action)
+
+        // Then
+        viewModelTest.finish()
+        verifyAll {
+            fakePendingAuthHandler.instance.ssoAuthDone()
+        }
+    }
+
+    @Test
+    fun `given password auth has been done when handling passwordAuthDone action then corresponding method of pending auth handler is called`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val action = SessionOverviewAction.PasswordAuthDone(password = A_PASSWORD)
+        givenCurrentSessionIsTrusted()
+        every { fakePendingAuthHandler.instance.passwordAuthDone(any()) } just runs
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(action)
+
+        // Then
+        viewModelTest.finish()
+        verifyAll {
+            fakePendingAuthHandler.instance.passwordAuthDone(A_PASSWORD)
+        }
+    }
+
+    @Test
+    fun `given reAuth has been cancelled when handling reAuthCancelled action then corresponding method of pending auth handler is called`() {
+        // Given
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val action = SessionOverviewAction.ReAuthCancelled
+        givenCurrentSessionIsTrusted()
+        every { fakePendingAuthHandler.instance.reAuthCancelled() } just runs
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(action)
+
+        // Then
+        viewModelTest.finish()
+        verifyAll {
+            fakePendingAuthHandler.instance.reAuthCancelled()
+        }
+    }
+
     private fun givenSignoutSuccess(deviceId: String) {
         val interceptor = slot<UserInteractiveAuthInterceptor>()
         val flowResponse = mockk<RegistrationFlowResponse>()

From e47bf2b2004a707466772cabec3c4bcc631d5472 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Tue, 27 Sep 2022 14:48:00 +0200
Subject: [PATCH 16/17] Adding unit tests for reAuth needed case

---
 .../v2/overview/SessionOverviewViewModel.kt   |  2 -
 .../overview/SessionOverviewViewModelTest.kt  | 48 +++++++++++++++++++
 .../app/test/fakes/FakePendingAuthHandler.kt  |  3 +-
 3 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index afdd28096f..717c51978a 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -94,7 +94,6 @@ class SessionOverviewViewModel @AssistedInject constructor(
                 }
     }
 
-    // TODO add unit tests
     override fun handle(action: SessionOverviewAction) {
         when (action) {
             is SessionOverviewAction.VerifySession -> handleVerifySessionAction()
@@ -128,7 +127,6 @@ class SessionOverviewViewModel @AssistedInject constructor(
         _viewEvents.post(SessionOverviewViewEvent.ShowVerifyOtherSession(deviceId))
     }
 
-    // TODO add unit tests
     private fun handleSignoutSession() = withState { state ->
         if (state.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
             handleSignoutCurrentSession()
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index 205e173353..c05c6daa3f 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -44,6 +44,7 @@ import io.mockk.unmockkAll
 import io.mockk.verify
 import io.mockk.verifyAll
 import kotlinx.coroutines.flow.flowOf
+import org.amshove.kluent.shouldBeEqualTo
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
@@ -53,6 +54,7 @@ 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
 
@@ -321,6 +323,31 @@ class SessionOverviewViewModelTest {
                 .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
+        val deviceFullInfo = mockk<DeviceFullInfo>()
+        every { deviceFullInfo.isCurrentDevice } returns false
+        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
+        val reAuthNeeded = givenSignoutReAuthNeeded(A_SESSION_ID_1)
+        val signoutAction = SessionOverviewAction.SignoutSession
+        givenCurrentSessionIsTrusted()
+        val expectedPendingAuth = DefaultBaseAuth(session = reAuthNeeded.flowResponse.session)
+        val expectedReAuthEvent = SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode)
+
+        // When
+        val viewModel = createViewModel()
+        val viewModelTest = viewModel.test()
+        viewModel.handle(signoutAction)
+
+        // Then
+        viewModelTest
+                .assertEvent { it == expectedReAuthEvent }
+                .finish()
+        fakePendingAuthHandler.instance.pendingAuth shouldBeEqualTo expectedPendingAuth
+        fakePendingAuthHandler.instance.uiaContinuation shouldBeEqualTo reAuthNeeded.uiaContinuation
+    }
+
     @Test
     fun `given SSO auth has been done when handling ssoAuthDone action then corresponding method of pending auth handler is called`() {
         // Given
@@ -399,6 +426,27 @@ class SessionOverviewViewModelTest {
         }
     }
 
+    private fun givenSignoutReAuthNeeded(deviceId: String): SignoutSessionResult.ReAuthNeeded {
+        val interceptor = slot<UserInteractiveAuthInterceptor>()
+        val flowResponse = mockk<RegistrationFlowResponse>()
+        every { flowResponse.session } returns A_SESSION_ID_1
+        val errorCode = "errorCode"
+        val promise = mockk<Continuation<UIABaseAuth>>()
+        val reAuthNeeded = SignoutSessionResult.ReAuthNeeded(
+                pendingAuth = mockk(),
+                uiaContinuation = promise,
+                flowResponse = flowResponse,
+                errCode = errorCode,
+        )
+        every { interceptSignoutFlowResponseUseCase.execute(flowResponse, errorCode, promise) } returns reAuthNeeded
+        coEvery { signoutSessionUseCase.execute(deviceId, capture(interceptor)) } coAnswers {
+            secondArg<UserInteractiveAuthInterceptor>().performStage(flowResponse, errorCode, promise)
+            Result.success(Unit)
+        }
+
+        return reAuthNeeded
+    }
+
     private fun givenSignoutError(deviceId: String, error: Throwable) {
         coEvery { signoutSessionUseCase.execute(deviceId, any()) } returns Result.failure(error)
     }
diff --git a/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt b/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt
index 5d49dc3a77..9feea016e3 100644
--- a/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt
+++ b/vector/src/test/java/im/vector/app/test/fakes/FakePendingAuthHandler.kt
@@ -18,8 +18,9 @@ package im.vector.app.test.fakes
 
 import im.vector.app.features.auth.PendingAuthHandler
 import io.mockk.mockk
+import io.mockk.spyk
 
 class FakePendingAuthHandler {
 
-    val instance = mockk<PendingAuthHandler>()
+    val instance = spyk(mockk<PendingAuthHandler>())
 }

From 082fa1e69ee884f766975b08db420fbbfeb07713 Mon Sep 17 00:00:00 2001
From: Maxime NATUREL <maxime.naturel@niji.fr>
Date: Thu, 29 Sep 2022 10:27:13 +0200
Subject: [PATCH 17/17] Adding confirmation dialog for all type of sessions

---
 .../v2/overview/SessionOverviewAction.kt      |  2 +-
 .../v2/overview/SessionOverviewFragment.kt    | 38 ++++++++++++++++---
 .../v2/overview/SessionOverviewViewEvent.kt   |  1 -
 .../v2/overview/SessionOverviewViewModel.kt   | 13 ++-----
 .../overview/SessionOverviewViewModelTest.kt  | 28 ++------------
 5 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
index c0d428b951..42e79ac89f 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewAction.kt
@@ -20,7 +20,7 @@ import im.vector.app.core.platform.VectorViewModelAction
 
 sealed class SessionOverviewAction : VectorViewModelAction {
     object VerifySession : SessionOverviewAction()
-    object SignoutSession : SessionOverviewAction()
+    object SignoutOtherSession : SessionOverviewAction()
     object SsoAuthDone : SessionOverviewAction()
     data class PasswordAuthDone(val password: String) : SessionOverviewAction()
     object ReAuthCancelled : SessionOverviewAction()
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
index 341b0233b7..4af4913183 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewFragment.kt
@@ -28,6 +28,7 @@ import androidx.core.view.isVisible
 import com.airbnb.mvrx.Success
 import com.airbnb.mvrx.fragmentViewModel
 import com.airbnb.mvrx.withState
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import dagger.hilt.android.AndroidEntryPoint
 import im.vector.app.R
 import im.vector.app.core.date.VectorDateFormatter
@@ -42,6 +43,7 @@ import im.vector.app.features.crypto.recover.SetupMode
 import im.vector.app.features.settings.devices.v2.list.SessionInfoViewState
 import im.vector.app.features.workers.signout.SignOutUiWorker
 import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
+import org.matrix.android.sdk.api.extensions.orFalse
 import javax.inject.Inject
 
 /**
@@ -87,17 +89,12 @@ class SessionOverviewFragment :
                     navigator.open4SSetup(requireActivity(), SetupMode.PASSPHRASE_AND_NEEDED_SECRETS_RESET)
                 }
                 is SessionOverviewViewEvent.RequestReAuth -> askForReAuthentication(it)
-                SessionOverviewViewEvent.ConfirmSignoutCurrentSession -> confirmSignoutCurrentSession()
                 SessionOverviewViewEvent.SignoutSuccess -> viewNavigator.goBack(requireActivity())
                 is SessionOverviewViewEvent.SignoutError -> showFailure(it.error)
             }
         }
     }
 
-    private fun confirmSignoutCurrentSession() {
-        activity?.let { SignOutUiWorker(it).perform() }
-    }
-
     private fun initSessionInfoView() {
         views.sessionOverviewInfo.onLearnMoreClickListener = {
             Toast.makeText(context, "Learn more verification status", Toast.LENGTH_LONG).show()
@@ -112,10 +109,39 @@ class SessionOverviewFragment :
 
     private fun initSignoutButton() {
         views.sessionOverviewSignout.debouncedClicks {
-            viewModel.handle(SessionOverviewAction.SignoutSession)
+            confirmSignoutSession()
         }
     }
 
+    private fun confirmSignoutSession() = withState(viewModel) { state ->
+        if (state.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
+            confirmSignoutCurrentSession()
+        } else {
+            confirmSignoutOtherSession()
+        }
+    }
+
+    private fun confirmSignoutCurrentSession() {
+        activity?.let { SignOutUiWorker(it).perform() }
+    }
+
+    private fun confirmSignoutOtherSession() {
+        activity?.let {
+            MaterialAlertDialogBuilder(it)
+                    .setTitle(R.string.action_sign_out)
+                    .setMessage(R.string.action_sign_out_confirmation_simple)
+                    .setPositiveButton(R.string.action_sign_out) { _, _ ->
+                        signoutSession()
+                    }
+                    .setNegativeButton(R.string.action_cancel, null)
+                    .show()
+        }
+    }
+
+    private fun signoutSession() {
+        viewModel.handle(SessionOverviewAction.SignoutOtherSession)
+    }
+
     override fun onDestroyView() {
         cleanUpSessionInfoView()
         super.onDestroyView()
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
index 0d8a2ac8af..4ff31d1a81 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewEvent.kt
@@ -28,7 +28,6 @@ sealed class SessionOverviewViewEvent : VectorViewEvents {
             val lastErrorCode: String?
     ) : SessionOverviewViewEvent()
 
-    object ConfirmSignoutCurrentSession : SessionOverviewViewEvent()
     object SignoutSuccess : SessionOverviewViewEvent()
     data class SignoutError(val error: Throwable) : SessionOverviewViewEvent()
 }
diff --git a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
index 717c51978a..bd5c7725eb 100644
--- a/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModel.kt
@@ -97,7 +97,7 @@ class SessionOverviewViewModel @AssistedInject constructor(
     override fun handle(action: SessionOverviewAction) {
         when (action) {
             is SessionOverviewAction.VerifySession -> handleVerifySessionAction()
-            SessionOverviewAction.SignoutSession -> handleSignoutSession()
+            SessionOverviewAction.SignoutOtherSession -> handleSignoutOtherSession()
             SessionOverviewAction.SsoAuthDone -> handleSsoAuthDone()
             is SessionOverviewAction.PasswordAuthDone -> handlePasswordAuthDone(action)
             SessionOverviewAction.ReAuthCancelled -> handleReAuthCancelled()
@@ -127,18 +127,13 @@ class SessionOverviewViewModel @AssistedInject constructor(
         _viewEvents.post(SessionOverviewViewEvent.ShowVerifyOtherSession(deviceId))
     }
 
-    private fun handleSignoutSession() = withState { state ->
-        if (state.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
-            handleSignoutCurrentSession()
-        } else {
+    private fun handleSignoutOtherSession() = withState { state ->
+        // signout process for current session is not handled here
+        if (!state.deviceInfo.invoke()?.isCurrentDevice.orFalse()) {
             handleSignoutOtherSession(state.deviceId)
         }
     }
 
-    private fun handleSignoutCurrentSession() {
-        _viewEvents.post(SessionOverviewViewEvent.ConfirmSignoutCurrentSession)
-    }
-
     private fun handleSignoutOtherSession(deviceId: String) {
         viewModelScope.launch {
             setLoading(true)
diff --git a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
index c05c6daa3f..4f3cc66d63 100644
--- a/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
+++ b/vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/SessionOverviewViewModelTest.kt
@@ -199,26 +199,6 @@ class SessionOverviewViewModelTest {
                 .finish()
     }
 
-    @Test
-    fun `given current session when handling signout action then confirmation event is posted`() {
-        // Given
-        val deviceFullInfo = mockk<DeviceFullInfo>()
-        every { deviceFullInfo.isCurrentDevice } returns true
-        every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
-        val signoutAction = SessionOverviewAction.SignoutSession
-        givenCurrentSessionIsTrusted()
-
-        // When
-        val viewModel = createViewModel()
-        val viewModelTest = viewModel.test()
-        viewModel.handle(signoutAction)
-
-        // Then
-        viewModelTest
-                .assertEvent { it is SessionOverviewViewEvent.ConfirmSignoutCurrentSession }
-                .finish()
-    }
-
     @Test
     fun `given another session and no reAuth is needed when handling signout action then signout process is performed`() {
         // Given
@@ -227,7 +207,7 @@ class SessionOverviewViewModelTest {
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
         givenSignoutSuccess(A_SESSION_ID_1)
         every { refreshDevicesUseCase.execute() } just runs
-        val signoutAction = SessionOverviewAction.SignoutSession
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
         givenCurrentSessionIsTrusted()
         val expectedViewState = SessionOverviewViewState(
                 deviceId = A_SESSION_ID_1,
@@ -263,7 +243,7 @@ class SessionOverviewViewModelTest {
         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.SignoutSession
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
         givenCurrentSessionIsTrusted()
         val expectedViewState = SessionOverviewViewState(
                 deviceId = A_SESSION_ID_1,
@@ -297,7 +277,7 @@ class SessionOverviewViewModelTest {
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
         val error = Exception()
         givenSignoutError(A_SESSION_ID_1, error)
-        val signoutAction = SessionOverviewAction.SignoutSession
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
         givenCurrentSessionIsTrusted()
         val expectedViewState = SessionOverviewViewState(
                 deviceId = A_SESSION_ID_1,
@@ -330,7 +310,7 @@ class SessionOverviewViewModelTest {
         every { deviceFullInfo.isCurrentDevice } returns false
         every { getDeviceFullInfoUseCase.execute(A_SESSION_ID_1) } returns flowOf(deviceFullInfo)
         val reAuthNeeded = givenSignoutReAuthNeeded(A_SESSION_ID_1)
-        val signoutAction = SessionOverviewAction.SignoutSession
+        val signoutAction = SessionOverviewAction.SignoutOtherSession
         givenCurrentSessionIsTrusted()
         val expectedPendingAuth = DefaultBaseAuth(session = reAuthNeeded.flowResponse.session)
         val expectedReAuthEvent = SessionOverviewViewEvent.RequestReAuth(reAuthNeeded.flowResponse, reAuthNeeded.errCode)