--- page_title: 7. Life Cycle Events product: EC Headless platform: Android page_source: https://juspay.io/in/docs/ec-headless/android/base-sdk-integration/life-cycle-events llms_txt: https://juspay.io/in/docs/llms.txt product_llms_txt: https://juspay.io/in/docs/ec-headless/llms.txt --- ## 7. Life Cycle Events Express Checkout SDK runs in a fragment. Hence, to handle certain events based upon activity life cycle, client will need to forward those events to Express Checkout 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 ### Step 7.1. 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 **[Note:]** For native android integration, if your activity is not overriding onBackPressed(), our SDK takes care of hardware backpress for **SDK version 2.1.25** and above.`onBackPressed()` hence need not be implemented for SDK version 2.1.25 and above. For other plugins (REACT, Flutter, etc.), `onBackPressed()`has to be implemented. #### Code Snippets: - #### Java Code Snippet: ```java @Override public void onBackPressed() { boolean handleBackpress = hyperServicesHolder.onBackPressed(); if(!handleBackpress) { super.onBackPressed(); } } ``` ### Step 7.2. (Conditional) 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 // 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); // } ``` ### Step 7.3. (Conditional) 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 // 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: ### CheckoutActivity.java ``` { //block:start:process-sdk-call if (hyperInstance.isInitialised()){ hyperInstance.process(processPayload); } //block:end:process-sdk-call // block:start:create-hyper-callback private HyperPaymentsCallbackAdapter createHyperPaymentsCallbackAdapter() { return new HyperPaymentsCallbackAdapter() { @Override public void onEvent(JSONObject jsonObject, JuspayResponseHandler responseHandler) { Intent redirect = new Intent(CheckoutActivity.this, ResponsePage.class); redirect.putExtra("responsePayload", jsonObject.toString()); System.out.println(jsonObject); try { String event = jsonObject.getString("event"); if (event.equals("hide_loader")) { // Hide Loader dialog.hide(); } else if (event.equals("initiate_result")) { boolean error = jsonObject.optBoolean("error"); JSONObject innerPayload = jsonObject.optJSONObject("payload"); String status = innerPayload.optString("status"); if (status.equals("success")) { // Initiate was successful, handle accordingly (call Process) } else { // Initiate failed, handle accordingly (call initiate() again) } } // Handle Process Result // This case will reach once the Hypercheckout screen closes // block:start:handle-process-result else if (event.equals("process_result")) { boolean error = jsonObject.optBoolean("error"); JSONObject innerPayload = jsonObject.optJSONObject("payload"); String status = innerPayload.optString("status"); if (!error) { switch (status) { case "charged": // Successful Transaction // check order status via S2S API redirect.putExtra("status", "OrderSuccess"); startActivity(redirect); break; case "cod_initiated": redirect.putExtra("status", "CODInitiated"); startActivity(redirect); break; } } else { switch (status) { case "backpressed": // user back-pressed from PP without initiating transaction break; case "user_aborted": // user initiated a txn and pressed back // check order status via S2S API Intent successIntent = new Intent(CheckoutActivity.this, ResponsePage.class); redirect.putExtra("status", "UserAborted"); startActivity(redirect); break; case "pending_vbv": redirect.putExtra("status", "PendingVBV"); startActivity(redirect); break; case "authorizing": // txn in pending state // check order status via S2S API redirect.putExtra("status", "Authorizing"); startActivity(redirect); break; case "authorization_failed": redirect.putExtra("status", "AuthorizationFailed"); startActivity(redirect); break; case "authentication_failed": redirect.putExtra("status", "AuthenticationFailed"); startActivity(redirect); break; case "api_failure": redirect.putExtra("status", "APIFailure"); startActivity(redirect); break; // txn failed // check order status via S2S API } } } // block:end:handle-process-result } catch (Exception e) { // merchant code... } } }; } // block:end:create-hyper-callback //block:start:onBackPressed @Override public void onBackPressed() { boolean handleBackpress = hyperServicesHolder.onBackPressed(); if(!handleBackpress) { super.onBackPressed(); } } //block:end:onBackPressed /* Optional Block These functions are only supposed to be implemented in case if you are overriding onActivityResult or onRequestPermissionsResult Life cycle hooks - onActivityResult - Handling onActivityResult hook and passing data to HyperServices Instance, to handle App Switch @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. } - onRequestPermissionsResult - Handling onRequestPermissionsResult hook and passing data to HyperServices Instance, to OTP reading permissions @Override public void onRequestPermissionsResult(requestCode: Int, permissions: Array, 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 - [6. Handling Payment Response](https://juspay.io/in/docs/ec-headless/android/base-sdk-integration/handling-payment-response) - [Get Customer API](https://juspay.io/in/docs/ec-headless/android/base-sdk-integration/getcustomer)