First integration

• Android 5.0 (API Level 21) and up.
• AndroidX libraries compatibility.
• Java 8 compatibility.

1. Add the Mobile SDK for Android.

Drag and drop oppwa.mobile.aar & ipworks3ds_sdk.aar (use ipworks3ds_sdk_deploy.aar for production) to the "libs" folder of the module where you plan to integrate Mobile SDK. In the build.gradle file of this module add:

implementation fileTree(dir: "libs", include: ["*.aar"])




2. Add the required dependencies to your build.gradle:

implementation "androidx.appcompat:appcompat:x.x.x"
implementation "androidx.lifecycle:lifecycle-extensions:x.x.x"
implementation "androidx.browser:browser:x.x.x"
implementation "androidx.fragment:fragment:x.x.x"
implementation "com.google.android.material:material:x.x.x"
implementation "com.google.android.gms:play-services-base.x.x"


If you want to use prebuilt checkout also declare the CheckoutActivity:

<activity
    tools:replace="android:theme"
    android:name="com.oppwa.mobile.connect.checkout.dialog.CheckoutActivity"
    android:theme="@style/Theme.Checkout.Light"
    android:windowSoftInputMode="adjustPan"
    android:exported="false"
    android:launchMode="singleTop"/>

NOTE: Don't set screenOrientation attribute for the CheckoutActivity if your targetSdkVersion is 27 or higher.
NOTE: Make sure you set the tools:replace="android:theme" attribute for the CheckoutActivity. It belongs to the Android tools namespace, so you must first declare this namespace in the <manifest> element: xmlns:tools="http://schemas.android.com/tools". Also if you use your custom style it must extend the Theme.Checkout style.


3. In addition, declare the "INTERNET" permission before the application tag:

<uses-permission android:name="android.permission.INTERNET"/>

public String requestCheckoutId() {
    URL url;
    String urlString;
    HttpURLConnection connection = null;
    String checkoutId = null;

    urlString = YOUR_URL + "?amount=48.99&currency=EUR&paymentType=DB";

    try {
        url = new URL(urlString);
        connection = (HttpURLConnection) url.openConnection();
        
        JsonReader reader = new JsonReader(
                    new InputStreamReader(connection.getInputStream(), "UTF-8"));

        reader.beginObject();

        while (reader.hasNext()) {
            if (reader.nextName().equals("checkoutId")) {
                checkoutId = reader.nextString();

                break;
            }
        }

        reader.endObject();
        reader.close();
    } catch (Exception e) {
        /* error occurred */
    } finally {
        if (connection != null) {
            connection.disconnect();
        }
    }

    return checkoutId;
}

fun requestCheckoutId(): String? { 
    val url: URL 
    var connection: HttpURLConnection? = null 
    var checkoutId: String? = null 

    val urlString = YOUR_URL.toString() + "?amount=48.99&currency=EUR&paymentType=DB" 
      
    try { 
        url = URL(urlString) 
        connection = url.openConnection() as HttpURLConnection 

        val reader = JsonReader(InputStreamReader(connection.inputStream, "UTF-8"))
        reader.beginObject() 

        while (reader.hasNext()) { 
            if (reader.nextName() == "checkoutId") { 
                checkoutId = reader.nextString() 

                break 
            } 
        } 

        reader.endObject() 
        reader.close() 
    } catch (e: Exception) { 
        /* error occurred */ 
    } finally { 
        connection?.disconnect() 
    } 

    return checkoutId 
}

1. Configure the Checkout Settings

Define the settings for the checkout screen. Initialize CheckoutSettings with received checkout ID, it controls the information that is shown to the shopper.
For the first integration we recommend you to enable only synchronous payment methods, other payment brands need additional configuration.

Set<String> paymentBrands = new LinkedHashSet<String>();

paymentBrands.add("VISA");
paymentBrands.add("MASTER");
paymentBrands.add("DIRECTDEBIT_SEPA");

CheckoutSettings checkoutSettings = new CheckoutSettings(checkoutId, paymentBrands, Connect.ProviderMode.TEST);

// Set shopper result URL
checkoutSettings.setShopperResultUrl("companyname://result");

val paymentBrands = hashSetOf("VISA", "MASTER", "DIRECTDEBIT_SEPA") 
 
val checkoutSettings = CheckoutSettings(checkoutId, paymentBrands, Connect.ProviderMode.TEST) 
 
// Set shopper result URL 
checkoutSettings.shopperResultUrl = "companyname://result"

NOTE: To learn more about shopper result url refer to Asynchronous Payments guide.

2. Present the Checkout Page

Set up the Intent and start the checkout activity:

Intent intent = checkoutSettings.createCheckoutActivityIntent(this);

startActivityForResult(intent, CheckoutActivity.REQUEST_CODE_CHECKOUT);

val intent = checkoutSettings.createCheckoutActivityIntent(this) 
 
startActivityForResult(intent, CheckoutActivity.REQUEST_CODE_CHECKOUT)

Finally, override onActivityResult to get notified when the checkout process is done.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (resultCode) {
        case CheckoutActivity.RESULT_OK:
            /* transaction completed */
            Transaction transaction = data.getParcelableExtra(CheckoutActivity.CHECKOUT_RESULT_TRANSACTION);

            /* resource path if needed */
            String resourcePath = data.getStringExtra(CheckoutActivity.CHECKOUT_RESULT_RESOURCE_PATH);

            if (transaction.getTransactionType() == TransactionType.SYNC) {
                /* check the result of synchronous transaction */
            } else {
                /* wait for the asynchronous transaction callback in the onNewIntent() */
            }

            break;
        case CheckoutActivity.RESULT_CANCELED:
            /* shopper cancelled the checkout process */
            break;
        case CheckoutActivity.RESULT_ERROR:
            /* error occurred */
            PaymentError error = data.getParcelableExtra(CheckoutActivity.CHECKOUT_RESULT_ERROR);
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { 
    super.onActivityResult(requestCode, resultCode, data) 
 
    when (resultCode) { 
        CheckoutActivity.RESULT_OK -> { 
            /* transaction completed */ 
            val transaction: Transaction = data!!.getParcelableExtra(CheckoutActivity.CHECKOUT_RESULT_TRANSACTION)!! 
 
            /* resource path if needed */ 
            val resourcePath = data.getStringExtra(CheckoutActivity.CHECKOUT_RESULT_RESOURCE_PATH) 
            
            if (transaction.transactionType == TransactionType.SYNC) { 
                /* check the result of synchronous transaction */ 
            } else { 
                /* wait for the asynchronous transaction callback in the onNewIntent() */          
            }
        }

        CheckoutActivity.RESULT_CANCELED -> { 
            /* shopper cancelled the checkout process */ 
        } 

        CheckoutActivity.RESULT_ERROR -> { 
            /* error occurred */ 
            val error: PaymentError = data!!.getParcelableExtra(CheckoutActivity.CHECKOUT_RESULT_ERROR)!! 
        } 
    } 
}

public String requestPaymentStatus() {
    URL url;
    String urlString;
    HttpURLConnection connection = null;
    String paymentStatus = null;

    urlString = YOUR_URL + "/paymentStatus?resourcePath=" + URLEncoder.encode(RESOURCE_PATH, "UTF-8");

    try {
        url = new URL(urlString);
        connection = (HttpURLConnection) url.openConnection();

        JsonReader jsonReader = new JsonReader(
                    new InputStreamReader(connection.getInputStream(), "UTF-8"));

        jsonReader.beginObject();
            
        while (jsonReader.hasNext()) {
            if (jsonReader.nextName().equals("paymentResult")) {
                paymentStatus = jsonReader.nextString();

                break;
            }
        }
            
        jsonReader.endObject();
        jsonReader.close();
    } catch (Exception e) {
        /* error occurred */
    } finally {
        if (connection != null) {
            connection.disconnect();
        }
    }

    return paymentStatus;
}

fun requestPaymentStatus(): String? { 
    val url: URL 
    var connection: HttpURLConnection? = null 
    var paymentStatus: String? = null 

    val urlString = YOUR_URL.toString() + "/paymentStatus?resourcePath=" + URLEncoder.encode(RESOURCE_PATH, "UTF-8") 

    try { 
    url = URL(urlString) 
        connection = url.openConnection() as HttpURLConnection 

        val jsonReader = JsonReader(InputStreamReader(connection.inputStream, "UTF-8"))     
        jsonReader.beginObject() 

        while (jsonReader.hasNext()) { 
            if (jsonReader.nextName() == "paymentResult") { 
                paymentStatus = jsonReader.nextString() 

                break 
            } 
        } 

        jsonReader.endObject() 
        jsonReader.close() 
    } catch (e: Exception) { 
        /* error occurred */ 
    } finally { 
        connection?.disconnect() 
    } 

    return paymentStatus 
}

CheckoutSettings checkoutSettings = new CheckoutSettings(checkoutId, paymentBrands, Connect.ProviderMode.LIVE);

val checkoutSettings = CheckoutSettings(checkoutId, paymentBrand, Connect.ProviderMode.LIVE)