feat: prefer restored transport on hw reconnect

Author: ovitrif

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

@@ -32,6 +32,7 @@ import to.bitkit.ext.create
 import to.bitkit.ext.rawId
 import to.bitkit.models.HwWallet
 import to.bitkit.models.HwWalletReceivedTx
+import to.bitkit.models.TransportType
 import to.bitkit.models.toAccountType
 import to.bitkit.models.toAddressType
 import to.bitkit.models.toCoreNetwork
@@ -72,7 +73,7 @@ class HwWalletRepo @Inject constructor(
     val receivedTxs: SharedFlow<HwWalletReceivedTx> = _receivedTxs.asSharedFlow()
 
     /** Forwards UI-delivered transport events, e.g. the USB attach intent from the OS app picker. */
-    fun onTransportRestored() = trezorRepo.onTransportRestored()
+    fun onTransportRestored(transportType: TransportType) = trezorRepo.onTransportRestored(transportType)
 
     /** Pairing-code request raised by the device during connect; the UI shows the Pair Device sheet. */
     val needsPairingCode = trezorRepo.needsPairingCode

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

@@ -489,7 +489,10 @@ class TrezorRepo @Inject constructor(
 
     fun hasKnownDevices(): Boolean = _state.value.knownDevices.isNotEmpty()
 
-    suspend fun autoReconnect(walletIndex: Int = 0): Result<TrezorFeatures> = withContext(ioDispatcher) {
+    suspend fun autoReconnect(
+        walletIndex: Int = 0,
+        preferredTransport: TransportType? = null,
+    ): Result<TrezorFeatures> = withContext(ioDispatcher) {
         if (isConnectInProgress()) {
             // A live handshake looks like a stale session (transport connected,
             // features pending), so resetting here would drop the session the
@@ -523,7 +526,15 @@ class TrezorRepo @Inject constructor(
                 val idMatch = knownDevices.firstNotNullOfOrNull { known ->
                     scannedDevices.find { it.id == known.id }
                 }
-                val match = idMatch ?: usbDevice ?: throw AppError("No known device found nearby")
+                // Prefer the transport that just came back, so e.g. a USB replug does
+                // not reconnect over BLE when the same device is known on both.
+                val preferredMatch = preferredTransport?.let { preferred ->
+                    scannedDevices.find {
+                        it.id in knownIds && it.transportType.toTransportType() == preferred
+                    }
+                }
+                val match = preferredMatch ?: idMatch ?: usbDevice
+                    ?: throw AppError("No known device found nearby")
                 connect(match.id).getOrThrow()
             }
         }.onSuccess {
@@ -679,7 +690,7 @@ class TrezorRepo @Inject constructor(
      */
     private fun observeTransportRestored() {
         trezorTransport.transportRestored.onEach {
-            launchTransportReconnect()
+            launchTransportReconnect(it)
         }.launchIn(scope)
     }
 
@@ -688,32 +699,32 @@ class TrezorRepo @Inject constructor(
      * e.g. the USB attach intent the OS app picker routes to the activity (attach is
      * not broadcast to receivers, unlike detach).
      */
-    fun onTransportRestored() = launchTransportReconnect()
+    fun onTransportRestored(transportType: TransportType) = launchTransportReconnect(transportType)
 
     /**
      * Serializes reconnect triggers into one in-flight retry loop. A Trezor
      * re-enumerates USB during its unlock flow, so a single replug delivers several
      * attach intents; letting each spawn its own loop staggers connect attempts for
      * many seconds, and every attempt restarts the device's PIN entry.
      */
-    private fun launchTransportReconnect() {
+    private fun launchTransportReconnect(transportType: TransportType) {
         if (transportReconnectJob?.isActive == true) return
-        transportReconnectJob = scope.launch { retryAutoReconnect() }
+        transportReconnectJob = scope.launch { retryAutoReconnect(transportType) }
     }
 
     /**
      * A device is often not discoverable right after its transport returns (a BLE
      * Trezor takes a few seconds to advertise again), so retry the silent reconnect
      * with growing delays instead of giving up on the first empty scan.
      */
-    private suspend fun retryAutoReconnect() {
+    private suspend fun retryAutoReconnect(transportType: TransportType) {
         repeat(TRANSPORT_RESTORED_MAX_ATTEMPTS) { attempt ->
             if (_state.value.connected != null || isConnectInProgress()) return
             delay(TRANSPORT_RESTORED_RECONNECT_DELAY * (attempt + 1))
             // A connect may have started while this attempt was waiting.
             if (_state.value.connected != null || isConnectInProgress()) return
             Logger.info("Attempting auto-reconnect after transport restored, attempt '${attempt + 1}'", context = TAG)
-            if (autoReconnect().isSuccess) return
+            if (autoReconnect(preferredTransport = transportType).isSuccess) return
         }
     }
 

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

@@ -42,6 +42,7 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import to.bitkit.ext.bluetoothManager
 import to.bitkit.ext.usbManager
+import to.bitkit.models.TransportType
 import to.bitkit.utils.Logger
 import java.io.File
 import java.util.UUID
@@ -119,10 +120,10 @@ class TrezorTransport @Inject constructor(
     private val _externalDisconnect = MutableSharedFlow<String>(extraBufferCapacity = 1)
     val externalDisconnect: SharedFlow<String> = _externalDisconnect
 
-    private val _transportRestored = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
+    private val _transportRestored = MutableSharedFlow<TransportType>(extraBufferCapacity = 1)
 
-    /** Emits when a transport becomes available again: Bluetooth back on or a Trezor plugged in. */
-    val transportRestored: SharedFlow<Unit> = _transportRestored
+    /** Emits the transport that became available again: Bluetooth back on or a Trezor plugged in. */
+    val transportRestored: SharedFlow<TransportType> = _transportRestored
 
     @Volatile
     private var espMigrated = false
@@ -175,12 +176,12 @@ class TrezorTransport @Inject constructor(
                 emitExternalDisconnect(path)
             }
         },
-        onBluetoothOn = { _transportRestored.tryEmit(Unit) },
+        onBluetoothOn = { _transportRestored.tryEmit(TransportType.BLUETOOTH) },
         onUsbDetached = { path ->
             if (path in usbConnections.keys) emitExternalDisconnect(path)
         },
         onUsbAttached = { device ->
-            if (isTrezorDevice(device)) _transportRestored.tryEmit(Unit)
+            if (isTrezorDevice(device)) _transportRestored.tryEmit(TransportType.USB)
         },
     )
 

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

@@ -110,6 +110,7 @@ import to.bitkit.models.Suggestion
 import to.bitkit.models.Toast
 import to.bitkit.models.TransactionSpeed
 import to.bitkit.models.TransferType
+import to.bitkit.models.TransportType
 import to.bitkit.models.msatFloorOf
 import to.bitkit.models.safe
 import to.bitkit.models.sanitizedDeeplinkLogValue
@@ -3058,7 +3059,7 @@ class AppViewModel @Inject constructor(
         }
     }
 
-    fun onUsbDeviceAttached() = hwWalletRepo.onTransportRestored()
+    fun onUsbDeviceAttached() = hwWalletRepo.onTransportRestored(TransportType.USB)
 
     fun submitPairingCode(code: String) = hwWalletRepo.submitPairingCode(code)
 

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

@@ -332,9 +332,9 @@ class HwWalletRepoTest : BaseUnitTest() {
     fun `forwards transport restored to the trezor repo`() = test {
         val sut = createRepo()
 
-        sut.onTransportRestored()
+        sut.onTransportRestored(TransportType.USB)
 
-        verify(trezorRepo).onTransportRestored()
+        verify(trezorRepo).onTransportRestored(TransportType.USB)
     }
 
     @Test

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

@@ -41,6 +41,7 @@ import kotlin.time.Clock
 import kotlin.time.ExperimentalTime
 
 @OptIn(ExperimentalTime::class)
+@Suppress("LargeClass")
 class TrezorRepoTest : BaseUnitTest() {
 
     companion object Fixtures {
@@ -120,17 +121,19 @@ class TrezorRepoTest : BaseUnitTest() {
         on { this.model }.thenReturn(model)
     }
 
+    @Suppress("LongParameterList")
     private fun mockKnownDevice(
         id: String = DEVICE_ID,
         name: String? = DEVICE_NAME,
         path: String = DEVICE_PATH,
         label: String? = DEVICE_LABEL,
         model: String? = DEVICE_MODEL,
+        transportType: TransportType = TransportType.USB,
     ) = KnownDevice(
         id = id,
         name = name,
         path = path,
-        transportType = TransportType.USB,
+        transportType = transportType,
         label = label,
         model = model,
         lastConnectedAt = 123L,
@@ -214,7 +217,7 @@ class TrezorRepoTest : BaseUnitTest() {
 
     @Test
     fun `transport restored auto-reconnects to a known device`() = test {
-        val transportRestored = MutableSharedFlow<Unit>()
+        val transportRestored = MutableSharedFlow<TransportType>()
         val features = mockFeatures()
         val device = mockDeviceInfo()
         whenever(trezorTransport.transportRestored).thenReturn(transportRestored)
@@ -224,15 +227,15 @@ class TrezorRepoTest : BaseUnitTest() {
         whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features)
         sut = createSut()
 
-        transportRestored.emit(Unit)
+        transportRestored.emit(TransportType.USB)
         advanceUntilIdle()
 
         assertNotNull(sut.state.value.connected)
     }
 
     @Test
     fun `transport restored retries reconnect until the device is discoverable`() = test {
-        val transportRestored = MutableSharedFlow<Unit>()
+        val transportRestored = MutableSharedFlow<TransportType>()
         val features = mockFeatures()
         val device = mockDeviceInfo()
         whenever(trezorTransport.transportRestored).thenReturn(transportRestored)
@@ -243,13 +246,36 @@ class TrezorRepoTest : BaseUnitTest() {
         whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features)
         sut = createSut()
 
-        transportRestored.emit(Unit)
+        transportRestored.emit(TransportType.USB)
         advanceUntilIdle()
 
         assertNotNull(sut.state.value.connected)
         verify(trezorService, times(2)).scan()
     }
 
+    @Test
+    fun `reconnect prefers the transport that came back`() = test {
+        val features = mockFeatures()
+        val bleDevice = mockDeviceInfo(id = "ble-1", transportType = TrezorTransportType.BLUETOOTH, path = "ble-path")
+        val usbDevice = mockDeviceInfo(id = "usb-1", transportType = TrezorTransportType.USB, path = "usb-path")
+        whenever(hwWalletStore.loadKnownDevices()).thenReturn(
+            listOf(
+                mockKnownDevice(id = "ble-1", transportType = TransportType.BLUETOOTH),
+                mockKnownDevice(id = "usb-1"),
+            ),
+        )
+        whenever(trezorService.isConnected()).thenReturn(false)
+        whenever(trezorService.scan()).thenReturn(listOf(bleDevice, usbDevice))
+        whenever(trezorService.connect(eq("usb-1"), any())).thenReturn(features)
+        sut = createSut()
+
+        sut.onTransportRestored(TransportType.USB)
+        advanceUntilIdle()
+
+        verify(trezorService).connect(eq("usb-1"), any())
+        verify(trezorService, never()).connect(eq("ble-1"), any())
+    }
+
     @Test
     fun `repeated transport restored triggers run a single reconnect`() = test {
         val features = mockFeatures()
@@ -260,7 +286,7 @@ class TrezorRepoTest : BaseUnitTest() {
         whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features)
         sut = createSut()
 
-        repeat(3) { sut.onTransportRestored() }
+        repeat(3) { sut.onTransportRestored(TransportType.USB) }
         advanceUntilIdle()
 
         assertNotNull(sut.state.value.connected)
@@ -283,13 +309,13 @@ class TrezorRepoTest : BaseUnitTest() {
 
     @Test
     fun `transport restored skips reconnect while device awaits pairing code`() = test {
-        val transportRestored = MutableSharedFlow<Unit>()
+        val transportRestored = MutableSharedFlow<TransportType>()
         whenever(trezorTransport.transportRestored).thenReturn(transportRestored)
         whenever(trezorTransport.needsPairingCode).thenReturn(MutableStateFlow(true))
         whenever(hwWalletStore.loadKnownDevices()).thenReturn(listOf(mockKnownDevice()))
         sut = createSut()
 
-        transportRestored.emit(Unit)
+        transportRestored.emit(TransportType.USB)
         advanceUntilIdle()
 
         verify(trezorService, never()).disconnect()
@@ -306,7 +332,7 @@ class TrezorRepoTest : BaseUnitTest() {
         whenever(trezorService.connect(eq(DEVICE_ID), any())).thenReturn(features)
         sut = createSut()
 
-        sut.onTransportRestored()
+        sut.onTransportRestored(TransportType.USB)
         advanceUntilIdle()
 
         assertNotNull(sut.state.value.connected)
@@ -333,7 +359,7 @@ class TrezorRepoTest : BaseUnitTest() {
 
     @Test
     fun `transport restored does not reconnect when a device is already connected`() = test {
-        val transportRestored = MutableSharedFlow<Unit>()
+        val transportRestored = MutableSharedFlow<TransportType>()
         val features = mockFeatures()
         val device = mockDeviceInfo()
         whenever(trezorTransport.transportRestored).thenReturn(transportRestored)
@@ -343,7 +369,7 @@ class TrezorRepoTest : BaseUnitTest() {
         sut.scan()
         sut.connect(DEVICE_ID)
 
-        transportRestored.emit(Unit)
+        transportRestored.emit(TransportType.USB)
         advanceUntilIdle()
 
         verify(trezorService, times(1)).scan()

app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt

@@ -42,6 +42,7 @@ import to.bitkit.models.PubkyProfile
 import to.bitkit.models.SamRockPaymentMethod
 import to.bitkit.models.SamRockSetupRequest
 import to.bitkit.models.TransactionSpeed
+import to.bitkit.models.TransportType
 import to.bitkit.repositories.ActivityRepo
 import to.bitkit.repositories.BackupRepo
 import to.bitkit.repositories.BlocktankRepo
@@ -255,7 +256,7 @@ class AppViewModelSendFlowTest : BaseUnitTest() {
     fun `onUsbDeviceAttached forwards to the hardware wallet repo`() = test {
         sut.onUsbDeviceAttached()
 
-        verify(hwWalletRepo).onTransportRestored()
+        verify(hwWalletRepo).onTransportRestored(TransportType.USB)
     }
 
     @Test