Android Mobile SDK

Introduction

Arkose Labs' mobile SDKs let you wrap our solution with Android native function calls. This guarantees seamless integration of your mobile apps with Arkose's full interactive challenges on detection and enforcement and does so without the extended wait times for separate mobile solutions.

This page covers the Mobile SDK for Android. If you are developing in iOS, see the Mobile SDK for iOS page.

The Arkose Mobile SDK for iOS:

  • Wraps Arkose's Advanced Enforcement Challenge in native Android OS "Web View"

  • Has 1-to-1 feature availability between web and mobile solutions.

  • Integrates with your apps through native functions.

  • Handles errors through callback events.

  • Complies with Arkose Internal Security guidelines.

  • Complies with Google Play Store guidelines for ease of integration.

  • Is fully compatible with new Enforcement Challenge-API (EC-API) releases.

  • Supports minimum version Android OS 5.1

Mobile SDK High Level Design

Mobile SDK Builds Availability

The Arkose Labs Mobile SDKs are available via the Mobile SDK's Support page. Please talk with your CSM (Customer Success Manager) about your intended usage and request access.

Compatibility

The Arkose Labs Mobile SDK for Android works with Android 5.1 and up.

All existing detection and challenge features on our web solutions are also available on the Mobile SDKs. All new ones are automatically added; you don't need to update your application every time we release a new Web platform. All challenge updates can be done without updating the SDKs or releasing a new version of your application.

Security

The Arkose Labs Mobile SDKs are Arkose Labs Security reviewed and comply with Google Play Store guidelines.

Performance

We created the Arkose Labs Mobile SDKs with stability and performance in mind. Their use has no significant impact on the host application’s performance.

Installation

Follow the steps below to set up Arkose Labs Mobile SDK for Android in Android Studio in your host application. This applies to both our detection and enforcement components.

Prerequisites

  • A host Android application. You must be able to build and run this application.

  • For the full end-to-end Arkose setup, you must also complete the standard Arkose Server-Side setup instructions.

Integration Steps

Set up development file

  1. Under src/main, create a libs folder.

  2. Copy your .aar file to src/main/libs

  3. In the app level build.gradle file, add this line to its dependencies block.

implementation fileTree(dir: "libs", include: ["*.aar"])
implementation 'androidx.biometric:biometric:1.2.0-alpha04'
  1. In the toolbar, click on File. Then in its menu click Sync Project with Gradle Files.

Import and add Arkose code to your application

  1. Import the necessary SDK classes. Add the below code in your main file, right after you import your android and androidx classes and before your class definition statements.
import com.arkoselabs.sdk.ArkoseChallenge;
import com.arkoselabs.sdk.ArkoseConfig;
import com.arkoselabs.sdk.ArkoseManager;
  1. Update Android proguard or R8 rules to keep all the classes under com.arkoselabs.sdk.*

    -keep public class com.arkoselabs.sdk.**
    
  2. In the main screen activity section (Under src/main/java), in the onCreate method of the activity, initialize the SDK with ArkoseConfig object with API URL, API Key and other parameters

// Build the configuration object
final ArkoseConfig arkoseConfig = new ArkoseConfig.Builder()
  .apiKey(SPECIFY_YOUR_API_KEY)
  .blobData("") //encrypted blob data (optional)
  .loading(true) // setting this to false will not show the default loading spinner
  .enableBackButton(true) // To disable/enable device back button in EC process. Default is 'true'
  .setDismissChallengeOnTouchOutside(false) // To disable/enable touch outside of EC dialog to dismiss EC. Default is 'true'
  .language("") // Can set language here (optional).
  // This to set animation while EC will be loading.
  // You can set your own custom animation by putting value R.anim.<AnimStyle>
  .viewFrameAnimation(R.anim.custom_animation) 
  .build();

// Set the log level
ArkoseManager.setLogLevel(ArkoseManager.INFO);

// Initialize the SDK
// For v2.0.0 SDK
//ArkoseManager.initialize(arkoseConfig);

// For v2.1.0 SDK
ArkoseManager.initialize(arkoseConfig, getApplication());

  1. If you want to add your own custom animation, then the value of viewFrameAnimation will be R.anim.<CustomAnimStyle>. The CustomAnimStyle is your animation xml file.
    We provide a number of inbuilt animations in the Mobile SDK. Use the desired animation style by replacing the <AnimStyle> in R.anim.<AnimStyle> parameter.
    1. blink
    2. fade
    3. scale_center
    4. sequential
    5. slide_down
    6. slide_left
    7. slide_right
    8. slide_up
    9. zoom_in
    10. zoom_out
  2. To show the Enforcement View from the onClick() method of the Login Button, call showEnforcementChallenge method with FragmentActivity as its parameter. This will run Arkose detection component (when running Arkose enforcement component, it also runs Arkose’s Enforcement Challenge). Fill in the method definitions with what you want to happen when that method is invoked as described in the comments. Note there are separate code examples for our detection and enforcement components.
ArkoseChallenge arkoseChallenge = ArkoseManager.showEnforcementChallenge(this);
arkoseChallenge.
        .addOnSuccessListener(arkoseChallengeResponse -> {
            // invoked On Enforcement Challenge success
         })
         
        .addOnFailureListener(arkoseChallengeResponse -> {
            // invoked on Enforcement Challenge failed
        })
        
        .addOnErrorListener(arkoseChallengeResponse -> {
             // invoked on getting error while loading EC
        })
        
        .addOnWarningListener(arkoseChallengeResponse -> {
             // invoked when an issue occurs which needs to be shared with 
                the app as a warning
        })

        .addOnResizeListener(arkoseChallengeResponse -> {
             // Provides the width and height of the visible EC from an SDK call
             // While you cannot set the width and height values yourself, 
             // you can make use of their new values from the resizing 
             // as you'd like, such as putting them in a log entry.
        })
        
        .addOnReadyListener(() -> {
              //Do Something on ready callback received
        })
        
        .addOnShowListener(() -> {
              //Do Something on show callback received
        })
        
        .addOnShownListener(() -> {
              //Do Something on shown callback received
        })
        
        .addOnHideListener(() -> {
              //Do Something on hide callback received
        })
        
        .addOnResetListener(() -> {
              //Do Something on reset callback received 
        })

        .addOnViewFramePosition(arkoseChallengeResponse -> {
              // Do Something to set the position of view frame
              // Example:
              // arkoseECResponse.getWindow().getAttributes().gravity = Gravity.BOTTOM;
              // arkoseECResponse.getWindow().getAttributes().width = ViewGroup.LayoutParams.MATCH_PARENT;
          })
        
        .addOnSuppressListener(() -> {
              //Do Something on suppress callback received
            }
        });

ArkoseLabs.getActivityClient(this).ShowEnforcementChallenge(arkoseConfig)
        .addOnSuccessListener(new OnCompleteListener < ArkoseECResponse > () {
            @Override
            public void onComplete(ArkoseECResponse arkoseEnforcementChallengeResponse) {
                // invoked On Detection success
            }
         })
         
        .addOnErrorListener(new OnErrorListener<ArkoseECResponse>() {
            @Override
            public void onError(ArkoseECResponse arkoseECResponse) {
             // invoked on getting error while loading detection
            }
        })
        
        .addOnWarningListener(new OnErrorListener<ArkoseECResponse>() {
            @Override
            public void onWarning(ArkoseECResponse arkoseECResponse) {
             // invoked on getting warning while loading detection
            }
        })
        
        .addOnReadyListener(new OnReadyListener() {
            @Override
            public void onReady() {
              //Do Something on ready callback received
            }
        })
        
        .addOnShowListener(new OnShowListener() {
            @Override
            public void onShow() {
              //Do Something on show callback received
            }

        .addOnHideListener(new OnHideListener() {
            @Override
            public void onHide() {
              //Do Something on hide callback received
            }
        })
                
        .addOnSuppressListener(new OnSuppressListener() {
            @Override
            public void onSuppress() {
              //Do Something on suppress callback received
            }
        });

  1. To create a view Fragment that can be embedded in another activity, use ArkoseLabs.createEnforcementChallenge() method which returns an instance of ArkoseChallenge. This will create and set up a view Fragment which can be accessed using the method ArkoseChallenge.getEnforcementChallengeFragment. The example below shows how you can create the ArkoseLabs challenge view Fragment and embed it into your app's activity.
// Create Arkose challenge fragment
ArkoseChallenge arkoseChallenge = ArkoseManager.createEnforcementChallenge();
arkoseChallenge
        .addOnSuccessListener(arkoseChallengeResponse -> {
            // invoked On Enforcement Challenge success
         })
        .addOnFailureListener(arkoseChallengeResponse -> {
            // invoked on Enforcement Challenge failed
        });
         // Add other listeners as needed

// Add the fragment to the activity
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.replace(R.id.frameLayout, arkoseChallenge.getEnforcementChallengeFragment());
ft.commit();

Build the revised project

  1. Go to the Build menu and click on Clean Project.

  2. Go to the Build menu and click on Rebuild Project.

Run and test the app

  1. Run your Android application.

    1. If running Arkose enforcement component the view shows an Arkose Labs Enforcement Challenge.
    2. If running Arkose detection component, the view runs Arkose detection component.
  2. If running Arkose enforcement component, verify the challenge.

  3. When the verification or detection is successful, the onComplete event returns a response token. The following sample code shows what this should look like and what to do with the token. Note there are separate code samples for detection and enforcement.

.addOnSuccessListener(arkoseChallengeResponse -> {
  // invoked On Enforcement Challenge success
  String userResponseToken = arkoseChallengeResponse.getResponse().toString();
  // Get value of the token
  String userResponseToken = arkoseChallengeResponse.getResponse().getString("token");
  Log.i(TAG,"Arkose EC complete: " + userResponseToken);
  // sendToBackendServer(userResponseToken);
})

public void onComplete(ArkoseECResponse arkoseECResponse) {
  String userResponseToken = arkoseECResponse.getResponse().toString();
  // Get value of the token
  String userResponseToken = arkoseECResponse.getResponse().getString("token");
  Log.i(TAG,"Arkose Detection complete: " + userResponseToken);
  // sendToBackendServer(userResponseToken);
}

ArkoseConfig Configuration

Note that Arkose’s detection component is part of our overall Arkose Bot Manager platform. Thus the names of some methods and variables refer only to enforcement when actually dealing with detection as well. Unless otherwise specified, the configuration components apply to both detection and enforcement components, although perhaps in different ways as specified.

Configuration ObjectTypeDescriptionApplicable Component
ArkoseConfigPublic componentEnables a consistent public parameter data model for the View in which it is called.

An initialized model object later passed as parameters to the showEnforcementChallenge() Arkose Labs Mobile SDK.

Note that our detection component is part of our overall Arkose Bot Manager platform. Thus the names of some methods and variables refer only to enforcement when actually dealing with detection as well.
Detection
Enforcement
showEnforcementChallengePublic MethodMethod that starts the Arkose Labs detection when using our detection component and enforcement when using our enforcement component.

Before calling this method, the model object (ArkoseConfig) must be initialized with the additional configuration parameters.

This method adds two listeners:

- addOnSuccessListener: Invoked on successful verification. Overrides the onComplete method with a response.

- addOnFailureListener: Invoked when Enforcement Challenge verification fails. Overrides the onFailed method with a response.
Detection
Enforcement
createEnforcementChallengePublic MethodMethod that creates the Arkose Labs object without invoking the display function.

Before calling this method, the model object (ArkoseConfig) must be initialized with the additional configuration parameters given in the next table. These values are set in the strings.xml file.

This method is used in conjunction with getEnforcementChallengeFragment method to allow embedding into the parent app activity as a fragment.
Detection
Enforcement
OnLoadedListenerFunctionListener function invoked when the SDK has been loaded.Detection
Enforcement
OnReadyListenerFunctionListener function invoked when the Enforcement or Detection is ready.

The Enforcement or Detection cannot be triggered before this event. You may want to disable the UI you are protecting until this event has been triggered.
Detection
Enforcement
OnShowListenerFunctionListener function invoked when the Enforcement or Detection is completed.

The function is also invoked when an Enforcement Challenge or detection is re-displayed (e.g. if the user closes the EC or detection view and tries to continue). Note that the close button only appears when in Lightbox mode.
Detection
Enforcement
OnShownListenerFunctionListener function invoked when the Enforcement Challenge or Detection is displayed. The function is only invoked the first time an Enforcement Challenge is displayed.Enforcement
OnCompletedListenerFunctionListener function invoked when
either:
a. For our enforcement component, a session is classified as not needing a challenge or a challenge has been successfully completed.

b. For our detection component, a session detection has been successfully completed.

A Response Object is passed to this function.
Detection
Enforcement
OnHideListenerFunctionListener function invoked when the EC or detection view is hidden. For example, this happens after an EC or detection is completed or if the user clicks the close button. Note that the close button only appears when in Lightbox mode.Detection
Enforcement
OnSuppressListenerFunctionListener function invoked when:

a. The Enforcement Challenge is suppressed (i.e. A session was classified as not requiring a challenge).

b. The Detection is running and is analyzing the user intent.
Detection
Enforcement
OnResetListenerFunctionListener function invoked after the Enforcement resets. Typically occurs after a challenge has been successfully answered.Enforcement
OnErrorListenerFunctionListener function invoked when an error occurs when loading the challenge or detection.

A Response Object is passed to this function.
Detection
Enforcement
OnWarningListenerFunctionListener function invoked when an issue occurs which needs to be shared with the app as a warning, based on which App can take custom actions, when loading the challenge or detection.

A Response Object is passed to this function.
Detection
Enforcement
OnFailedListenerFunctionListener function invoked when a challenge has failed (the user has failed the challenge multiple times and is not allowed to continue the session).

A Response Object is passed to this function.
Enforcement
OnResizeListenerFunctionListener function invoked when a challenge is loaded. It provides the width and height of the visible EC from an SDK call.

A Response Object is passed to this function.
Enforcement
OnViewFramePositionListenerFunctionListener function invoked when a challenge is loaded. It allows the parent APP to set the view frame window attributes as desired by calling the getWindow() function on the ArkoseECResponse parameter.

E.g.
arkoseECResponse.getWindow().getAttributes().gravity = Gravity.BOTTOM;

A Response Object is passed to this function.
Enforcement

Enforcement Challenge Configuration Parameters / strings.xml

You can change the following Enforcement Challenge configuration parameters by specifying their values in the ArkoseConfig object.

EC Configuration MethodsDescription
Builder apiBaseUrl(String apiBaseUrl)Base URL of Arkose Bot Manager as supplied by Arkose Labs.
Builder apiKey(String apiKey)Public key for your account.
Builder apiFile(String apiFile)JavaScript file name of Arkose Labs EC as supplied by Arkose Labs.
Builder blobData(String blobData)Mainly used to share any client encrypted data blobs with Arkose Bot Manager. It is optional.

Default: ""
Builder language(String language)Not applicable to our detection component.

Language setting for the EC.

Default: "en"
Builder userAgent(String userAgent)Specify any userAgent setting for ease of testing forced Enforcement Challenge for a session. It is optional.

Please talk with your CSM (Customer Success Manager) about your intended usage and request backend configuration.

Default: (inbuilt webview’s userAgent string)
Builder loading(Boolean val)Specify whether loading spinner is shown or not.

Default: true
Builder enableBackButton(Boolean val)Specify whether device back button dismisses EC dialog or not. If this configuration is enabled, and the user uses the back button, onHide listener is triggered and EC dialog is dismissed.

Default: true
Builder setDismissChallengeOnTouchOutside(Boolean val)Specify whether touching outside of EC dialog will dismiss the EC dialog or not. If this configuration is enabled, and user touches outside of the EC dialog, onHide listener is triggered and EC dialog is dismissed.

Default: true

Logging and Troubleshooting

Prerequisites

  1. Install the Android Debug Bridge (adb) binary or driver on the machine where the logs will go.

  2. An Android phone or Android emulator. On it, under Settings > Developer, enable the USB Debugging option

Steps

On the machine where the logs will go:

  1. Download the SDK platform for your platform (Windows / Mac) from SDK Platform Tools release notes | Android Developers

  2. Unzip the folder and check it contains an adb.exe file.

  3. From the command prompt, enter the path where adb is located on the machine. This image shows an example of what you get after you enter the path.

  1. On your Android device, enable USB debugging:

    1. At Phone>Settings>About Phone>, tap Build Number seven times. You should see a message saying that you are now a developer.

    2. On the device, go to Developer options and turn on USB debugging.

    3. Connect the device to the system and trust/allow the system.

    4. To test if adb is working properly:

      1. Use a USB cable to connect your Android device to your computer.

      2. At the computer’s command prompt, run the command adb devices to show the devices connected to the system.

  1. To start verbose logging in the terminal window, at the computer’s command prompt, run adb logcat -s ArkoseLabsShowEnforcementChallenge:v If instead, you want to save the logs, run adb logcat -d > <path-where-you-want-to-save-file>/<filename>.txt Ctrl+C stops the logging.

adb logcat Options

adb logcat has several command options. These include:

  • adb logcat : Prints log data to the screen.

  • adb logcat *:V : Lowest priority, filter to only show Verbose level log entries.

  • adb logcat --help : Shows all logcat options and arguments.

  • adb logcat -c : Clears the logs .

  • adb logcat -s <TAG>:<PRIORITY> :

    • -s: Sets default filter to silent.

    • <TAG>: A log component tag (or * for all).

    • <PRIORITY> can be:

      • V: Verbose (default for <TAG>)

      • D: Debug (default for *)

      • I: Info

      • W: Warn

      • E: Error

      • F: Fatal

      • S: Silent (suppress all output)