Timed sheets

app/src/main/java/to/bitkit/data/SettingsStore.kt

@@ -99,8 +99,11 @@ data class SettingsData(
     val enableAutoReadClipboard: Boolean = false,
     val enableSendAmountWarning: Boolean = false,
     val backupVerified: Boolean = false,
+    val notificationsVerified: Boolean = false,
     val dismissedSuggestions: List<String> = emptyList(),
-    val lastTimeAskedBalanceWarningMillis: Long = 0,
+    val balanceWarningIgnoredMillis: Long = 0,
+    val backupWarningIgnoredMillis: Long = 0,
+    val notificationsIgnoredMillis: Long = 0,
     val balanceWarningTimes: Int = 0,
     val coinSelectAuto: Boolean = true,
     val coinSelectPreference: CoinSelectionPreference = CoinSelectionPreference.BranchAndBound,

app/src/main/java/to/bitkit/ui/screens/wallets/HomeUiState.kt

@@ -33,6 +33,15 @@ data class HomeUiState(
     val currentPrice: PriceDTO? = null,
     val isEditingWidgets: Boolean = false,
     val deleteWidgetAlert: WidgetType? = null,
-    val highBalanceSheetVisible: Boolean = false,
     val showEmptyState: Boolean = false,
+    val timedSheet: TimedSheets? = null,
 )
+
+/**@param priority Priority levels for timed sheets (higher number = higher priority)*/
+enum class TimedSheets(val priority: Int) {
+    APP_UPDATE(2),
+    BACKUP(3),
+    NOTIFICATIONS(2),
+    QUICK_PAY(1),
+    HIGH_BALANCE(2)
+}

app/src/main/java/to/bitkit/ui/screens/wallets/HomeViewModel.kt

@@ -3,6 +3,7 @@
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -12,9 +13,12 @@
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.datetime.Clock
+import to.bitkit.BuildConfig
 import to.bitkit.data.SettingsStore
 import to.bitkit.data.dto.TransferType
+import to.bitkit.di.BgDispatcher
 import to.bitkit.models.Suggestion
 import to.bitkit.models.WidgetType
 import to.bitkit.models.toSuggestionOrNull
@@ -25,7 +29,9 @@
 import to.bitkit.repositories.CurrencyRepo
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.repositories.WidgetsRepo
+import to.bitkit.services.AppUpdaterService
 import to.bitkit.ui.screens.widgets.blocks.toWeatherModel
+import to.bitkit.utils.Logger
 import java.math.BigDecimal
 import javax.inject.Inject
 import kotlin.time.Duration.Companion.seconds
@@ -37,6 +43,8 @@
     private val settingsStore: SettingsStore,
     private val currencyRepo: CurrencyRepo,
     private val activityRepo: ActivityRepo,
+    private val appUpdaterService: AppUpdaterService,
+    @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(HomeUiState())
@@ -80,20 +88,6 @@
                 _uiState.update { newState }
             }
         }
-
-        viewModelScope.launch {
-            combine(
-                settingsStore.data,
-                walletRepo.balanceState
-            ) { settings, balanceState ->
-                _uiState.value.copy(
-                    showEmptyState = settings.showEmptyBalanceView && balanceState.totalSats == 0uL
-                )
-            }.collect { newState ->
-                checkHighBalance()
-                _uiState.update { newState }
-            }
-        }
     }
 
     private fun setupArticleRotation() {
@@ -146,40 +140,130 @@
         _currentFact.value = null
     }
 
-    private fun checkHighBalance() {
-        if (_uiState.value.highBalanceSheetVisible) return
-
+    fun checkTimedSheets() {
         viewModelScope.launch {
-            delay(CHECK_DELAY_MILLISECONDS)
+            if (_uiState.value.timedSheet != null) return@launch
+
+            delay(CHECK_DELAY_MILLIS)
+
+            TimedSheets.entries.sortedByDescending { it.priority }.forEach { sheet ->
+                val displaySheet = when (sheet) {
+                    TimedSheets.APP_UPDATE -> displayAppUpdate()
+                    TimedSheets.BACKUP -> displayBackupSheet()
+                    TimedSheets.NOTIFICATIONS -> displayNotificationSheet()
+                    TimedSheets.QUICK_PAY -> displayQuickPaySheet()
+                    TimedSheets.HIGH_BALANCE -> displayHighBalance()
+                }
+                if (displaySheet) {
+                    _uiState.update { it.copy(timedSheet = sheet) }
+                    return@launch
+                }
+            }
+        }
+    }
 
-            val settings = settingsStore.data.first()
-            val currentTime = Clock.System.now().toEpochMilliseconds()
+    suspend fun displayQuickPaySheet() : Boolean {
+        val settings = settingsStore.data.first()
+        if (settings.quickPayIntroSeen) return false
+        return walletRepo.balanceState.value.totalLightningSats > 0U
+    }
+    suspend fun displayNotificationSheet() : Boolean {
+        val settings = settingsStore.data.first()
 
-            val totalOnChainSats = walletRepo.balanceState.value.totalSats
-            val balanceUsd = satsToUsd(totalOnChainSats) ?: return@launch
-            val thresholdReached = balanceUsd > BigDecimal(BALANCE_THRESHOLD_USD)
+        if (settings.notificationsVerified) return false
 
-            val isTimeOutOver = settings.lastTimeAskedBalanceWarningMillis == 0L ||
-                (currentTime - settings.lastTimeAskedBalanceWarningMillis > ASK_INTERVAL_MILLIS)
+        val currentTime = Clock.System.now().toEpochMilliseconds()
+        val isTimeOutOver = settings.notificationsIgnoredMillis == 0L ||
+            (currentTime - settings.notificationsIgnoredMillis > ONE_DAY_ASK_INTERVAL_MILLIS)
 
-            val belowMaxWarnings = settings.balanceWarningTimes < MAX_WARNINGS
+        val shouldShow = isTimeOutOver
 
-            if (thresholdReached && isTimeOutOver && belowMaxWarnings) {
-                settingsStore.update {
-                    it.copy(
-                        balanceWarningTimes = it.balanceWarningTimes + 1,
-                        lastTimeAskedBalanceWarningMillis = currentTime
-                    )
-                }
-                _uiState.update { it.copy(highBalanceSheetVisible = true) }
+        if (shouldShow) {
+            settingsStore.update { it.copy(notificationsIgnoredMillis = currentTime) }
+        }
+
+        return shouldShow
+    }
+
+    suspend fun displayBackupSheet() : Boolean {
+        val settings = settingsStore.data.first()
+
+        if (settings.backupVerified) return false
+
+        val currentTime = Clock.System.now().toEpochMilliseconds()
+        val isTimeOutOver = settings.backupWarningIgnoredMillis == 0L ||
+            (currentTime - settings.backupWarningIgnoredMillis > ONE_DAY_ASK_INTERVAL_MILLIS)
+
+        val hasBalance = walletRepo.balanceState.value.totalSats > 0U
+
+        val shouldShow = isTimeOutOver && hasBalance
+
+        if (shouldShow) {
+            settingsStore.update { it.copy(backupWarningIgnoredMillis = currentTime) }
+        }
+
+        return shouldShow
+    }
+
+    private suspend fun displayAppUpdate(): Boolean = withContext(bgDispatcher) {
+        try {
+            val androidReleaseInfo = appUpdaterService.getReleaseInfo().platforms.android
+            val currentBuildNumber = BuildConfig.VERSION_CODE
+
+            if (androidReleaseInfo.buildNumber <= currentBuildNumber) return@withContext false
+
+            if (androidReleaseInfo.isCritical) {
+                handleCriticalUpdate()
+                return@withContext false
             }
 
-            if (!thresholdReached) {
-                settingsStore.update {
-                    it.copy(balanceWarningTimes = 0)
-                }
+            return@withContext true
+        } catch (e: Exception) {
+            Logger.warn("Failure fetching new releases", e = e)
+            return@withContext false
+        }
+    }
+
+    private suspend fun handleCriticalUpdate() {
+        // mainScreenEffect( // TODO
+        //     MainScreenEffect.Navigate(
+        //         route = Routes.CriticalUpdate,
+        //         navOptions = navOptions {
+        //             popUpTo(0) { inclusive = true }
+        //         }
+        //     )
+        // )
+    }
+
+    private suspend fun displayHighBalance(): Boolean {
+        val settings = settingsStore.data.first()
+        val currentTime = Clock.System.now().toEpochMilliseconds()
+
+        val totalOnChainSats = walletRepo.balanceState.value.totalSats
+        val balanceUsd = satsToUsd(totalOnChainSats) ?: return false
+        val thresholdReached = balanceUsd > BigDecimal(BALANCE_THRESHOLD_USD)
+
+        val isTimeOutOver = settings.balanceWarningIgnoredMillis == 0L ||
+            (currentTime - settings.balanceWarningIgnoredMillis > ONE_DAY_ASK_INTERVAL_MILLIS)
+
+        val belowMaxWarnings = settings.balanceWarningTimes < MAX_WARNINGS
+
+        if (!thresholdReached) {
+            settingsStore.update {
+                it.copy(balanceWarningTimes = 0)
             }
         }
+
+        if (thresholdReached && isTimeOutOver && belowMaxWarnings) {
+            settingsStore.update {
+                it.copy(
+                    balanceWarningTimes = it.balanceWarningTimes + 1,
+                    balanceWarningIgnoredMillis = currentTime
+                )
+            }
+            return true
+        }
+        return false
     }
 
     private fun satsToUsd(sats: ULong): BigDecimal? {
@@ -193,10 +277,6 @@
         }
     }
 
-    fun dismissHighBalanceSheet() {
-        _uiState.update { it.copy(highBalanceSheetVisible = false) }
-    }
-
     fun removeSuggestion(suggestion: Suggestion) {
         viewModelScope.launch {
             settingsStore.addDismissedSuggestion(suggestion)
@@ -331,10 +411,13 @@
         private const val BALANCE_THRESHOLD_USD = 500L
         private const val MAX_WARNINGS = 3
 
-        /** 1 day - how long this prompt will be hidden if user taps Later*/
-        private const val ASK_INTERVAL_MILLIS = 1000 * 60 * 60 * 24
+        /** how long this prompt will be hidden if user taps Later*/
+        private const val ONE_DAY_ASK_INTERVAL_MILLIS = 1000 * 60 * 60 * 24
+
+        /** how long this prompt will be hidden if user taps Later*/
+        private const val ONE_WEEK_ASK_INTERVAL_MILLIS = ONE_DAY_ASK_INTERVAL_MILLIS * 7
 
-        /**How long user needs to stay on the home screen before he will see this prompt*/
-        private const val CHECK_DELAY_MILLISECONDS = 2500L
+        /**How long user needs to stay on the home screen before he see this prompt*/
+        private const val CHECK_DELAY_MILLIS = 2500L
     }
 }

app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt

@@ -109,7 +109,6 @@ class AppViewModel @Inject constructor(
     private val blocktankRepo: BlocktankRepo,
     private val connectivityRepo: ConnectivityRepo,
     private val healthRepo: HealthRepo,
-    private val appUpdaterService: AppUpdaterService,
 ) : ViewModel() {
     val healthState = healthRepo.healthState
 
@@ -197,7 +196,6 @@ class AppViewModel @Inject constructor(
 
         observeLdkNodeEvents()
         observeSendEvents()
-        fetchNewReleases()
     }
 
     private fun observeLdkNodeEvents() {
@@ -1466,32 +1464,6 @@ class AppViewModel @Inject constructor(
         }
     }
 
-    private fun fetchNewReleases() {
-        viewModelScope.launch(bgDispatcher) {
-            runCatching {
-                val androidReleaseInfo = appUpdaterService.getReleaseInfo().platforms.android
-                val currentBuildNumber = BuildConfig.VERSION_CODE
-
-                if (androidReleaseInfo.buildNumber <= currentBuildNumber) return@launch
-
-                if (androidReleaseInfo.isCritical) {
-                    mainScreenEffect(
-                        MainScreenEffect.Navigate(
-                            route = Routes.CriticalUpdate,
-                            navOptions = navOptions {
-                                popUpTo(0) { inclusive = true }
-                            }
-                        )
-                    )
-                } else {
-                    showSheet(sheetType = Sheet.Update)
-                }
-            }.onFailure { e ->
-                Logger.warn("Failure fetching new releases", e = e)
-            }
-        }
-    }
-
     private fun onConfirmAmountWarning(warning: SanityWarning) {
         viewModelScope.launch {
             _sendUiState.update {