SDK Integration

Android

1. Download the Mobile SDK for Android.
Import oppwa.mobile.aar into your project (File > New > New Module > Import .JAR/.AAR Package).
Then, reference it from your application (File > Project Structure > Dependencies > Add Module Dependency).



2. 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
    android:name="com.oppwa.mobile.connect.checkout.dialog.CheckoutActivity"
    android:theme="@style/Theme.Checkout.Light"
    android:windowSoftInputMode="adjustPan"/>




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

private IProviderBinder providerBinder;
private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        providerBinder = (IProviderBinder) service;
        /* we have a connection to the service */
	try {
	    providerBinder.initializeProvider(Connect.ProviderMode.TEST);
	} catch (PaymentException ee) {
	    /* error occurred */
	}
    }
 
    @Override
    public void onServiceDisconnected(ComponentName name) {
        providerBinder = null;
    }
};

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

    Intent intent = new Intent(this, ConnectService.class);

    startService(intent);
    bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
}

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

    unbindService(serviceConnection);
    stopService(new Intent(this, ConnectService.class));
}

private var providerBinder: IProviderBinder? = null 
private val serviceConnection = object : ServiceConnection { 
     override fun onServiceConnected(name: ComponentName?, service: IBinder?) { 
         providerBinder = service as IProviderBinder 
         /* we have a connection to the service */ 
         try { 
             providerBinder!!.initializeProvider(Connect.ProviderMode.TEST) 
         } catch (ee: PaymentException) { 
             /* error occurred */ 
         } 
     } 
 
    override fun onServiceDisconnected(name: ComponentName) { 
         bproviderBinder = null 
     } 
}

override fun onStart() { 
    super.onStart() 
      
    val intent = Intent(this, ConnectService::class.java) 
      
    startService(intent) 
    bindService(intent, serviceConnection, BIND_AUTO_CREATE) 
}

override fun onStop() { 
    super.onStop() 
      
    unbindService(serviceConnection) 
    stopService(Intent(this, ConnectService::class.java)) 
}

Transaction transaction = null;

try {
    transaction = new Transaction(paymentParams);
    providerBinder.submitTransaction(transaction);
} catch (PaymentException ee) {
    /* error occurred */
}

try { 
     val transaction = Transaction(paymentParams) 
     providerBinder.submitTransaction(transaction) 
} catch (ee: PaymentException) { 
     /* error occurred */ 
}

Now, let the class implement the ITransactionListener interface. After initializing the provider add the transaction listener

providerBinder.addTransactionListener(YourActivity.this);

providerBinder.addTransactionListener(this@YourActivity)

and 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 {
    providerBinder.requestCheckoutInfo(CHECKOUT_ID);
} catch (PaymentException e) {
   /* error occurred */
}

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

try {
    providerBinder.requestCheckoutInfo(CHECKOUT_ID)
} 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.

providerBinder.initializeProvider(Connect.ProviderMode.LIVE); 

providerBinder.initializeProvider(Connect.ProviderMode.LIVE)

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