> ## Documentation Index
> Fetch the complete documentation index at: https://telr-docs.cashfree.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Android Integration
> Learn more about the android sdk integration in your app
## Payment Gateway Android Guide
This integration allows you to integrate with a Telr Android SDK in your app. You can view the integration video on Youtube.
### Setting Up SDK
```
implementation 'com.cashfree.pg:api:2.2.0'
```
### Step 1: Creating an Order
The first step in the Telr Payment Gateway integration is to create an Order. You need to do this before any payment can be processed. You can add an endpoint to your server which creates this order and is used for communication with your frontend.
Order creation must happen from your backend (as this API uses your secret key). Please do not call this directly from your mobile application.
##### API Request for Creating an Order
Here's a sample request for creating an order using your desired backend language. Telr offers backend SDKs to simplify the integration process.
You can find the SDKs [here](/api-reference/payments/sdk#payment-sdk).
```javascript javascript theme={null}
import { Cashfree } from "cashfree-pg";
Cashfree.XClientId = {Client ID};
Cashfree.XClientSecret = {Client Secret Key};
Cashfree.XEnvironment = Cashfree.Environment.PRODUCTION;
function createOrder() {
var request = {
"order_amount": "1",
"order_currency": "INR",
"customer_details": {
"customer_id": "node_sdk_test",
"customer_name": "",
"customer_email": "example@gmail.com",
"customer_phone": "9999999999"
},
"order_meta": {
"return_url": "https://test.cashfree.com/pgappsdemos/return.php?order_id=order_123"
},
"order_note": ""
}
Cashfree.PGCreateOrder("2023-08-01", request).then((response) => {
var a = response.data;
console.log(a)
})
.catch((error) => {
console.error('Error setting up order request:', error.response.data);
});
}
```
```python python theme={null}
from cashfree_pg.models.create_order_request import CreateOrderRequest
from cashfree_pg.api_client import Cashfree
from cashfree_pg.models.customer_details import CustomerDetails
Cashfree.XClientId = {Client ID}
Cashfree.XClientSecret = {Client Secret Key}
Cashfree.XEnvironment = Cashfree.XSandbox
x_api_version = "2023-08-01"
def create_order():
customerDetails = CustomerDetails(customer_id="123", customer_phone="9999999999")
createOrderRequest = CreateOrderRequest(order_amount=1, order_currency="INR", customer_details=customerDetails)
try:
api_response = Cashfree().PGCreateOrder(x_api_version, createOrderRequest, None, None)
print(api_response.data)
except Exception as e:
print(e)
```
```java java theme={null}
import com.cashfree.*;
Cashfree.XClientId = {Client Key};
Cashfree.XClientSecret = {Client Secret Key};
Cashfree.XEnvironment = Cashfree.SANDBOX;
static void createOrder() {
CustomerDetails customerDetails = new CustomerDetails();
customerDetails.setCustomerId("123");
customerDetails.setCustomerPhone("9999999999");
CreateOrderRequest request = new CreateOrderRequest();
request.setOrderAmount(1.0);
request.setOrderCurrency("INR");
request.setCustomerDetails(customerDetails);
try {
Cashfree cashfree = new Cashfree();
ApiResponse response = cashfree.PGCreateOrder("2023-08-01", request, null, null, null);
System.out.println(response.getData().getOrderId());
} catch (ApiException e) {
throw new RuntimeException(e);
}
}
```
```go go theme={null}
import (
cashfree "github.com/cashfree/cashfree-pg/v3"
)
func createOrder() {
clientId := {Client ID}
clientSecret := {Client Secret Key}
cashfree.XClientId = &clientId
cashfree.XClientSecret = &clientSecret
cashfree.XEnvironment = cashfree.SANDBOX
request := cashfree.CreateOrderRequest{
OrderAmount: 1,
CustomerDetails: cashfree.CustomerDetails{
CustomerId: "1",
CustomerPhone: "9999999999",
},
OrderCurrency: "INR",
OrderSplits: []cashfree.VendorSplit{},
}
version := "2023-08-01"
response, httpResponse, err := cashfree.PGCreateOrder(&version, &request, nil, nil, nil)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println(httpResponse.StatusCode)
fmt.Println(response)
}
}
```
```csharp csharp theme={null}
using cashfree_pg.Client;
using cashfree_pg.Model;
Cashfree.XClientId = {Client ID};
Cashfree.XClientSecret = {Client Secret Key};
Cashfree.XEnvironment = Cashfree.PRODUCTION;
var cashfree = new Cashfree();
var xApiVersion = "2023-08-01";
void CreateOrder() {
var customerDetails = new CustomerDetails("123", null, "9999999999");
var createOrdersRequest = new CreateOrderRequest(null, 1.0, "INR", customerDetails);
try {
// Create Order
var result = cashfree.PGCreateOrder(xApiVersion, createOrdersRequest, null, null, null);
Console.WriteLine(result);
Console.WriteLine(result.StatusCode);
Console.WriteLine((result.Content as OrderEntity));
} catch (ApiException e) {
Console.WriteLine("Exception when calling PGCreateOrder: " + e.Message);
Console.WriteLine("Status Code: " + e.ErrorCode);
Console.WriteLine(e.StackTrace);
}
}
```
```php php theme={null}
\Cashfree\Cashfree::$XClientId = "";
\Cashfree\Cashfree::$XClientSecret = "";
\Cashfree\Cashfree::$XEnvironment = Cashfree\Cashfree::$SANDBOX;
$cashfree = new \Cashfree\Cashfree();
$x_api_version = "2023-08-01";
$create_orders_request = new \Cashfree\Model\CreateOrdersRequest();
$create_orders_request->setOrderAmount(1.0);
$create_orders_request->setOrderCurrency("INR");
$customer_details = new \Cashfree\Model\CustomerDetails();
$customer_details->setCustomerId("123");
$customer_details->setCustomerPhone("9999999999");
$create_orders_request->setCustomerDetails($customer_details);
try {
$result = $cashfree->PGCreateOrder($x_api_version, $create_orders_request);
print_r($result);
} catch (Exception $e) {
echo 'Exception when calling PGCreateOrder: ', $e->getMessage(), PHP_EOL;
}
```
```bash curl theme={null}
curl --location 'https://sandbox.cashfree.com/pg/orders' \
--header 'X-Client-Secret: {{clientKey}}' \
--header 'X-Client-Id: {{clientId}}'
--header 'x-api-version: 2023-08-01' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--data-raw '{
"order_amount": 10.10,
"order_currency": "INR",
"customer_details": {
"customer_id": "USER123",
"customer_name": "joe",
"customer_email": "joe.s@cashfree.com",
"customer_phone": "+919876543210"
},
"order_meta": {
"return_url": "https://b8af79f41056.eu.ngrok.io?order_id=order_123",
}
}'
```
After successfully creating an order, you will receive a unique `order_id` and `payment_session_id` that you need for subsequent steps.
You can view all the complete api request and response for `/orders` [here](/api-reference/payments/latest/orders/create).
### Step 2: Opening the Payment Page
Once the order is created, the next step is to open the payment page so the customer can make the payment. Telr Android SDK offer below payment flow.
In this flow, SDK provides a webview based checkout implementation to facilitate a quick integration with our payment gateway. Your customers can fill in the necessary details in the web page and complete the payment.
This mode also handles all the business logic and UI Components to make the payment smooth and easy to use.
This flow is for merchants who wants to quickly provide UPI Intent functionality using cashfree's mobile SDK. In this flow, SDK provides a pre-built native Android screen to facilitate a quick integration with our payment gateway. Your customers will see a list of UPI apps installed in their phone which they can select to initiate payment.
This mode handles all the business logic and UI Components to make the payment smooth and easy to use. The SDK allows the merchant to customize the UI in terms of color coding, fonts.
To complete the payment, we can follow the following steps:
1. Create a `CFSession` object.
2. Create a `CFTheme` object.
3. Create a `CFWebCheckoutPayment/CFUPIIntentCheckoutPayment` object.
4. Set payment callback.
5. Initiate the payment using the payment object created from \[step 3]
We go through these step by step below.
#### Create a Session
This object contains essential information about the order, including the payment session ID (`payment_session_id`) and order ID (`order_id`) obtained from Step 1. It also specifies the environment (sandbox or production).
```java java theme={null}
CFSession cfSession = new CFSession.CFSessionBuilder()
.setEnvironment(CFSession.Environment.SANDBOX)
.setPaymentSessionID("paymentSessionID")
.setOrderId("orderID")
.build();
```
```kotlin kotlin theme={null}
val cfSession = CFSessionBuilder()
.setEnvironment(CFSession.Environment.SANDBOX)
.setPaymentSessionID("paymentSessionID")
.setOrderId("orderID")
.build()
```
#### Customize Theme (Optional)
You can customize the appearance of the checkout screen using CFTheme. This step is optional but can help maintain consistency with your app's design.
```java java theme={null}
CFWebCheckoutTheme cfTheme = new CFWebCheckoutTheme.CFWebCheckoutThemeBuilder()
.setNavigationBarBackgroundColor("#6A3FD3")
.setNavigationBarTextColor("#FFFFFF")
.build();
```
```kotlin kotlin theme={null}
val cfTheme = CFWebCheckoutThemeBuilder()
.setNavigationBarBackgroundColor("#000000")
.setNavigationBarTextColor("#FFFFFF")
.build()
```
```java java theme={null}
CFIntentTheme cfTheme = new CFIntentTheme.CFIntentThemeBuilder()
.setPrimaryTextColor("#000000")
.setBackgroundColor("#FFFFFF")
.build();
```
```kotlin kotlin theme={null}
val cfTheme = CFIntentThemeBuilder()
.setPrimaryTextColor("#000000")
.setBackgroundColor("#FFFFFF")
.build()
```
#### Create Checkout Payment Object
This object combines all the configurations (session, theme) into a single checkout configuration. Finally, call `doPayment()` to open the Telr web checkout screen. This will present the user with the payment options and handle the payment process.
```java java theme={null}
CFWebCheckoutPayment cfWebCheckoutPayment = new CFWebCheckoutPayment.CFWebCheckoutPaymentBuilder()
.setSession(cfSession)
.setCFWebCheckoutUITheme(cfTheme)
.build();
```
```kotlin kotlin theme={null}
val cfWebCheckoutPayment = CFWebCheckoutPaymentBuilder()
.setSession(cfSession)
.setCFWebCheckoutUITheme(cfTheme)
.build()
```
This flow is for merchants who wants to quickly provide UPI functionality using cashfree's mobile SDK without handling other modes like Cards or Net banking.
```java java theme={null}
CFUPIIntentCheckout cfupiIntentCheckout = new CFUPIIntentCheckout.CFUPIIntentBuilder()
// Use either the enum or the application package names to order the UPI apps as per your needed
// Remove both if you want to use the default order which cashfree provides based on the popularity
// NOTE - only one is needed setOrder or setOrderUsingPackageName
.setOrder(Arrays.asList(CFUPIIntentCheckout.CFUPIApps.BHIM, CFUPIIntentCheckout.CFUPIApps.PHONEPE))
.setOrderUsingPackageName(Arrays.asList("com.dreamplug.androidapp", "in.org.npci.upiapp"))
.build();
CFUPIIntentCheckoutPayment cfupiIntentCheckoutPayment = new CFUPIIntentCheckoutPayment.CFUPIIntentPaymentBuilder()
.setSession(cfSession)
.setCfUPIIntentCheckout(cfupiIntentCheckout)
.setCfIntentTheme(cfTheme)
.build();
```
```kotlin kotlin theme={null}
val cfupiIntentCheckout = CFUPIIntentBuilder() // Use either the enum or the application package names to order the UPI apps as per your needed
// Remove both if you want to use the default order which cashfree provides based on the popularity
// NOTE - only one is needed setOrder or setOrderUsingPackageName
.setOrderUsingPackageName(Arrays.asList("com.dreamplug.androidapp", "in.org.npci.upiapp"))
.setOrder(Arrays.asList(CFUPIIntentCheckout.CFUPIApps.BHIM, CFUPIIntentCheckout.CFUPIApps.PHONEPE))
.build()
val cfupiIntentCheckoutPayment = CFUPIIntentPaymentBuilder()
.setSession(cfSession)
.setCfUPIIntentCheckout(cfupiIntentCheckout)
.setCfIntentTheme(cfTheme)
.build()
```
#### Setup payment callback
The SDK exposes an interface `CFCheckoutResponseCallback` to receive callbacks from the SDK once the payment journey ends.
This interface consists of 2 methods:
```java java theme={null}
public void onPaymentVerify(String orderID)
public void onPaymentFailure(CFErrorResponse cfErrorResponse, String orderID)
```
```kotlin kotlin theme={null}
fun onPaymentVerify(orderID: String)
fun onPaymentFailure(cfErrorResponse: CFErrorResponse, orderID: String)
```
Make sure to set the callback at activity's onCreate as this also handles the activity restart cases.
```java java theme={null}
public class YourActivity extends AppCompatActivity implements CFCheckoutResponseCallback {
...
@Override
public void onPaymentVerify(String orderID) {
}
@Override
public void onPaymentFailure(CFErrorResponse cfErrorResponse, String orderID) {
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_upi_intent_checkout);
try {
// If you are using a fragment then you need to add this line inside onCreate() of your Fragment
CFPaymentGatewayService.getInstance().setCheckoutCallback(this);
} catch (CFException e) {
e.printStackTrace();
}
}
...
}
```
```kotlin kotlin theme={null}
class YourActivity : AppCompatActivity(), CFCheckoutResponseCallback {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_drop_checkout)
try {
CFPaymentGatewayService.getInstance().setCheckoutCallback(this)
} catch (e: CFException) {
e.printStackTrace()
}
}
override fun onPaymentVerify(orderID: String) {
Log.d("onPaymentVerify", "verifyPayment triggered")
}
override fun onPaymentFailure(cfErrorResponse: CFErrorResponse, orderID: String) {
Log.e("onPaymentFailure $orderID", cfErrorResponse.message)
}
...
}
```
#### Open Checkout Screen
Finally, call `doPayment()` to open the Telr checkout screen. This will present the user with the payment options and handle the payment process.
```java java theme={null}
// replace the WebCheckoutActivity class with your class name
CFPaymentGatewayService.getInstance().doPayment(WebCheckoutActivity.this, cfWebCheckoutPayment);
```
```kotlin kotlin theme={null}
// replace the WebCheckoutActivity class with your class name
CFPaymentGatewayService.getInstance().doPayment(this@WebCheckoutActivity, cfWebCheckoutPayment)
```
```java java theme={null}
// replace the UPIIntentCheckoutActivity class with your class name
CFPaymentGatewayService.getInstance().doPayment(UPIIntentCheckoutActivity.this, cfupiIntentCheckoutPayment);
```
```kotlin kotlin theme={null}
// replace the UPIIntentCheckoutActivity class with your class name
CFPaymentGatewayService.getInstance().doPayment(this@UPIIntentCheckoutActivity, cfupiIntentCheckoutPayment)
```
### Step 3: Sample Code
```java java theme={null}
package com.cashfree.sdk_sample;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.cashfree.pg.api.CFPaymentGatewayService;
import com.cashfree.pg.core.api.CFSession;
import com.cashfree.pg.core.api.webcheckout.CFTheme;
import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback;
import com.cashfree.pg.core.api.exception.CFException;
import com.cashfree.pg.core.api.utils.CFErrorResponse;
import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutPayment;
import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback;
public class WebCheckoutActivity extends AppCompatActivity implements CFCheckoutResponseCallback {
String orderID = "ORDER_ID";
String paymentSessionID = "TOKEN";
CFSession.Environment cfEnvironment = CFSession.Environment.PRODUCTION;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_drop_checkout);
try {
CFPaymentGatewayService.getInstance().setCheckoutCallback(this);
} catch (CFException e) {
e.printStackTrace();
}
}
@Override
public void onPaymentVerify(String orderID) {
Log.e("onPaymentVerify", "verifyPayment triggered");
// Start verifying your payment
}
@Override
public void onPaymentFailure(CFErrorResponse cfErrorResponse, String orderID) {
Log.e("onPaymentFailure " + orderID, cfErrorResponse.getMessage());
}
public void doWebCheckoutPayment() {
try {
CFSession cfSession = new CFSession.CFSessionBuilder()
.setEnvironment(cfEnvironment)
.setPaymentSessionID(paymentSessionID)
.setOrderId(orderID)
.build();
// Replace with your application's theme colors
CFWebCheckoutTheme cfTheme = new CFWebCheckoutTheme.CFWebCheckoutThemeBuilder()
.setNavigationBarBackgroundColor("#fc2678")
.setNavigationBarTextColor("#ffffff")
.build();
CFWebCheckoutPayment cfWebCheckoutPayment = new CFWebCheckoutPayment.CFWebCheckoutPaymentBuilder()
.setSession(cfSession)
.setCFWebCheckoutUITheme(cfTheme)
.build();
CFPaymentGatewayService.getInstance().doPayment(WebCheckoutActivity.this, cfWebCheckoutPayment);
} catch (CFException exception) {
exception.printStackTrace();
}
}
}
```
```kotlin kotlin theme={null}
package com.cashfree.sdk_sample.kotlin
import androidx.appcompat.app.AppCompatActivity
import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback
import com.cashfree.pg.core.api.CFSession
import android.os.Bundle
import com.cashfree.sdk_sample.R
import com.cashfree.pg.api.CFPaymentGatewayService
import android.content.Intent
import android.app.Activity
import com.cashfree.pg.core.api.utils.CFErrorResponse
import android.text.TextUtils
import android.util.Log
import android.widget.Toast
import com.cashfree.pg.core.api.CFSession.CFSessionBuilder
import com.cashfree.pg.core.api.exception.CFException
import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutTheme
import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutTheme.CFWebCheckoutThemeBuilder
import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutPayment
import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutPayment.CFWebCheckoutPaymentBuilder
class WebCheckoutActivity : AppCompatActivity(), CFCheckoutResponseCallback { var orderID = "ORDER_ID" var paymentSessionID = "PAYMENT_SESSION_ID" var cfEnvironment = CFSession.Environment.PRODUCTION override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_drop_checkout) try { CFPaymentGatewayService.getInstance().setCheckoutCallback(this) } catch (e: CFException) { e.printStackTrace() } }
var cfEnvironment = CFSession.Environment.SANDBOX
override fun onPaymentVerify(orderID: String) {
Log.d("onPaymentVerify", "verifyPayment triggered")
}
override fun onPaymentFailure(cfErrorResponse: CFErrorResponse, orderID: String) {
Log.e("onPaymentFailure $orderID", cfErrorResponse.message)
}
fun doWebCheckoutPayment() {
try {
val cfSession = CFSessionBuilder()
.setEnvironment(cfEnvironment)
.setPaymentSessionID(paymentSessionID)
.setOrderId(orderID)
.build()
val cfTheme = CFWebCheckoutThemeBuilder()
.setNavigationBarBackgroundColor("#000000")
.setNavigationBarTextColor("#FFFFFF")
.build()
val cfWebCheckoutPayment = CFWebCheckoutPaymentBuilder()
.setSession(cfSession)
.setCFWebCheckoutUITheme(cfTheme)
.build()
CFPaymentGatewayService.getInstance().doPayment(this@WebCheckoutActivity, cfWebCheckoutPayment)
} catch (exception: CFException) {
exception.printStackTrace()
}
}
}
```
```java java theme={null}
package com.cashfree.sdk_sample;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.cashfree.pg.api.CFPaymentGatewayService;
import com.cashfree.pg.core.api.CFSession;
import com.cashfree.pg.core.api.CFTheme;
import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback;
import com.cashfree.pg.core.api.exception.CFException;
import com.cashfree.pg.core.api.utils.CFErrorResponse;
import com.cashfree.pg.ui.api.upi.intent.CFIntentTheme;
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckout;
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckoutPayment;
public class UPIIntentCheckoutActivity extends AppCompatActivity implements CFCheckoutResponseCallback {
String orderID = "ORDER_ID";
String paymentSessionID = "PAYMENT_SESSION_ID";
CFSession.Environment cfEnvironment = CFSession.Environment.SANDBOX;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_upi_intent_checkout);
try {
CFPaymentGatewayService.getInstance().setCheckoutCallback(this);
} catch (CFException e) {
e.printStackTrace();
}
}
@Override
public void onPaymentVerify(String orderID) {
Log.e("onPaymentVerify", "verifyPayment triggered");
// Start verifying your payment
}
@Override
public void onPaymentFailure(CFErrorResponse cfErrorResponse, String orderID) {
Log.e("onPaymentFailure " + orderID, cfErrorResponse.getMessage());
}
public void doUPIIntentCheckoutPayment() {
try {
CFSession cfSession = new CFSession.CFSessionBuilder()
.setEnvironment(cfEnvironment)
.setOrderToken(token)
.setOrderId(orderID)
.build();
// Replace with your application's theme colors
CFIntentTheme cfTheme = new CFIntentTheme.CFIntentThemeBuilder()
.setButtonBackgroundColor("#6A3FD3")
.setButtonTextColor("#FFFFFF")
.setPrimaryTextColor("#000000")
.setSecondaryTextColor("#000000")
.build();
CFUPIIntentCheckout cfupiIntentCheckout = new CFUPIIntentCheckout.CFUPIIntentBuilder()
// Use either the enum or the application package names to order the UPI apps as per your needed
// Remove both if you want to use the default order which cashfree provides based on the popularity
// NOTE - only one is needed setOrder or setOrderUsingPackageName
.setOrder(Arrays.asList(CFUPIIntentCheckout.CFUPIApps.BHIM, CFUPIIntentCheckout.CFUPIApps.PHONEPE))
.setOrderUsingPackageName(Arrays.asList("com.dreamplug.androidapp", "in.org.npci.upiapp"))
.build();
CFUPIIntentCheckoutPayment cfupiIntentCheckoutPayment = new CFUPIIntentCheckoutPayment.CFUPIIntentPaymentBuilder()
.setSession(cfSession)
.setCfUPIIntentCheckout(cfupiIntentCheckout)
.setCfIntentTheme(cfTheme)
.build();
CFPaymentGatewayService.getInstance().doPayment(UPIIntentCheckoutActivity.this, cfupiIntentCheckoutPayment);
} catch (CFException exception) {
exception.printStackTrace();
}
}
}
```
```kotlin kotlin theme={null}
package com.cashfree.sdk_sample.kotlin
import androidx.appcompat.app.AppCompatActivity
import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback
import com.cashfree.pg.core.api.CFSession
import android.os.Bundle
import com.cashfree.sdk_sample.R
import com.cashfree.pg.api.CFPaymentGatewayService
import android.content.Intent
import android.app.Activity
import com.cashfree.pg.core.api.utils.CFErrorResponse
import android.text.TextUtils
import android.util.Log
import android.widget.Toast
import com.cashfree.pg.core.api.CFSession.CFSessionBuilder
import com.cashfree.pg.core.api.exception.CFException
import com.cashfree.pg.ui.api.upi.intent.CFIntentTheme
import com.cashfree.pg.ui.api.upi.intent.CFIntentTheme.CFIntentThemeBuilder
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckout
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckout.CFUPIIntentBuilder
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckoutPayment
import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckoutPayment.CFUPIIntentPaymentBuilder
class UPIIntentCheckoutActivity : AppCompatActivity(), CFCheckoutResponseCallback {
var orderID = "ORDER_ID"
var token = "TOKEN"
var cfEnvironment = CFSession.Environment.SANDBOX
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_drop_checkout)
try {
CFPaymentGatewayService.getInstance().setCheckoutCallback(this)
doDropCheckoutPayment()
} catch (e: CFException) {
e.printStackTrace()
}
}
override fun onPaymentVerify(orderID: String) {
Log.d("onPaymentVerify", "verifyPayment triggered")
}
override fun onPaymentFailure(cfErrorResponse: CFErrorResponse, orderID: String) {
Log.e("onPaymentFailure $orderID", cfErrorResponse.message)
}
fun doUPIIntentCheckoutPayment() {
try {
val cfSession = CFSessionBuilder()
.setEnvironment(cfEnvironment)
.setPaymentSessionID(token)
.setOrderId(orderID)
.build()
val cfTheme = CFIntentThemeBuilder()
.setPrimaryTextColor("#000000")
.setBackgroundColor("#FFFFFF")
.build()
val cfupiIntentCheckout = CFUPIIntentBuilder()
// Use either the enum or the application package names to order the UPI apps as per your needed
// Remove both if you want to use the default order which cashfree provides based on the popularity
// NOTE - only one is needed setOrder or setOrderUsingPackageName
.setOrderUsingPackageName(Arrays.asList("com.dreamplug.androidapp", "in.org.npci.upiapp"))
.setOrder(Arrays.asList(CFUPIIntentCheckout.CFUPIApps.BHIM, CFUPIIntentCheckout.CFUPIApps.PHONEPE))
.build()
val cfupiIntentCheckoutPayment = CFUPIIntentPaymentBuilder()
.setSession(cfSession)
.setCfUPIIntentCheckout(cfupiIntentCheckout)
.setCfIntentTheme(cfTheme)
.build()
CFPaymentGatewayService.getInstance().doPayment(this@UPIIntentActivity, cfupiIntentCheckoutPayment)
} catch (exception: CFException) {
exception.printStackTrace()
}
}
}
```
[Github Sample](https://github.com/cashfree/nextgen-android)
### Step 4: Confirming the Payment
After the payment is completed, you need to confirm whether the payment was successful by checking the order status. Once the payment finishes, the user will be redirected back to your activity to your implementation of the `CFCheckoutResponseCallback` interface.
You must always verify payment status from your backend. Before delivering the goods or services, please ensure you call check the order status from your backend. Ensure you check the order status from your server endpoint.
To verify an order you can call our `/pg/orders` endpoint from your backend. You can also use our SDK to achieve the same.
```go golang theme={null}
version := "2023-08-01"
response, httpResponse, err := cashfree.PGFetchOrder(&version, "", nil, nil, nil)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println(httpResponse.StatusCode)
fmt.Println(response)
}
```
```javascript javascript theme={null}
let version = "2023-08-01"
Telr.PGFetchOrder(version, "").then((response) => {
console.log('Order fetched successfully:', response.data);
}).catch((error) => {
console.error('Error:', error.response.data.message);
});
```
```php php theme={null}
$x_api_version = "2023-08-01";
try {
$response = $cashfree->PGFetchOrder($x_api_version, "");
print_r($response);
} catch (Exception $e) {
echo 'Exception when calling PGFetchOrder: ', $e->getMessage(), PHP_EOL;
}
```
```java java theme={null}
import com.cashfree.*;
//other code
try {
Cashfree.XClientId = "";
Cashfree.XClientSecret = "";
Cashfree.XEnvironment = Telr.SANDBOX;
Telr cashfree = new Telr();
String xApiVersion = "2023-08-01";
ApiResponse responseFetchOrder = cashfree.PGFetchOrder(xApiVersion, "", null, null, null);
System.out.println(response.getData().getOrderId());
} catch (ApiException e) {
throw new RuntimeException(e);
}
```
```python python theme={null}
from cashfree_pg.models.create_order_request import CreateOrderRequest
from cashfree_pg.api_client import Telr
from cashfree_pg.models.customer_details import CustomerDetails
from cashfree_pg.models.order_meta import OrderMeta
Cashfree.XClientId = ""
Cashfree.XClientSecret = ""
Cashfree.XEnvironment = Telr.SANDBOX
x_api_version = "2023-08-01"
try:
api_response = Telr().PGFetchOrder(x_api_version, "order_3242X4jQ5f0S9KYxZO9mtDL1Kx2Y7u", None)
print(api_response.data)
except Exception as e:
print(e)
```
```csharp csharp theme={null}
using cashfree_pg.Client;
using cashfree_pg.Model;
Cashfree.XClientId = "";
Cashfree.XClientSecret = "";
Cashfree.XEnvironment = Telr.SANDBOX;
var cashfree = new Telr();
var xApiVersion = "2023-08-01";
try {
var result = cashfree.PGFetchOrder(xApiVersion, ">", null, null);
Console.WriteLine(result);
Console.WriteLine(result.StatusCode);
Console.WriteLine((result.Content as OrderEntity));
} catch (ApiException e) {
Console.WriteLine("Exception when calling PGFetchOrder: " + e.Message);
Console.WriteLine("Status Code: " + e.ErrorCode);
Console.WriteLine(e.StackTrace);
}
```
```bash curl theme={null}
curl --request GET \
--url https://sandbox.cashfree.com/pg/orders/{order_id} \
--header 'accept: application/json' \
--header 'x-api-version: 2023-08-01'
--header 'x-client-id: "YOUR APP ID GOES HERE"'
--header 'x-client-secret: "YOUR SECRET KEY GOES HERE'
```
### Testing
You should now have a working checkout button that redirects your customer to Telr Checkout. If your integration isn’t working:
1. Open the Network tab in your browser’s developer tools.
2. Click the button and check the console logs.
3. Use console.log(session) inside your button click listener to confirm the correct error returned.
### Error Codes
To confirm the error returned in your android application, you can view the error codes that are exposed by the SDK.
| ERROR CODES | MESSAGE |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| MISSING\_CALLBACK | The callback is missing in the request. |
| ORDER\_ID\_MISSING | The "order\_id" is missing in the request. |
| CARD\_EMI\_TENURE\_MISSING | The "emi\_tenure" is missing or invalid (It has to be greater than 0). |
| INVALID\_UPI\_APP\_ID\_SENT | The id sent is invalid. The value has to be one of the following: "tez://","phonepe://","paytm://","bhim://. Please refer the note in CFUPI class for more details |
| INVALID\_PAYMENT\_OBJECT\_SENT | The payment object that is set does not match any payment mode. Please set the correct payment mode and try again. |
| WALLET\_OBJECT\_MISSING | The CFWallet object is missing in the request |
| NETBANKING\_OBJECT\_MISSING | The CFNetbanking object is missing in the request. |
| UPI\_OBJECT\_MISSING | The CFUPI object is missing in the request. |
| CARD\_OBJECT\_MISSING | The CFCard object is missing in the request. |
| INVALID\_WEB\_DATA | The url seems to be corrupt. Please reinstantiate the order. |
| SESSION\_OBJECT\_MISSING | The "session" is missing in the request |
| PAYMENT\_OBJECT\_MISSING | The "payment" is missing in the request |
| ENVIRONMENT\_MISSING | The "environment" is missing in the request. |
| ORDER\_TOKEN\_MISSING | The "order\_token" is missing in the request. |
| CHANNEL\_MISSING | The "channel" is missing in the request. |
| CARD\_NUMBER\_MISSING | The "card\_number" is missing in the request. |
| CARD\_EXPIRY\_MONTH\_MISSING | The "card\_expiry\_mm" is missing in the request. |
| CARD\_EXPIRY\_YEAR\_MISSING | The "card\_expiry\_yy" is missing in the request. |
| CARD\_CVV\_MISSING | The "card\_cvv" is missing in the request. |
| UPI\_ID\_MISSING | The "upi\_id" is missing in the request |
| WALLET\_CHANNEL\_MISSING | The "channel" is missing in the wallet payment request |
| WALLET\_PHONE\_MISSING | The "phone number" is missing in the wallet payment request |
| NB\_BANK\_CODE\_MISSING | The "bank\_code" is missing in the request |
| WRONG\_CALLING\_CONTEXT | Calling context must be activity or fragment |
| NO\_UPI\_APP\_AVAILABLE | You don't have any UPI apps installed or ready for payment. |
| NO\_EMI\_PLAN\_AVAILABLE | This account does not have EMI plans configured, or the order amount is less than 2499 |
### Other Options
If you require to initialise the SDK yourself then follow the steps below. Make sure to initialise the SDK in Application class to avoid any Runtime issues.
`false`
```java java theme={null}
Executors.newSingleThreadExecutor().execute(() -> {
CFPaymentGatewayService.initialize(getApplicationContext());
});
```
```kotlin kotlin theme={null}
Executors.newSingleThreadExecutor().execute {
CFPaymentGatewayService.initialize(applicationContext)
}
```
To enable SDK logging add the following to your `values.xml` file.
`3`
Following are the Logging levels.
* VERBOSE = 2
* DEBUG = 3
* INFO = 4
* WARN = 5
* ERROR = 6
* ASSERT = 7
If you want to disable quick checkout flow in the payment journey you can add the following to your values.xml file.
`false`
Add the following to your values.xml file.
`false`