// FirebaseAuthWebException may not exist. Check whether the class exists

// first before trying to cache its methods.

android_web_exception::CacheClass(env, activity, util::kClassOptional);

if (android_web_exception::GetClass() != nullptr) {

android_web_exception::CacheMethodIds(env, activity);

}

return authresult::CacheMethodIds(env, activity) &&

additional_user_info::CacheMethodIds(env, activity) &&

api_not_available_exception::CacheMethodIds(env, activity) &&

action_code_exception::CacheMethodIds(env, activity) &&

email_exception::CacheMethodIds(env, activity) &&

weak_password_exception::CacheMethodIds(env, activity) &&

invalid_credentials_exception::CacheMethodIds(env, activity) &&

invalid_user_exception::CacheMethodIds(env, activity) &&

recent_login_required_exception::CacheMethodIds(env, activity) &&

user_collision_exception::CacheMethodIds(env, activity) &&

firebase_auth_exception::CacheMethodIds(env, activity) &&

firebase_network_exception::CacheMethodIds(env, activity) &&

too_many_requests_exception::CacheMethodIds(env, activity) &&

firebase_exception::CacheMethodIds(env, activity);

authresult::ReleaseClass(env);

additional_user_info::ReleaseClass(env);

api_not_available_exception::ReleaseClass(env);

action_code_exception::ReleaseClass(env);

email_exception::ReleaseClass(env);

weak_password_exception::ReleaseClass(env);

invalid_credentials_exception::ReleaseClass(env);

invalid_user_exception::ReleaseClass(env);

recent_login_required_exception::ReleaseClass(env);

user_collision_exception::ReleaseClass(env);

firebase_auth_exception::ReleaseClass(env);

firebase_network_exception::ReleaseClass(env);

too_many_requests_exception::ReleaseClass(env);

firebase_exception::ReleaseClass(env);

// Class may not exist - not yet released on Android

if (android_web_exception::GetClass() != nullptr) {

android_web_exception::ReleaseClass(env);

}

jobject exception) {

const jobject j_error_code = env->CallObjectMethod(

exception, firebase_auth_exception::GetMethodId(

firebase_auth_exception::kGetErrorCode));

util::CheckAndClearJniExceptions(env);

return util::JniStringToString(env, j_error_code);

if (!exception) return kAuthErrorNone;

// The exceptions and error mappings are all listed here:

// go/firebase-exceptions

//

// Note: The order of the following if conditions are based on class

// hierarchy. We have to check for subclasses before the superclasses.

// The exception types and their inheritance are listed in the comment above

// each block.

std::string error;

if (env->IsInstanceOf(exception, firebase_auth_exception::GetClass())) {

error = GetFirebaseAuthExceptionErrorCode(env, exception);

} else {

error = ::firebase::util::GetMessageFromException(env, exception);

}

// This cannot be static because the ::GetClass() call isn't guaranteed to

// persist as the same pointer.

const struct ClassMap {

jclass exception_class;

const ErrorCodeMapping* error_map;

AuthError catch_all;

} exception_map[] = {

// FirebaseApiNotAvailableException derives from FirebaseException,

// so error codes are not available. This exception is currently mapped to

// a single error in c++, so it's a catch all. The error code string would

// be: "ERROR_API_NOT_AVAILABLE"

{api_not_available_exception::GetClass(), nullptr,

kAuthErrorApiNotAvailable},

// FirebaseAuthActionCodeException

{action_code_exception::GetClass(), kActionCodes,

kAuthErrorUnimplemented},

// FirebaseAuthEmailException

{email_exception::GetClass(), kEmailCodes, kAuthErrorUnimplemented},

// FirebaseAuthWeakPasswordException

{weak_password_exception::GetClass(), kWeakPasswordCodes,

kAuthErrorUnimplemented},

// FirebaseAuthInvalidCredentialsException

{invalid_credentials_exception::GetClass(), kCredentialCodes,

kAuthErrorUnimplemented},

// FirebaseAuthInvalidUserException

{invalid_user_exception::GetClass(), kUserCodes, kAuthErrorUnimplemented},

// FirebaseAuthRecentLoginRequiredException

{recent_login_required_exception::GetClass(), kRecentLoginCodes,

kAuthErrorUnimplemented},

// FirebaseAuthUserCollisionException

{user_collision_exception::GetClass(), kUserCollisionCodes,

kAuthErrorUnimplemented},

// FirebaseAuthWebException

{android_web_exception::GetClass(), kWebCodes, kAuthErrorUnimplemented},

// FirebaseAuthException

{firebase_auth_exception::GetClass(), kFirebaseAuthCodes,

kAuthErrorUnimplemented},

// FirebaseNetworkException

{firebase_network_exception::GetClass(), nullptr,

kAuthErrorNetworkRequestFailed},

// FirebaseTooManyRequestsException

{too_many_requests_exception::GetClass(), kTooManyRequestsCodes,

kAuthErrorTooManyRequests},

// FirebaseException

{firebase_exception::GetClass(), kFirebaseCodes, kAuthErrorUnimplemented},

};

for (size_t i = 0; i < FIREBASE_ARRAYSIZE(exception_map); i++) {

if (exception_map[i].exception_class &&

env->IsInstanceOf(exception, exception_map[i].exception_class)) {

const ErrorCodeMapping* error_map = exception_map[i].error_map;

while (error_map != nullptr && error_map->error_str != nullptr) {

if (StringStartsWith(error, error_map->error_str)) {

// When signing in with an invalid email, the error is a generic

// message with a long json blob, with the error message contained

// within, so we need to check for that case.

if (error_map->result_error == kAuthErrorFailure &&

error.find("EMAIL_NOT_FOUND") != -1) {

return kAuthErrorUserNotFound;

}

return error_map->result_error;

}

error_map++;

}

return exception_map[i].catch_all;

}

}

return kAuthErrorUnimplemented;

std::string* error_message) {

jobject exception = env->ExceptionOccurred();

if (exception != nullptr) {

env->ExceptionClear();

AuthError error_code = ErrorCodeFromException(env, exception);

*error_message = ::firebase::util::GetMessageFromException(env, exception);

env->DeleteLocalRef(exception);

return error_code;

}

return kAuthErrorNone;

util::FutureResult result_code,

bool* success) {

*success = false;

switch (result_code) {

case util::kFutureResultSuccess:

*success = true;

return kAuthErrorNone;

case util::kFutureResultFailure:

return ErrorCodeFromException(env, result);

case util::kFutureResultCancelled:

return kAuthErrorCancelled;

default:

return kAuthErrorFailure;

}

// Delete existing global reference before overwriting it.

if (*impl != nullptr) {

env->DeleteGlobalRef(static_cast<jobject>(*impl));

*impl = nullptr;

}

// Create new global reference, so it's valid indefinitely.

if (j_local != nullptr) {

jobject j_global = env->NewGlobalRef(j_local);

env->DeleteLocalRef(j_local);

*impl = static_cast<void*>(j_global);

}

bool success, void* void_data) {

JNIEnv* env = Env(d->auth_data);

// Update the currently signed-in user on success.

// Note: `result` is only valid when success is true.

if (success && result != nullptr) {

// `result` is of type AuthResult.

const jobject j_user = env->CallObjectMethod(

result, authresult::GetMethodId(authresult::kGetUser));

util::CheckAndClearJniExceptions(env);

// Update our pointer to the Android FirebaseUser that we're wrapping.

// Note: Cannot call UpdateCurrentUser(d->auth_data) because the Java

// Auth class has not been updated at this point.

SetImplFromLocalRef(env, j_user, &d->auth_data->user_impl);

AuthResult* auth_result = static_cast<AuthResult*>(void_data);

auth_result->user = d->auth_data->auth->current_user();

// Grab the additional user info too.

// Additional user info is not guaranteed to exist, so could be nullptr.

const jobject j_additional_user_info = env->CallObjectMethod(

result, authresult::GetMethodId(authresult::kGetAdditionalUserInfo));

util::CheckAndClearJniExceptions(env);

ReadAdditionalUserInfo(env, j_additional_user_info,

&auth_result->additional_user_info);

env->DeleteLocalRef(j_additional_user_info);

// Construct the AuthResult.credential, if it exists.

const jobject j_credential = env->CallObjectMethod(

result, authresult::GetMethodId(authresult::kGetCredential));

util::CheckAndClearJniExceptions(env);

if (j_credential != nullptr) {

// This call converts the local reference to a global one, so no

// need to delete the local reference here.

auth_result->credential =

InternalAuthResultProvider::GetCredential(j_credential);

}

}

bool success, void* void_data) {

JNIEnv* env = Env(d->auth_data);

// Update the currently signed-in user on success.

// Note: `result` is only valid when success is true.

if (success && result != nullptr) {

// `result` is of type AuthResult.

const jobject j_user = env->CallObjectMethod(

result, authresult::GetMethodId(authresult::kGetUser));

util::CheckAndClearJniExceptions(env);

// Update our pointer to the Android FirebaseUser that we're wrapping.

// Note: Cannot call UpdateCurrentUser(d->auth_data) because the Java

// Auth class has not been updated at this point.

SetImplFromLocalRef(env, j_user, &d->auth_data->user_impl);

}

User* user_ptr = static_cast<User*>(void_data);

*user_ptr = d->auth_data->auth->current_user();