---
page_title: 7. Life Cycle Events
product: EC Headless
platform: Flutter
page_source: https://juspay.io/in/docs/ec-headless/flutter/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



#### Code Snippets: -

#### Flutter Code Snippet:

```flutter
onWillPop: () async {
      if (Platform.isAndroid) {
        var backpressResult = await widget.hyperSDK.onBackPress();

        if (backpressResult.toLowerCase() == "true") {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    }
```


---

## Complete Code Reference

The following code files are referenced in the steps above:

### payment_page.dart

```
{
  // Overriding onBackPressed to handle hardware backpress
  // block:start:onBackPressed

    onWillPop: () async {
      if (Platform.isAndroid) {
        var backpressResult = await widget.hyperSDK.onBackPress();

        if (backpressResult.toLowerCase() == "true") {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    }
    // block:end:onBackPressed


  // Calling process on hyperSDK to open the checkout screen
  // block:start:process-sdk

  await widget.hyperSDK.process(processPayload, hyperSDKCallbackHandler);
  // block:end:process-sdk
}

// Define handler for callbacks from hyperSDK
// block:start:callback-handler

void hyperSDKCallbackHandler(MethodCall methodCall) {
  switch (methodCall.method) {
    case "hide_loader":
      setState(() {
        showLoader = false;
      });
      break;
    case "process_result":
      var args = {};

      try {
        args = json.decode(methodCall.arguments);
      } catch (e) {
        print(e);
      }

      var error = args["error"] ?? false;

      var innerPayload = args["payload"] ?? {};

      var status = innerPayload["status"] ?? " ";
      var pi = innerPayload["paymentInstrument"] ?? " ";
      var pig = innerPayload["paymentInstrumentGroup"] ?? " ";

      if (!error) {
        switch (status) {
          case "charged":
            {
              // block:start:check-order-status
              // Successful Transaction
              // check order status via S2S API
              // block:end:check-order-status
              setState(() {
                paymentSuccess = true;
                paymentFailed = false;
              });
            }
            break;
          case "cod_initiated":
            {
              // User opted for cash on delivery option displayed on the checkout screen
            }
            break;
        }
      } else {
        var errorCode = args["errorCode"] ?? " ";
        var errorMessage = args["errorMessage"] ?? " ";
        switch (status) {
          case "backpressed":
            {
              // user back-pressed from PP without initiating any txn
              setState(() {
                paymentFailed = true;
                paymentSuccess = false;
              });
            }
            break;
          case "user_aborted":
            {
              // user initiated a txn and pressed back
              // check order status via S2S API
            }
            break;
          case "pending_vbv":
            {}
            break;
          case "authorizing":
            {
              // txn in pending state
              // check order status via S2S API
            }
            break;
          case "authorization_failed":
            {}
            break;
          case "authentication_failed":
            {}
            break;
          case "api_failure":
            {
              // txn failed
              // check order status via S2S API
            }
            break;
          case "new":
            {
              // order created but txn failed
              // check order status via S2S API
            }
            break;
        }
      }
  }
}
// block:end:callback-handler

```


---

## See Also

- [6. Handling Payment Response](https://juspay.io/in/docs/ec-headless/flutter/base-sdk-integration/handling-payment-response)
- [Get Customer API](https://juspay.io/in/docs/ec-headless/flutter/base-sdk-integration/getcustomer)