First integration

• Android 4.4 (API Level 19) and up.
• AndroidX libraries compatibility.
• Java 8 compatibility.

1. Import the Mobile SDK for Android.

Download oppwa.mobile.aar and import it as the module into your project:
File > New > New Module > Import .JAR/.AAR Package

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

// this name must match the library name defined with an include: in your settings.gradle file
implementation project(":oppwa.mobile")

implementation "androidx.appcompat:appcompat:x.x.x"
implementation "androidx.browser:browser:x.x.x"
implementation "com.google.android.material:material:x.x.x"
implementation "com.google.android.gms:play-services-wallet:x.x.x"



3. Open your AndroidManifest.xml and declare the connect service within the application tag:

<service
    android:name="com.oppwa.mobile.connect.service.ConnectService"
    android:exported="false"/>


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.


4. 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)