Auth Request Management

private final AuthRequestResponseEvent authRequestResponseEvent = new AuthRequestResponseEvent() {
    @Override
    public void onSuccess(@NonNull AuthRequestResponse authRequestResponse) {
        final AuthRequestResponse.Result result = authRequestResponse.getResult();
        if (result == AuthRequestResponse.Result.APPROVED) {
            // auth request was successfully verified and approved
        } else if (result == AuthRequestResponse.Result.DENIED) {
            // auth request was was denied by the user
        } else {
            // auth request failed verification, check failure
            final Failure failure = authRequestResponse.getFailure();
        }
    }

    @Override
    public void onFailure(@NonNull Exception e) {
        // failed to get the response, check exception
    }
};

private final AuthRequestPushReceivedEvent authRequestPushReceivedEvent = new AuthRequestPushReceivedEvent() {
    @Override
    public void onSuccess(@Nullable Void aVoid) {
        // an auth request push event was received. calling checkForAuthRequest() should now give a valid pending auth request
        checkForPendingAuthRequest();
    }

    @Override
    public void onFailure(@NonNull Exception e) {
        // failed to get the auth request push event, check exception
    }
};

private final GetAuthRequestEventCallback getAuthRequestEventCallback = new GetAuthRequestEventCallback() {
    @Override
    public void onSuccess(@Nullable AuthRequest result) {
        if (result != null) {
            startAuthFlow(result);
        }
    }

    @Override
    public void onFailure(@NonNull Exception e) {
        // failed to get the auth request, check exception
    }
};

@Override
public void onResume() {
    super.onResume();
    authRequestManager.registerForEvents(authRequestPushReceivedEvent, authRequestResponseEvent);
}

@Override
public void onPause() {
    authRequestManager.registerForEvents(authRequestPushReceivedEvent, authRequestResponseEvent);
    super.onPause();
}

private void checkForPendingAuthRequest() {
    if (!AuthenticatorManager.instance.isDeviceLinked()) {
        return;
    }

    authRequestManager.checkForAuthRequest(getAuthRequestEventCallback);
}

private void startAuthFlow(AuthRequest authRequest) {
    // You may deny the auth request anytime by supplying a DenialReason to
    // authRequestManager.denyAndSend(authRequest, denialReasonObject);

    // accepting the request will automatically send the response if the conditions
    // for the policy were not met
    final boolean failedPolicy = authRequestManager.acceptAndSendIfFailed(authRequest);

    if (!failedPolicy) {
        // get the auth methods requiring verification for this auth request
        final List<Factor> methodsToVerify = authRequestManager.getAuthMethodsToVerify(authRequest);

        // verify the auth methods
        verifyMethods(methodsToVerify);
    }
}

private void verifyAuthMethods(List<AuthMethod> authMethodsToVerify) {
    for (AuthMethod authMethod : authMethodsToVerify) {
        verifyAuthMethod(authMethod);
    }
}

private void verifyAuthMethod(AuthMethod authMethod) {
    switch (authMethod) {
        case PIN_CODE:
            verifyPinCode();
            break;
        case CIRCLE_CODE:
            verifyCircleCode();
            break;
        case LOCATIONS:
            verifyLocations();
            break;
        case BIOMETRIC:
            verifyBiometric();
            break;
        case WEARABLES:
            verifyWearables();
            break;
        case GEOFENCING:
            verifyGeofence();
            break;
    }
}

private void verifyGeofence() {
    // verify that Manifest.permission.ACCESS_FINE_LOCATION is granted prior to this call
    GeofencesManager geofencesManager = AuthMethodManagerFactory.getGeofencesManager();
    geofencesManager.verifyGeofencesForAuthRequest(currentAuthRequest, new AuthMethodAuthRequestVerificationCallback() {
        @Override
        public void onVerificationSuccess(final boolean authRequestWasSent) {
            // To check if this was a conditional geofence, then make sure to call authRequestManager.getAuthMethodsToVerify(currentAuthRequest).
            // If this list is different, from the prior call to it, then it was a condition geofence.
        }

        @Override
        public void onVerificationFailure(final boolean authRequestWasSent,
                                   final @NonNull AuthMethodFailure failure,
                                   final boolean unlinkTriggered,
                                   final boolean unlinkWarningTriggered,
                                   final @Nullable Integer attemptsRemaining) {
            // failed to verify the remote geofence location, check failure
        }
    });
}

private void verifyPinCode(String pinCode) {
    PINCodeManager pinCodeManager = AuthMethodManagerFactory.getPINCodeManager();
    // retrieve pincode from user prior to this call
    pinCodeManager.verifyPINCodeForAuthRequest(pinCode, currentAuthRequest, new AuthMethodAuthRequestVerificationCallback() {
        @Override public void onVerificationSuccess(boolean b) {
            verifiedAuthMethod(AuthMethod.PIN_CODE);
        }

        @Override public void onVerificationFailure(boolean b, @NonNull AuthMethodFailure authMethodFailure, boolean b1, boolean b2, @Nullable Integer integer) {
            showToast("Failed to verify PIN Code. " + integer + " attempts remaining");
        }
    });
}

...

private void sendResponse(AuthRequest authRequest) {
    // once all factors are verified, send the response for the auth request
    authRequestManager.send(authRequest);
}