Merge branch 'fix/get-detail-by-tx-id' into fix/tag-syncing

Author: jvsena42

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

@@ -6,10 +6,12 @@ import com.synonym.bitkitcore.ActivityFilter
 import com.synonym.bitkitcore.PaymentType
 import com.synonym.bitkitcore.SortDirection
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
 import org.lightningdevkit.ldknode.PaymentDetails
 import to.bitkit.data.CacheStore
 import to.bitkit.data.dto.InProgressTransfer
@@ -22,7 +24,8 @@ import to.bitkit.services.CoreService
 import to.bitkit.utils.Logger
 import javax.inject.Inject
 import javax.inject.Singleton
-import kotlin.time.Duration.Companion.seconds
+
+private const val SYNC_TIMEOUT_MS = 40_000L
 
 @Singleton
 class ActivityRepo @Inject constructor(
@@ -31,39 +34,49 @@ class ActivityRepo @Inject constructor(
     private val lightningRepo: LightningRepo,
     private val cacheStore: CacheStore,
 ) {
-
-    var isSyncingLdkNodePayments = false
+    var isSyncingLdkNodePayments = MutableStateFlow(false)
+        private set
 
     val inProgressTransfers = cacheStore.data.map { it.inProgressTransfers }
 
     suspend fun syncActivities(): Result<Unit> = withContext(bgDispatcher) {
         Logger.debug("syncActivities called", context = TAG)
 
         return@withContext runCatching {
-            if (isSyncingLdkNodePayments) {
-                Logger.warn("LDK-node payments are already being synced, skipping", context = TAG)
-                return@withContext Result.failure(Exception())
+            withTimeout(SYNC_TIMEOUT_MS) {
+                Logger.debug("isSyncingLdkNodePayments = ${isSyncingLdkNodePayments.value}", context = TAG)
+                isSyncingLdkNodePayments.first { !it }
             }
 
-            deletePendingActivities()
+            isSyncingLdkNodePayments = MutableStateFlow(true)
 
-            isSyncingLdkNodePayments = true
+            deletePendingActivities()
             return@withContext lightningRepo.getPayments()
                 .onSuccess { payments ->
                     Logger.debug("Got payments with success, syncing activities", context = TAG)
                     syncLdkNodePayments(payments = payments)
                     updateActivitiesMetadata()
                     boostPendingActivities()
                     updateInProgressTransfers()
-                    isSyncingLdkNodePayments = false
+                    isSyncingLdkNodePayments = MutableStateFlow(false)
                     return@withContext Result.success(Unit)
                 }.onFailure { e ->
                     Logger.error("Failed to sync ldk-node payments", e, context = TAG)
-                    isSyncingLdkNodePayments = false
+                    isSyncingLdkNodePayments = MutableStateFlow(false)
                     return@withContext Result.failure(e)
                 }.map { Unit }
         }.onFailure { e ->
-            Logger.error("syncLdkNodePayments error", e, context = TAG)
+            when (e) {
+                is TimeoutCancellationException -> {
+                    isSyncingLdkNodePayments = MutableStateFlow(false)
+                    Logger.error("Timeout waiting for sync to complete, forcing reset", e, context = TAG)
+                }
+
+                else -> {
+                    isSyncingLdkNodePayments = MutableStateFlow(false)
+                    Logger.error("syncActivities error", e, context = TAG)
+                }
+            }
         }
     }
 
@@ -127,9 +140,6 @@ class ActivityRepo @Inject constructor(
                     "activity with paymentHashOrTxId:$paymentHashOrTxId not found, trying again after sync",
                     context = TAG
                 )
-                Logger.debug("5 seconds delay", context = TAG)
-                delay(5.seconds)
-                Logger.debug("Syncing LN node called", context = TAG)
 
                 lightningRepo.sync().onSuccess {
                     Logger.debug("Syncing LN node SUCCESS", context = TAG)

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

@@ -258,9 +258,9 @@ class LightningRepo @Inject constructor(
     suspend fun sync(): Result<Unit> = executeWhenNodeRunning("Sync") {
         syncState()
         if (_lightningState.value.isSyncingWallet) {
-            Logger.warn("Sync already in progress, waiting for existing sync.")
-            return@executeWhenNodeRunning Result.success(Unit)
+            Logger.warn("Sync already in progress, waiting for existing sync.", context = TAG)
         }
+        _lightningState.first { !it.isSyncingWallet }
 
         _lightningState.update { it.copy(isSyncingWallet = true) }
         lightningService.sync()

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

@@ -71,6 +71,7 @@ import to.bitkit.ui.theme.AppThemeSurface
 import to.bitkit.ui.theme.Colors
 import to.bitkit.ui.utils.copyToClipboard
 import to.bitkit.ui.utils.getScreenTitleRes
+import to.bitkit.utils.Logger
 import to.bitkit.viewmodels.ActivityDetailViewModel
 import to.bitkit.viewmodels.ActivityListViewModel
 
@@ -85,7 +86,11 @@ fun ActivityDetailScreen(
 ) {
     val activities by listViewModel.filteredActivities.collectAsStateWithLifecycle()
     val item = activities?.find { it.rawId() == route.id }
-        ?: return
+    if (item == null) {
+        Logger.error("Activity not found")
+        return
+    }
+
 
     val app = appViewModel ?: return
     val copyToastTitle = stringResource(R.string.common__copied)

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

@@ -944,6 +944,7 @@ class AppViewModel @Inject constructor(
                                 )
                             )
                         )
+                        lightningRepo.sync()
                     }.onFailure { e ->
                         Logger.error(msg = "Error sending onchain payment", e = e, context = TAG)
                         toast(

app/src/test/java/to/bitkit/repositories/ActivityRepoTest.kt

@@ -86,17 +86,7 @@ class ActivityRepoTest : BaseUnitTest() {
         assertTrue(result.isSuccess)
         verify(lightningRepo).getPayments()
         verify(coreService.activity).syncLdkNodePayments(payments, forceUpdate = false)
-        assertFalse(sut.isSyncingLdkNodePayments)
-    }
-
-    @Test
-    fun `syncActivities skips when already syncing`() = test {
-        sut.isSyncingLdkNodePayments = true
-
-        val result = sut.syncActivities()
-
-        assertTrue(result.isFailure)
-        verify(lightningRepo, never()).getPayments()
+        assertFalse(sut.isSyncingLdkNodePayments.value)
     }
 
     @Test
@@ -108,7 +98,7 @@ class ActivityRepoTest : BaseUnitTest() {
 
         assertTrue(result.isFailure)
         assertEquals(exception, result.exceptionOrNull())
-        assertFalse(sut.isSyncingLdkNodePayments)
+        assertFalse(sut.isSyncingLdkNodePayments.value)
     }
 
     @Test