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 v1:

• 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.0

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.0 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.

SDK Kotlin Compatibility

Overview

Kotlin v1.7.20+ is now supported in our Android XML and Jetpack Compose SDKs, ensuring wider integration capabilities. This document outlines the SDK's Kotlin version compatibility matrix and associated compose configuration requirements.

Kotlin-Compose Compatibility Reference

For the most up-to-date Kotlin-Compose compatibility information, refer to the official Jetpack Compose compiler documentation.

Troubleshooting Build Issues

Common Error Messages:

1. Module was compiled with an incompatible version of Kotlin: Ensure your Kotlin version and Compose compiler version are compatible according to the tables above.
2. Compose compiler errors: Double-check your kotlinCompilerExtensionVersion matches the recommendations for your Kotlin version.

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.

Steps for Integration in an XML-based Application

Dependency Management:

Include the dependencies using the Authenticated Package Manager(APM)

Prerequisites:

1. You have received the Arkose provided credentials (username and token) from Arkose Command Center. Please visit How to Request a Mobile SDK Token for more information.

2. Store these credentials securely on your CI environment and in your project's local.properties for fetching locally.

3. Declare Credentials:

   maven {
       url = uri("https://maven.pkg.github.com/ArkoseLabs/alsdk-android-packages")
       credentials{
           username = "TODO: Insert Arkose provided username here"
           password = "TODO: Insert Arkose provided token here"
       }
   }

   🚧

   Ensure these credentials are stored securely and not shared outside authorized usage.

4. Add the SDK Dependency to Your Project:

   To integrate an SDK package into your project, use the following format for the dependency:

   implementation 'ArkoseLabs.sdk.x.xx.xxxxx'

5. Sync the Project with Gradle Files

   After adding the dependency, sync your project with the Gradle files to ensure all dependencies are correctly resolved. Use the Sync Project with Gradle Files option in Android Studio or run:

   ./gradlew sync

Legacy Support Include the dependencies using manual AAR file

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

2. Copy your .aar file (s) 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'
implementation 'com.google.code.gson:gson:2.11.0'

ProGuard Rules

Update the Android ProGuard or R8 configuration with the following rule sets:

-dontwarn com.google.android.play.core.integrity.IntegrityManagerFactory
-dontwarn com.google.android.play.core.integrity.StandardIntegrityManager
-dontwarn okhttp3.OkHttpClient$Builder
-dontwarn okhttp3.OkHttpClient
-dontwarn okhttp3.logging.HttpLoggingInterceptor$Level
-dontwarn okhttp3.logging.HttpLoggingInterceptor$Logger
-dontwarn okhttp3.logging.HttpLoggingInterceptor
-dontwarn retrofit2.Converter$Factory
-dontwarn retrofit2.Retrofit$Builder
-dontwarn retrofit2.Retrofit
-dontwarn retrofit2.converter.gson.GsonConverterFactory

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.

   Java

   import com.arkoselabs.sdk.ArkoseChallenge;
   import com.arkoselabs.sdk.ArkoseConfig;
   import com.arkoselabs.sdk.ArkoseManager;

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.

   Java

   // Build the configuration object
   final ArkoseConfig arkoseConfig = new ArkoseConfig.Builder()
     .apiKey(<YOUR_PUBLIC_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)
     .setClientAPIRetryCount(0) // Can set number of retry count for when onError is triggered for certain client-side errors (optional)
     .setStyleTheme("") // Can set EC style theme (optional)
     .viewFrameAnimation(R.anim.custom_animation) // This to set animation while EC will be loading. You can set your own custom animation by putting value R.anim.<AnimStyle>
     .setTimeoutUntilReady(0) // SDK timeout in seconds (optional, positive integer).
     .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());
   

3. 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.

   1. 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

4. 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.

   EnforcementDeprecated Legacy Support

   ArkoseChallenge arkoseChallenge = ArkoseManager.showEnforcementChallenge(this);
   arkoseChallenge.
           .addOnCompletedListener(arkoseChallengeResponse -> {
               // invoked On Enforcement Challenge completed
            })
            
           .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(() -> {
                 //Deprecated since Arkose SDK v2.13.0
           })
           
           .addOnShownListener(new ArkoseChallenge.OnShownListener() {
               @Override
               public void onShown(ArkoseChallengeResponse response) {
                 //Do Something on shown callback received
               }
   
               @Override
               public void onShown() {
                //Deprecated since Arkose SDK v2.13.0
               }
           })
           
           .addOnHideListener(() -> { 
                //Deprecated since Arkose SDK v2.13.0
           })
           
           .addOnHideListener(new ArkoseChallenge.OnHideListener() {
               @Override
               public void onHide() {
                 //Deprecated since Arkose SDK v2.13.0
               }
   
               @Override
               public void onHide(ArkoseChallengeResponse response) {
                 //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(() -> {
                 //Deprecated since Arkose SDK v2.13.0
           })
           .addOnSuppressListener(new ArkoseChallenge.OnSuppressListener() {
               @Override
               public void onSuppress(ArkoseChallengeResponse response) {
                 //Do Something on suppress callback received
               }
   
               @Override
               public void onSuppress() {
                 //Deprecated since Arkose SDK v2.13.0
               }
            });
   

   ArkoseLabs.getActivityClient(this).ShowEnforcementChallenge(arkoseConfig)
           .addOnCompletedListener(new OnCompletedListener < ArkoseECResponse > () {
               @Override
               public void onCompleted(ArkoseECResponse arkoseEnforcementChallengeResponse) {
                   // invoked On Detection completed
               }
            })
            
           .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
               }
           });
   

5. To create a view Fragment that can be embedded in another activity, use ArkoseManager.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.

   Java

   // Create Arkose challenge fragment
   ArkoseChallenge arkoseChallenge = ArkoseManager.createEnforcementChallenge();
   arkoseChallenge
           .addOnCompletedListener(arkoseChallengeResponse -> {
               // invoked On Enforcement Challenge completed
            })
           .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();
   

6. Resetting the Arkose Session
   The Arkose session can be reset dynamically to initiate a new challenge with updated configurations or other triggering events. This effectively clears the current session data and allows for a fresh start. To reset the session, follow these steps:

   • Create a new ArkoseConfig instance with the desired configuration.
   • Call ArkoseManager.updateConfig(arkoseConfig, arkoseChallenge); to update the session.

   • ArkoseConfig arkoseConfig = new ArkoseConfig.Builder()
                     .apiKey("<YOUR_PUBLIC_KEY>")
                     .blobData("<YOUR_ENCRYPTED_DATA>") //encrypted blob data (optional)
                     .language("<YOUR_PREFERED_LANGUAGE>") // Can Set Language here. (optional)
                     .setStyleTheme("<YOUR_PREFERED_STYLE_THEME>")// Can set EC style theme (optional)
                     .build();
             /* 
             * Call updateConfig() to apply the new configuration.
             * This will reset the session and apply any changes.
             */
             ArkoseManager.updateConfig(arkoseConfig, arkoseChallenge); 

Steps for Integration in a Compose-based Application

Dependency Management:

Include the dependencies using the Authenticated Package Manager(APM)

Prerequisites:

1. You have received the Arkose provided credentials (username and token) from Arkose Command Center. Please visit How to Request a Mobile SDK Token for more information.

2. Store these credentials securely on your CI environment and in your project's local.properties for fetching locally.

3. Declare Credentials:

   maven {
       url = uri("https://maven.pkg.github.com/ArkoseLabs/alsdk-android-packages")
       credentials{
           username = "TODO: Insert Arkose provided username here"
           password = "TODO: Insert Arkose provided token here"
       }
   }

   🚧

   Ensure these credentials are stored securely and not shared outside authorized usage.

4. Add the SDK Dependency to Your Project:

   1. To integrate an SDK package into your project, use the following format for the dependency:

      implementation 'ArkoseLabs.sdk.x.xx.xxxxx'

   2. To support Compose-based application, add the following additional dependency:

      implementation 'ArkoseLabs.sdk:android-compose:x.xx.xxxxx'

5. Sync the Project with Gradle Files

   After adding the dependency, sync your project with the Gradle files to ensure all dependencies are correctly resolved. Use the Sync Project with Gradle Files option in Android Studio or run:

   ./gradlew sync

Legacy Support: Include dependencies using manual AAR file

1. Under src/main, create a libs folder.
2. Copy your .aar files to src/main/libs
   1. ArkoseLabsSDK.aar
   2. ArkoseLabsSDKCompose.aar
      1. NOTE: this companion framework file is intended for Jetpack Compose integrations.
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'
   implementation 'com.google.code.gson:gson:2.11.0'

ProGuard rules

Update the Android ProGuard or R8 configuration with the following rule sets:

-dontwarn com.google.android.play.core.integrity.IntegrityManagerFactory
-dontwarn com.google.android.play.core.integrity.StandardIntegrityManager
-dontwarn okhttp3.OkHttpClient$Builder
-dontwarn okhttp3.OkHttpClient
-dontwarn okhttp3.logging.HttpLoggingInterceptor$Level
-dontwarn okhttp3.logging.HttpLoggingInterceptor$Logger
-dontwarn okhttp3.logging.HttpLoggingInterceptor
-dontwarn retrofit2.Converter$Factory
-dontwarn retrofit2.Retrofit$Builder
-dontwarn retrofit2.Retrofit
-dontwarn retrofit2.converter.gson.GsonConverterFactory

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 Activity class, before your class definition statements.

   Kotlin

   import com.arkoselabs.compose.sdk.ArkoseConfigCompose
   import com.arkoselabs.compose.sdk.EnforcementChallenge

2. Initialize the mutableStateOf state object to show/hide Enforcement Challenge.

   Kotlin

   val showEc = remember { mutableStateOf(false) }

3. To show the Enforcement Challenge dialog from the onClick lambda function of a Login Button, update the mutableStateOf that controls the visibility of the EnforcementChallenge() composable.

   Kotlin

   var sessionResetTime by remember { mutableIntStateOf(0) } //in milliseconds
   ...
   ...
   ...
   when {
               showEc.value -> EnforcementChallenge(
                       onDismiss = {
                           showEc.value = false
                       },
                       sessionResetTime = sessionResetTime, //optional
                       config = ArkoseConfigCompose(
                               apiKey = apiKeyText,
                               enableBackButton = true, //optional
                               noSuppress = true, //optional
                               blobData = "", //optional
                               loading = true, //optional
                               language = "", //optional
                               dismissChallengeOnTouchOutside = false, //optional
                               clientAPIRetryCount = 0, //optional
                               styleTheme = "", //optional
                               timeoutInSecondsUntilReady = 0 // SDK timeout in seconds (optional, positive integer).
                       ),
                       onCompleted = {
                           "Arkose Enforcement Challenge onCompleted -> ${it.response}".log()
                       },
                       onFailure = {
                           "Arkose Enforcement Challenge OnFailure -> ${it.response}".log()
                       },
                       onError = {
                           "Arkose Enforcement Challenge OnError -> ${it.response}".log()
                       },
                       onWarning = {
                           "Arkose Enforcement Challenge OnWarning".log()
                       },
                       onResize = {
                           "Arkose Enforcement Challenge OnResize -> ${it.response}".log()
                       },
                       onViewFramePosition = {
                           "Arkose Enforcement Challenge OnViewFramePosition -> ${it.response}".log()
                       },
                       onReady = {
                           "Arkose Enforcement Challenge OnReady".log()
                       },
                       onShow = {
                           "Arkose Enforcement Challenge OnShow".log()
                       },
                       onShown = {
                           "Arkose Enforcement Challenge OnShown-> ${it?.response}".log()
                       },
                       onHide = {
                           "Arkose Enforcement Challenge OnHide-> ${it?.response}".log()
                       },
                       onReset = {
                           "Arkose Enforcement Challenge OnReset".log()
                       },
                       onSuppress = {
                           "Arkose Enforcement Challenge OnSuppress-> ${it?.response}".log()
                       }
               )
           }

Alternatively:

4. To embed the Enforcement Challenge in an Activity, create a new InlineActivity.

   Kotlin

   import com.arkoselabs.compose.sdk.ArkoseConfigCompose
   import com.arkoselabs.compose.sdk.EnforcementChallengeInline
   
   class InlineActivity : ComponentActivity() {

5. Use the inline composable object EnforcementChallengeInline(), which will be tied to the lifecycle of InlineActivity.

   Kotlin

   @Composable
   fun InlineScreen(onFinish: () -> Unit) {
   
   val isVisible = remember { mutableStateOf(true) }
   var sessionResetTime by remember { mutableIntStateOf(0) } //in milliseconds
   ...
   ...
   Column {
                   EnforcementChallengeInline(
                       onDismiss = {
                           onFinish()
                       },
                       sessionResetTime = sessionResetTime, //optional
                       isVisible = isVisible,  //optional
                       config = ArkoseConfigCompose(
                           apiKey = AppConfig.API_KEY,
                           enableBackButton = true, //optional
                           noSuppress = false //optional
                       ),
                       onCompleted = {
                           "Arkose Enforcement Challenge onCompleted -> ${it.response}".log()
                       },
                       onFailure = {
                           "Arkose Enforcement Challenge OnFailure -> ${it.response}".log()
                       },
                       onError = {
                           "Arkose Enforcement Challenge OnError -> ${it.response}".log()
                       },
                       onWarning = {
                           "Arkose Enforcement Challenge OnWarning".log()
                       },
                       onResize = {
                           "Arkose Enforcement Challenge OnResize -> ${it.response}".log()
                       },
                       onViewFramePosition = {
                           "Arkose Enforcement Challenge OnViewFramePosition -> ${it.response}".log()
                       },
                       onReady = {
                           "Arkose Enforcement Challenge OnReady".log()
                       },
                       onShow = {
                           "Arkose Enforcement Challenge OnShow".log()
                       },
                       onShown = {
                           "Arkose Enforcement Challenge OnShown".log()
                       },
                       onHide = {
                           "Arkose Enforcement Challenge OnHide".log()
                       },
                       onReset = {
                           "Arkose Enforcement Challenge OnReset".log()
                       },
                       onSuppress = {
                           "Arkose Enforcement Challenge OnSuppress".log()
                       }
                   )
               }

6. Invoke finish() on InlineActivity when exiting the screen to prevent memory leaks.

   Kotlin

   class InlineActivity : ComponentActivity() {
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
   
           setContent {
           ...
           ...
           InlineScreen(onFinish = { finish() })
           ...
           ...
           }

7. Resetting the Arkose Session
   Arkose sessions in Jetpack Compose can be reset dynamically by modifying the properties of a mutable ArkoseConfigCompose instance. Since Jetpack Compose automatically recomposes when a state changes, updating the config will automatically reset the session.

   • Create a Mutable ArkoseConfig Instance
   • Customers should first initialize a mutable ArkoseConfigCompose instance using remember:

   • // Create a mutable ArkoseConfigCompose instance
     var arkoseConfig by remember {
         mutableStateOf(
             ArkoseConfigCompose(
                 apiKey = AppConfig.API_KEY,
                 enableBackButton = true, // Optional
                 noSuppress = false // Optional
             )
         )
     }

   • Pass the Mutable Config to EnforcementChallengeInline
     The mutable arkoseConfig should be passed to EnforcementChallengeInline, allowing it to automatically detect and apply any updates.

   • EnforcementChallengeInline(
         onDismiss = {
             closeButtonState.value = false
             onFinish()
         },
         sessionResetTime = sessionResetTime.intValue,
         isVisible = isVisible,
         config = arkoseConfig // Pass the mutable ArkoseConfig instance
         .
         .
         .
     )

   • Reset the Session by Updating arkoseConfig
     Whenever the customer wants to reset the session, they only need to update arkoseConfig properties. The Composable function will automatically apply the new configuration and reset the session.

   • // Update the arkoseConfig properties to reset the session
     arkoseConfig = ArkoseConfigCompose(
         language = "<YOUR_PREFERRED_LANGUAGE>", // Optional: Set preferred language
         styleTheme = "<YOUR_PREFERRED_STYLE_THEME>", // Optional: Set EC style theme
         blobData = "<YOUR_ENCRYPTED_DATA>" // Optional: Encrypted blob data
     )

   • Example Use Case
   • Here’s an example of resetting the session when a user clicks a button:

   • Button(onClick = {
         arkoseConfig = ArkoseConfigCompose(
             blobData = "updated_blob_data"
         )
     }) {
         Text("Reset Session")
     }

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.

2. 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.

3. If running Arkose enforcement component, verify the challenge.

4. When the verification or detection is successful, the onCompleted 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.

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

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

Jetpack Compose Support

Integrating the Arkose Mobile SDKs into Jetpack Compose apps is straightforward, eliminating the need for extra configuration and allowing developers to incorporate SDK features into composable objects with ease.

For optimal app and SDK performance, it's advised to utilize baseline profiles, which leverage Jetpack Compose's just-in-time (JIT) compilation. This approach, especially when creating baseline profiles for critical user actions like showing the Enforcement Challenge, prompts Android Runtime to optimize execution through ahead-of-time (AOT) compilation, significantly boosting performance. For guidance on crafting a Baseline Profile, consult the Android Documentation.

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.

Enforcement Challenge Configuration Parameters / strings.xml

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

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.

4. 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.

5. 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)