Integrate Turbo UPI Headless

Integration Steps

Follow these steps:

1. Initialise the SDK and set up the Checkout instance (Razorpay) to handle payment outcomes like success and errors by listening to delegate methods.

   SwiftObjective C

   copy

   var razorpay = RazorpayCheckout.initWithKey("rzp_test_0wFRWIZnH65uny", 
                               andDelegate: self, 
                               withPaymentWebView: wkWebView,
                               plugin: RazorpayTurboUPI.pluginInstance())

2. You need to link the customer’s UPI account with your app. Use the code samples given below to fetch the UPI account.

   Watch Out!

   If the device binding is not completed and getLinkedUpiAccounts is triggered, it will return an OnError with a DEVICE_BINDING_INCOMPLETE error message.

   • Get the customer's linked UpiAccount list using the below code. This function can be called from anywhere in the application, providing multiple entry points for customers to link their UPI account with your app.

     SwiftObjective C

     copy

     razorpay?.upiTurbo?.getLinkedUpiAccounts("<mobile_num>", resultDelegate: self)

     Request Parameters

     mobile_num

     string The customer's mobile number.

     Delegate

     object The Delegate to be sent is of type UpiTurboResultDelegate.

   • If your customer has already linked the UPI account, use the following code to fetch it. If there are no linked UPI accounts, an empty list is returned.

     SwiftObjective C

     copy

     extension ViewController: UPITurboResultDelegate {
     func onSuccessFetchingLinkedAcc(_ accList: [UpiAccount]) {
         if accList.count > 0 {
             print("Success Fetching Accounts")
         } else {
             // call linkNewUpiAccount()
         }
     }
     
     func onErrorFetchingLinkedAcc(_ error: TurboUpiPlugin.TurboError?) {
         print("Error: \(error?.errorDescription)")
         print("Error code: \(error?.errorCode)")
     }
     }

   Response Parameters

   onSuccess

   This function is triggered if the list is fetched successfully. accList can be empty to indicate that no accounts have been linked yet.

   onError

   This function is triggered in case an error is thrown during the retrieval process, either by the Razorpay SDK or the Bank SDK.

3. If the customer has not linked any UPI account, use the following code to link the newly created UPI account with your app. This function can be called from anywhere in the application, providing multiple entry points for customers to link their UPI account with your app.

   SwiftObjective C

   copy

   self.razorpay?.upiTurbo?.linkNewUpiAccount("<mobile_num>", linkActionDelegate: self)

   Request Parameters

   mobileNumber

   mandatory

   string Customer's mobile number needed to initialise the SDKs.

   linkActionDelegate

   UpiTurboLinkAccountDelegate Used as a callback to send a response or failure to you. Given below are the functions:

   • action.code: This function denotes that the user registration is incomplete and additional action is required.
   • action.data: This function denotes that the user has registered UpiAccounts on the device. It returns a list of UpiAccount objects, which can then be used to show the details on UI.
   • action.error: Returns an error object with a description and message relating to a failure in either one of the registration steps or in retrieving the UpiAccount list.

   • Link the customer's new UPI account using the below code:

     SwiftObjective C

     copy

     extension ViewController: UpiTurboLinkAccountDelegate {
      func onResponse(_ action: LinkUpiAction) {
         switch action.code {
         case .sendSms:
             guard action.error == nil else {
                 return
             }
             action.registerDevice()
         case .selectBank:
             guard action.error == nil else {
                 return
             }
             if let banks = action.data as? [UpiBank] {
             let selectedBank = banks[0]
             action.selectedBank(selectedBank)
             }
         case .selectBankAccount:
             guard action.error == nil else {
                 return
             }
             if let bankAccounts = action.data as? [UpiBankAccount] {
                 let bankAccount = bankAccounts[0]
                 action.selectedBankAccount(bankAccount)
             }
         case .setUpiPin:
             let card = UpiCard("last6Digits", "expiry", "cvv")
             action.setUpiPin(bankAccount, card)
         case .linkAccountResponse:
             guard action.error == nil else {
                 return
             }
             if let banks = action.data as? [UpiAccount] {
                 //save the upi account response
             }
         default: break
         }
      }
     }

     action

     The current state of customer registration with which you can call further functions. All values for this variable are exposed as an enum for ease of integration. Know more about the

     action parameters

     .

4. To accept payments, call Custom Checkout’s authorize method with the following payload:

   SwiftObjective C

   copy

   let payload: [String: AnyHashable] = [
       "currency": "INR",
       "amount": "700",
       "email": "gaurav.kumar@example.com",
       "contact": "9999999999",
       "method": "upi",
       "upi": [
           "flow": "in_app"
       ],
       "order_id": "order_L2MUBUOeFItcpU",  //optional
   ]
   var turboPayload: [String: Any] = [:]
   turboPayload["upiAccount"] = upiAccount
   turboPayload["payload"] = payload
   
   razorpay?.authorize(turboPayload)

Non-Transactional Flows

You can directly interact with the exposed methods of the Turbo Framework to perform the non-transactional flows listed below.

razorpay?.upiTurbo?.fetchAccountBalance(upiAccount: upiAccount) { (accountBalance, error) in
    if error == nil {
        //error
    } else if let accountBalance = accountBalance {
        //success
        print(accountBalance.balance)
    }
}

razorpay?.upiTurbo?.changeUpiPin(upiAccount: upiAccount) { (bankAccount, error) in
    if error == nil {
        //error
    } else if let account = bankAccount {
        //success
        print(“UPI Pin Updated”)
    }
}

razorpay?.upiTurbo?.resetUpiPin(upiAccount: upiAccount, card: cardObj) { (bankAcount, error) in
    if error == nil {
        //error
    } else if let account = bankAccount {
        //success
    }
}

razorpay?.upiTurbo?.delink(upiAccount: upiAccount) { (isSuccess, error) in
    if let error = error {
        //error
    } else if isSuccess == true {
        //success
    }
}

Additional Features

To get the device binding status, please use the variable razorpay.upiTurbo.deviceBindingDone of type boolean. It indicates whether the device binding, which is a prerequisite for adding UPI accounts, is done with the user's mobile number.

if self.razorpay?.upiTurbo?.deviceBindingDone {
    // Device Binded       
} else {
    // Call Link New Account for Device Binding
}

Models Exposed from the SDKs

The SDKs given below provide access to exposed models for seamless integration.

2. Test Integration

We recommend the following:

• Complete the integration on UAT before using the prod builds.
• Perform the UAT using the Razorpay-provided API keys.

3. Go-live Checklist

Complete these steps to take your integration live:

• You should get your app id whitelisted by Razorpay to test on prod.

  Handy Tips

  Contact our

  integrations team

  to get your mobile number and app whitelisted.

• Import the prod library from the Github repository → https://github.com/upi-turbo/ios-sample-app custom_ui/turbo branch.

• Switch to Prod environment and podfile.

• Replace the UAT credential with the

  Razorpay live keys

  for prod testing.