If an error occurs while creating a credential, pass through an error

code/message to the sign-in Future that is ultimately returned when we
try to sign in with that credential.

Currently only affects EmailAuthProvider on Android, but can be used by other
credentials in the future.

(Changes to iOS and Desktop are to properly copy the error_code_ and error_message_ in the copy constructor and assignment operator).

PiperOrigin-RevId: 249327161

Author: jonsimantov

auth/src/android/auth_android.cc

@@ -279,9 +279,9 @@ void Auth::DestroyPlatformAuth(AuthData* auth_data) {
                       auth::GetMethodId(auth::kRemoveAuthStateListener),
                       static_cast<jobject>(auth_data->listener_impl));
   assert(env->ExceptionCheck() == false);
-  env->CallVoidMethod(static_cast<jobject>(auth_data->id_token_listener_impl),
-                      jni_id_token_listener::GetMethodId(
-                          jni_id_token_listener::kDisconnect));
+  env->CallVoidMethod(
+      static_cast<jobject>(auth_data->id_token_listener_impl),
+      jni_id_token_listener::GetMethodId(jni_id_token_listener::kDisconnect));
   assert(env->ExceptionCheck() == false);
   env->CallVoidMethod(AuthImpl(auth_data),
                       auth::GetMethodId(auth::kRemoveIdTokenListener),
@@ -400,14 +400,20 @@ Future<User*> Auth::SignInWithCredential(const Credential& credential) {
   const auto handle = futures.SafeAlloc<User*>(kAuthFn_SignInWithCredential);
   JNIEnv* env = Env(auth_data_);
 
-  jobject pending_result = env->CallObjectMethod(
-      AuthImpl(auth_data_), auth::GetMethodId(auth::kSignInWithCredential),
-      CredentialFromImpl(credential.impl_));
-
-  if (!CheckAndCompleteFutureOnError(env, &futures, handle)) {
-    RegisterCallback(pending_result, handle, auth_data_,
-                     ReadUserFromSignInResult);
-    env->DeleteLocalRef(pending_result);
+  // If the credential itself is in an error state, don't try signing in.
+  if (credential.error_code_ != kAuthErrorNone) {
+    futures.Complete(handle, credential.error_code_,
+                     credential.error_message_.c_str());
+  } else {
+    jobject pending_result = env->CallObjectMethod(
+        AuthImpl(auth_data_), auth::GetMethodId(auth::kSignInWithCredential),
+        CredentialFromImpl(credential.impl_));
+
+    if (!CheckAndCompleteFutureOnError(env, &futures, handle)) {
+      RegisterCallback(pending_result, handle, auth_data_,
+                       ReadUserFromSignInResult);
+      env->DeleteLocalRef(pending_result);
+    }
   }
   return MakeFuture(&futures, handle);
 }
@@ -419,13 +425,19 @@ Future<SignInResult> Auth::SignInAndRetrieveDataWithCredential(
       kAuthFn_SignInAndRetrieveDataWithCredential);
   JNIEnv* env = Env(auth_data_);
 
-  jobject pending_result = env->CallObjectMethod(
-      AuthImpl(auth_data_), auth::GetMethodId(auth::kSignInWithCredential),
-      CredentialFromImpl(credential.impl_));
-
-  if (!CheckAndCompleteFutureOnError(env, &futures, handle)) {
-    RegisterCallback(pending_result, handle, auth_data_, ReadSignInResult);
-    env->DeleteLocalRef(pending_result);
+  // If the credential itself is in an error state, don't try signing in.
+  if (credential.error_code_ != kAuthErrorNone) {
+    futures.Complete(handle, credential.error_code_,
+                     credential.error_message_.c_str());
+  } else {
+    jobject pending_result = env->CallObjectMethod(
+        AuthImpl(auth_data_), auth::GetMethodId(auth::kSignInWithCredential),
+        CredentialFromImpl(credential.impl_));
+
+    if (!CheckAndCompleteFutureOnError(env, &futures, handle)) {
+      RegisterCallback(pending_result, handle, auth_data_, ReadSignInResult);
+      env->DeleteLocalRef(pending_result);
+    }
   }
   return MakeFuture(&futures, handle);
 }

auth/src/android/credential_android.cc

@@ -273,7 +273,10 @@ Credential::~Credential() {
   }
 }
 
-Credential::Credential(const Credential& rhs) : impl_(nullptr) { *this = rhs; }
+Credential::Credential(const Credential& rhs)
+    : impl_(nullptr), error_code_(kAuthErrorNone) {
+  *this = rhs;
+}
 
 // Increase the reference count when copying.
 Credential& Credential::operator=(const Credential& rhs) {
@@ -284,6 +287,8 @@ Credential& Credential::operator=(const Credential& rhs) {
   } else {
     impl_ = nullptr;
   }
+  error_code_ = rhs.error_code_;
+  error_message_ = rhs.error_message_;
   return *this;
 }
 
@@ -324,11 +329,33 @@ Credential EmailAuthProvider::GetCredential(const char* email,
   jobject j_cred = env->CallStaticObjectMethod(
       emailcred::GetClass(), emailcred::GetMethodId(emailcred::kGetCredential),
       j_email, j_password);
-  if (firebase::util::CheckAndClearJniExceptions(env)) j_cred = nullptr;
   env->DeleteLocalRef(j_email);
   env->DeleteLocalRef(j_password);
+  AuthError error_code = kAuthErrorNone;
+  std::string error_message;
+  if (!j_cred) {
+    // Read error from exception, except give more specific errors for email and
+    // password being blank.
+    if (strlen(email) == 0) {
+      firebase::util::CheckAndClearJniExceptions(env);
+      error_code = kAuthErrorMissingEmail;
+      error_message = "An email address must be provided.";
+    } else if (strlen(password) == 0) {
+      firebase::util::CheckAndClearJniExceptions(env);
+      error_code = kAuthErrorMissingPassword;
+      error_message = "A password must be provided.";
+    } else {
+      error_code = CheckAndClearJniAuthExceptions(env, &error_message);
+    }
+  }
 
-  return Credential(CredentialLocalToGlobalRef(j_cred));
+  Credential cred = Credential(CredentialLocalToGlobalRef(j_cred));
+  if (!j_cred) {
+    cred.error_code_ = error_code;
+    cred.error_message_ = error_message;
+  }
+
+  return cred;
 }
 
 // static

auth/src/desktop/credential_desktop.cc

@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "auth/src/include/firebase/auth/credential.h"
-
 #include "app/src/assert.h"
 #include "auth/src/desktop/auth_credential.h"
 #include "auth/src/desktop/credential_impl.h"
+#include "auth/src/include/firebase/auth/credential.h"
 
 namespace firebase {
 namespace auth {
@@ -27,6 +26,8 @@ Credential::Credential(const Credential& rhs) : impl_(nullptr) {
   if (rhs.impl_) {
     impl_ = new CredentialImpl(*(static_cast<CredentialImpl*>(rhs.impl_)));
   }
+  error_code_ = rhs.error_code_;
+  error_message_ = rhs.error_message_;
 }
 
 Credential& Credential::operator=(const Credential& rhs) {
@@ -37,6 +38,9 @@ Credential& Credential::operator=(const Credential& rhs) {
     impl_ = new CredentialImpl(*(static_cast<CredentialImpl*>(rhs.impl_)));
   }
 
+  error_code_ = rhs.error_code_;
+  error_message_ = rhs.error_message_;
+
   return *this;
 }
 

auth/src/include/firebase/auth/credential.h

@@ -18,15 +18,18 @@
 #define FIREBASE_AUTH_CLIENT_CPP_SRC_INCLUDE_FIREBASE_AUTH_CREDENTIAL_H_
 
 #include <stdint.h>
+
 #include <string>
+
 #include "firebase/internal/common.h"
+#include "firebase/auth/types.h"
 
 namespace firebase {
 
 // Predeclarations.
 class App;
 
-template<typename T>
+template <typename T>
 class Future;
 
 namespace auth {
@@ -68,10 +71,10 @@ class Credential {
   /// @see EmailAuthProvider::GetCredential()
   /// @see FacebookAuthProvider::GetCredential()
   /// @see GoogleAuthProvider::GetCredential()
-  explicit Credential(void* impl) : impl_(impl) {}
+  explicit Credential(void* impl) : impl_(impl), error_code_(kAuthErrorNone) {}
 
  public:
-  Credential() : impl_(NULL) {}
+  Credential() : impl_(nullptr), error_code_(kAuthErrorNone) {}
   ~Credential();
 
   /// Copy constructor.
@@ -97,16 +100,20 @@ class Credential {
   /// @returns True if the credential is valid, false otherwise.
   bool is_valid() const;
 
-  /// @cond FIREBASE_APP_INTERNAL
  protected:
   /// @cond FIREBASE_APP_INTERNAL
   friend class Auth;
   friend class User;
-  /// @endcond
 
   /// Platform-specific implementation.
   /// For example, FIRAuthCredential* on iOS.
   void* impl_;
+
+  // If not kAuthErrorNone, then use this error code and string to override
+  // whatever error we would normally return when trying to sign-in with this
+  // credential.
+  AuthError error_code_;
+  std::string error_message_;
   /// @endcond
 };
 

auth/src/ios/credential_ios.mm

@@ -62,6 +62,8 @@ @implementation PhoneListenerDataObjC
   if (rhs.impl_ != NULL) {
     impl_ = new FIRAuthCredentialPointer(CredentialFromImpl(rhs.impl_));
   }
+  error_code_ = rhs.error_code_;
+  error_message_ = rhs.error_message_;
 }
 
 // Default assigment.
@@ -70,6 +72,8 @@ @implementation PhoneListenerDataObjC
     delete static_cast<FIRAuthCredentialPointer*>(impl_);
     impl_ = new FIRAuthCredentialPointer(CredentialFromImpl(rhs.impl_));
   }
+  error_code_ = rhs.error_code_;
+  error_message_ = rhs.error_message_;
   return *this;
 }