Convert DiscoverReadersAction and ConnectionManager to use suspend/Flow

kidinov · kidinov · commit 4f70a4ee9f56 · 2025-12-03T15:28:25.000+08:00
diff --git a/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/CardReaderManager.kt b/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/CardReaderManager.kt
@@ -45,7 +45,7 @@ interface CardReaderManager {
 
     fun setupTapToPayUx(config: TapToPayUxConfig)
 
-    fun startConnectionToReader(cardReader: CardReader, locationId: String)
+    suspend fun startConnectionToReader(cardReader: CardReader, locationId: String)
     suspend fun disconnectReader(): Boolean
     fun cancelReconnection()
 
diff --git a/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/CardReaderManagerImpl.kt b/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/CardReaderManagerImpl.kt
@@ -92,7 +92,7 @@ internal class CardReaderManagerImpl(
         connectionManager.setupTapToPayUx(config)
     }
 
-    override fun startConnectionToReader(cardReader: CardReader, locationId: String) {
+    override suspend fun startConnectionToReader(cardReader: CardReader, locationId: String) {
         if (!terminal.isInitialized()) error("Terminal not initialized")
         connectionManager.startConnectionToReader(cardReader, locationId)
     }
diff --git a/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/connection/ConnectionManager.kt b/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/connection/ConnectionManager.kt
@@ -5,7 +5,6 @@ import android.app.Application
 import android.content.pm.PackageManager
 import android.os.Build
 import com.stripe.stripeterminal.external.callable.Callback
-import com.stripe.stripeterminal.external.callable.ReaderCallback
 import com.stripe.stripeterminal.external.models.ConnectionConfiguration.BluetoothConnectionConfiguration
 import com.stripe.stripeterminal.external.models.ConnectionConfiguration.TapToPayConnectionConfiguration
 import com.stripe.stripeterminal.external.models.DeviceType
@@ -32,8 +31,6 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.launch
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 private const val ARTIFICIAL_STATUS_UPDATE_DELAY_IN_MILLIS = 500L
 
@@ -124,43 +121,35 @@ internal class ConnectionManager(
         }
     }
 
-    fun startConnectionToReader(cardReader: CardReader, locationId: String) {
+    suspend fun startConnectionToReader(cardReader: CardReader, locationId: String) {
         (cardReader as CardReaderImpl).let {
             updateReaderStatus(CardReaderStatus.Connecting)
-            val readerCallback = object : ReaderCallback {
-                override fun onSuccess(reader: Reader) {
-                    updateReaderStatus(CardReaderStatus.Connected(CardReaderImpl(reader)))
+            try {
+                val reader = when (it.cardReader.deviceType) {
+                    DeviceType.TAP_TO_PAY_DEVICE -> connectToBuiltInReader(cardReader, locationId)
+                    else -> connectToExternalReader(cardReader, locationId)
                 }
-
-                override fun onFailure(e: TerminalException) {
-                    updateReaderStatus(
-                        CardReaderStatus.NotConnected(
-                            errorCode = e.errorCode.toErrorCode(),
-                            errorMessage = e.errorMessage,
-                        )
+                updateReaderStatus(CardReaderStatus.Connected(CardReaderImpl(reader)))
+            } catch (e: TerminalException) {
+                updateReaderStatus(
+                    CardReaderStatus.NotConnected(
+                        errorCode = e.errorCode.toErrorCode(),
+                        errorMessage = e.errorMessage,
                     )
-                }
-            }
-
-            when (it.cardReader.deviceType) {
-                DeviceType.TAP_TO_PAY_DEVICE -> connectToBuiltInReader(cardReader, locationId, readerCallback)
-                else -> connectToExternalReader(cardReader, locationId, readerCallback)
+                )
             }
         }
     }
 
-    suspend fun disconnectReader() = suspendCoroutine { continuation ->
-        terminal.disconnectReader(object : Callback {
-            override fun onFailure(e: TerminalException) {
-                updateReaderStatus(CardReaderStatus.NotConnected())
-                continuation.resume(false)
-            }
-
-            override fun onSuccess() {
-                updateReaderStatus(CardReaderStatus.NotConnected())
-                continuation.resume(true)
-            }
-        })
+    suspend fun disconnectReader(): Boolean {
+        return try {
+            terminal.disconnectReader()
+            updateReaderStatus(CardReaderStatus.NotConnected())
+            true
+        } catch (e: TerminalException) {
+            updateReaderStatus(CardReaderStatus.NotConnected())
+            false
+        }
     }
 
     fun cancelReconnection() {
@@ -213,31 +202,27 @@ internal class ConnectionManager(
         terminal.setupTapToPayUx(config)
     }
 
-    private fun connectToExternalReader(
+    private suspend fun connectToExternalReader(
         cardReader: CardReaderImpl,
-        locationId: String,
-        readerCallback: ReaderCallback
-    ) {
-        terminal.connectToReader(
+        locationId: String
+    ): Reader {
+        return terminal.connectToReader(
             cardReader.cardReader,
-            BluetoothConnectionConfiguration(locationId, true, bluetoothReaderListener),
-            readerCallback
+            BluetoothConnectionConfiguration(locationId, true, bluetoothReaderListener)
         )
     }
 
-    private fun connectToBuiltInReader(
+    private suspend fun connectToBuiltInReader(
         cardReader: CardReaderImpl,
-        locationId: String,
-        readerCallback: ReaderCallback
-    ) {
-        terminal.connectToMobile(
+        locationId: String
+    ): Reader {
+        return terminal.connectToMobile(
             cardReader.cardReader,
             TapToPayConnectionConfiguration(
                 locationId,
                 autoReconnectOnUnexpectedDisconnect = true,
                 tapToPayReaderListener
-            ),
-            readerCallback
+            )
         )
     }
 
diff --git a/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/connection/actions/DiscoverReadersAction.kt b/libs/cardreader/src/main/java/com/woocommerce/android/cardreader/internal/connection/actions/DiscoverReadersAction.kt
@@ -1,21 +1,24 @@
 package com.woocommerce.android.cardreader.internal.connection.actions
 
 import androidx.annotation.RequiresPermission
-import com.stripe.stripeterminal.external.callable.Callback
-import com.stripe.stripeterminal.external.callable.DiscoveryListener
 import com.stripe.stripeterminal.external.models.DiscoveryConfiguration
 import com.stripe.stripeterminal.external.models.Reader
 import com.stripe.stripeterminal.external.models.TerminalException
 import com.woocommerce.android.cardreader.LogWrapper
+import com.woocommerce.android.cardreader.internal.LOG_TAG
 import com.woocommerce.android.cardreader.internal.connection.actions.DiscoverReadersAction.DiscoverReadersStatus.Failure
 import com.woocommerce.android.cardreader.internal.connection.actions.DiscoverReadersAction.DiscoverReadersStatus.FoundReaders
 import com.woocommerce.android.cardreader.internal.connection.actions.DiscoverReadersAction.DiscoverReadersStatus.Started
 import com.woocommerce.android.cardreader.internal.connection.actions.DiscoverReadersAction.DiscoverReadersStatus.Success
-import com.woocommerce.android.cardreader.internal.sendAndLog
 import com.woocommerce.android.cardreader.internal.wrappers.TerminalWrapper
-import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
 
 private const val DISCOVERY_TIMEOUT_IN_SECONDS = 60
 
@@ -55,40 +58,22 @@ internal class DiscoverReadersAction(
         ],
     )
     private fun discoverReaders(config: DiscoveryConfiguration): Flow<DiscoverReadersStatus> {
-        return callbackFlow {
-            sendAndLog(Started, logWrapper)
-            var foundReaders: List<Reader>? = null
-            val cancelable = terminal.discoverReaders(
-                config,
-                object : DiscoveryListener {
-                    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
-                        if (readers != foundReaders) {
-                            foundReaders = readers
-                            this@callbackFlow.sendAndLog(FoundReaders(readers), logWrapper)
-                        }
-                    }
-                },
-                object : Callback {
-                    override fun onFailure(e: TerminalException) {
-                        this@callbackFlow.sendAndLog(Failure(e), logWrapper)
-                        this@callbackFlow.close()
-                    }
-
-                    override fun onSuccess() {
-                        this@callbackFlow.sendAndLog(Success, logWrapper)
-                        this@callbackFlow.close()
-                    }
+        return terminal.discoverReaders(config)
+            .distinctUntilChanged()
+            .map<List<Reader>, DiscoverReadersStatus> { readers -> FoundReaders(readers) }
+            .onStart { emit(Started) }
+            .onCompletion { cause ->
+                if (cause == null || cause is CancellationException) {
+                    emit(Success)
+                }
+            }
+            .catch { e ->
+                if (e is TerminalException) {
+                    emit(Failure(e))
+                } else {
+                    throw e
                 }
-            )
-            awaitClose {
-                cancelable.takeIf { !it.isCompleted }?.cancel(noopCallback)
             }
-        }
+            .onEach { logWrapper.d(LOG_TAG, it.toString()) }
     }
 }
-
-private val noopCallback = object : Callback {
-    override fun onFailure(e: TerminalException) {}
-
-    override fun onSuccess() {}
-}

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ internal class CardReaderManagerImpl(`
`92`	`92`	`connectionManager.setupTapToPayUx(config)`
`93`	`93`	`}`
`94`	`94`
`95`		`- override fun startConnectionToReader(cardReader: CardReader, locationId: String) {`
	`95`	`+ override suspend fun startConnectionToReader(cardReader: CardReader, locationId: String) {`
`96`	`96`	`if (!terminal.isInitialized()) error("Terminal not initialized")`
`97`	`97`	`connectionManager.startConnectionToReader(cardReader, locationId)`
`98`	`98`	`}`