SDK Integration

Android

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 "com.google.android.material:material:x.x.x"
implementation "com.google.android.gms:play-services-base:x.x.x"



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 
}

First you need to create an PaymentParams object and initialize it with collected shopper payment details, it's required for processing a transaction.

Use fabric initializers to create an appropriate subclass of PaymentParams. See code sample for credit card payment params:

PaymentParams paymentParams = new CardPaymentParams(
        checkoutId,
        brand,
        number,
        holder,
        expiryMonth,
        expiryYear,
        cvv
);

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

val paymentParams: PaymentParams = CardPaymentParams( 
         checkoutId, 
         brand, 
         number, 
         holder, 
         expiryMonth, 
         expiryYear, 
         cvv 
) 
 
// Set shopper result URL 
paymentParams.shopperResultUrl = "companyname://result"

NOTE: To learn more about shopper result URL refer to Asynchronous payments guide.

You can also validate each parameter separately before creating an PaymentParams object. Android mSDK provides convenience validation methods for each payment parameter. See code sample for card number validation:

if (!CardPaymentParams.isNumberValid("4200 0000 0000 0000")) {
    /* display error that card number is invalid */
}

if (!CardPaymentParams.isNumberValid("4200 0000 0000 0000")) { 
     /* display error that card number is invalid */ 
}

new CardPaymentParams(checkoutId, number, holder, expiryMonth, expiryYear, cvv);

CardPaymentParams(checkoutId, number, holder, expiryMonth, expiryYear, cvv)

Create a transaction with the collected valid payment parameters. Then submit it using PaymentProvider method and implement the callback.

Check type of the transaction returned in the callback:

• if it's synchronous payment, you can immediately request payment result from your server,
• otherwise transaction will contain redirect url, shopper should be redirected to this URL to pass additional checks on payment provider side (e.g. pass 3D Secure check).

Transaction transaction = null;

try {
   OppPaymentProvider paymentProvider = new OppPaymentProvider(context, Connnect.ProviderMode.TEST);
    transaction = new Transaction(paymentParams);
    paymentProvider.submitTransaction(transaction, transactionListener);
} catch (PaymentException ee) {
    /* error occurred */
}

try { 
     val paymentProvider = OppPaymentProvider(context, Connnect.ProviderMode.TEST)
     val transaction = Transaction(paymentParams) 
     paymentProvider.submitTransaction(transaction, transactionListener) 
} catch (ee: PaymentException) { 
     /* error occurred */ 
}

Now, let the class implement the ITransactionListener interface. Implement the following ITransactionListener methods:

@Override
public void transactionFailed(Transaction transaction, PaymentError paymentError) {
    /* add your implementation here */
}

@Override
public void transactionCompleted(Transaction transaction) {
    /* add your implementation here */
}

override fun transactionFailed(transaction: Transaction, paymentError: PaymentError) { 
    /* add your implementation here */ 
} 
 
override fun transactionCompleted(transaction: Transaction) { 
    /* add your implementation here */ 
}

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 
}

To get the resourcePath you should make the additional request to the server.

try {
    paymentProvider.requestCheckoutInfo(CHECKOUT_ID, transactionListener);
} catch (PaymentException e) {
   /* error occurred */
}

@Override
public void paymentConfigRequestSucceeded(CheckoutInfo checkoutInfo) {
    /* get the resource path in this ITransactionListener callback */
    String resourcePath = checkoutInfo.getResourcePath();
}

try {
    paymentProvider.requestCheckoutInfo(CHECKOUT_ID, transactionListener)
} catch (e: PaymentException) {
    /* error occurred */
}

override fun paymentConfigRequestSucceeded(checkoutInfo: CheckoutInfo) { 
    /* get the resource path in this ITransactionListener callback */
    val resourcePath = checkoutInfo.resourcePath 
}

2. Adjust the server type to LIVE in your initialization of PaymentProvider.

paymentProvider.setProviderMode(Connect.ProviderMode.LIVE); 

paymentProvider.setProviderMode(Connect.ProviderMode.LIVE)

OppPaymentProvider paymentProvider = new OppPaymentProvider(context, Connnect.ProviderMode.LIVE); 

val paymentProvider = OppPaymentProvider(context, Connnect.ProviderMode.LIVE)

3. Change your backend to use the correct API endpoints and credentials.