---
page_title: Life Cycle Events
product: UPI TPAP SDK
platform: Android
page_source: https://juspay.io/in/docs/upi-tpap-sdk/android/interaction-with-sdk/life-cycle-events
llms_txt: https://juspay.io/in/docs/llms.txt
product_llms_txt: https://juspay.io/in/docs/upi-tpap-sdk/llms.txt
---


## Life Cycle Events



UPI In-app SDK runs in a fragment. Hence, to handle certain events based upon activity life cycle, client will need to forward those events to the SDK.

These events are crucial for seamless functioning of features like OTP reading, App Switches (UPI Intent), Hardware backpress.

Following are the Life cycle events which SDK needs


###   onBackPressed


In order to handle hardware backpress done by user, you have to call `onBackPressed()` on HyperServices Instance in the onBackPressed function of your Checkout Activity.

onBackPressed function returns a boolean. When this return value is true hardware backpressed is consumed by Juspay SDK, if its false you need to handle backpress



#### Code Snippets: -

#### Java Code Snippet:

```java
@Override
  public void onBackPressed() {
      boolean handleBackpress = hyperServicesHolder.onBackPressed();
      if(!handleBackpress) {
          super.onBackPressed();
      }
  }
```

#### Kotlin Code Snippet:

```kotlin
override fun onBackPressed() {
        val handleBackpress: Boolean = hyperServicesHolder?.handleBackPress() == true
        if (handleBackpress) {
            super.onBackPressed()
        }
    }
```



###   onActivityResult


In order to handle results of App Switches in cases like UPI Intent transactions, you need to call `super.onActivityResult()` if available, if not you can make same function call on HyperServices Instance.

> **Note**
> This is a conditional step, and is only supposed to be implemented if you are **overriding** onActivityResult.





#### Code Snippets: -

#### Java Code Snippet:

```java
@Override
  public void onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

    // If super.onActivityResult is available use following:
    super.onActivityResult(requestCode, resultCode, data);

    // In case super.onActivityResult is NOT available please use following:
    if (data != null) {
        hyperServices.onActivityResult(requestCode, resultCode, data);
    }
  }
```

#### Kotlin Code Snippet:

```kotlin
// If super.onActivityResult is available use following:
        super.onActivityResult(requestCode, resultCode, data);

        // In case super.onActivityResult is NOT available please use following:
        if (data != null) {
            hyperServices.onActivityResult(requestCode, resultCode, data);
        }
```



###   onRequestPermissionsResult


In order to handle results of Permission Request results for cases like OTP Reading, you need to call `super.onRequestPermissionsResult()` in your onRequestPermissionsResult lifeCycle hook, if available, if not you can make same function call on HyperServices Instance.

> **Note**
> This is a conditional step, and is only supposed to be implemented if you are **overriding**  onRequestPermissionsResult





#### Code Snippets: -

#### Java Code Snippet:

```java
@Override
  public void onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {

      // If super.onRequestPermissionsResult is available use following:
      super.onRequestPermissionsResult(requestCode, permissions, grantResults);

      // In case super.onActivityResult is NOT available please use following:
      hyperServicesHolder.onRequestPermissionsResult(requestCode, permissions, grantResults);
  }
```

#### Kotlin Code Snippet:

```kotlin
//  If super.onRequestPermissionsResult is available use following:
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        // In case super.onActivityResult is NOT available please use following:
        hyperServices.onRequestPermissionsResult(requestCode, permissions, grantResults);
```


---

## Complete Code Reference

The following code files are referenced in the steps above:

### IntegrationReferenceActivity.java

```
package in.juspay.devtools;

import androidx.appcompat.app.AppCompatActivity;

import android.content.pm.ApplicationInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.WebView;
import android.widget.EditText;

import org.json.JSONException;
import org.json.JSONObject;

//HyperServices imports
import in.juspay.hypersdk.data.JuspayResponseHandler;
import in.juspay.hypersdk.ui.HyperPaymentsCallbackAdapter;
import in.juspay.hyperinteg.HyperServiceHolder;

public class IntegrationReferenceActivity extends AppCompatActivity {
	public Helpers helper;
	private JSONObject processData;
	private JSONObject initiateData;
	private JSONObject merchantData;
	private boolean hasProcessInQueue;
	private HyperServiceHolder hyperServicesHolder;

	/*******************Integration reference start*****************************/
	//HyperSDK instance used for all operation on the sdk.
	//code-copy-marker

    @Override
    protected void onStart() {
        super.onStart();
        //block:start:create-hyper-services-instance

        hyperServicesHolder = new HyperServiceHolder(this);

        //block:end:create-hyper-services-instance
        initiateUpiSDK();
        hyperServicesHolder.setCallback(createHyperPaymentsCallbackAdapter());
    }

    //block:start:initiate-sdk
    //This function initiate the Juspay SDK
    private void initiateUpiSDK() {
        if(!hyperServicesHolder.isInitialised()){
            initiatePayload = createInitiatePayload();
            hyperServicesHolder.initiate(initiatePayload);
        }
    }
    //block:end:initiate-sdk

    //block:start:create-initiate-payload
    // This function creates intiate payload.
    private JSONObject createInitiatePayload() {
        JSONObject sdkPayload = new JSONObject();
        JSONObject innerPayload = new JSONObject();
        JSONObject signaturePayload = new JSONObject();
        try {
            signaturePayload.put("merchant_id", "<MERCHANT_ID>");     // Put your Merchant ID here
            signaturePayload.put("customer_id", "<CUSTOMER_ID>");     // Put Customer ID here
            signaturePayload.put("timestamp", "<timestamp>");         // Time when request is created in milliseconds.
            // generating inner payload
            innerPayload.put("action", "initiate");
            innerPayload.put("merchantKeyId", "<MERCHANT_KEY_ID>");   // Put your Merchant ID here
            innerPayload.put("clientId", "CLIENT_ID");                // Put your Client ID here
            innerPayload.put("environment", "production");
            innerPayload.put("issuingPsp", "YES_BIZ");
            innerPayload.put("signature", "....");                    // Generated signature for signature payload
            String stringifiedSignaturePayload = signaturePayload.toString();
            innerPayload.put("signaturePayload", stringifiedSignaturePayload);

            // block:start:generatingRequestId
            sdkPayload.put("requestId",  ""+ UUID.randomUUID());
            // block:end:generatingRequestId
            sdkPayload.put("service", "in.juspay.hyperapi");
            sdkPayload.put("payload", innerPayload);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sdkPayload;
    }
  //block:end:create-initiate-payload

  //block:start:create-initiate-payload-clientAuthToken
    // This function creates intiate payload for ClientAuthToken Support
    private JSONObject createInitiatePayload() {
        JSONObject sdkPayload = new JSONObject();
        JSONObject innerPayload = new JSONObject();
        try {
            // generating inner payload
            innerPayload.put("action", "initiate");
            innerPayload.put("clientId", "CLIENT_ID");                // Put your Client ID here
            innerPayload.put("environment", "production");
            innerPayload.put("issuingPsp", "YES_BIZ");
            innerPayload.put("clientAuthToken", "token");

            // block:start:generatingRequestId
            sdkPayload.put("requestId",  ""+ UUID.randomUUID());
            // block:end:generatingRequestId
            sdkPayload.put("service", "in.juspay.hyperapi");
            sdkPayload.put("payload", innerPayload);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return sdkPayload;
    }
  //block:end:create-initiate-payload-clientAuthToken

  // block:start:create-hyper-callback
    private HyperPaymentsCallbackAdapter createHyperPaymentsCallbackAdapter() {
        return new HyperPaymentsCallbackAdapter() {
            @Override
            public void onEvent(JSONObject data, JuspayResponseHandler handler) {
                try {
                  // block:start:handle-sdk-response
                  String event = data.getString("event");
    
                  // block:start:show-loader
                  if (event.equals("show_loader")) {
                    // Show some loader here
                  }
                  // block:end:show-loader
    
                  // block:start:hide-loader
                  else if (event.equals("hide_loader")) {
                    // Hide Loader
                  }
                  // block:end:hide-loader
    
                  // block:start:initiate-result
                  else if (event.equals("initiate_result")) {
                    // Get the response
                    JSONObject response = data.optJSONObject("payload");
                  }
                  // block:end:initiate-result
    
                  // block:start:process-result
                  else if (event.equals("process_result")) {
                    // Get the response
                    JSONObject response = data.optJSONObject("payload");
                    //Merchant handling
                  }
                  // block:end:process-result
    
                  // block:start:log-stream
                  else if (event.equals("log_stream")){
                    Log.i("=>Clickstream", data.toString());
                  }
                  // block:end:log-stream
    
                  // block:start:session-expiry
                  else if (event.equals("session_expired")){
                    // Handle Session Expiry
                  }
                  // block:end:session-expiry
    
                } catch (Exception e) {
                  // merchant code...
                }
                // block:end:handle-sdk-response
            }
        };
    }
    // block:end:create-hyper-callback

  public void callProcess() {
    // block:start:process-sdk

    JSONObject processPayload = new JSONObject();
    JSONObject innerPayload = new JSONObject();

    try {
        // generating inner payload
        innerPayload.put("action", "upiCheckPermission");

        processPayload.put("requestId",  ""+ UUID.randomUUID());
        processPayload.put("service", "in.juspay.hyperapi");
        processPayload.put("payload", innerPayload);

    } catch (Exception e) {
        e.printStackTrace();
    }

    if (hyperServicesHolder.isInitialised()) {
      hyperServicesHolder.process(processPayload);
    }
    // block:end:process-sdk
  
  }  
  // block:start:terminate
  public void callTerminate() {
    hyperServicesHolder.terminate();
  }
  // block:start:terminate

  //block:start:onBackPressed
  @Override
  public void onBackPressed() {
      boolean handleBackpress = hyperServicesHolder.onBackPressed();
      if(!handleBackpress) {
          super.onBackPressed();
      }
  }
  //block:end:onBackPressed

  // block:start:onActivityResult
  @Override
  public void onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

    // If super.onActivityResult is available use following:
    super.onActivityResult(requestCode, resultCode, data);

    // In case super.onActivityResult is NOT available please use following:
    if (data != null) {
        hyperServices.onActivityResult(requestCode, resultCode, data);
    }
  }

  // block:end:onActivityResult

  //block:start:onRequestPermissionsResult
  @Override
  public void onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {

      // If super.onRequestPermissionsResult is available use following:
      super.onRequestPermissionsResult(requestCode, permissions, grantResults);

      // In case super.onActivityResult is NOT available please use following:
      hyperServicesHolder.onRequestPermissionsResult(requestCode, permissions, grantResults);
  }
  //block:end:onRequestPermissionsResult
}
```

### IntegrationReferenceActivity.kt

```
package `in`.juspay.devtools

import `in`.juspay.hypersdk.data.JuspayResponseHandler;
import `in`.juspay.hypersdk.ui.HyperPaymentsCallbackAdapter;
import `in`.juspay.hyperinteg.HyperServiceHolder;
import android.content.Intent
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.coordinatorlayout.widget.CoordinatorLayout
import com.google.android.material.snackbar.Snackbar
import org.json.JSONObject
import java.util.*

class IntegrationReferenceActivity : AppCompatActivity() {

    var hyperServicesHolder: HyperServiceHolder? = null
    var initiatePayload: JSONObject? = null

    override fun onStart() {
        super.onStart()
        //block:start:create-hyper-services-instance

        hyperServicesHolder = HyperServiceHolder(this)

        //block:end:create-hyper-services-instance

        initiatePaymentsSDK()
        hyperServicesHolder!!.setCallback(createHyperPaymentsCallbackAdapter())
    }
    //block:start:create-initiate-payload
    private fun createInitiatePayload(): JSONObject {
        val sdkPayload = JSONObject()
        val innerPayload = JSONObject()
        try {
            // generating inner payload
            innerPayload.put("action", "initiate")
            innerPayload.put("merchantKeyId", "<MERCHANT_KEY_ID>")   // Put your Merchant ID here
            innerPayload.put("clientId", "CLIENT_ID")                // Put your Client ID here
            innerPayload.put("environment", "production")
            innerPayload.put("issuingPsp", "YES_BIZ")
            innerPayload.put("signature", "....")                    // Generated signature for signature payload
            innerPayload.put("signaturePayload", signaturePayload)

            // block:start:generatingRequestId
            sdkPayload.put("requestId",  ""+ UUID.randomUUID())
            // block:end:generatingRequestId
            sdkPayload.put("service", "in.juspay.hyperapi")
            sdkPayload.put("payload", innerPayload)

            signaturePayload.put("merchant_id", "<MERCHANT_ID>")     // Put your Merchant ID here
            signaturePayload.put("customer_id", "<CUSTOMER_ID>")     // Put Customer ID here
            signaturePayload.put("timestamp", "<timestamp>")         // Time when request is created in milliseconds.
        } catch (e: Exception) {
            e.printStackTrace()
        }
        return sdkPayload
    }
    //block:end:create-initiate-payload


    //block:start:create-initiate-payload-clientAuthToken
    private fun createInitiatePayload(): JSONObject {
        val sdkPayload = JSONObject()
        val innerPayload = JSONObject()
        try {
            // generating inner payload
            innerPayload.put("action", "initiate")
            innerPayload.put("clientId", "CLIENT_ID")                // Put your Client ID here
            innerPayload.put("environment", "production")
            innerPayload.put("issuingPsp", "YES_BIZ")
            innerPayload.put("clientAuthToken", "token")                 

            // block:start:generatingRequestId
            sdkPayload.put("requestId",  ""+ UUID.randomUUID())
            // block:end:generatingRequestId
            sdkPayload.put("service", "in.juspay.hyperapi")
            sdkPayload.put("payload", innerPayload)

        } catch (e: Exception) {
            e.printStackTrace()
        }
        return sdkPayload
    }
    //block:end:create-initiate-payload-clientAuthToken


    //block:start:initiate-sdk
    private fun initiatePaymentsSDK() {
        if (!hyperServicesHolder!!.isInitiated) {
            initiatePayload = createInitiatePayload()
            hyperServicesHolder!!.initiate(createInitiatePayload())
        }
    }
    //block:end:initiate-sdk

    //block:start:create-hyper-callback
    private fun createHyperPaymentsCallbackAdapter(): HyperPaymentsCallbackAdapter {
        return object : HyperPaymentsCallbackAdapter() {
            override fun onEvent(jsonObject: JSONObject, responseHandler: JuspayResponseHandler?) {
                try {
                  // block:start:handle-sdk-response
                    val event = jsonObject.getString("event")

                    // block:start:hide-loader
                    if (event == "hide_loader") {
                        // Hide Loader
                    }
                    // block:end:hide-loader

                    // block:start:show-loader
                    else if (event == "show_loader") {
                        // Show some loader
                    }
                    // block:end:show-loader

                    // block:start:initiate-result
                    else if (event == "initiate_result") {
                        val innerPayload = jsonObject.optJSONObject("payload")
                    }
                    // block:end:initiate-result

                    // block:start:process-result
                    else if (event == "process_result") {
                        val innerPayload = jsonObject.optJSONObject("payload")
                    }
                    // block:end:process-result

                    // block:start:log-stream
                    else if (event == "log_stream") {
                        val innerPayload = jsonObject.optJSONObject("payload")
                    }
                    // block:end:log-stream

                    // block:start:session-expiry
                    else if (event == "session_expired") {
                        // Handle Session Expiry
                    }
                    // block:end:session-expiry

                } catch (e: Exception) {
                    // merchant code...
                }
                // block:end:handle-sdk-response
            }
        }
    }
    //block:end:create-hyper-callback

    // block:start:process-sdk
    fun callProcess(sdk_payload: JSONObject?) {
        val sdkPayload = JSONObject()
        val innerPayload = JSONObject()
        try {
            // generating inner payload
            innerPayload.put("action", "upiCheckPermission")

            sdkPayload.put("requestId",  ""+ UUID.randomUUID())
            sdkPayload.put("service", "in.juspay.hyperapi")
            sdkPayload.put("payload", innerPayload)

        } catch (e: Exception) {
            e.printStackTrace()
        }
        if(hyperServicesHolder!!.isInitiated)
        hyperServicesHolder?.process(sdk_payload)
    }
    // block:end:process-sdk

  // block:start:terminate
  fun callTerminate() {
    hyperServicesHolder?.terminate()
  }
  // block:start:terminate

  //block:start:onBackPressed
    override fun onBackPressed() {
        val handleBackpress: Boolean = hyperServicesHolder?.handleBackPress() == true
        if (handleBackpress) {
            super.onBackPressed()
        }
    }
   //block:end:onBackPressed

    @Override
    public void onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        // block:start:onActivityResult

        // If super.onActivityResult is available use following:
        super.onActivityResult(requestCode, resultCode, data);

        // In case super.onActivityResult is NOT available please use following:
        if (data != null) {
            hyperServices.onActivityResult(requestCode, resultCode, data);
        }

        // block:end:onActivityResult

        // Rest of your code.
    }

    @Override
    public void onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        // block:start:onRequestPermissionsResult

        //  If super.onRequestPermissionsResult is available use following:
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        // In case super.onActivityResult is NOT available please use following:
        hyperServices.onRequestPermissionsResult(requestCode, permissions, grantResults);

        // block:end:onRequestPermissionsResult
    }

}
```


---

## See Also

- [Handle SDK Response](https://juspay.io/in/docs/upi-tpap-sdk/android/interaction-with-sdk/handle-sdk-response)
- [Intent Handling](https://juspay.io/in/docs/upi-tpap-sdk/android/interaction-with-sdk/intent-handling)