JarCastingAdyen Components for Android
Adyen Components for Android allows you to accept in-app payments by providing you with the building blocks you need to create a checkout experience.
For an overview of how you can integrate with Adyen on Android check out the Documentation Website
Support
If you have a feature request, or spotted a bug or a technical problem, create a GitHub issue. For other questions, contact our support team.
Installation
The Components are available through jcenter, you only need to add the Gradle dependency.
Import with Gradle
Import the Component module for the Payment Method you want to use by adding it to your build.gradle file. For example, for the Drop-in solution you should add:
implementation "com.adyen.checkout:drop-in:3.8.0"
For a Credit Card component you should add:
implementation "com.adyen.checkout:card-ui:3.8.0"
Drop-in
The Drop-in is the implementation that handles the presentation of all available payment methods and the subsequent entry of a customer's payment details. It is initialized with the response of /paymentMethods, and provides everything you need to make an API call to /payments and /payments/details.
Usage
The Drop-in requires the response of the /paymentMethods endpoint to be initialized. To pass the response to Drop-in, decode the response to the PaymentMethodsApiResponse class.
You can provide the raw JSONObject to the SERIALIZER object to deserialize the data.
val paymentMethodsApiResponse = PaymentMethodsApiResponse.SERIALIZER.deserialize(jsonObject)
The Drop-in relies on you to implement the calls to your server. When calling /payments or /payments/details is required, it will trigger an intent to the DropInService which you need to extend. The data comes as a JSONObject that you can use to compose your final /payments call on your back end. After the call, you return a CallResult with a type and message, each type expects a certain message.
- ACTION - If the result contains an
actionobject, return it in the message to continue the payment flow. - FINISHED - If there is no
actionthe payment flow is finished, the message will be passed along as the result. - ERROR - If an error happened during the connection.
class YourDropInService : DropInService() {
override fun makePaymentsCall(paymentComponentData: JSONObject): CallResult {
// make /payments call with the component data
return CallResult(CallResult.ResultType.ACTION, "action JSON object")
}
override fun makeDetailsCall(actionComponentData: JSONObject): CallResult {
// make /payments/details call with the component data
return CallResult(CallResult.ResultType.FINISHED, "Success")
}
}
Don't forget to also add the service your manifest.
<service
android:name=".YourDropInService"
android:permission="android.permission.BIND_JOB_SERVICE"/>
Some payment methods need additional configuration. For example, to enable the card form, the Drop-in needs a public key from the Customer Area to be used for encryption. These payment method specific configuration parameters can be set in the DropInConfiguration:
val dropInConfiguration = DropInConfiguration.Builder(this@MainActivity,
resultIntent, YourDropInService::class.java)
.addCardConfiguration(cardConfiguration)
.build()
You can find an example on how to create the cardConfiguration in the Components section.
After serializing the payment methods and creating the configuration, the Drop-in is ready to be initialized. Just call the .startPayment() method, the final result sent on the CallResult will be added to your resultIntent to start your Activity.
DropIn.startPayment(this@YourActivity, paymentMethodsApiResponse, dropInConfiguration)
Components
In order to have more flexibility over the checkout flow, you can use our Components to present each payment method individually in your own Activity.
To do that you need the data of that specific payment method parsed to the PaymentMethod class, and to create the configuration object (check out the docs for a more detailed guide on how to initialize the CardConfiguration.Builder).
val cardConfiguration = CardConfiguration.Builder(context).build()
val cardComponent = CardComponent.PROVIDER.get(this@YourActivity, paymentMethod, cardConfiguration)
Then you need to add the Component View to your layout.
<com.adyen.checkout.card.CardView
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
Then, after the component is initialized, you can attach it to the view to start getting user data.
cardView.attach(cardComponent, this@YourActivity)
From this moment you will start receiving updates when the user inputs data. When the data is valid, you can send it to the /payments endpoint.
cardComponent.observe(this@MainActivity, Observer {
if (it?.isValid == true) {
// you can now use it.data to send your payments/ request
}
})
ProGuard
If you use ProGuard or R8, the following rules should be enough to maintain all expected functionality. Please let us know if you find any issues.
-keep class com.adyen.checkout.base.model.** { *; }
-keep class com.adyen.threeds2.** { *; }
-keepclassmembers public class * implements com.adyen.checkout.base.PaymentComponent {
public <init>(...);
}
-keepclassmembers public class * implements com.adyen.checkout.base.ActionComponent {
public <init>(...);
}
Common Issues
- Our
TextInputLayoutuses a MaterialComponents style, so it requires your app theme to extendTheme.MaterialComponents. If you use aTheme.AppCompatyou might need to override this style. But note that this will also change the appearance of the TextInputLayout.
<style name="AdyenCheckout.TextInputLayout" >
<item name="boxStrokeColor">@color/colorAccent</item>
<item name="hintTextAppearance">@style/AdyenCheckout.HintTextStyle</item>
<item name="android:minHeight">@dimen/input_layout_height</item>
</style>
See also
License
This repository is open source and available under the MIT license. For more information, see the LICENSE file.
