[PM-13626] Remember last opened view for 5 minutes

app/src/main/java/com/x8bit/bitwarden/data/auth/datasource/disk/AuthDiskSource.kt

@@ -7,6 +7,7 @@ import com.x8bit.bitwarden.data.auth.datasource.disk.model.PendingAuthRequestJso
 import com.x8bit.bitwarden.data.auth.datasource.disk.model.UserStateJson
 import com.x8bit.bitwarden.data.vault.datasource.network.model.SyncResponseJson
 import kotlinx.coroutines.flow.Flow
+import java.time.Instant
 
 /**
  * Primary access point for disk information.
@@ -352,4 +353,14 @@ interface AuthDiskSource {
      * Stores the new device notice state for the given [userId].
      */
     fun storeNewDeviceNoticeState(userId: String, newState: NewDeviceNoticeState?)
+
+    /**
+     * Gets the last lock timestamp for the given [userId].
+     */
+    fun getLastLockTimestamp(userId: String): Instant?
+
+    /**
+     * Stores the last lock timestamp for the given [userId].
+     */
+    fun storeLastLockTimestamp(userId: String, lastLockTimestamp: Instant?)
 }

app/src/main/java/com/x8bit/bitwarden/data/auth/datasource/disk/AuthDiskSourceImpl.kt

@@ -16,6 +16,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.onSubscription
 import kotlinx.serialization.json.Json
+import java.time.Instant
 import java.util.UUID
 
 // These keys should be encrypted
@@ -49,6 +50,7 @@ private const val USES_KEY_CONNECTOR = "usesKeyConnector"
 private const val ONBOARDING_STATUS_KEY = "onboardingStatus"
 private const val SHOW_IMPORT_LOGINS_KEY = "showImportLogins"
 private const val NEW_DEVICE_NOTICE_STATE = "newDeviceNoticeState"
+private const val LAST_LOCK_TIMESTAMP = "lastLockTimestamp"
 
 /**
  * Primary implementation of [AuthDiskSource].
@@ -154,6 +156,7 @@ class AuthDiskSourceImpl(
         storeIsTdeLoginComplete(userId = userId, isTdeLoginComplete = null)
         storeAuthenticatorSyncUnlockKey(userId = userId, authenticatorSyncUnlockKey = null)
         storeShowImportLogins(userId = userId, showImportLogins = null)
+        storeLastLockTimestamp(userId = userId, lastLockTimestamp = null)
 
         // Do not remove the DeviceKey or PendingAuthRequest on logout, these are persisted
         // indefinitely unless the TDE flow explicitly removes them.
@@ -502,6 +505,19 @@ class AuthDiskSourceImpl(
         )
     }
 
+    override fun getLastLockTimestamp(userId: String): Instant? {
+        return getLong(key = LAST_LOCK_TIMESTAMP.appendIdentifier(userId))?.let {
+            Instant.ofEpochMilli(it)
+        }
+    }
+
+    override fun storeLastLockTimestamp(userId: String, lastLockTimestamp: Instant?) {
+        putLong(
+            key = LAST_LOCK_TIMESTAMP.appendIdentifier(userId),
+            value = lastLockTimestamp?.toEpochMilli(),
+        )
+    }
+
     private fun generateAndStoreUniqueAppId(): String =
         UUID
             .randomUUID()

app/src/main/java/com/x8bit/bitwarden/data/platform/datasource/disk/SettingsDiskSource.kt

@@ -1,5 +1,6 @@
 package com.x8bit.bitwarden.data.platform.datasource.disk
 
+import com.x8bit.bitwarden.data.platform.manager.model.AppResumeScreenData
 import com.x8bit.bitwarden.data.platform.repository.model.UriMatchType
 import com.x8bit.bitwarden.data.platform.repository.model.VaultTimeoutAction
 import com.x8bit.bitwarden.ui.platform.feature.settings.appearance.model.AppLanguage
@@ -356,4 +357,14 @@ interface SettingsDiskSource {
      * Stores the given [count] completed create send actions for the device.
      */
     fun storeCreateSendActionCount(count: Int?)
+
+    /**
+     * Stores the given [screenData] as the screen to resume to identified by [userId].
+     */
+    fun storeAppResumeScreen(userId: String, screenData: AppResumeScreenData?)
+
+    /**
+     * Gets the screen data to resume to for the device identified by [userId] or null if no screen
+     */
+    fun getAppResumeScreen(userId: String): AppResumeScreenData?
 }

app/src/main/java/com/x8bit/bitwarden/data/platform/datasource/disk/SettingsDiskSourceImpl.kt

@@ -1,6 +1,7 @@
 package com.x8bit.bitwarden.data.platform.datasource.disk
 
 import android.content.SharedPreferences
+import com.x8bit.bitwarden.data.platform.manager.model.AppResumeScreenData
 import com.x8bit.bitwarden.data.platform.repository.model.UriMatchType
 import com.x8bit.bitwarden.data.platform.repository.model.VaultTimeoutAction
 import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow
@@ -10,7 +11,6 @@ import com.x8bit.bitwarden.ui.platform.feature.settings.appearance.model.AppThem
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.onSubscription
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import java.time.Instant
 
@@ -40,6 +40,7 @@ private const val IS_VAULT_REGISTERED_FOR_EXPORT = "isVaultRegisteredForExport"
 private const val ADD_ACTION_COUNT = "addActionCount"
 private const val COPY_ACTION_COUNT = "copyActionCount"
 private const val CREATE_ACTION_COUNT = "createActionCount"
+private const val RESUME_SCREEN = "resumeScreen"
 
 /**
  * Primary implementation of [SettingsDiskSource].
@@ -175,6 +176,7 @@ class SettingsDiskSourceImpl(
         storeClearClipboardFrequencySeconds(userId = userId, frequency = null)
         removeWithPrefix(prefix = ACCOUNT_BIOMETRIC_INTEGRITY_VALID_KEY.appendIdentifier(userId))
         storeVaultRegisteredForExport(userId = userId, isRegistered = null)
+        storeAppResumeScreen(userId = userId, screenData = null)
 
         // The following are intentionally not cleared so they can be
         // restored after logging out and back in:
@@ -482,6 +484,16 @@ class SettingsDiskSourceImpl(
         )
     }
 
+    override fun storeAppResumeScreen(userId: String, screenData: AppResumeScreenData?) {
+        putString(
+            key = RESUME_SCREEN.appendIdentifier(userId),
+            value = screenData?.let { json.encodeToString(it) },
+        )
+    }
+
+    override fun getAppResumeScreen(userId: String): AppResumeScreenData? =
+        getString(RESUME_SCREEN.appendIdentifier(userId))?.let { json.decodeFromStringOrNull(it) }
+
     private fun getMutableLastSyncFlow(
         userId: String,
     ): MutableSharedFlow<Instant?> =

app/src/main/java/com/x8bit/bitwarden/data/platform/manager/AppResumeManager.kt

@@ -0,0 +1,37 @@
+package com.x8bit.bitwarden.data.platform.manager
+
+import com.x8bit.bitwarden.data.platform.manager.model.AppResumeScreenData
+import com.x8bit.bitwarden.data.platform.manager.model.SpecialCircumstance
+
+/**
+ * Manages the screen from which the app should be resumed after unlock.
+ */
+interface AppResumeManager {
+
+    /**
+     * Sets the screen from which the app should be resumed after unlock.
+     *
+     * @param screenData The screen identifier (e.g., "HomeScreen", "SettingsScreen").
+     */
+    fun setResumeScreen(screenData: AppResumeScreenData)
+
+    /**
+     * Gets the screen from which the app should be resumed after unlock.
+     *
+     * @return The screen identifier, or an empty string if not set.
+     */
+    fun getResumeScreen(): AppResumeScreenData?
+
+    /**
+     * Gets the special circumstance associated with the resume screen for the current user.
+     *
+     * @return The special circumstance, or null if no special circumstance
+     * is associated with the resume screen.
+     */
+    fun getResumeSpecialCircumstance(): SpecialCircumstance?
+
+    /**
+     * Clears the saved resume screen for the current user.
+     */
+    fun clearResumeScreen()
+}

app/src/main/java/com/x8bit/bitwarden/data/platform/manager/AppResumeManagerImpl.kt

@@ -0,0 +1,75 @@
+package com.x8bit.bitwarden.data.platform.manager
+
+import com.x8bit.bitwarden.data.auth.datasource.disk.AuthDiskSource
+import com.x8bit.bitwarden.data.auth.repository.AuthRepository
+import com.x8bit.bitwarden.data.platform.datasource.disk.SettingsDiskSource
+import com.x8bit.bitwarden.data.platform.manager.model.AppResumeScreenData
+import com.x8bit.bitwarden.data.platform.manager.model.SpecialCircumstance
+import com.x8bit.bitwarden.data.vault.manager.VaultLockManager
+import java.time.Clock
+
+// 5 minutes
+private const val UNLOCK_NAVIGATION_TIME_MS: Long = 5 * 60
+
+/**
+ * Primary implementation of [AppResumeManager].
+ */
+class AppResumeManagerImpl(
+    private val settingsDiskSource: SettingsDiskSource,
+    private val authDiskSource: AuthDiskSource,
+    private val authRepository: AuthRepository,
+    private val vaultLockManager: VaultLockManager,
+    private val clock: Clock,
+) : AppResumeManager {
+
+    override fun setResumeScreen(screenData: AppResumeScreenData) {
+        authRepository.activeUserId?.let {
+            settingsDiskSource.storeAppResumeScreen(
+                userId = it,
+                screenData = screenData,
+            )
+        }
+    }
+
+    override fun getResumeScreen(): AppResumeScreenData? {
+        return authRepository.activeUserId?.let { userId ->
+            settingsDiskSource.getAppResumeScreen(userId)
+        }
+    }
+
+    override fun getResumeSpecialCircumstance(): SpecialCircumstance? {
+        val userId = authRepository.activeUserId ?: return null
+        val timeNowMinus5Min = clock.instant().minusSeconds(UNLOCK_NAVIGATION_TIME_MS)
+        val lastLockTimestamp = authDiskSource.getLastLockTimestamp(
+            userId = userId,
+        ) ?: return null
+
+        if (timeNowMinus5Min.isAfter(lastLockTimestamp)) {
+            clearResumeScreen()
+            return null
+        }
+        return when (val resumeScreenData = getResumeScreen()) {
+            AppResumeScreenData.GeneratorScreen -> SpecialCircumstance.GeneratorShortcut
+            AppResumeScreenData.SendScreen -> SpecialCircumstance.SendShortcut
+            is AppResumeScreenData.SearchScreen -> SpecialCircumstance.SearchShortcut(
+                searchTerm = resumeScreenData.searchTerm,
+            )
+
+            AppResumeScreenData.VerificationCodeScreen -> {
+                SpecialCircumstance.VerificationCodeShortcut
+            }
+
+            else -> null
+        }
+    }
+
+    override fun clearResumeScreen() {
+        val userId = authRepository.activeUserId ?: return
+        if (vaultLockManager.isVaultUnlocked(userId = userId)) {
+            settingsDiskSource.storeAppResumeScreen(
+                userId = userId,
+                screenData = null,
+            )
+        }
+    }
+}

app/src/main/java/com/x8bit/bitwarden/data/platform/manager/di/PlatformManagerModule.kt

@@ -15,6 +15,8 @@ import com.x8bit.bitwarden.data.platform.datasource.disk.legacy.LegacyAppCenterM
 import com.x8bit.bitwarden.data.platform.datasource.network.authenticator.RefreshAuthenticator
 import com.x8bit.bitwarden.data.platform.datasource.network.service.EventService
 import com.x8bit.bitwarden.data.platform.datasource.network.service.PushService
+import com.x8bit.bitwarden.data.platform.manager.AppResumeManager
+import com.x8bit.bitwarden.data.platform.manager.AppResumeManagerImpl
 import com.x8bit.bitwarden.data.platform.manager.AppStateManager
 import com.x8bit.bitwarden.data.platform.manager.AppStateManagerImpl
 import com.x8bit.bitwarden.data.platform.manager.AssetManager
@@ -64,6 +66,7 @@ import com.x8bit.bitwarden.data.platform.repository.EnvironmentRepository
 import com.x8bit.bitwarden.data.platform.repository.ServerConfigRepository
 import com.x8bit.bitwarden.data.platform.repository.SettingsRepository
 import com.x8bit.bitwarden.data.vault.datasource.disk.VaultDiskSource
+import com.x8bit.bitwarden.data.vault.manager.VaultLockManager
 import com.x8bit.bitwarden.data.vault.repository.VaultRepository
 import dagger.Module
 import dagger.Provides
@@ -329,4 +332,22 @@ object PlatformManagerModule {
         autofillEnabledManager = autofillEnabledManager,
         accessibilityEnabledManager = accessibilityEnabledManager,
     )
+
+    @Provides
+    @Singleton
+    fun provideAppResumeManager(
+        settingsDiskSource: SettingsDiskSource,
+        authDiskSource: AuthDiskSource,
+        authRepository: AuthRepository,
+        vaultLockManager: VaultLockManager,
+        clock: Clock,
+    ): AppResumeManager {
+        return AppResumeManagerImpl(
+            settingsDiskSource = settingsDiskSource,
+            authDiskSource = authDiskSource,
+            authRepository = authRepository,
+            vaultLockManager = vaultLockManager,
+            clock = clock,
+        )
+    }
 }

app/src/main/java/com/x8bit/bitwarden/data/platform/manager/model/AppResumeScreenData.kt

@@ -0,0 +1,34 @@
+package com.x8bit.bitwarden.data.platform.manager.model
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Data class representing the Screen Data for app resume.
+ */
+@Serializable
+sealed class AppResumeScreenData {
+
+    /**
+     * Data object representing the Generator screen for app resume.
+     */
+    @Serializable
+    data object GeneratorScreen : AppResumeScreenData()
+
+    /**
+     * Data object representing the Send screen for app resume.
+     */
+    @Serializable
+    data object SendScreen : AppResumeScreenData()
+
+    /**
+     * Data class representing the Search screen for app resume.
+     */
+    @Serializable
+    data class SearchScreen(val searchTerm: String) : AppResumeScreenData()
+
+    /**
+     * Data object representing the Verification Code screen for app resume.
+     */
+    @Serializable
+    data object VerificationCodeScreen : AppResumeScreenData()
+}

app/src/main/java/com/x8bit/bitwarden/data/platform/manager/model/SpecialCircumstance.kt

@@ -104,6 +104,24 @@ sealed class SpecialCircumstance : Parcelable {
     @Parcelize
     data object AccountSecurityShortcut : SpecialCircumstance()
 
+    /**
+     * Deeplink to the Send.
+     */
+    @Parcelize
+    data object SendShortcut : SpecialCircumstance()
+
+    /**
+     * Deeplink to the Search.
+     */
+    @Parcelize
+    data class SearchShortcut(val searchTerm: String) : SpecialCircumstance()
+
+    /**
+     * Deeplink to the Verification Code.
+     */
+    @Parcelize
+    data object VerificationCodeShortcut : SpecialCircumstance()
+
     /**
      * A subset of [SpecialCircumstance] that are only relevant in a pre-login state and should be
      * cleared after a successful login.

app/src/main/java/com/x8bit/bitwarden/data/vault/manager/VaultLockManager.kt

@@ -2,7 +2,6 @@ package com.x8bit.bitwarden.data.vault.manager
 
 import com.bitwarden.core.InitUserCryptoMethod
 import com.bitwarden.crypto.Kdf
-import com.bitwarden.sdk.AuthClient
 import com.x8bit.bitwarden.data.vault.manager.model.VaultStateEvent
 import com.x8bit.bitwarden.data.vault.repository.model.VaultUnlockData
 import com.x8bit.bitwarden.data.vault.repository.model.VaultUnlockResult

app/src/main/java/com/x8bit/bitwarden/data/vault/manager/VaultLockManagerImpl.kt

@@ -50,6 +50,7 @@ import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import java.time.Clock
 import kotlin.time.Duration.Companion.minutes
 
 /**
@@ -70,6 +71,7 @@ class VaultLockManagerImpl(
     private val userLogoutManager: UserLogoutManager,
     private val trustedDeviceManager: TrustedDeviceManager,
     dispatcherManager: DispatcherManager,
+    private val clock: Clock,
 ) : VaultLockManager {
     private val unconfinedScope = CoroutineScope(dispatcherManager.unconfined)
 
@@ -268,6 +270,10 @@ class VaultLockManagerImpl(
         )
         if (!wasVaultLocked) {
             mutableVaultStateEventSharedFlow.tryEmit(VaultStateEvent.Locked(userId = userId))
+            authDiskSource.storeLastLockTimestamp(
+                userId = userId,
+                lastLockTimestamp = clock.instant(),
+            )
         }
     }