Refactor cloud backup and mobile manager ownership

.github/workflows/ci.yml

@@ -48,6 +48,8 @@ jobs:
           java-version: '17'
       - name: Run ktlint
         run: cd android && ./gradlew ktlintCheck
+      - name: Run detekt
+        run: cd android && ./gradlew detekt
 
   compile-android:
     runs-on: ubuntu-latest
@@ -101,6 +103,9 @@ jobs:
       - name: Compile Android
         run: cd android && ./gradlew assembleDevDebug
 
+      - name: Run Android unit tests
+        run: cd android && ./gradlew testDevDebugUnitTest
+
   compile-ios:
     runs-on: macos-26
     env:
@@ -145,6 +150,9 @@ jobs:
       - name: Compile iOS
         run: cd ios && xcodebuild -scheme Cove -sdk iphonesimulator -arch arm64 build
 
+      - name: Run iOS unit tests
+        run: cd ios && xcodebuild -scheme Cove -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' -only-testing:CoveTests -parallel-testing-enabled NO test
+
   test:
     strategy:
       matrix:

android/app/build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     id("com.android.application")
     id("com.android.compose.screenshot")
+    id("dev.detekt")
     id("org.jetbrains.kotlin.plugin.compose")
     id("org.jlleitschuh.gradle.ktlint")
 }
@@ -104,6 +105,7 @@ dependencies {
     implementation("androidx.compose.material:material-icons-extended")
     testImplementation("junit:junit:4.13.2")
     testImplementation("org.json:json:20251224")
+    testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
     androidTestImplementation("androidx.test.ext:junit:1.3.0")
     androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
@@ -161,3 +163,32 @@ ktlint {
         exclude("**/uniffi/**")
     }
 }
+
+val detektBaselineFile = file("$rootDir/detekt-baseline.xml")
+
+detekt {
+    toolVersion = "2.0.0-alpha.3"
+    config.setFrom(files("$rootDir/detekt.yml"))
+    buildUponDefaultConfig = true
+    baseline = detektBaselineFile
+    basePath.set(rootDir)
+    failOnSeverity = dev.detekt.gradle.extensions.FailOnSeverity.Warning
+}
+
+tasks.withType<dev.detekt.gradle.Detekt>().configureEach {
+    baseline.set(detektBaselineFile)
+    exclude("**/cove_core/**")
+    exclude("**/uniffi/**")
+    exclude("**/build/**")
+}
+
+tasks.withType<dev.detekt.gradle.DetektCreateBaselineTask>().configureEach {
+    baseline.set(detektBaselineFile)
+    exclude("**/cove_core/**")
+    exclude("**/uniffi/**")
+    exclude("**/build/**")
+}
+
+tasks.named("detekt") {
+    dependsOn("detektDevDebug")
+}

android/app/src/androidTest/java/org/bitcoinppl/cove/flows/onboarding/OnboardingFullLaunchTest.kt

@@ -197,7 +197,7 @@ class OnboardingFullLaunchTest {
             .skipCloudBackupAfterImport()
             .acceptTermsAfterImport()
             .chooseNativeImportedWalletFromSelectionSheet()
-            .assertImportedMainnetWalletHasHistoryAndNoBitcoin()
+            .assertImportedMainnetWalletShowsHistory()
     }
 
     @Test

android/app/src/androidTest/java/org/bitcoinppl/cove/test/FullLaunchRobot.kt

@@ -258,14 +258,16 @@ class FullLaunchOnboardingRobot(
         }
 
         knownEmptyMainnetMnemonic.forEachIndexed { index, word ->
-            device.waitUntilVisible(tag("hotWalletImport.word.${index + 1}")).text = word
+            val wordSelector = tag("hotWalletImport.word.${index + 1}")
+            device.waitUntilVisible(wordSelector).text = word
+            device.waitUntilTextEquals(wordSelector, word)
         }
 
         device.dismissKeyboardIfShown()
         device.clickUntilVisible(
             clickSelector = tag("hotWalletImport.import"),
             targetSelector = text("Protect this wallet with Cloud Backup?"),
-            timeoutMillis = 20_000,
+            timeoutMillis = 60_000,
         )
 
         return this
@@ -307,9 +309,14 @@ class FullLaunchOnboardingRobot(
         return this
     }
 
-    fun assertImportedMainnetWalletHasHistoryAndNoBitcoin(): FullLaunchOnboardingRobot {
-        device.waitUntilSendShowsNoFunds()
+    fun assertImportedMainnetWalletShowsHistory(): FullLaunchOnboardingRobot {
+        device.waitUntilVisible(text("Send"), timeoutMillis = 30_000)
         device.waitUntilVisible(text("Transactions"), timeoutMillis = 30_000)
+        device.waitUntilAnyVisible(
+            text("Sent"),
+            text("Received"),
+            timeoutMillis = 90_000,
+        )
 
         return this
     }
@@ -539,7 +546,7 @@ private fun UiDevice.advanceUntilVisible(
     advance: UiDevice.() -> Boolean = { false },
 ): UiObject2 {
     val deadline = System.currentTimeMillis() + timeoutMillis
-    var didAdvance = false
+    var lastAdvanceAt = 0L
 
     while (System.currentTimeMillis() < deadline) {
         findObject(targetSelector.value)?.let { return it }
@@ -550,8 +557,10 @@ private fun UiDevice.advanceUntilVisible(
             continue
         }
 
-        if (!didAdvance) {
-            didAdvance = advance()
+        val now = System.currentTimeMillis()
+        if (now - lastAdvanceAt >= 750) {
+            advance()
+            lastAdvanceAt = now
         }
         waitForIdle()
         Thread.sleep(250)
@@ -614,7 +623,7 @@ private fun UiDevice.clickUntilVisible(
 
         val clickNode = tryScrollUntilSafelyClickable(clickSelector)
         if (clickNode?.isEnabled == true) {
-            clickCenter(clickNode)
+            clickNode.click()
         }
 
         Thread.sleep(500)
@@ -753,26 +762,23 @@ private fun UiDevice.clickCenterIfVisible(selector: DescribedSelector): Boolean
     return false
 }
 
-private fun UiDevice.waitUntilSendShowsNoFunds() {
-    val noFundsSelector = text("No funds available to send")
-    val initialScanIncompleteSelector = text("Initial Scan Incomplete")
-    val deadline = System.currentTimeMillis() + 90_000
+private fun UiDevice.waitUntilTextEquals(
+    selector: DescribedSelector,
+    expected: String,
+    timeoutMillis: Long = 5_000,
+) {
+    val deadline = System.currentTimeMillis() + timeoutMillis
 
     while (System.currentTimeMillis() < deadline) {
-        clickCenter(waitUntilVisible(text("Send"), timeoutMillis = 30_000))
-
-        val sendUnavailable = waitUntilAnyVisible(noFundsSelector, initialScanIncompleteSelector, timeoutMillis = 10_000)
-        if (sendUnavailable.description == noFundsSelector.description) {
+        val node = findObject(selector.value)
+        if (node?.text == expected) {
             return
         }
 
-        waitUntilVisible(text("Can't send until initial scan completes."))
-        clickCenter(waitUntilVisible(text("OK")))
-        waitForIdle()
-        Thread.sleep(2_000)
+        Thread.sleep(100)
     }
 
-    error("Timed out waiting for Send to report no funds after scan completion\n${dumpWindowHierarchy()}")
+    error("Timed out waiting for ${selector.description} to equal \"$expected\"\n${dumpWindowHierarchy()}")
 }
 
 private class DescribedSelector(

android/app/src/main/java/org/bitcoinppl/cove/AndroidManagerCache.kt

@@ -0,0 +1,194 @@
+package org.bitcoinppl.cove
+
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import org.bitcoinppl.cove.flows.SendFlow.SendFlowManager
+import org.bitcoinppl.cove.flows.SendFlow.SendFlowPresenter
+import org.bitcoinppl.cove_core.WalletMetadata
+import org.bitcoinppl.cove_core.types.WalletId
+
+@Stable
+@Suppress("InjectDispatcher", "TooGenericExceptionCaught", "TooManyFunctions")
+internal class AndroidManagerCache(
+    private val mainScope: CoroutineScope,
+) {
+    private val tag = "AppManager"
+
+    internal var walletManager: WalletManager? by mutableStateOf(null)
+        private set
+
+    internal var sendFlowManager: SendFlowManager? by mutableStateOf(null)
+        private set
+
+    internal var coinControlManager: CoinControlManager? by mutableStateOf(null)
+        private set
+
+    internal fun setWalletManager(manager: WalletManager) {
+        Log.d(tag, "setting wallet manager for wallet ${manager.id}")
+        walletManager = manager
+    }
+
+    internal fun cachedWalletManager(id: WalletId): WalletManager? =
+        walletManager?.takeIf { it.id == id }
+
+    internal fun walletMetadata(
+        id: WalletId,
+        wallets: List<WalletMetadata>,
+    ): WalletMetadata? {
+        cachedWalletManager(id)?.walletMetadata?.let { return it }
+        return wallets.firstOrNull { it.id == id }
+    }
+
+    internal fun getWalletManager(id: WalletId): WalletManager {
+        walletManager?.let {
+            if (it.id == id) {
+                Log.d(tag, "found and using wallet manager for $id")
+                return it
+            }
+
+            // selecting a different wallet is the boundary for ending in-flight scans
+            Log.d(tag, "closing old wallet manager for ${it.id}")
+            clearWalletManager()
+        }
+
+        Log.d(tag, "did not find wallet manager for $id, creating new: ${walletManager?.id}")
+
+        return try {
+            val manager = WalletManager(id = id)
+            walletManager = manager
+            manager
+        } catch (e: Exception) {
+            Log.e(tag, "Failed to create wallet manager", e)
+            throw e
+        }
+    }
+
+    internal fun getSendFlowManager(
+        wm: WalletManager,
+        presenter: SendFlowPresenter,
+    ): SendFlowManager {
+        sendFlowManager?.let {
+            if (it.id == wm.id) {
+                Log.d(tag, "found and using sendflow manager for ${wm.id}")
+                it.presenter = presenter
+                return it
+            }
+
+            // close old manager before replacing
+            Log.d(tag, "closing old sendflow manager for ${it.id}")
+            clearSendFlowManager()
+        }
+
+        Log.d(tag, "did not find SendFlowManager for ${wm.id}, creating new")
+        val manager = SendFlowManager(wm.newSendFlowManager(wm.balance), presenter)
+        sendFlowManager = manager
+        return manager
+    }
+
+    internal fun setCoinControlManager(manager: CoinControlManager) {
+        coinControlManager = manager
+    }
+
+    internal fun clearCoinControlManager(manager: CoinControlManager) {
+        if (coinControlManager === manager) {
+            coinControlManager = null
+        }
+    }
+
+    internal fun reconcileAfterLabelImport(walletId: WalletId) {
+        mainScope.launch {
+            val refreshed =
+                runCatchingCancellable(tag, "failed to reconcile after label import") {
+                    reconcileAfterLabelImportAndWait(walletId)
+                }.getOrDefault(false)
+            if (!refreshed) {
+                walletManager
+                    ?.takeIf { it.id == walletId }
+                    ?.notifyLabelRefreshFailed()
+            }
+        }
+    }
+
+    internal suspend fun reconcileAfterLabelImportAndWait(walletId: WalletId): Boolean {
+        val refreshed =
+            walletManager
+                ?.takeIf { it.id == walletId }
+                ?.reconcileAfterLabelImportAndWait()
+                ?: false
+
+        coinControlManager
+            ?.takeIf { it.id == walletId }
+            ?.reloadLabels()
+
+        sendFlowManager
+            ?.takeIf { it.id == walletId }
+            ?.reconcileAfterLabelImport()
+
+        return refreshed
+    }
+
+    internal fun clearWalletManager() {
+        clearWalletScopedChildManagers()
+
+        try {
+            walletManager?.close()
+        } catch (e: Exception) {
+            Log.w(tag, "Error closing WalletManager: ${e.message}")
+        }
+        walletManager = null
+    }
+
+    internal fun clearWalletManager(id: WalletId) {
+        if (walletManager?.id == id) {
+            clearWalletManager()
+        }
+
+        if (sendFlowManager?.id == id) {
+            clearSendFlowManager()
+        }
+    }
+
+    private fun clearWalletScopedChildManagers() {
+        clearSendFlowManager()
+        clearActiveCoinControlManager()
+    }
+
+    private fun clearSendFlowManager() {
+        try {
+            sendFlowManager?.close()
+        } catch (e: Exception) {
+            Log.w(tag, "Error closing SendFlowManager: ${e.message}")
+        }
+        sendFlowManager = null
+    }
+
+    private fun clearActiveCoinControlManager() {
+        try {
+            coinControlManager?.close()
+        } catch (e: Exception) {
+            Log.w(tag, "Error closing CoinControlManager: ${e.message}")
+        }
+        coinControlManager = null
+    }
+
+    internal fun clearInactiveSendFlowManager(router: RouterManager) {
+        val manager = sendFlowManager ?: return
+        if (routeStackContainsSendWallet(router.default, router.routes, manager.id)) return
+
+        clearSendFlowManager()
+    }
+
+    internal fun refreshFiatValuesForCachedWallet(scope: CoroutineScope) {
+        walletManager?.let { wm ->
+            scope.launch(Dispatchers.IO) {
+                wm.forceWalletScan()
+                wm.updateWalletBalance()
+            }
+        }
+    }
+}