Asynchronous Payments

Android

Secure browsing

Issuer page will be opened in a secure web view using Chrome Custom Tabs.

Register a custom URL scheme

Define the name of your custom scheme (for example companyname) and add intent filter to your target activity in the AndroidManifest.xml

<activity
    android:name="YOUR_ACTIVITY"
    android:launchMode="singleTask">

    <intent-filter>
        <data android:scheme="companyname"/>

        <action android:name="android.intent.action.VIEW"/>

        <category android:name="android.intent.category.DEFAULT"/>
        <category android:name="android.intent.category.BROWSABLE"/>
    </intent-filter>
</activity>

Shopper result URL

As soon as asynchronous payment is processed, shopper result URL is opened. You should set it in CheckoutSettings class to handle payment result.

Sample URL: companyname://result.
The scheme should be the same that you've registered in the previous step. The rest part of URL can be any valid string (but not empty).

CheckoutSettings checkoutSettings = new CheckoutSettings(checkoutId, paymentBrands, providerMode)
    .setShopperResultUrl("companyname://result");

val checkoutSettings = CheckoutSettings(checkoutId, paymentBrands, providerMode) 
        .setShopperResultUrl("companyname://result")

Do not set shopperResultUrl if it's already sent in the first step (prepare checkout request). It will cause an override error.

Handle the redirect intent in target activity

Override onNewIntent method of your target activity to handle redirect intent and make payment status request.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);

    if (intent.getScheme().equals("companyname")) {
        //  request payment status if ActivityResultCallback is received
    }
}

override fun onNewIntent(intent: Intent) { 
    super.onNewIntent(intent) 

 
    if (intent.scheme == "companyname") { 
        // request payment status if ActivityResultCallback is received
    } 
}

Handle the aborted transactions

mSDK doesn't provide a built-in option to handle an aborted Asynchronus Payment. However there is a way to implement it inside your application.

In order to do that, your application would require to know the transaction's state. Let's create TransactionState enumeration for example.

enum TransactionState {
    NEW,
    PENDING,
    COMPLETED
}

enum class TransactionState {
    NEW,
    PENDING,
    COMPLETED
}

Mark a new transaction as NEW and save the value till the end of checkout process.

Handle CheckoutActivityResult, if the payment was Asynchronus change the transaction state to PENDING

private void handleCheckoutResult(@NonNull CheckoutActivityResult result) {
    if (result.isCanceled()) {
        // shopper cancelled the checkout process
        return;
    }

    if (result.isErrored()) {
        // error occurred during the checkout process
        return;
    }

    Transaction transaction = result.getTransaction();

    if (transaction != null) {
        if (transaction.getTransactionType() == TransactionType.SYNC) {
            transactionState = TransactionState.COMPLETED;
        } else {
            // onNewIntent() might be already invoked if activity was destroyed in background,
            // make sure you don't overwrite COMPLETED state
            if (!transactionState.equals(TransactionState.COMPLETED)) {
                transactionState = TransactionState.PENDING;
            }
        }
    }
}

private fun handleCheckoutResult(result: CheckoutActivityResult) {
    if (result.isCanceled) {
        // shopper cancelled the checkout process
         return
    }

    if (result.isErrored) {
        // error occurred during the checkout process
        return
    }

    val transaction: Transaction? = result.transaction

    if (transaction != null) {
        if (transaction.transactionType === TransactionType.SYNC) {
            transactionState = TransactionState.COMPLETED;
        } else {
            // onNewIntent() might be already invoked if activity was destroyed in background,
            // make sure you don't overwrite COMPLETED state
            if (!transactionState.equals(TransactionState.COMPLETED)) {
                transactionState = TransactionState.PENDING;
            }
        }
    }
}

Override onNewIntent() method of your target activity to handle redirect intent and change the transaction's state to COMPLETED.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);

    if (intent.getScheme().equals("companyname")) {
        transactionState = TransactionState.COMPLETED;
    }
}

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)

    if (intent.scheme == "companyname") {
        transactionState = TransactionState.COMPLETED;
    }
}

Override onResume() method of your target activity. If the transaction's state isn't COMPLETED at this point then it was aborted.

@Override
protected void onResume() {
    super.onResume();

    if (transactionState.equals(TransactionState.PENDING)) {
        // handle aborted transaction
    } else if (transactionState.equals(TransactionState.COMPLETED)) {
        requestPaymentStatus(resourcePath);
    }
}

override fun onResume(intent: Intent) {
    super.onNewIntent(intent)

    if (transactionState.equals(TransactionState.PENDING)) {
        // handle aborted transaction
    } else if (transactionState.equals(TransactionState.COMPLETED)) {
        requestPaymentStatus(resourcePath);
    }
}