conversion start (#1543)

Author: noguier

Card/src/main/java/com/braintreepayments/api/card/CardClient.kt

@@ -14,6 +14,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.json.JSONException
 import org.json.JSONObject
+import kotlin.coroutines.cancellation.CancellationException
 
 /**
  * Used to tokenize credit or debit cards using a [Card]. For more information see the
@@ -43,21 +44,13 @@ class CardClient internal constructor(
     /**
      * Create a [CardNonce].
      *
-     *
      * The tokenization result is returned via a [CardTokenizeCallback] callback.
      *
-     *
-     *
      * On success, the [CardTokenizeCallback.onCardResult] method will be
      * invoked with a [CardResult.Success] including a nonce.
      *
-     *
-     *
      * If creation fails validation, the [CardTokenizeCallback.onCardResult]
-     * method will be invoked with a [CardResult.Failure] including an
-     * [ErrorWithResponse] exception.
-     *
-     *
+     * method will be invoked with a [CardResult.Failure] including an exception.
      *
      * If an error not due to validation (server error, network issue, etc.) occurs, the
      * [CardTokenizeCallback.onCardResult] method will be invoked with a
@@ -67,79 +60,58 @@ class CardClient internal constructor(
      * @param callback [CardTokenizeCallback]
      */
     fun tokenize(card: Card, callback: CardTokenizeCallback) {
+        coroutineScope.launch {
+            val result = tokenize(card)
+            callback.onCardResult(result)
+        }
+    }
+
+    private suspend fun tokenize(card: Card): CardResult {
         analyticsParamRepository.reset()
         braintreeClient.sendAnalyticsEvent(CardAnalytics.CARD_TOKENIZE_STARTED)
-        coroutineScope.launch {
-            try {
-                val configuration = braintreeClient.getConfiguration()
-                val shouldTokenizeViaGraphQL =
-                    configuration.isGraphQLFeatureEnabled(
-                        GraphQLConstants.Features.TOKENIZE_CREDIT_CARDS
-                    )
-                if (shouldTokenizeViaGraphQL) {
-                    card.sessionId = analyticsParamRepository.sessionId
-                    try {
-                        val tokenizePayload = card.buildJSONForGraphQL()
-                        coroutineScope.launch {
-                            try {
-                                val tokenizationResponse =
-                                    apiClient.tokenizeGraphQL(tokenizePayload)
-                                handleTokenizeResponse(tokenizationResponse, null, callback)
-                            } catch (e: Exception) {
-                                handleTokenizeResponse(null, e, callback)
-                            }
-                        }
-                    } catch (e: JSONException) {
-                        callbackFailure(callback, CardResult.Failure(e))
-                    }
-                } else {
-                    coroutineScope.launch {
-                        try {
-                            val tokenizationResponse = apiClient.tokenizeREST(card)
-                            handleTokenizeResponse(tokenizationResponse, null, callback)
-                        } catch (e: Exception) {
-                            handleTokenizeResponse(null, e, callback)
-                        }
-                    }
-                }
-            } catch (e: Exception) {
-                callbackFailure(callback, CardResult.Failure(e))
+        return try {
+            val configuration = braintreeClient.getConfiguration()
+            val shouldTokenizeViaGraphQL =
+                configuration.isGraphQLFeatureEnabled(
+                    GraphQLConstants.Features.TOKENIZE_CREDIT_CARDS
+                )
+
+            val tokenizationResponse = if (shouldTokenizeViaGraphQL) {
+                card.sessionId = analyticsParamRepository.sessionId
+                val tokenizePayload = card.buildJSONForGraphQL()
+                apiClient.tokenizeGraphQL(tokenizePayload)
+            } else {
+                apiClient.tokenizeREST(card)
             }
+
+            handleTokenizeResponse(tokenizationResponse)
+        } catch (e: Exception) {
+            if (e is CancellationException) throw e
+            tokenizeFailure(e)
         }
     }
 
-    private fun handleTokenizeResponse(
-        tokenizationResponse: JSONObject?, exception: Exception?,
-        callback: CardTokenizeCallback
-    ) {
-        if (tokenizationResponse != null) {
-            if (tokenizationResponse.has("errors") &&
-                tokenizationResponse.getJSONArray(GraphQLConstants.Keys.ERRORS).length() > 0
-            ) {
-                callbackFailure(callback, CardResult.Failure(BraintreeException(tokenizationResponse.toString())))
-                return
-            }
+    private fun handleTokenizeResponse(tokenizationResponse: JSONObject): CardResult {
+        return if (tokenizationResponse.has("errors") &&
+            tokenizationResponse.getJSONArray(GraphQLConstants.Keys.ERRORS).length() > 0
+        ) {
+            tokenizeFailure(BraintreeException(tokenizationResponse.toString()))
+        } else {
             try {
                 val cardNonce = fromJSON(tokenizationResponse)
-                callbackSuccess(callback, CardResult.Success(cardNonce))
+                braintreeClient.sendAnalyticsEvent(CardAnalytics.CARD_TOKENIZE_SUCCEEDED)
+                CardResult.Success(cardNonce)
             } catch (e: JSONException) {
-                callbackFailure(callback, CardResult.Failure(e))
+                tokenizeFailure(e)
             }
-        } else if (exception != null) {
-            callbackFailure(callback, CardResult.Failure(exception))
         }
     }
 
-    private fun callbackFailure(callback: CardTokenizeCallback, cardResult: CardResult.Failure) {
+    private fun tokenizeFailure(error: Exception): CardResult.Failure {
         braintreeClient.sendAnalyticsEvent(
             CardAnalytics.CARD_TOKENIZE_FAILED,
-            AnalyticsEventParams(errorDescription = cardResult.error.message)
+            AnalyticsEventParams(errorDescription = error.message)
         )
-        callback.onCardResult(cardResult)
-    }
-
-    private fun callbackSuccess(callback: CardTokenizeCallback, cardResult: CardResult.Success) {
-        braintreeClient.sendAnalyticsEvent(CardAnalytics.CARD_TOKENIZE_SUCCEEDED)
-        callback.onCardResult(cardResult)
+        return CardResult.Failure(error)
     }
 }