Payment-method icon

BLIK Android Component

Add BLIK to an existing Android Components integration.

If you are using Android Components v5.0.0 or later:

This payment method requires no additional configuration.

Follow the Components integration guide and use the following module and Component names:

This page explains how to add BLIK to your existing Android Components integration.

Requirements

Requirement Description
Integration type Make sure that you have built your Components integration.

BLIK for Android requires at least v3.8.0 of Components. For more information, refer to Release notes.

Setup steps Before you begin, add BLIK in your test Customer Area.

Set up the BLIK Component

  1. Import the BLIK Component to your build.gradle file:
    Copy code
    implementation "com.adyen.checkout:blik:<latest-version>"

    For the latest version, refer to our GitHub.

  2. Build a client-side configuration of the BLIK Component:
    Copy code
    val blikConfiguration =
    BlikConfiguration.Builder(context, "YOUR_CLIENT_KEY")
    // When you are ready to accept live payments, change the value to one of our live environments.
    .setEnvironment(Environment.TEST)
    .build()
  3. Add the Component view to your layout:
    Copy code
    <com.adyen.checkout.blik.BlikView
    android:id="@+id/YOUR_COMPONENT_VIEW_ID"
    .../>

    You will attach the initialized component to this view when collecting payment details.

Collect payment details

Use the client-side Component to collect the phone number from your shopper.

  1. Deserialize the /paymentMethods response with the SERIALIZER object:
    Copy code
    val paymentMethodsApiResponse = PaymentMethodsApiResponse.SERIALIZER.deserialize(paymentMethodsResponse)
  2. From the result, get the object containing paymentMethods.type: blik.
  3. Initialize an instance of the Component. Call PROVIDER.get from the BLIK Component and pass the following:
    • The context (for example, this@YourActivity)
    • The PaymentMethod object (for example, paymentMethod)
    • The BlikConfiguration object:
      Copy code
      val blikComponent = BlikComponent.PROVIDER.get(this@YourActivity, paymentMethod, blikConfiguration)
  4. Attach the Component to the view to start getting your shopper's payment details. You need to call attach from the payment method's Component view and pass in:
    • the BlikComponent
    • the context (for example, this@YourActivity): BlikView.attach(blikComponent, this@YourActivity)
      You start receiving updates when the shopper enters their phone number.
  5. Check if isValid is true, and when the shopper proceeds to pay, pass the paymentComponentState.data.paymentMethod to your server:
    Copy code
    blikComponent.observe(this@MainActivity) { state ->
    if (state?.isValid == true) {
    //serialize data
    val paymentComponentData = PaymentComponentData.SERIALIZER.serialize(state.data)
    // When the shopper pays, pass the serialized `state.data` to your server to send a /payments request
    }
    }

Handle the await action

Step 1: Deserialize the action object

In your client-side app, deserialize the action object from the /payments response:

Copy code
val action = Action.SERIALIZER.deserialize(paymentResponse.action)

Step 2: Initialize the Component

  1. Before initializing the Component, make sure that you have added the following to your build.gradle file:

    Initialize component
    Expand view
    Copy link to code block
    Copy code
    Copy code
    implementation "com.adyen.checkout:await:<latest-version>"

    Check the latest version on GitHub.

  2. Create a configuration object for the Component, passing your client key:

    Create configuration object
    Expand view
    Copy link to code block
    Copy code
    Copy code
    val awaitConfiguration = AwaitConfiguration.Builder(context, "YOUR_CLIENT_KEY")
    .setEnvironment(Environment.TEST)
    .build()
  3. To initialize an instance of the Component, call PROVIDER.get from the Component and pass in the context (for example, this@YourActivity), application class, and the configuration object created in the previous step:

    Initialize instance of component
    Expand view
    Copy link to code block
    Copy code
    Copy code
    val awaitComponent = AwaitComponent.PROVIDER.get(this@YourActivity, application, awaitConfiguration)
  4. From your instance, call handleAction and pass:

    • the context (for example, this@YourActivity)
    • the action object from the deserialized /payments response.
    Call handleAction
    Expand view
    Copy link to code block
    Copy code
    Copy code
    awaitComponent.handleAction(this@YourActivity, action)

Step 3: Check the payment result

The Component notifies the observer with the actionComponentData object from the data in intent.data. Pass this to your server to make a /payments/details request.

Check payment result
Expand view
Copy link to code block
Copy code
Copy code
awaitcomponent.observe(this) { actionComponentData ->
// Send a /payments/details/ call containing the `actionComponentData`
sendPaymentDetails(actionComponentData)
}

Test and go live

In order to successfully authorize a BLIK One Click payment in TEST, please use BLIK code 999016.

Important steps:

  1. Make sure your implementation satisfies BLIK’s guidelines.
  2. Test your integration end-to-end.
  3. Add BLIK in your live Customer Area.

See also