Deprecated Integration Methods

Xamarin Integration

Xamarin SDK has been deprecated and will no longer be updated.

Prerequisites:

• You have set up your Judopay account.

  • Sign up for your sandbox account, to receive access to your Judopay dashboard and the sandbox environment.

• Your judoIds and tokens are configured and enabled as appropriate.

  • For more information on permissions, see Permissions.

• You have the latest version of the Android SDK. For more details, see Integrating Android with Judopay.

• You have the latest version of the iOS SDK. For more details, see Integrating iOS with Judopay.

For Mobile apps, we recommend using payment session authentication.

Integration Requirements:

• Xamarin Studio 6.1 / Visual Studio 2015

• Xamarin Forms 2.3.2.127

• Xcode 8

• Android 7.0 (API 24) SDK and build tools 24.0.3 installed

• The SDK is compatible with Android Jelly Bean (4.1) and above and iOS 8 and above.

Integrate Judopay into your project by visiting the Xamarin component store:

1. Search for Judopay

2. Add the component to your Android and iOS projects

Setting up Xamarin

1. Ensure all integration steps are completed.

2. Add your app’s sandbox token and secret to your Judo instance in your Xamarin Forms page:

var judo = new Judo
{
    JudoId = "<JUDO_ID>",
    Token = "<API_TOKEN>",
    Secret = "<API_SECRET>",
    Environment = JudoEnvironment.Sandbox,
    Amount = 1.50m,
    Currency = "GBP",
    ConsumerReference = "YourUniqueReference"
};

3. Add additional configuration depending on the project you are integrating, as follows:

Android

Due to a bug in Xamarin.Forms the page does not resize correctly when the keyboard is visible.

An additional piece of code must be added to your Android Activity:

1. Add the code snippet after the Xamarin.Forms.Forms.Init method call inside the OnCreate method of your Activity:

Window.SetSoftInputMode(SoftInput.AdjustResize);
AndroidBugfix5497.assistActivity(this);

iOS

Xamarin.Forms has issues resolving dependencies using DependencyService unless they have been registered.

1. Add the following in your AppDelegate.cs after the LoadApplication(new App()) method call in your FinishedLaunching method:

DependencyService.Register<ClientService>();
DependencyService.Register<HttpClientHelper>();
// Required if using Apple Pay
DependencyService.Register<ApplePayService>();

Going Live with Xamarin

You will need to have tested your app in the sandbox environment before going live.

Point to the Live Environment

1. Within your app’s Xamarin Forms page change the line specifying the targeted environment from SANDBOX to LIVE:

   Environment = JudoEnvironment.Live,

2. Replace your sandbox API Token and Secret for the live API Token and Secret 

   ApiToken = "<API_TOKEN>",
   
   ApiSecret = "<API_SECRET>",

Find these in JudopayPortal > Your apps > {app name} > Live Tokens

Use the live environment for testing before deploying your app.

PayByBankApp

PayByBankApp payment method is no longer supported and will no longer be updated.

PayByBankApp is a new, easy and secure alternative payment method, that enables your consumers to pay online quickly and securely via their trusted mobile Bank app.

PayByBankApp facilitates the enablement of consumers using bank transfers to easily pay for goods and services online.

Without the need to enter card details or additional passwords every time a purchase is made, it is designed to simplify the checkout experience, giving consumers more control and visibility of their finances when making a purchase.

Add the PayByBankApp button easily using the Mobile Payments Widget within Judopay’s mobile SDK.

Consumer Journey on a Merchant's Mobile App

The consumer's journey on a mobile app, when selecting the PayByBankApp button:

Features of PayByBankApp

Features of PayByBankApp:

• Strong authentication.

• PSD2 Compliant - Meeting the Strong Customer Authentication (SCA) Requirements.

• Increased Consumer Trust - Existing bank brands are known to the consumer.

• Works through the consumer’s existing Bank app.

• Merchant Liability Shifted to the Issuer:

  • All transactions are authenticated via the consumers Bank app, so all liability is shifted away from the merchant to the issuing bank.

  • Everything is tokenised:

  • The merchant, Judopay and the distributor does not have any bank details of the consumer.

Benefits of PayByBankApp to your Consumers

Your consumers:

• Can check their balances in real time.

• Choose which account to pay from.

• No need to enter card details, or any additional passwords.

• Can see money move from their account in seconds.

• Stay secure with payment authorisation taking place in their Bank app.

• Consumers will be auto-enrolled when their online Bank app is installed.

If a consumer uses PayByBankApp with more than one Bank app on their phone, they will get the choice of which Bank app to open at the point of purchase, with the choice of setting their default option.

Once the consumer clicks the PayByBankApp button, they will be taken to their Bank app to complete the payment.

Certified Browsers and Devices

Browsers

Zapp has certified the Web Merchant Button library to work with the following browsers: 

Devices and OS Versions

Zapp has certified the Web Merchant Button library to work with the following mobile devices and operating systems:

Landscape orientation is not supported for Web on mobile browsers.

Integrating PayByBankApp - Android

PayByBankApp payment method is no longer supported and will no longer be updated.

Integrating PayByBankApp for Android

To add the PayByBankApp button

1. Insert the button in the layout file:

<com.judopay.judokit.android.ui.common.PayByBankButton        
android:id="@+id/payByBankButton"       
android:layout_width="wrap_content"        
android:layout_height="wrap_content" />

2. Set OnClickListener to the PayByBankApp button

   The JudoActivity will start and pass the result to merchant:

payByBankButton.setOnClickListener {           
    val intent = Intent(this, JudoActivity::class.java)            
    intent.putExtra(JUDO_OPTIONS, judo)            
    startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)      
 }

3. Enable the PayByBankApp in the Payment Selector Screen:

   • Build the Judo configuration object:

     • Set the payment widget type to:

       • PaymentWidgetType.PAYMENT_METHODS

     • Set the currency:

       • GBP

val amount = Amount.Builder()
            .setAmount("1")
            .setCurrency(Currency.GBP)
            .build()
            
Judo.Builder(PaymentWidgetType.PAYMENT_METHODS)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Start JudoActivity with the JudoConfiguration object:

val intent = Intent(this, JudoActivity::class.java)           
    intent.putExtra(JUDO_OPTIONS, judo)           
    startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)

For the PayByBankApp button to appear in the Payments Widget, a banking app must already be installed.

The PayByBankApp Button is displayed:

To display the PayByBankApp as a Payment Method for Android:

1. Add the intent-filter to the AndroidManifest.xml file.

   This registers the deep link URL:

<activity
  android:name=".MainActivity"
  android:launchMode="singleTask">
  <intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

        <data
           android:scheme="your"
           android:host="scheme" />
  </intent-filter>
</activity>

2. Create the Judo  object:

   • Set PaymentWidgetType to:

     • PAY_BY_BANK_APP, or

     • PAYMENT_METHODS

       If using the payments widget.

   • Set currency:

     • GBP

3. Create the PBBAConfiguration object:

   • Set deepLinkScheme to the defined scheme in the AndroidManifest.xml file:

 val pbbaConfiguration = PBBAConfiguration.Builder()
        .setDeepLinkScheme("your://scheme")
        .build()
Judo.Builder(PaymentWidgetType.PAY_BY_BANK_APP)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Override the onNewIntent method to catch the deeplink URL

   • Add the deepLinkURL to the PBBAConfiguration object

   • Start JudoActivity with the desired payment widget type

   • Add the same logic in onCreate

 override fun onNewIntent(intent: Intent?) {
        checkForDeepLink(intent)
        super.onNewIntent(intent)
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        checkForDeepLink()
        ...
    }
    
    private fun checkForDeepLink(intent: Intent? = this.intent) {
        val uri = intent?.data
        val newIntent = Intent(this, JudoActivity::class.java)
        if (uri.contains("your://scheme")) {  
            val newPbbaConfig = pbbaConfiguration.newBuilder()
                .setDeepLinkURL(uri)
                .build()
            val judo = getJudo(PaymentWidgetType.PAY_BY_BANK_APP).newBuilder()
                .setPBBAConfiguration(newPbbaConfig)
                .build()
            newIntent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(newIntent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
        }
    }
    
    private fun getJudo(widgetType: PaymentWidgetType): Judo {
        return Judo.Builder(widgetType)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

5. To catch the first response, create a broadcastReceiver:

private val broadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
    val result = intent?.getParcelableExtra<JudoResult>(PBBA_RESULT)
        // Handle result
    }
}

6. Register the defined receiver in onCreate:

LocalBroadcastManager.getInstance(this).registerReceiver(
    orderIdReceiver,
    IntentFilter(BR_PBBA_RESULT)
)

7. Catch the result in the onActivityResult method:

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
   super.onActivityResult(requestCode, resultCode, data)

     if (requestCode == JUDO_PAYMENT_WIDGET_REQUEST_CODE) {
       when (resultCode) {
         PAYMENT_SUCCESS -> {
         val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
             //Process successful payment
              }
         PAYMENT_CANCELLED -> {
         val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
            //Process cancelled payment
              } 
         PAYMENT_ERROR -> {
         val error = data?.getParcelableExtra<JudoError>(JUDO_ERROR)
            //Process unsuccessful payment
              }    
          }
      }
}

Integrating PayByBankApp Directly to your App for Android

Not using the Mobile SDK Payments Widget?

To Integrate directly to your app:

1. Insert the button in the layout file:

<com.judokit.android.ui.common.PayByBankButton
  android:id="@+id/payByBankButton"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content" 
  />

2. Add intent-filter to the AndroidManifest.xml file.

   This will register the deep link URL:

activity
 android:name=".MainActivity"
 android:launchMode="singleTask">
 <intent-filter>
 <action android:name="android.intent.action.VIEW" />

 <category android:name="android.intent.category.DEFAULT" />
 <category android:name="android.intent.category.BROWSABLE" />

 <data
   android:scheme="your"
   android:host="scheme" />
 </intent-filter>
 </activity>

3. Create the Judo object:

   • Set the PaymentWidgetType to PAY_BY_BANK_APP

   • Create the PBBAConfiguration object

   • Set deepLinkScheme to the defined scheme in the AndroidManifest.xml file:

 val pbbaConfiguration = PBBAConfiguration.Builder()
        .setDeepLinkScheme("your://scheme")
        .build()
Judo.Builder(PaymentWidgetType.PAY_BY_BANK_APP)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Override the onNewIntent method to catch the deeplink URL:

   • Add the deepLinkURL to the PBBAConfiguration object

   • Start JudoActivity with the desired payment widget type

   • Add the same logic in onCreate

 override fun onNewIntent(intent: Intent?) {
        checkForDeepLink(intent)
        super.onNewIntent(intent)
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        checkForDeepLink()
        ...
    }
    
    private fun checkForDeepLink(intent: Intent? = this.intent) {
        val uri = intent?.data
        val newIntent = Intent(this, JudoActivity::class.java)
        if (uri.contains("your://scheme")) {  
            val newPbbaConfig = pbbaConfiguration.newBuilder()
                .setDeepLinkURL(uri)
                .build()
            val judo = getJudo(PaymentWidgetType.PAY_BY_BANK_APP).newBuilder()
                .setPBBAConfiguration(newPbbaConfig)
                .build()
            newIntent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(newIntent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
        }
    }
    
    private fun getJudo(widgetType: PaymentWidgetType): Judo {
        return Judo.Builder(widgetType)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

5. To catch the first response, create a broadcastReceiver:

private val broadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
    val result = intent?.getParcelableExtra<JudoResult>(PBBA_RESULT)
        // Handle result
    }
}

6. Register the defined receiver in onCreate:

LocalBroadcastManager.getInstance(this).registerReceiver(
    orderIdReceiver,
    IntentFilter(BR_PBBA_RESULT)
)

7. Set OnClickListener to the previously defined PayByBankApp button

   JudoActivity will start and pass the result to merchant:
   

payByBankButton.setOnClickListener {
  val intent = Intent(this, JudoActivity::class.java)
  intent.putExtra(JUDO_OPTIONS, judo)
  startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
 }

8. Catch the result in the onActivityResult method:

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)

    if (requestCode == JUDO_PAYMENT_WIDGET_REQUEST_CODE) {
       when (resultCode) {
       PAYMENT_SUCCESS -> {
       val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
           //Process successful payment
             }
       PAYMENT_CANCELLED -> {
       val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
           //Process cancelled payment
             } 
       PAYMENT_ERROR -> {
       val error = data?.getParcelableExtra<JudoError>(JUDO_ERROR)
           //Process unsuccessful payment
                }    
            }
        }
    }

Integrating PayByBankApp - iOS

PayByBankApp payment method is no longer supported and will no longer be updated.

Integrating PayByBankApp using the Payments Widget for iOS

Displaying PayByBankApp as a Payment Method for iOS

To display the PayByBankApp as a Payment Method for iOS:

1. In the info.plist of app and LSApplicationQueriesSchemes add the URL scheme of the merchant(CFBundleURLSchemes)::

<key>CFBundleURLTypes</key>
    <array>
        <dict>
            <key>CFBundleTypeRole</key>
            <string>Editor</string>
            <key>CFBundleURLSchemes</key>
            <array>
                <string>judo</string>
            </array>
        </dict>
    </array>
    <key>LSApplicationQueriesSchemes</key>
    <array>
        <string>zapp</string>
    </array>

3. Add deeplink to the pbbaConfiguration object:

  self.pbbaConfig = [JPPBBAConfiguration new];
  self.pbbaConfig.deeplinkScheme = @"judo://pay";

4. To enable the PayByBankApp set the following options:

   1. Add the pbba method to:

      The paymentMethods  array in JPConfiguration

   2. Set currency:

      GBP

Integrating PayByBankApp Directly to your App for iOS

Not using the Mobile SDK Payments Widget?

To Integrate directly to your app:

Prerequisites

• "Bank3 Test App" - Contact: developersupport@judopayments.com to get access, so you can test the PayByBankApp flow.

• You have set your app's URL Scheme.

• You have added zapp to the ApplicationQueriesSchemes:

An example of the Info.plist file:

Step 1: Initialising the SDK

To integrate with the Judopay SDK directly to your iOS app, you can use either a:

• basic authorization

  This uses a token and secret

• session authorization

  This uses a token and paymentSession

You can select the sandbox mode for testing purposes.
Set the value:isSandboxed = true

let authorization: JPAuthorization = JPBasicAuthorization(token: JUDO_TOKEN,
  andSecret: JUDO_SECRET)
        judoKit = JudoKit(authorization: authorization)
        judoKit.isSandboxed = true

Step 2: Check for Installed Bank Apps

To ensure a good customer experience, it is recommended to only display the PayByBankApp button when the consumer has a compatible mobile Banking app.

Before adding the PayByBankApp button in Step 3, check if any compatible PayByBankApp Bank apps are installed, using the JudoKit isBankingAppAvailable  method:

if (JudoKit.isBankingAppAvailable()) {
    // Add the PBBA button
}

Step 3: Adding the PayByBankApp Button

We recommend you use the branded button to invoke a PayByBankApp transaction, however it is not mandatory.

The PayByBankApp Button uses the delegate property.

The delegate property points to any class that implements the JPPBBAButtonDelegate interface:

let pbbaButton = JPPBBAButton(frame: container.bounds);
    pbbaButton.delegate = self
        view.addSubview(pbbaButton)

The JPBBAButton is a subclass of UIView, not UIButton.
Take this into consideration when integrating the PayByBankApp button via the Interface Builder.

The JPPBBAButtonDelegate interface has only one method: pbbaButtonDidPress(sender:), which is responsible for handling the button tap action.

Recommended PayByBankApp Button Size:

• Minimum: Width 160pt | Height 40pt

• Maximum: Width 310pt | Height 48pt

Step 4: Adding the Delegate Method

The delegate method is responsible for the button tap action.

To add the delegate method:

1. Call the invokePBBA method in the Judopay SDK and provide the required configuration parameters:

func pbbaButtonDidPress(_ sender: JPPBBAButton) {

    let amount = JPAmount(AMOUNT_VALUE, currency: "GBP")
    let reference = JPReference(consumerReference: CONSUMER_REF)

    configuration = JPConfiguration(judoID: JUDO_ID, amount: amount, reference: reference)

    let pbbaConfiguration = JPPBBAConfiguration()
    pbbaConfiguration.mobileNumber = YOUR_MOBILE_NUMBER
    pbbaConfiguration.emailAddress = YOUR_EMAIL_ADDRESS
    pbbaConfiguration.appearsOnStatement = YOUR_APPEARS_ON_STATEMENT
    pbbaConfiguration.deeplinkScheme = YOUR_DEEPLINK_SCHEME

    configuration.pbbaConfiguration = pbbaConfiguration

    judoKit.invokePBBA(with: configuration) { [weak self] (response, error) in
        if let response = response {
            // Handle response
        }

        if let error = error {
            // Handle error
        }
    }
}

• Each Judopay transaction takes a JPConfiguration instance as a parameter.The configuration object sets up all the required parameters for a successful transaction. It also sets any optional parameters which you can configure to personalise the payment flow.

• PayByBankApp transactions require some extra parameters to be set up, in addition to the basic transaction configuration. These optional parameters are defined in the JPPBBAConfiguration class, and used to add additional information to the transaction. The following two parameters are recommended:

  • deeplinkScheme

  • deeplinkURL

• Call the invokePBBA method from the Judopay SDK.

The PayByBankApp flow will be triggered, opening the Bank app for consumers to make their transactions.

For more details, see Step 5: Handling the deeplinkURL.

It is a good idea to handle the errors within this step.

The most important information from the response is the orderId, accessed via response.orderDetails.orderId.

The orderId is used to manually check the transaction status.

For more details, see Manually Checking the Transaction Status.

Step 5: Handling the deeplinkURL

Following the completed transaction, the bank flow will be triggered when the invokePBBA method is called, even if the deeplinkURL parameter is not provided.

However, if the deeplinkURL parameter is provided, calling invokePBBA will trigger the transaction status polling logic.

To handle the deeplinkURL:

1. Listen to this event.

2. Capture the redirect URL.

To capture the redirect URL:

• In your AppDelegate file, add the following methods:

  • application(_:open:options:)

  • application(_:didFinishLaunchingWithOptions:)

func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {

     if let url = launchOptions?[.url] as? URL {
         UserDefaults.standard.set(url, forKey: "deeplinkURL")
     }

     ...
}

func application(
    _ app: UIApplication, open url: URL,
    options: [UIApplication.OpenURLOptionsKey : Any] = [:]
    ) -> Bool {

     UserDefaults.standard.set(url, forKey: "deeplinkURL")

     ...
}

3. Pass the URL to the JPPBBAConfiguration instance.

For the purpose of this exercise, the deeplinkURL is saved in the app's UserDefaults.

You can save the deeplinkURL in the Keychain or any alternative.

Step 6: Polling the Transaction Status

Once the Bank app has redirected the consumer back to your app, you can start polling the transaction status.

To start the PayByBankApp polling status:

1. Add the deeplinkURL to the configuration

2. Call the invokePBBA(configuration:) method:

func handleDeeplink() {
     guard let url = UserDefaults.standard.url(forKey: "deeplinkURL") else {
         return
     }

     configuration.pbbaConfiguration?.deeplinkURL = url

     judoKit.invokePBBA(with: configuration) { [weak self] (response, error) in
         if let response = response {
             // Handle response
         }

         if let error = error {
             // Handle error
         }
     }
 }

3. In the JPResponse object, you can inspect the orderDetails containing information about the transaction status.

Another option is to put a check in your viewDidAppear(animated:) method.
If a deeplinkURL is set up, add it to the configuration and call the invokePBBA(configuration:) method again. This will start the polling status.

Manually Checking the Transaction Status

There may be cases where the Bank app closes before the transaction flow completes. This would mean the deeplinkURL is not returned and the polling process to check the transaction status will not begin.

To manually check the transaction status:

1. Invoke a manual order status request:

   Use the JPApiService to invoke a manual order status request.

2. Get the orderId from the initial request:

judoKit.invokePBBA(with: configuration) { [weak self] (response, error) in 
    if let response = response { 
        let orderId = response.orderDetails?.orderId 
            // Persist the orderId for later use 
} 
}

3. Use the orderId to manually check the transaction status:

   Create an instance of JPApiService

You would do this in the same way as Initialising the Judopay SDK, see Step 1: Initialising the SDK.

4. Call the invokeOrderStatus method, with the orderId:

let apiService = JPApiService(authorization: authorization, isSandboxed: true)

    apiService.invokeOrderStatus(withOrderId: orderId) { (response, error) in
    // Handle response
}

The response will contain both the transaction status, and the order details of the transaction.

For a sample app, see Judopay's Judokit for iOS on Github.

3D Secure 1 Test Cards

Following 3D Secure 1 no longer being supported, the test cards used for 3D Secure 1 flows have been deprecated.

Authorisation Successful with 3D Secure 1

Authorisation Declined with 3D Secure 1

Authorisation Referred with 3D Secure 1

{    
"oneUseToken": "2uhOsi...8KZcn=",     
"cardLastfour": "3436",       
"endDate": "12/20",        
"cardScheme": "Visa",          
"cardFunding": "Debit",            
"error": false,        
"clientDetails": 0 
}

{   
"error":     {       
"message": "Sorry, we're unable to process your request. Please check your details and try again."   
}
}

{
    "receiptId": "415874660497166336",
    "result": "Requires 3D Secure",
    "message": "Issuer authentication required",
    "acsUrl": "https://gw1.paymentsensegateway.com:4430/ACS/Default.aspx",
    "md": "1902...2484",
    "paReq": "eJxd...kqXcvg=="
}

{oneUseToken:
"F4e7PxeRZLA31G98SfcQcIlxPR8LtC8nBpFt1CDUV1JcSOHK56",
cardLastfour: "7521",
endDate: "12/21",
cardScheme: "Visa",
cardFunding: "Credit"}

{receiptId: "614040999953559552",
                                                                            
result: "Requires 3D Secure",
                                                                            
message: "Issuer authentication
                                                                            
required",
                                                                            
acsUrl:
                                                                            
"https://gw1.judocommerce.com:4430/ACS/Default.aspx",
                                                                            
md: "200821101926255601402655",
                                                                            
paReq:
                                                                            
"encryptedPaReqMessageWillBeHere",
                                                                            
result: "Requires 3D Secure"}

$receiptId =
  $_GET['receiptId'];
  // Set the receiptID = the ID received back from the Issuer
  Service.
  $MD =
  $_POST['MD'];
  // Set $MD = MD Received from 3DS Issuer
  $PaRes =
  $_POST['PaRes'];
  // Set $PaRes = PaRes Received from 3DS Issuer
  $data =
  json_encode(array('Md' =>$MD,'PaRes' =>$PaRes));
  // Encode to JSON format
  $userEncode =
  base64_encode("yourAPIToken:yourAPISecret");
  // Setup base64 Encoded ID / Password for submission
  $headers =
  array(
              'Content-Type:application/json',
              'Authorization: Basic
  '.$userEncode,
              'API-Version: 5.7.1',
  );
  // Set curl headers for the correct format and API Version
  $ch =
  curl_init("https://gw1.judopay-sandbox.com/transactions/".$receiptId);
  // Initialise the Curl Options (this uses our sandbox endpoint,
  this will differ for production)
  curl_setopt($ch,
  CURLOPT_RETURNTRANSFER, true);
  // Raw return format
  curl_setopt($ch,
  CURLOPT_CUSTOMREQUEST, "PUT");
  // Set curl to PUT
  curl_setopt($ch,
  CURLOPT_POSTFIELDS,$data);
  // Set the PUT fields to the $data above
  curl_setopt($ch,
  CURLOPT_HTTPHEADER, $headers);
  // Setup Curl headers
  $response =
  curl_exec($ch);
  // Execute the curl against the Judo endpoint

{
  "receiptId":"614047134823608320",
  "yourPaymentReference":"a0b1e12",
  "type":"PreAuth",
  "createdAt":"2020-08-21T11:43:49.2501+01:00",
  "result":"Success",
  "message":"AuthCode:
  214733",
  "judoId":100183086,
  "merchantName":"wayne
  lawrence",
  "appearsOnStatementAs":"APL*/waynelawrence
  ",
  "originalAmount":"1.01",
  "amountCollected":"0.00",
  "netAmount":"1.01",
  "amount":"1.01",
  "currency":"GBP",
  "cardDetails":
  {"cardLastfour":"6891",
  "endDate":"1220",
  "cardToken":
  "lT1AakP6IkLlu8IVUBr5VDx7gcPV9VA1",
  "cardType":1,
  "cardScheme":
  "Visa",
  "cardFunding":"Credit",
  "cardCategory":"",
  "cardQualifier":0,
  "cardCountry":"FR",
  "bank":"Credit
  Industriel Et Commercial"},
  "consumer":
  {"consumerToken":"eaw3rv5Xy7wajdNt",
  "yourConsumerReference":"665e37f"},
  "device":{"identifier":"0b7fae264ee04cfba082c764169f52a5"},
  "riskScore":0,"threeDSecure":
  {"attempted":true,
  "result":"PASSED"},
  "externalBankResponseCode":"",
  "billingAddress":{}
  }

var judo = new JudoPay("yourAPIToken", true);
var payment = judo.createCardDetails('payment-iframe',configMinimum);

var paymentPromise = "";
$("#submit-payment-button").click(function(){
   if (judo.getPaymentMethod()=="CARD") {
      var paymentPromise = judo.createToken(payment);
      paymentPromise.then(function(result) {
         if (typeof result.error !== 'undefined') {
            if (typeof result.oneUseToken !== 'undefined') {
 
                      // This is where the token is sent to your back office for payment
             // request (expanded example below)
 
            }
         } 
      }
   }
}

<?php
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');
 
$OneUseToken = $_GET["myToken"];
 
$userEncode = base64_encode("yourAPIToken:yourAPISecret");
$data=json_encode(
array(
'oneUseToken' =>$OneUseToken,
'yourConsumerReference' =>substr(md5(rand()), 0, 7),
'yourPaymentReference' => substr(md5(rand()), 0, 7),     
'judoId' => 'yourJudoId',
'amount' => 1.0,
'currency' => "GBP"
));
$headers = array(
Content-Type:application/json',
'Authorization: Basic '.$userEncode,
'API-Version: 5.7.1',
);
$ch = curl_init("https://gw1.judopay-sandbox.com/transactions/payments");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS,$data);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($ch);
 
echo $response;
 
?>

$.get("handle3.php",{myToken : result.oneUseToken}, function(data) {
 
   if (data.result=="SUCCESS") {
     // Handle a Success Result
     var receiptId = data['receiptId'];
     // Handle a Failure, you can look the data result for further detail
     // To add other actions
     alert(‘Payment Success’ + receiptId);
   } else {
     alert(‘Payment Failed’);
   }
}
);

{"receiptId":"615495218204119040",
"yourPaymentReference":"bbd5067",
"type":"Payment",
"createdAt":"2020-08-25T11:38:06.7811+01:00",
"result":"Success",
"message":"AuthCode: 058967",
"judoId":100183086,
"merchantName":"testmerchant",
"appearsOnStatementAs":"APL*/testmerchant ",
"originalAmount":"1.00",
"netAmount":"1.00",
"amount":"1.00",
"currency":"GBP",
"cardDetails":
{"cardLastfour":"6891",
   "endDate":"1220",
   "cardToken":"DgoimaGqpm8ngRKnAl7xgXvFS0zuf3JQ",
   "cardType":1,
   "cardScheme":"Visa",
   "cardFunding":"Credit",
   "cardCategory":"",
   "cardQualifier":0,
   "cardCountry":"FR",
   "bank":"Credit Industriel Et Commercial"},
"consumer":
{"consumerToken":"dQxfNBY5cddXeMhe",
   "yourConsumerReference":"3190912"
},
"riskScore":0,
"threeDSecure":
{"attempted":true,
   "result":"PASSED"},
"externalBankResponseCode":"",
"billingAddress":{}
}

<?php

$receiptId = $_GET['receiptId'];

if (empty($receiptId))  {
  echo '<BR> Sorry there was an error - missing receiptId';
} else {
  $MD = $_POST['MD'];
  $PaRes = $_POST['PaRes'];
  $data = json_encode(array('Md' =>$MD,'PaRes' =>$PaRes));
  $userEncode = base64_encode("yourAPIToken:yourAPISecret");
  $headers = array(
  'Content-Type:application/json',
  'Authorization: Basic '.$userEncode,
  'API-Version: 5.7.1',
  );
  $ch = curl_init("https://gw1.judopay-sandbox.com/transactions/".$receiptId);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
  curl_setopt($ch, CURLOPT_POSTFIELDS,$data);
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  $response = curl_exec($ch);
  echo $response;
}
?>

--header 'Api-Version: 6.4' \
--header 'Content-Type: application/json' \
--header 'Authorization: Basic XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' \
--data-raw '{  
       "judoId":"100016172",
       "amount": 125.00,
       "currency": "GBP",
        "yourConsumerReference": "example_customer_reference_00001",
        "yourPaymentReference": "example_payment_reference_00001",
        "yourPaymentMetaData":{
            "invoiceNumber": "000546" ,
            "customerNumber": "ABC123456"
                },
         "clientIpAddress": "127.0.0.1",
         "clientUserAgent": "example browser 5.25"
}

"postUrl": "https://pay.judopay-sandbox.com/v1",
"reference": "yth67_82nhjmf903jnmaiine…"

{  
    "judoId":"958389",
    "amount":1.01,
    "yourConsumerReference":"JudoTest?0000771",
    "yourPaymentReference":"{{$guid}}",
    "currency":"GBP"
}

{
"payByLinkUrl": "https://pay.karatepay.com/KDyPdg",
"postUrl": "https://pay.karatepay.com/v1",
"reference": "5QcAAAEAAAAbAAAAEAAAAHZVMqgikR_bu-hMzNlt8pHULA3kxJaF9-pulnDlTfvKusklaQ"
}

React Native V2.1

Version 2.1 is now deprecated.

For Mobile apps, it is recommended not to make a transaction from the app, as the Token and Secret could become compromised.
Use the server to make the transaction.
Create a Register Card app and enable the Register Card Transactions permission.

Requirements

• Version 0.62+

Installing React-Native

1. In your package.json file add under scripts section:

   postinstall": "node node_modules/judo-react-native/scripts/sample-app_postinstall.js node_modules/judo-react-native"

2. Under the dependencies section add:

   judo-react-native": "file:../",In your root project folder run:sh rm yarn.lock && rm -rf node_modules yarn install

3. Navigate to ios/folder and run:  rm -rf Pods/ && rm Podfile.lock pod install

To run the Judopay React Native SD:

1. Import:

import {
  RNJudo,
  type JudoOptions,
  type JudoApplePayOptions,
  type JudoGooglePayOptions,
  type PaymentOptions
} from "judo-react-native";

2. Configure the JudoOptions object:

const judoOptions: JudoOptions = {
  token: "<TOKEN>",
  secret: "<SECRET>",
  judoId: "<JUDO_ID>",
  isSandbox: true,
  amount: "0.01",
  currency: "GBP",
  consumerReference: "myCustomerReference",
  paymentReference: "myPaymentReference",
  metaData: {metadatakey: "metadataValue", metadatakey2: "metadataValue2"}
};

token | secret | judoId | amount | currency = mandatory fields.

You will need to pass the judoOptions object each time you want to make a call to the JudoPay React Native SDK.

Setting Up React Native

To create a Payment:

try {
  let response = await RNJudo.makePayment(judoOptions);
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle unsuccessful result
  }
} catch (e) {
    //handle error
}

To create a PreAuth:

try {
  let response = await RNJudo.makePreAuth(judoOptions);
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle unsuccessful result
  }
} catch (e) {
  //handle error
}

response object will contain all data contained in JPTransactionData.h the same field is exposed in Android. e - error.

All error codes found in NSError+Judo.h are the same for Android.

Payment Methods UI

For the payment methods UI to appear, pass the following 3 objects:

• paymentOptions

• applePayOptions

• googlePayOptions

Payment Options

Select one of the following constants:

const paymentOptions: PaymentOptions = {
  paymentMethods: RNJudo.PAYMENT_METHOD_NONE
};
Payment method types: {
  RNJudo.PAYMENT_METHOD_NONE
  RNJudo.PAYMENT_METHOD_CARD
  RNJudo.PAYMENT_METHOD_GOOGLE_PAY
  RNJudo.PAYMENT_METHOD_APPLE_PAY
  RNJudo.PAYMENT_METHOD_ALL
}

Call showPaymentMethods:

try {
  let response = await RNJudo.showPaymentMethods(
    Object.assign({}, judoOptions, applePayOptions, googlePayOptions, paymentOptions)
  );
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle non-success flow
  }
} catch (e) {
    //handle error
}

Apple Pay Options

Apple Pay configuration:

try {
  let response = await RNJudo.showPaymentMethods(
    Object.assign({}, judoOptions, applePayOptions, googlePayOptions, paymentOptions)
  );
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle non-success flow
  }
} catch (e) {
    //handle error
}

Select one of the following constants:

Transaction types: {
  RNJudo.APPLE_PAY_TRANSACTION_PAYMENT
  RNJudo.APPLE_PAY_TRANSACTION_PAYMENT
}

Shipping types: {
  RNJudo.APPLE_PAYMENT_SHIPPING
  RNJudo.APPLE_PAYMENT_DELIVERY
  RNJudo.APPLE_PAYMENT_STORE_PICKUP
  RNJudo.APPLE_PAYMENT_SERVICE_PICKUP
}

Apple Pay payment summary item types: {
  RNJudo.APPLE_PAYMENT_SUMMARY_FINAL
  RNJudo.APPLE_PAYMENT_SUMMARY_PENDING
}

Apple pay button light/dark styles: {
  RNJudo.APPLE_PAY_BUTTON_THEME_LIGHT
  RNJudo.APPLE_PAY_BUTTON_THEME_DARK
}

To make an Apple Pay transaction:

try {
  let response = await RNJudo.makeApplePayPayment(
    Object.assign({}, judoOptions, applePayOptions)
  );
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle non-success flow
  }
} catch (e) {
    //handle error
}

You can call judoOptions and applePayOptions, the same as showPaymentMethods.

Google Pay Options

Google Pay configuration:

const googlePayOptions: JudoGooglePayOptions = {
  googlePayTestEnvironment: false,
  isPayment: false, // pre-auth
  isRequestBilling: false,
  isRequestContactDetails: false,
  isRequestShipping: false
};

To make a Google Pay transaction:

try {
  let response = await RNJudo.makeGooglePayPayment(
    Object.assign({}, judoOptions, googlePayOptions)
  );
  if (response.result === "Success") {
    //Handle successful result
  } else {
    //Handle unsuccess flow
  }
} catch (e) {
    //handle error
}

You can call judoOptions and googlePayOptions, the same as showPaymentMethods.

Google Pay™ as a Payment Method

Configuring the Wallet

Wallet Configuration is now deprecated.

There are two environments for Google Pay™:

• Sandbox

• Production 

Ensure you configure the Wallet to specify your payment environment.

This is reflected by the WalletConstants enum in the android wallet package:

public static final int PAYMENTS_ENVIRONMENT = WalletConstants.ENVIRONMENT_PRODUCTION;
public static final int PAYMENTS_ENVIRONMENT = WalletConstants.ENVIRONMENT_SANDBOX;

Google Pay™ supports both tokenized and non-tokenized cards. 

Tokenised:  Google Pay™ generates a token which represents the card. Only this token is sent when making a payment. Your customer's card number does not leave Google Pay™.

For security reasons, Judopay only currently supports tokenized cards.

Therefore you must configure your application to only support the tokenized card method. 

This means any invalid cards will not appear as a payment option when your consumer tries to pay with your application.

public static final List<Integer> SUPPORTED_METHODS = Arrays.asList(
   // PAYMENT_METHOD_TOKENIZED_CARD refers to EMV tokenized credentials stored in the
   // Google Pay app, assuming it's installed.
        WalletConstants.PAYMENT_METHOD_TOKENIZED_CARD
);

1. Set the Gateway name to judopay: public static final String GATEWAY_TOKENIZATION_NAME = "judopay";

2. When creating a new PaymentsClient (another Android class), initialise it with the PAYMENTS_ENVIRONMENT, and the activity launching your payment:

public static PaymentsClient createPaymentsClient(Activity activity) {
    Wallet.WalletOptions walletOptions = new Wallet.WalletOptions.Builder()
            .setEnvironment(Constants.PAYMENTS_ENVIRONMENT)
            .build();
    return Wallet.getPaymentsClient(activity, walletOptions);
}

3. Set the tokenization parameters with your merchant ID (Judo ID):

public static final List<Pair<String, String>> GATEWAY_TOKENIZATION_PARAMETERS = Arrays.asList(
    Pair.create("gatewayMerchantId", "{YOUR_JUDO_ID}")
);

4. Specify the card networks to support, and the allowed shipping countries. This might vary depending on your application and product.

// The allowed networks to be requested from the API. If the user has cards from networks not
// specified here in their account, these will not be offered for them to choose in the popup.
public static final List<Integer> SUPPORTED_NETWORKS = Arrays.asList(
        WalletConstants.CARD_NETWORK_AMEX,
        WalletConstants.CARD_NETWORK_DISCOVER,
        WalletConstants.CARD_NETWORK_VISA,
        WalletConstants.CARD_NETWORK_MASTERCARD
);

// Supported countries for shipping (use ISO 3166-1 alpha-2 country codes).
// Relevant only when requesting a shipping address.
public static final List<String> SHIPPING_SUPPORTED_COUNTRIES = Arrays.asList(
        "US",
        "GB"
);

Generating a Google Pay™ Payment

In your checkout activity:

• Find the view/button to trigger the payment

• Add the request payment listener

The Google Pay sample application project has a sample view layout for a Google Pay button you can use

 (googlepay_button.xml) which follows the Google Pay style conventions.

// Arbitrarily-picked result code.
private static final int LOAD_PAYMENT_DATA_REQUEST_CODE = 991;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_checkout);


    mGooglePayButton = findViewById(R.id.googlepay_button);
    mGooglePayStatusText = findViewById(R.id.googlepay_status);

    mGooglePayButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            requestPayment(view);
        }
    });

    // It's recommended to create the PaymentsClient object inside the onCreate method.
    mPaymentsClient = PaymentsUtil.createPaymentsClient(this);
    checkIsReadyToPay();
}

// This method is called when the Pay with Google button is clicked.
public void requestPayment(View view) {
    // Disables the button to prevent multiple clicks.
    mGooglePayButton.setClickable(false);

    // The price provided to the API should include taxes and shipping.
    // This price is not displayed to the user.
    String price = PaymentsUtil.microsToString(YOUR_ITEM_PRICE);

    TransactionInfo transaction = PaymentsUtil.createTransaction(price);
    PaymentDataRequest request = PaymentsUtil.createPaymentDataRequest(transaction);
    Task<PaymentData> futurePaymentData = mPaymentsClient.loadPaymentData(request);

    // Since loadPaymentData may show in the UI asking the user to select a payment method, we use
    // AutoResolveHelper to wait for the user interacting with it. Once completed,
    // onActivityResult will be called with the result.
    AutoResolveHelper.resolveTask(futurePaymentData, this, LOAD_PAYMENT_DATA_REQUEST_CODE);
}

private void checkIsReadyToPay() {
    // The call to isReadyToPay is asynchronous and returns a Task. We need to provide an
    // OnCompleteListener to be triggered when the result of the call is known.
    PaymentsUtil.isReadyToPay(mPaymentsClient).addOnCompleteListener(
            new OnCompleteListener<Boolean>() {
                public void onComplete(Task<Boolean> task) {
                    try {
                        boolean result = task.getResult(ApiException.class);
                        setGooglePayAvailable(result);
                    } catch (ApiException exception) {
                        // Process error
                        Log.w("isReadyToPay failed", exception);
                    }
                }
            });
}

private void setGooglePayAvailable(boolean available) {
    // If isReadyToPay returns true, show the button and hide the "checking" text. Otherwise,
    // notify the user that Pay with Google is not available.
    // Please adjust to fit in with your current user flow. You are not required to explicitly
    // let the user know if isReadyToPay returns false.
    if (available) {
        mGooglePayStatusText.setVisibility(View.GONE);
        mGooglePayButton.setVisibility(View.VISIBLE);
    } else {
        mGooglePayStatusText.setText(R.string.googlepay_status_unavailable);
    }
}

1. Create the PaymentDataRequest, passing in the gateway name and parameters set earlier.

2. Ensure to set the tokenization type as: WalletConstants.PAYMENT_METHOD_TOKENIZATION_TYPE_PAYMENT_GATEWAY:

public static PaymentDataRequest createPaymentDataRequest(TransactionInfo transactionInfo) {
    PaymentMethodTokenizationParameters.Builder paramsBuilder =
            PaymentMethodTokenizationParameters.newBuilder()
                    .setPaymentMethodTokenizationType(
                            WalletConstants.PAYMENT_METHOD_TOKENIZATION_TYPE_PAYMENT_GATEWAY)
                    .addParameter("gateway", Constants.GATEWAY_TOKENIZATION_NAME);
    for (Pair<String, String> param : Constants.GATEWAY_TOKENIZATION_PARAMETERS) {
        paramsBuilder.addParameter(param.first, param.second);
    }

    return createPaymentDataRequest(transactionInfo, paramsBuilder.build());
}

private static PaymentDataRequest createPaymentDataRequest(TransactionInfo transactionInfo, 
PaymentMethodTokenizationParameters params) {
    PaymentDataRequest request =
            PaymentDataRequest.newBuilder()
                    .setPhoneNumberRequired(false)
                    .setEmailRequired(true)
                    .setShippingAddressRequired(true)

                    // Omitting ShippingAddressRequirements altogether means all countries are
                    // supported.
                    .setShippingAddressRequirements(
                            ShippingAddressRequirements.newBuilder()
                                    .addAllowedCountryCodes(Constants.SHIPPING_SUPPORTED_COUNTRIES)
                                    .build())

                    .setTransactionInfo(transactionInfo)
                    .addAllowedPaymentMethods(Constants.SUPPORTED_METHODS)
                    .setCardRequirements(
                            CardRequirements.newBuilder()
                                    .addAllowedCardNetworks(Constants.SUPPORTED_NETWORKS)
                                    .setAllowPrepaidCards(true)
                                    .setBillingAddressRequired(true)

                                    // Omitting this parameter will result in the API returning
                                    // only a "minimal" billing address (post code only).
                                    .setBillingAddressFormat(WalletConstants.BILLING_ADDRESS_FORMAT_FULL)
                                    .build())
                    .setPaymentMethodTokenizationParameters(params)

                    // If the UI is not required, a returning user will not be asked to select
                    // a card. Instead, the card they previously used will be returned
                    // automatically (if still available).
                    // Prior whitelisting is required to use this feature.
                    .setUiRequired(true)
                    .build();

    return request;
}

Handle a Successful Payment

Catch the payment result in your checkout activity:

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
        case LOAD_PAYMENT_DATA_REQUEST_CODE:
            switch (resultCode) {
                case Activity.RESULT_OK:
                    PaymentData paymentData = PaymentData.getFromIntent(data);
                    handlePaymentSuccess(paymentData);
                    break;
                case Activity.RESULT_CANCELED:
                    // Nothing to here normally - the user simply cancelled without selecting a
                    // payment method.
                    break;
                case AutoResolveHelper.RESULT_ERROR:
                    Status status = AutoResolveHelper.getStatusFromIntent(data);
                    handleError(status.getStatusCode());
                    break;
            }

            // Re-enables the Pay with Google button.
            mGooglePayButton.setClickable(true);
            break;
    }
}

The function below demonstrates how to handle the payment request returned from the intent, and send on the necessary tokenized card details to the Judopay API to be processed:

private void handlePaymentSuccess(PaymentData paymentData) {
    // PaymentMethodToken contains the payment information, as well as any additional
    // requested information, such as billing and shipping address.
    PaymentMethodToken token = paymentData.getPaymentMethodToken();

    // getPaymentMethodToken will only return null if PaymentMethodTokenizationParameters was
    // not set in the PaymentRequest.
    if (token != null) {
        String encryptedToken = token.getToken();
        String cardNetwork = paymentData.getCardInfo().getCardNetwork();
        String cardDetails = paymentData.getCardInfo().getCardDetails();

        JudoApiService apiService = getJudo().getApiService(getApplicationContext());
        GooglePayRequest request = getGooglePayRequest(encryptedToken, cardNetwork, cardDetails);
        apiService.googlePayPreAuth(request);
    }
}

private GooglePayRequest getGooglePayRequest(String encryptedToken, String cardNetwork, string cardDetails) {
    return new GooglePayRequest.Builder()
            .setJudoId("YOUR_JUDO_ID")
            .setGooglePayWallet(new GooglePayWallet.Builder()
                    .setCardNetwork(cardNetwork)
                    .setCardDetails(cardDetails)
                    .setToken(encryptedToken)
                    .build())
            .setAmount(YOUR_PRICE)
            .setCurrency(Currency.GBP)
            .setConsumerReference(UNIQUE_GUID)
            .build();
}

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '8.0'
use_frameworks!
pod 'JudoKit', '~> 6.2'

Judopay.configure do |config| config.judo_id = 12345 config.api_token = 'your-token' 
config.api_secret = 'your-secret' 
# Set to true on production, defaults to false which is 
#the sandbox config.use_production = false
end

Judopay.configure do |config| config.judo_id = 12345 config.api_token = 'your-token' 
config.api_secret = 'your-secret' 
# Set to true on production, defaults to false 
#which is the sandbox config.use_production = true 
end