fix: unify timed sheets behavior

app/src/main/java/to/bitkit/di/TimedSheetModule.kt

@@ -0,0 +1,18 @@
+package to.bitkit.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import to.bitkit.utils.timedsheets.TimedSheetManager
+
+@Module
+@InstallIn(SingletonComponent::class)
+object TimedSheetModule {
+
+    @Provides
+    fun provideTimedSheetManagerProvider(): (CoroutineScope) -> TimedSheetManager {
+        return ::TimedSheetManager
+    }
+}

app/src/main/java/to/bitkit/ui/ContentView.kt

@@ -127,6 +127,7 @@ fun ContentView(
         appViewModel.mainScreenEffect.collect {
             when (it) {
                 is MainScreenEffect.Navigate -> navigator.navigate(it.route)
+                is MainScreenEffect.NavigateAndClearBackstack -> navigator.navigateAndClearBackstack(it.route)
                 is MainScreenEffect.ProcessClipboardAutoRead -> {
                     if (!navigator.isAtHome()) {
                         navigator.navigateToHome()

app/src/main/java/to/bitkit/ui/nav/Navigator.kt

@@ -50,6 +50,11 @@ class Navigator(@PublishedApi internal val backStack: NavBackStack<NavKey>) {
 
     fun isAtHome(): Boolean = backStack.lastOrNull() is Routes.Home
 
+    fun navigateAndClearBackstack(route: Routes) {
+        backStack.clear()
+        backStack.add(route)
+    }
+
     fun shouldShowTabBar(): Boolean = when (backStack.lastOrNull()) {
         is Routes.Home, is Routes.Savings, is Routes.Spending, is Routes.Activity.All -> true
         else -> false

app/src/main/java/to/bitkit/ui/nav/entries/SheetEntries.kt

@@ -3,6 +3,7 @@ package to.bitkit.ui.nav.entries
 import android.content.Intent
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
@@ -799,30 +800,33 @@ private fun EntryProviderScope<NavKey>.sheetFlowEntries(
     entry<Routes.Sheet.Update>(
         metadata = SheetSceneStrategy.sheet()
     ) {
+        DisposableEffect(Unit) {
+            onDispose { appViewModel.dismissTimedSheet() }
+        }
         UpdateSheet(
-            onCancel = {
-                appViewModel.dismissTimedSheet()
-                navigator.goBack()
-            },
+            onCancel = { navigator.goBack() },
         )
     }
 
     entry<Routes.Sheet.Backup>(
         metadata = SheetSceneStrategy.sheet()
     ) {
+        DisposableEffect(Unit) {
+            onDispose { appViewModel.dismissTimedSheet() }
+        }
         BackupIntroScreen(
             hasFunds = LocalBalances.current.totalSats > 0u,
-            onClose = {
-                appViewModel.dismissTimedSheet()
-                navigator.goBack()
-            },
+            onClose = { navigator.goBack() },
             onConfirm = { navigator.navigate(Routes.Backup.ShowMnemonic) },
         )
     }
 
     entry<Routes.Sheet.Notifications>(
         metadata = SheetSceneStrategy.sheet()
     ) {
+        DisposableEffect(Unit) {
+            onDispose { appViewModel.dismissTimedSheet() }
+        }
         BackgroundPaymentsIntroSheet(
             onContinue = {
                 appViewModel.dismissTimedSheet(skipQueue = true)
@@ -834,6 +838,9 @@ private fun EntryProviderScope<NavKey>.sheetFlowEntries(
     entry<Routes.Sheet.QuickPay>(
         metadata = SheetSceneStrategy.sheet()
     ) {
+        DisposableEffect(Unit) {
+            onDispose { appViewModel.dismissTimedSheet() }
+        }
         QuickPayIntroSheet(
             onContinue = {
                 appViewModel.dismissTimedSheet(skipQueue = true)
@@ -845,12 +852,12 @@ private fun EntryProviderScope<NavKey>.sheetFlowEntries(
     entry<Routes.Sheet.HighBalance>(
         metadata = SheetSceneStrategy.sheet()
     ) {
+        DisposableEffect(Unit) {
+            onDispose { appViewModel.dismissTimedSheet() }
+        }
         val context = LocalContext.current
         HighBalanceWarningSheet(
-            understoodClick = {
-                appViewModel.dismissTimedSheet()
-                navigator.goBack()
-            },
+            understoodClick = { navigator.goBack() },
             learnMoreClick = {
                 val intent = Intent(Intent.ACTION_VIEW, Env.STORING_BITCOINS_URL.toUri())
                 context.startActivity(intent)

app/src/main/java/to/bitkit/utils/timedsheets/TimedSheetItem.kt

@@ -0,0 +1,12 @@
+package to.bitkit.utils.timedsheets
+
+import to.bitkit.ui.components.TimedSheetType
+
+interface TimedSheetItem {
+    val type: TimedSheetType
+    val priority: Int
+
+    suspend fun shouldShow(): Boolean
+    suspend fun onShown()
+    suspend fun onDismissed()
+}

app/src/main/java/to/bitkit/utils/timedsheets/TimedSheetManager.kt

@@ -0,0 +1,87 @@
+package to.bitkit.utils.timedsheets
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import to.bitkit.ui.components.TimedSheetType
+import to.bitkit.utils.Logger
+
+class TimedSheetManager(private val scope: CoroutineScope) {
+    private val _currentSheet = MutableStateFlow<TimedSheetType?>(null)
+    val currentSheet: StateFlow<TimedSheetType?> = _currentSheet.asStateFlow()
+
+    private val registeredSheets = mutableListOf<TimedSheetItem>()
+    private var currentTimedSheet: TimedSheetItem? = null
+    private var checkJob: Job? = null
+
+    fun registerSheet(sheet: TimedSheetItem) {
+        registeredSheets.add(sheet)
+        registeredSheets.sortByDescending { it.priority }
+        Logger.debug(
+            "Registered timed sheet: ${sheet.type.name} with priority: ${sheet.priority}",
+            context = TAG
+        )
+    }
+
+    fun onHomeScreenEntered() {
+        Logger.debug("User entered home screen, starting timer", context = TAG)
+        checkJob?.cancel()
+        checkJob = scope.launch {
+            delay(CHECK_DELAY_MILLIS)
+            checkAndShowNextSheet()
+        }
+    }
+
+    fun onHomeScreenExited() {
+        Logger.debug("User exited home screen, cancelling timer", context = TAG)
+        checkJob?.cancel()
+        checkJob = null
+    }
+
+    fun dismissCurrentSheet(skipQueue: Boolean = false) {
+        if (currentTimedSheet == null) return
+
+        scope.launch {
+            currentTimedSheet?.onDismissed()
+            _currentSheet.value = null
+            currentTimedSheet = null
+
+            if (skipQueue) {
+                Logger.debug("Clearing timed sheet queue", context = TAG)
+            } else {
+                delay(CHECK_DELAY_MILLIS)
+                checkAndShowNextSheet()
+            }
+        }
+    }
+
+    private suspend fun checkAndShowNextSheet() {
+        Logger.debug("Registered sheets: ${registeredSheets.map { it.type.name }}")
+        for (sheet in registeredSheets.toList()) {
+            if (sheet.shouldShow()) {
+                Logger.debug(
+                    "Showing timed sheet: ${sheet.type.name} with priority: ${sheet.priority}",
+                    context = TAG
+                )
+                currentTimedSheet = sheet
+                _currentSheet.value = sheet.type
+                sheet.onShown()
+                registeredSheets.remove(sheet)
+                return
+            }
+        }
+
+        Logger.debug("No timed sheets need to be shown", context = TAG)
+        _currentSheet.value = null
+        currentTimedSheet = null
+    }
+
+    companion object {
+        private const val TAG = "TimedSheetManager"
+        private const val CHECK_DELAY_MILLIS = 2000L
+    }
+}

app/src/main/java/to/bitkit/utils/timedsheets/TimedSheetUtils.kt

@@ -0,0 +1,21 @@
+package to.bitkit.utils.timedsheets
+
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
+
+@OptIn(ExperimentalTime::class)
+fun checkTimeout(
+    lastIgnoredMillis: Long,
+    intervalMillis: Long,
+    additionalCondition: Boolean = true,
+): Boolean {
+    if (!additionalCondition) return false
+
+    val currentTime = Clock.System.now().toEpochMilliseconds()
+    val isTimeOutOver = lastIgnoredMillis == 0L ||
+        (currentTime - lastIgnoredMillis > intervalMillis)
+    return isTimeOutOver
+}
+
+const val ONE_DAY_ASK_INTERVAL_MILLIS = 1000 * 60 * 60 * 24L
+const val ONE_WEEK_ASK_INTERVAL_MILLIS = ONE_DAY_ASK_INTERVAL_MILLIS * 7L

app/src/main/java/to/bitkit/utils/timedsheets/sheets/AppUpdateTimedSheet.kt

@@ -0,0 +1,47 @@
+package to.bitkit.utils.timedsheets.sheets
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import to.bitkit.BuildConfig
+import to.bitkit.di.BgDispatcher
+import to.bitkit.services.AppUpdaterService
+import to.bitkit.ui.components.TimedSheetType
+import to.bitkit.utils.Logger
+import to.bitkit.utils.timedsheets.TimedSheetItem
+import javax.inject.Inject
+
+class AppUpdateTimedSheet @Inject constructor(
+    private val appUpdaterService: AppUpdaterService,
+    @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
+) : TimedSheetItem {
+    override val type = TimedSheetType.APP_UPDATE
+    override val priority = 5
+
+    override suspend fun shouldShow(): Boolean = withContext(bgDispatcher) {
+        return@withContext runCatching {
+            val androidReleaseInfo = appUpdaterService.getReleaseInfo().platforms.android
+            val currentBuildNumber = BuildConfig.VERSION_CODE
+
+            if (androidReleaseInfo.buildNumber <= currentBuildNumber) return@withContext false
+
+            if (androidReleaseInfo.isCritical) {
+                return@runCatching false
+            }
+            return@runCatching true
+        }.onFailure { e ->
+            Logger.warn("Failure fetching new releases", e = e, context = TAG)
+        }.getOrDefault(false)
+    }
+
+    override suspend fun onShown() {
+        Logger.debug("App update sheet shown", context = TAG)
+    }
+
+    override suspend fun onDismissed() {
+        Logger.debug("App update sheet dismissed", context = TAG)
+    }
+
+    companion object {
+        private const val TAG = "AppUpdateTimedSheet"
+    }
+}

app/src/main/java/to/bitkit/utils/timedsheets/sheets/BackupTimedSheet.kt

@@ -0,0 +1,51 @@
+package to.bitkit.utils.timedsheets.sheets
+
+import kotlinx.coroutines.flow.first
+import to.bitkit.data.SettingsStore
+import to.bitkit.ext.nowMillis
+import to.bitkit.repositories.WalletRepo
+import to.bitkit.ui.components.TimedSheetType
+import to.bitkit.utils.Logger
+import to.bitkit.utils.timedsheets.ONE_DAY_ASK_INTERVAL_MILLIS
+import to.bitkit.utils.timedsheets.TimedSheetItem
+import to.bitkit.utils.timedsheets.checkTimeout
+import javax.inject.Inject
+import kotlin.time.ExperimentalTime
+
+class BackupTimedSheet @Inject constructor(
+    private val settingsStore: SettingsStore,
+    private val walletRepo: WalletRepo,
+) : TimedSheetItem {
+    override val type = TimedSheetType.BACKUP
+    override val priority = 4
+
+    override suspend fun shouldShow(): Boolean {
+        val settings = settingsStore.data.first()
+        if (settings.backupVerified) return false
+
+        val hasBalance = walletRepo.balanceState.value.totalSats > 0U
+        if (!hasBalance) return false
+
+        return checkTimeout(
+            lastIgnoredMillis = settings.backupWarningIgnoredMillis,
+            intervalMillis = ONE_DAY_ASK_INTERVAL_MILLIS
+        )
+    }
+
+    override suspend fun onShown() {
+        Logger.debug("Backup sheet shown", context = TAG)
+    }
+
+    @OptIn(ExperimentalTime::class)
+    override suspend fun onDismissed() {
+        val currentTime = nowMillis()
+        settingsStore.update {
+            it.copy(backupWarningIgnoredMillis = currentTime)
+        }
+        Logger.debug("Backup sheet dismissed", context = TAG)
+    }
+
+    companion object {
+        private const val TAG = "BackupTimedSheet"
+    }
+}