Android SDK in an XML/View-based apps

// UI & resources: required for the SDK's screens to build and render
implementation 'androidx.appcompat:appcompat:1.4.2'
implementation 'com.google.android.material:material:1.6.1'   // required from SDK v2.22.0; minimum 1.5.0
implementation 'androidx.constraintlayout:constraintlayout:2.1.4'

// Kotlin runtime
implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.7.20'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'

// Serialization & device signals
implementation 'com.google.code.gson:gson:2.11.0'
implementation 'androidx.biometric:biometric:1.2.0-alpha04'

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

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
            }
        });

// Create Arkose challenge fragment
ArkoseChallenge arkoseChallenge = ArkoseManager.createEnforcementChallenge();
arkoseChallenge
        .addOnCompletedListener(arkoseChallengeResponse -> {
          // invoked On Enforcement Challenge completed
          dismissEnforcementChallenge();
         })
        .addOnFailureListener(arkoseChallengeResponse -> {
          // invoked on Enforcement Challenge failed
          boolean isRecoverable = arkoseChallengeResponse.getResponse().optBoolean("recoverable", false);
          if (!isRecoverable) {
            dismissEnforcementChallenge();
          }
        })
        .addOnHideListener(() -> {
          dismissEnforcementChallenge();
        });
        // Add other listeners as needed

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

/**
  * Removes the challenge fragment from the UI.
  * Create a function like below and 
  * invoke it from the terminal callbacks to remove the fragment from the container
  * e.g. addOnCompletedListener, addOnFailureListener, addOnHideListener, addOnErrorListener, addOnWarningListener
  */
private void dismissEnforcementChallenge() {
    try {
      if (arkoseChallenge != null)
            arkoseChallenge.removeChallengeFragment();
        Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.frameLayout);
        if (fragment != null) {
            getSupportFragmentManager().beginTransaction()
                    .remove(fragment)
                    .commitAllowingStateLoss();
        }
    } catch (Exception e) {
        Log.e(TAG, "Error hiding challenge: " + e.getMessage());
    }
}

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); 

private boolean isInlineRunOnTriggeredCalled = false;
private boolean isOnReadyCalled = false;

// Step 1: Configure ArkoseConfig with inlineRunOnTrigger enabled
ArkoseConfig arkoseConfig = new ArkoseConfig.Builder()
    .apiKey("<YOUR_PUBLIC_KEY>")
    .blobData("<YOUR_ENCRYPTED_DATA>") // Optional: encrypted blob data
    .language("<YOUR_PREFERRED_LANGUAGE>") // Optional: set language
    .setStyleTheme("<YOUR_PREFERRED_STYLE_THEME>") // Optional: set EC style theme
    .setInlineRunOnTrigger(true) // Enable preloading of enforcement challenge
    .build();
ArkoseManager.initialize(arkoseConfig, getApplication()); // initialize config with current context

// Step 2: Create Arkose challenge fragment (this preloads the challenge)
ArkoseChallenge arkoseChallenge = ArkoseManager.createEnforcementChallenge();

// Step 3: Set up event listeners
arkoseChallenge
    .addOnCompletedListener(arkoseChallengeResponse -> {
        // Handle enforcement challenge completion
        dismissEnforcementChallenge();
     })
    .addOnFailureListener(arkoseChallengeResponse -> {
        // Handle enforcement challenge failure
        boolean isRecoverable = arkoseChallengeResponse.getResponse().optBoolean("recoverable", false);
        if (!isRecoverable) {
          dismissEnforcementChallenge();
        }
     })
    .addOnReadyListener(() -> {
        isOnReadyCalled = true;
     })
    .addOnHideListener(() -> {
        dismissEnforcementChallenge();
     });
    // Add other listeners as needed

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

// Step 5: Trigger the challenge only after onReady callback (e.g., on button click)
btLogin.setOnClickListener(v -> {
    if (!isInlineRunOnTriggeredCalled) {
        if (arkoseChallenge != null && isOnReadyCalled) {
            isInlineRunOnTriggeredCalled = true;
            // This call resumes the preloaded challenge
            ArkoseManager.runTriggeredInline(arkoseChallenge);
        }
    }
});

/**
 * Removes the challenge fragment from the UI.
 * Create a function like below and 
 * invoke it from the terminal callbacks to remove the fragment from the container
 * e.g. addOnCompletedListener, addOnFailureListener, addOnHideListener, addOnErrorListener, addOnWarningListener
 */
private void dismissEnforcementChallenge() {
    try {
      if (arkoseChallenge != null)
            arkoseChallenge.removeChallengeFragment();
        Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.frameLayout);
        if (fragment != null) {
            getSupportFragmentManager().beginTransaction()
                    .remove(fragment)
                    .commitAllowingStateLoss();
        }
    } catch (Exception e) {
        Log.e(TAG, "Error hiding challenge: " + e.getMessage());
    }
}

.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);
})

// e.g
// Configure the buttons. Pass null for either to hide it.
ArkoseActionConfig cancelConfig = new ArkoseActionConfig(
        "Cancel", "Closes the challenge and returns to the previous screen");
ArkoseActionConfig resetConfig = new ArkoseActionConfig(
        "Reset", "Restarts the challenge");

ArkoseChallenge arkoseChallenge =
        ArkoseManager.showEnforcementChallenge(this, cancelConfig, resetConfig);

arkoseChallenge
        .addOnResetListener(() -> {
            // Invoked after the challenge session has reset.
        })
        .addOnHideListener(arkoseChallengeResponse -> {
            // Invoked when the user taps Cancel (challenge dismissed).
        });

arkoseChallenge.addOnPrepareForResetListener(completion -> {
    // Runs immediately when the user taps Reset.
    // Do any async prep here (e.g. refresh a token, update arkose config), then continue:
    completion.run(); // triggers the reset action
});

arkoseChallenge.addOnPrepareForResetListener(completion -> {
    ArkoseConfig newConfig = new ArkoseConfig.Builder()
            .apiKey(<YOUR_PUBLIC_KEY>)
            .blobData(<YOUR_NEW_ENCRYPTED_DATA>)
            .build();
    ArkoseManager.updateConfig(newConfig, arkoseChallenge); // stage the new config
    completion.run(); // triggers the reset action
});

public class MainActivity extends AppCompatActivity {
    private ArkoseChallenge arkChallenge;

    @Override
    protected void onPause() {
        super.onPause();
        if (arkChallenge != null) {
            arkChallenge.dispose();
        }
    }
}

public class XmlBasedActivity extends AppCompatActivity {
    private ArkoseChallenge arkoseChallenge;

    @Override
    protected void onPause() {
        super.onPause();
        hideChallenge();
    }

    private void hideChallenge() {
        if (arkoseChallenge != null) {
            // Call the removeChallengeFragment() method to remove challenege fragment
            arkoseChallenge.removeChallengeFragment();
        }
        Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.frameLayout);
        if (fragment != null) {
            getSupportFragmentManager().beginTransaction()
                .remove(fragment)
                .commitAllowingStateLoss();
        }
        arkoseChallenge = null;
    }
}