feat: connection issues view

CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Connection issues overlay with connectivity fixes across Send, Receive, and Transfer flows #878
 
 ## [2.2.0] - 2026-04-07
 
@@ -17,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Show loading state on Spending tab when node is not running #875
 
 ### Added
+- Transfer from Savings button on empty Spending screen when savings balance exists #882
 - Lightning Connections empty state with onboarding screen #857
 - Unified PIN management screen (enable/disable/change in one place) #857
 - Support entry in drawer menu #857

app/src/main/java/to/bitkit/repositories/LightningRepo.kt

@@ -58,6 +58,7 @@ import to.bitkit.env.Env
 import to.bitkit.ext.getSatsPerVByteFor
 import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.toPeerDetailsList
+import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.models.ALL_ADDRESS_TYPE_STRINGS
 import to.bitkit.models.CoinSelectionPreference
 import to.bitkit.models.NATIVE_WITNESS_TYPES
@@ -144,6 +145,10 @@ class LightningRepo @Inject constructor(
                         return@collect
                     }
 
+                    if (_lightningState.value.nodeLifecycleState.isRunning()) {
+                        connectToTrustedPeers()
+                    }
+
                     // Start retry loop if sync is failing
                     startSyncRetryLoopIfNeeded()
                 }
@@ -523,7 +528,11 @@ class LightningRepo @Inject constructor(
 
     private fun handleLdkEvent(event: Event) {
         when (event) {
-            is Event.ChannelPending, is Event.ChannelReady -> scope.launch { refreshChannelCache() }
+            is Event.ChannelPending, is Event.ChannelReady -> scope.launch {
+                refreshChannelCache()
+                syncState()
+            }
+
             is Event.ChannelClosed -> scope.launch { registerClosedChannel(event.channelId, event.reason) }
             else -> Unit
         }
@@ -983,15 +992,14 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    private suspend fun waitForUsableChannels() {
-        if (lightningService.channels?.any { it.isUsable } == true) return
+    suspend fun waitForUsableChannels() = withContext(bgDispatcher) {
+        if (_lightningState.value.channels.any { it.isUsable }) return@withContext
 
         Logger.info("Waiting for usable channels before sending payment", context = TAG)
-        syncState()
 
         withTimeoutOrNull(CHANNELS_USABLE_TIMEOUT_MS) {
             _lightningState.first { state -> state.channels.any { it.isUsable } }
-        } ?: Logger.warn("Timeout waiting for usable channels", context = TAG)
+        } ?: Logger.warn("Timed out waiting for usable channels", context = TAG)
     }
 
     @Suppress("LongParameterList")
@@ -1203,19 +1211,20 @@ class LightningRepo @Inject constructor(
         }
     }
 
-    suspend fun canSend(amountSats: ULong, fallbackToCachedBalance: Boolean = true) = withContext(bgDispatcher) {
-        if (!_lightningState.value.nodeLifecycleState.canRun()) {
-            return@withContext false
-        }
-        if (_lightningState.value.nodeLifecycleState.isStarting() && fallbackToCachedBalance) {
-            return@withContext amountSats <= (cacheStore.data.first().balance?.maxSendLightningSats ?: 0u)
-        }
-        if (lightningService.channels == null) {
-            withTimeoutOrNull(CHANNELS_READY_TIMEOUT_MS) {
-                _lightningState.first { lightningService.channels != null }
+    suspend fun awaitPeerConnected(timeout: Duration = 30.seconds) = withContext(bgDispatcher) {
+        if (lightningService.peers?.any { it.isConnected } == true) return@withContext
+        Logger.debug("Waiting for peer to reconnect (timeout='$timeout')...", context = TAG)
+        withTimeoutOrNull(timeout) {
+            while (lightningService.peers?.any { it.isConnected } != true) {
+                delay(1.seconds)
             }
         }
-        return@withContext lightningService.canSend(amountSats)
+    }
+
+    fun canSend(amountSats: ULong): Boolean {
+        val state = _lightningState.value
+        if (!state.nodeLifecycleState.canRun()) return false
+        return state.channels.totalNextOutboundHtlcLimitSats() >= amountSats
     }
 
     fun getNodeId(): String? =
@@ -1401,7 +1410,6 @@ class LightningRepo @Inject constructor(
         private const val LENGTH_CHANNEL_ID_PREVIEW = 10
         private const val MS_SYNC_LOOP_DEBOUNCE = 500L
         private const val SYNC_RETRY_DELAY_MS = 15_000L
-        private const val CHANNELS_READY_TIMEOUT_MS = 15_000L
         private const val CHANNELS_USABLE_TIMEOUT_MS = 15_000L
         val SEND_LN_TIMEOUT = 10.seconds
     }

app/src/main/java/to/bitkit/services/LightningService.kt

@@ -46,7 +46,6 @@ import to.bitkit.data.backup.VssStoreIdProvider
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
-import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.ext.uByteList
 import to.bitkit.ext.uri
 import to.bitkit.models.msatFloorOf
@@ -619,23 +618,6 @@ class LightningService @Inject constructor(
         }
     }
 
-    fun canSend(amountSats: ULong): Boolean {
-        val channels = this.channels
-        if (channels == null) {
-            Logger.warn("Channels not available", context = TAG)
-            return false
-        }
-
-        val totalNextOutboundHtlcLimitSats = channels.totalNextOutboundHtlcLimitSats()
-
-        if (totalNextOutboundHtlcLimitSats < amountSats) {
-            Logger.warn("Insufficient outbound capacity: $totalNextOutboundHtlcLimitSats < $amountSats", context = TAG)
-            return false
-        }
-
-        return true
-    }
-
     suspend fun send(
         address: Address,
         sats: ULong,

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

@@ -48,6 +48,7 @@ import to.bitkit.env.Env
 import to.bitkit.models.NodeLifecycleState
 import to.bitkit.models.Toast
 import to.bitkit.models.WidgetType
+import to.bitkit.repositories.ConnectivityState
 import to.bitkit.ui.Routes.ExternalConnection
 import to.bitkit.ui.components.AuthCheckScreen
 import to.bitkit.ui.components.DrawerMenu
@@ -170,6 +171,7 @@ import to.bitkit.ui.sheets.LnurlAuthSheet
 import to.bitkit.ui.sheets.PinSheet
 import to.bitkit.ui.sheets.QrScanningSheet
 import to.bitkit.ui.sheets.QuickPayIntroSheet
+import to.bitkit.ui.sheets.SendRoute
 import to.bitkit.ui.sheets.SendSheet
 import to.bitkit.ui.sheets.UpdateSheet
 import to.bitkit.ui.utils.AutoReadClipboardHandler
@@ -381,13 +383,15 @@ fun ContentView(
 
                         is Sheet.Receive -> {
                             val walletState by walletViewModel.walletState.collectAsStateWithLifecycle()
+                            val connectivityState by appViewModel.isOnline.collectAsStateWithLifecycle()
                             ReceiveSheet(
                                 startRoute = sheet.route,
                                 walletState = walletState,
+                                isOffline = connectivityState != ConnectivityState.CONNECTED,
                                 navigateToExternalConnection = {
                                     navController.navigateTo(ExternalConnection())
                                     appViewModel.hideSheet()
-                                }
+                                },
                             )
                         }
 
@@ -478,7 +482,7 @@ fun ContentView(
                         TabBar(
                             onSendClick = { appViewModel.showSheet(Sheet.Send()) },
                             onReceiveClick = { appViewModel.showSheet(Sheet.Receive()) },
-                            onScanClick = { appViewModel.showScannerSheet() },
+                            onScanClick = { appViewModel.showSheet(Sheet.Send(SendRoute.QrScanner)) },
                         )
                     }
                 }
@@ -576,7 +580,9 @@ private fun RootNavHost(
                 )
             }
             composableWithDefaultTransitions<Routes.SavingsConfirm> {
+                val connectivityState by appViewModel.isOnline.collectAsStateWithLifecycle()
                 SavingsConfirmScreen(
+                    isOffline = connectivityState != ConnectivityState.CONNECTED,
                     onConfirm = { navController.navigateTo(Routes.SavingsProgress) },
                     onAdvancedClick = { navController.navigateTo(Routes.SavingsAdvanced) },
                     onBackClick = { navController.popBackStack() },
@@ -607,23 +613,27 @@ private fun RootNavHost(
                 )
             }
             composableWithDefaultTransitions<Routes.SpendingAmount> {
+                val connectivityState by appViewModel.isOnline.collectAsStateWithLifecycle()
                 SpendingAmountScreen(
                     viewModel = transferViewModel,
+                    isOffline = connectivityState != ConnectivityState.CONNECTED,
                     onBackClick = { navController.popBackStack() },
                     onOrderCreated = { navController.navigateTo(Routes.SpendingConfirm) },
                     toastException = { appViewModel.toast(it) },
                     toast = { title, description ->
                         appViewModel.toast(
                             type = Toast.ToastType.ERROR,
                             title = title,
-                            description = description
+                            description = description,
                         )
                     },
                 )
             }
             composableWithDefaultTransitions<Routes.SpendingConfirm> {
+                val connectivityState by appViewModel.isOnline.collectAsStateWithLifecycle()
                 SpendingConfirmScreen(
                     viewModel = transferViewModel,
+                    isOffline = connectivityState != ConnectivityState.CONNECTED,
                     onBackClick = { navController.popBackStack() },
                     onCloseClick = { navController.navigateToHome() },
                     onLearnMoreClick = { navController.navigateTo(Routes.TransferLiquidity) },
@@ -807,6 +817,7 @@ private fun NavGraphBuilder.home(
     }
     composableWithDefaultTransitions<Routes.Spending> {
         val hasSeenSavingsIntro by settingsViewModel.hasSeenSavingsIntro.collectAsStateWithLifecycle()
+        val hasSeenSpendingIntro by settingsViewModel.hasSeenSpendingIntro.collectAsStateWithLifecycle()
         val lightningState by walletViewModel.lightningState.collectAsStateWithLifecycle()
         val lightningActivities by activityListViewModel.lightningActivities.collectAsStateWithLifecycle()
 
@@ -823,6 +834,13 @@ private fun NavGraphBuilder.home(
                     navController.navigateToTransferSavingsAvailability()
                 }
             },
+            onTransferFromSavingsClick = {
+                if (!hasSeenSpendingIntro) {
+                    navController.navigateToTransferSpendingIntro()
+                } else {
+                    navController.navigateToTransferSpendingAmount()
+                }
+            },
             onBackClick = { navController.popBackStack() },
         )
     }

app/src/main/java/to/bitkit/ui/components/ConnectionIssuesView.kt

@@ -0,0 +1,140 @@
+package to.bitkit.ui.components
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import to.bitkit.R
+import to.bitkit.ui.scaffold.SheetTopBar
+import to.bitkit.ui.shared.util.gradientBackground
+import to.bitkit.ui.theme.AppThemeSurface
+import to.bitkit.ui.theme.Colors
+import to.bitkit.ui.utils.withAccent
+
+@Composable
+fun ConnectionIssuesView(
+    titleText: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .gradientBackground()
+            .navigationBarsPadding()
+            .padding(horizontal = 16.dp)
+            .testTag("ConnectionIssueView")
+    ) {
+        SheetTopBar(titleText = titleText)
+        VerticalSpacer(24.dp)
+
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier
+                .fillMaxWidth()
+                .weight(1f)
+        ) {
+            DashedRingsLayer(outerOnly = true)
+
+            Image(
+                painter = painterResource(R.drawable.phone),
+                contentDescription = null,
+                contentScale = ContentScale.Fit,
+                modifier = Modifier
+                    .size(311.dp)
+                    .align(Alignment.Center)
+            )
+
+            DashedRingsLayer(outerOnly = false)
+        }
+
+        Display(
+            text = stringResource(R.string.other__connection_issues_title)
+                .withAccent(accentColor = Colors.Yellow),
+            modifier = Modifier.fillMaxWidth()
+        )
+
+        VerticalSpacer(8.dp)
+
+        BodyM(
+            text = stringResource(R.string.other__connection_issues_explain),
+            color = Colors.White64,
+            modifier = Modifier.fillMaxWidth()
+        )
+
+        VerticalSpacer(24.dp)
+
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            GradientCircularProgressIndicator(
+                strokeWidth = 1.dp,
+                modifier = Modifier.size(32.dp)
+            )
+        }
+
+        VerticalSpacer(16.dp)
+    }
+}
+
+private val outerRingRadii = listOf(200f)
+private val innerRingRadii = listOf(150f, 100f, 50f)
+
+@Composable
+private fun DashedRingsLayer(outerOnly: Boolean, modifier: Modifier = Modifier) {
+    val radii = if (outerOnly) outerRingRadii else innerRingRadii
+    Canvas(modifier = modifier.fillMaxSize()) {
+        val center = Offset(size.width * 0.25f, size.height * 0.40f)
+        radii.forEach { radiusDp -> drawDashedGradientRing(radiusDp, center) }
+    }
+}
+
+private fun DrawScope.drawDashedGradientRing(radiusDp: Float, center: Offset) {
+    val radius = radiusDp.dp.toPx()
+    val brush = Brush.linearGradient(
+        colors = listOf(Color.Black, Colors.Yellow),
+        start = Offset(center.x - radius, center.y - radius),
+        end = Offset(center.x + radius, center.y + radius),
+    )
+    drawCircle(
+        brush = brush,
+        radius = radius,
+        center = center,
+        style = Stroke(
+            width = 1.dp.toPx(),
+            pathEffect = PathEffect.dashPathEffect(
+                floatArrayOf(8.dp.toPx(), 6.dp.toPx()),
+            ),
+        ),
+    )
+}
+
+@Preview(showSystemUi = true)
+@Composable
+private fun Preview() {
+    AppThemeSurface {
+        BottomSheetPreview {
+            ConnectionIssuesView(titleText = "Send Bitcoin")
+        }
+    }
+}

app/src/main/java/to/bitkit/ui/components/IsOnlineTracker.kt

@@ -24,7 +24,7 @@ fun IsOnlineTracker(
     LaunchedEffect(connectivityState) {
         // Skip the first emission to prevent toast on startup
         if (isFirstEmission) {
-            setIsFirstEmission(true)
+            setIsFirstEmission(false)
             return@LaunchedEffect
         }