Dostt v1.0.89 - ReactNativeFirebaseAuthModule.java 源代码

package io.invertase.firebase.auth;

import android.app.Activity;
import android.net.Uri;
import android.os.Parcel;
import android.util.Log;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.ReadableMapKeySetIterator;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.N;
import com.google.firebase.auth.Q;
import com.google.firebase.auth.a0;
import com.google.firebase.auth.b0;
import com.google.firebase.auth.c0;
import com.google.firebase.auth.e;
import com.razorpay.rn.RazorpayModule;
import io.invertase.firebase.app.ReactNativeFirebaseAppModule;
import io.invertase.firebase.auth.ReactNativeFirebaseAuthModule;
import io.invertase.firebase.common.ReactNativeFirebaseModule;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

class ReactNativeFirebaseAuthModule extends ReactNativeFirebaseModule {
    private static final String TAG = "Auth";
    private HashMap<String, com.google.firebase.auth.h> credentials;
    private final HashMap<String, com.google.firebase.auth.K> mCachedResolvers;
    private com.google.firebase.auth.O mCredential;
    private Q.a mForceResendingToken;
    private String mLastPhoneNumber;
    private final HashMap<String, com.google.firebase.auth.L> mMultiFactorSessions;
    private String mVerificationId;
    public static final SimpleDateFormat ISO_8601_FORMATTER = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
    private static HashMap<String, FirebaseAuth.a> mAuthListeners = new HashMap<>();
    private static HashMap<String, FirebaseAuth.b> mIdTokenListeners = new HashMap<>();
    private static HashMap<String, String> emulatorConfigs = new HashMap<>();

    class a extends Q.b {
        private boolean a = false;
        final FirebaseAuth b;
        final Promise c;

        a(FirebaseAuth firebaseAuth, Promise promise) {
            this.b = firebaseAuth;
            this.c = promise;
        }

        public void b(com.google.firebase.auth.O o, Promise promise, Task task) {
            if (!task.isSuccessful()) {
                Exception exception = task.getException();
                Log.e(ReactNativeFirebaseAuthModule.TAG, "signInWithPhoneNumber:autoVerified:signInWithCredential:onComplete:failure", exception);
                if (this.a) {
                    return;
                }
                ReactNativeFirebaseAuthModule.this.promiseRejectAuthException(promise, exception);
                return;
            }
            Log.d(ReactNativeFirebaseAuthModule.TAG, "signInWithPhoneNumber:autoVerified:signInWithCredential:onComplete:success");
            if (this.a) {
                return;
            }
            WritableMap createMap = Arguments.createMap();
            Parcel obtain = Parcel.obtain();
            o.writeToParcel(obtain, 0);
            obtain.setDataPosition(16);
            String readString = obtain.readString();
            ReactNativeFirebaseAuthModule.this.mVerificationId = readString;
            obtain.recycle();
            createMap.putString("verificationId", readString);
            promise.resolve(createMap);
        }

        public void onCodeAutoRetrievalTimeOut(String str) {
            super.onCodeAutoRetrievalTimeOut(str);
        }

        public void onCodeSent(String str, Q.a aVar) {
            ReactNativeFirebaseAuthModule.this.mVerificationId = str;
            ReactNativeFirebaseAuthModule.this.mForceResendingToken = aVar;
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            this.c.resolve(createMap);
            this.a = true;
        }

        public void onVerificationCompleted(final com.google.firebase.auth.O o) {
            Task A = this.b.A(o);
            ExecutorService executor = ReactNativeFirebaseAuthModule.this.getExecutor();
            final Promise promise = this.c;
            A.addOnCompleteListener(executor, new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.a.this.b(o, promise, task);
                }
            });
        }

        public void onVerificationFailed(F9.m mVar) {
            Log.d(ReactNativeFirebaseAuthModule.TAG, "signInWithPhoneNumber:verification:failed");
            ReactNativeFirebaseAuthModule.this.promiseRejectAuthException(this.c, mVar);
        }
    }

    class b extends Q.b {
        final Promise a;
        final String b;

        b(Promise promise, String str) {
            this.a = promise;
            this.b = str;
        }

        public void onCodeSent(String str, Q.a aVar) {
            this.a.resolve(str);
        }

        public void onVerificationCompleted(com.google.firebase.auth.O o) {
            ReactNativeFirebaseAuthModule.this.resolveMultiFactorCredential(o, this.b, this.a);
        }

        public void onVerificationFailed(F9.m mVar) {
            ReactNativeFirebaseAuthModule.this.promiseRejectAuthException(this.a, mVar);
        }
    }

    class c extends Q.b {
        final Promise a;

        c(Promise promise) {
            this.a = promise;
        }

        public void onCodeSent(String str, Q.a aVar) {
            this.a.resolve(str);
        }

        public void onVerificationCompleted(com.google.firebase.auth.O o) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(this.a, "not-implemented", "This is currently not supported.");
        }

        public void onVerificationFailed(F9.m mVar) {
            ReactNativeFirebaseAuthModule.this.promiseRejectAuthException(this.a, mVar);
        }
    }

    class d extends Q.b {
        final String a;
        final String b;

        d(String str, String str2) {
            this.a = str;
            this.b = str2;
        }

        public void onCodeAutoRetrievalTimeOut(String str) {
            super.onCodeAutoRetrievalTimeOut(str);
            Log.d(ReactNativeFirebaseAuthModule.TAG, "verifyPhoneNumber:verification:onCodeAutoRetrievalTimeOut");
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onCodeAutoRetrievalTimeout", createMap);
        }

        public void onCodeSent(String str, Q.a aVar) {
            Log.d(ReactNativeFirebaseAuthModule.TAG, "verifyPhoneNumber:verification:onCodeSent");
            ReactNativeFirebaseAuthModule.this.mForceResendingToken = aVar;
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            createMap.putString("verificationId", str);
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onCodeSent", createMap);
        }

        public void onVerificationCompleted(com.google.firebase.auth.O o) {
            ReactNativeFirebaseAuthModule.this.mCredential = o;
            Log.d(ReactNativeFirebaseAuthModule.TAG, "verifyPhoneNumber:verification:onVerificationCompleted");
            WritableMap createMap = Arguments.createMap();
            Parcel obtain = Parcel.obtain();
            o.writeToParcel(obtain, 0);
            obtain.setDataPosition(16);
            String readString = obtain.readString();
            obtain.setDataPosition(obtain.dataPosition() + 8);
            createMap.putString(RazorpayModule.MAP_KEY_ERROR_CODE, obtain.readString());
            createMap.putString("verificationId", readString);
            obtain.recycle();
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onVerificationComplete", createMap);
        }

        public void onVerificationFailed(F9.m mVar) {
            Log.d(ReactNativeFirebaseAuthModule.TAG, "verifyPhoneNumber:verification:onVerificationFailed");
            WritableMap createMap = Arguments.createMap();
            createMap.putMap("error", ReactNativeFirebaseAuthModule.this.getJSError(mVar));
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onVerificationFailed", createMap);
        }
    }

    ReactNativeFirebaseAuthModule(ReactApplicationContext reactApplicationContext) {
        super(reactApplicationContext, TAG);
        this.mCachedResolvers = new HashMap<>();
        this.mMultiFactorSessions = new HashMap<>();
        this.credentials = new HashMap<>();
    }

    private com.google.firebase.auth.e buildActionCodeSettings(ReadableMap readableMap) {
        e.a k0 = com.google.firebase.auth.e.k0();
        String string = readableMap.getString("url");
        Objects.requireNonNull(string);
        e.a g = k0.g(string);
        if (readableMap.hasKey("handleCodeInApp")) {
            g = g.d(readableMap.getBoolean("handleCodeInApp"));
        }
        if (readableMap.hasKey("dynamicLinkDomain")) {
            g = g.c(readableMap.getString("dynamicLinkDomain"));
        }
        if (readableMap.hasKey("linkDomain")) {
            String string2 = readableMap.getString("linkDomain");
            Objects.requireNonNull(string2);
            g = g.f(string2);
        }
        if (readableMap.hasKey("android")) {
            ReadableMap map = readableMap.getMap("android");
            Objects.requireNonNull(map);
            boolean z = map.hasKey("installApp") && map.getBoolean("installApp");
            String string3 = map.hasKey("minimumVersion") ? map.getString("minimumVersion") : null;
            String string4 = map.getString("packageName");
            Objects.requireNonNull(string4);
            g = g.b(string4, z, string3);
        }
        if (readableMap.hasKey("iOS")) {
            String string5 = readableMap.getMap("iOS").getString("bundleId");
            Objects.requireNonNull(string5);
            g = g.e(string5);
        }
        return g.a();
    }

    private WritableArray convertProviderData(List<? extends b0> list, com.google.firebase.auth.A a2) {
        WritableArray createArray = Arguments.createArray();
        Iterator it = new ArrayList(list).iterator();
        while (it.hasNext()) {
            b0 b0Var = (b0) it.next();
            if (!"firebase".equals(b0Var.i())) {
                WritableMap createMap = Arguments.createMap();
                createMap.putString("providerId", b0Var.i());
                createMap.putString("uid", b0Var.c());
                createMap.putString("displayName", b0Var.r());
                Uri A = b0Var.A();
                if (A == null || "".equals(A.toString())) {
                    createMap.putNull("photoURL");
                } else {
                    createMap.putString("photoURL", A.toString());
                }
                String d2 = b0Var.d();
                if ("phone".equals(b0Var.i()) && (b0Var.d() == null || "".equals(b0Var.d()))) {
                    createMap.putString("phoneNumber", a2.d());
                } else if (d2 == null || "".equals(d2)) {
                    createMap.putNull("phoneNumber");
                } else {
                    createMap.putString("phoneNumber", d2);
                }
                if ("password".equals(b0Var.i()) && (b0Var.Y() == null || "".equals(b0Var.Y()))) {
                    createMap.putString("email", b0Var.c());
                } else if (b0Var.Y() == null || "".equals(b0Var.Y())) {
                    createMap.putNull("email");
                } else {
                    createMap.putString("email", b0Var.Y());
                }
                createArray.pushMap(createMap);
            }
        }
        return createArray;
    }

    @ReactMethod
    private void createUserWithEmailAndPassword(String str, String str2, String str3, final Promise promise) {
        Log.d(TAG, "createUserWithEmailAndPassword");
        FirebaseAuth.getInstance(F9.g.p(str)).f(str2, str3).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$createUserWithEmailAndPassword$4(promise, (com.google.firebase.auth.i) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$createUserWithEmailAndPassword$5(promise, exc);
            }
        });
    }

    private WritableMap firebaseUserToMap(com.google.firebase.auth.A a2) {
        WritableMap createMap = Arguments.createMap();
        String c2 = a2.c();
        String Y = a2.Y();
        Uri A = a2.A();
        String r = a2.r();
        String i = a2.i();
        boolean F = a2.F();
        String d2 = a2.d();
        String i0 = a2.i0();
        createMap.putString("uid", c2);
        createMap.putString("providerId", i);
        createMap.putBoolean("emailVerified", F);
        createMap.putBoolean("isAnonymous", a2.j0());
        if (Y == null || "".equals(Y)) {
            createMap.putNull("email");
        } else {
            createMap.putString("email", Y);
        }
        if (r == null || "".equals(r)) {
            createMap.putNull("displayName");
        } else {
            createMap.putString("displayName", r);
        }
        if (A == null || "".equals(A.toString())) {
            createMap.putNull("photoURL");
        } else {
            createMap.putString("photoURL", A.toString());
        }
        if (d2 == null || "".equals(d2)) {
            createMap.putNull("phoneNumber");
        } else {
            createMap.putString("phoneNumber", d2);
        }
        if (i0 == null || "".equals(i0)) {
            createMap.putNull("tenantId");
        } else {
            createMap.putString("tenantId", i0);
        }
        createMap.putArray("providerData", convertProviderData(a2.h0(), a2));
        WritableMap createMap2 = Arguments.createMap();
        if (a2.f0() != null) {
            createMap2.putDouble("creationTime", r2.q());
            createMap2.putDouble("lastSignInTime", r2.v());
        }
        createMap.putMap("metadata", createMap2);
        WritableArray createArray = Arguments.createArray();
        Iterator it = a2.g0().b().iterator();
        while (it.hasNext()) {
            createArray.pushMap(multiFactorInfoToMap((com.google.firebase.auth.J) it.next()));
        }
        WritableMap createMap3 = Arguments.createMap();
        createMap3.putArray("enrolledFactors", createArray);
        createMap.putMap("multiFactor", createMap3);
        return createMap;
    }

    private com.google.firebase.auth.h getCredentialForProvider(String str, String str2, String str3) {
        if (str.startsWith("oidc.")) {
            return com.google.firebase.auth.N.f(str).b(str2).a();
        }
        if (this.credentials.containsKey(str2) && this.credentials.get(str2) != null) {
            return this.credentials.get(str2);
        }
        switch (str) {
            case "apple.com":
                return com.google.firebase.auth.N.f(str).c(str2, str3).a();
            case "twitter.com":
                return a0.a(str2, str3);
            case "google.com":
                return com.google.firebase.auth.G.a(str2, str3);
            case "facebook.com":
                return com.google.firebase.auth.m.a(str2);
            case "oauth":
                return com.google.firebase.auth.N.d(str, str2, str3);
            case "phone":
                return getPhoneAuthCredential(str2, str3);
            case "password":
                return com.google.firebase.auth.k.a(str2, str3);
            case "github.com":
                return com.google.firebase.auth.E.a(str2);
            case "emailLink":
                return com.google.firebase.auth.k.b(str2, str3);
            default:
                return null;
        }
    }

    public com.facebook.react.bridge.WritableMap getJSError(java.lang.Exception r13) {
        throw new UnsupportedOperationException("Method not decompiled: io.invertase.firebase.auth.ReactNativeFirebaseAuthModule.getJSError(java.lang.Exception):com.facebook.react.bridge.WritableMap");
    }

    private com.google.firebase.auth.O getPhoneAuthCredential(String str, String str2) {
        com.google.firebase.auth.O o;
        if (str == null && (o = this.mCredential) != null) {
            this.mCredential = null;
            return o;
        }
        if (str != null) {
            return com.google.firebase.auth.Q.a(str, str2);
        }
        return null;
    }

    public void lambda$addAuthStateListener$0(String str, FirebaseAuth firebaseAuth) {
        com.google.firebase.auth.A j = firebaseAuth.j();
        WritableMap createMap = Arguments.createMap();
        Fh.g i = Fh.g.i();
        if (j != null) {
            createMap.putString("appName", str);
            createMap.putMap("user", firebaseUserToMap(j));
        } else {
            createMap.putString("appName", str);
        }
        Log.d(TAG, "addAuthStateListener:eventBody " + createMap.toString());
        i.o(new Fh.b("auth_state_changed", createMap, str));
    }

    public void lambda$addIdTokenListener$1(String str, FirebaseAuth firebaseAuth) {
        com.google.firebase.auth.A j = firebaseAuth.j();
        Fh.g i = Fh.g.i();
        WritableMap createMap = Arguments.createMap();
        if (j != null) {
            createMap.putBoolean("authenticated", true);
            createMap.putString("appName", str);
            createMap.putMap("user", firebaseUserToMap(j));
        } else {
            createMap.putString("appName", str);
            createMap.putBoolean("authenticated", false);
        }
        i.o(new Fh.b("auth_id_token_changed", createMap, str));
    }

    public void lambda$applyActionCode$32(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "applyActionCode:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "applyActionCode:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$checkActionCode$33(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.e(TAG, "checkActionCode:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
            return;
        }
        Log.d(TAG, "checkActionCode:onComplete:success");
        com.google.firebase.auth.d dVar = (com.google.firebase.auth.d) task.getResult();
        Objects.requireNonNull(dVar);
        com.google.firebase.auth.d dVar2 = dVar;
        WritableMap createMap = Arguments.createMap();
        WritableMap createMap2 = Arguments.createMap();
        createMap2.putString("email", dVar2.a(0));
        createMap2.putString("fromEmail", dVar2.a(1));
        createMap.putMap("data", createMap2);
        int b2 = dVar2.b();
        createMap.putString("operation", b2 != 0 ? b2 != 1 ? b2 != 2 ? b2 != 3 ? b2 != 4 ? "UNKNOWN" : "EMAIL_SIGNIN" : "ERROR" : "RECOVER_EMAIL" : "VERIFY_EMAIL" : "PASSWORD_RESET");
        promise.resolve(createMap);
    }

    public void lambda$confirmPasswordReset$31(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "confirmPasswordReset:onComplete:success");
            promiseNoUser(promise, Boolean.FALSE);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "confirmPasswordReset:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$confirmationResultConfirm$30(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.e(TAG, "confirmationResultConfirm:signInWithCredential:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        } else {
            Log.d(TAG, "confirmationResultConfirm:signInWithCredential:onComplete:success");
            com.google.firebase.auth.i iVar = (com.google.firebase.auth.i) task.getResult();
            Objects.requireNonNull(iVar);
            promiseWithAuthResult(iVar, promise);
        }
    }

    public void lambda$createUserWithEmailAndPassword$4(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "createUserWithEmailAndPassword:onComplete:success");
        promiseWithAuthResult(iVar, promise);
        Log.d(TAG, "createUserWithEmailAndPassword:onComplete:promiseResolved");
    }

    public void lambda$createUserWithEmailAndPassword$5(Promise promise, Exception exc) {
        Log.e(TAG, "createUserWithEmailAndPassword:onComplete:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$delete$14(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "delete:onComplete:success");
            promiseNoUser(promise, Boolean.FALSE);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "delete:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$fetchSignInMethodsForEmail$47(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.d(TAG, "fetchProvidersForEmail:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
            return;
        }
        Log.d(TAG, "fetchProvidersForEmail:onComplete:success");
        com.google.firebase.auth.W w = (com.google.firebase.auth.W) task.getResult();
        Objects.requireNonNull(w);
        List a2 = w.a();
        WritableArray createArray = Arguments.createArray();
        if (a2 != null) {
            Iterator it = a2.iterator();
            while (it.hasNext()) {
                createArray.pushString((String) it.next());
            }
        }
        promise.resolve(createArray);
    }

    public void lambda$finalizeMultiFactorEnrollment$28(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "finalizeMultiFactorEnrollment:onComplete:success");
            promise.resolve((Object) null);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "finalizeMultiFactorEnrollment:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$getIdToken$45(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.e(TAG, "getIdToken:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        } else {
            Log.d(TAG, "getIdToken:onComplete:success");
            com.google.firebase.auth.C c2 = (com.google.firebase.auth.C) task.getResult();
            Objects.requireNonNull(c2);
            promise.resolve(c2.f());
        }
    }

    public void lambda$getIdTokenResult$46(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.e(TAG, "getIdTokenResult:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
            return;
        }
        Log.d(TAG, "getIdTokenResult:onComplete:success");
        com.google.firebase.auth.C c2 = (com.google.firebase.auth.C) task.getResult();
        WritableMap createMap = Arguments.createMap();
        Objects.requireNonNull(c2);
        Fh.m.g("authTime", Fh.m.i(c2.a()), createMap);
        Fh.m.g("expirationTime", Fh.m.i(c2.c()), createMap);
        Fh.m.g("issuedAtTime", Fh.m.i(c2.d()), createMap);
        Fh.m.g("claims", c2.b(), createMap);
        Fh.m.g("signInProvider", c2.e(), createMap);
        Fh.m.g("token", c2.f(), createMap);
        promise.resolve(createMap);
    }

    public void lambda$getSession$27(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, task.getException());
            return;
        }
        com.google.firebase.auth.L l = (com.google.firebase.auth.L) task.getResult();
        String num = Integer.toString(l.hashCode());
        this.mMultiFactorSessions.put(num, l);
        promise.resolve(num);
    }

    public void lambda$linkWithCredential$34(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "link:onComplete:success");
            promiseWithAuthResult((com.google.firebase.auth.i) task.getResult(), promise);
            return;
        }
        com.google.firebase.auth.x exception = task.getException();
        if (exception instanceof com.google.firebase.auth.x) {
            com.google.firebase.auth.x xVar = exception;
            com.google.firebase.auth.h b2 = xVar.b();
            Log.d(TAG, "link:onComplete:collisionFailure", xVar);
            if (b2 != null) {
                Log.d(TAG, "link:onComplete:collisionFailure had credential", xVar);
                promiseRejectLinkAuthException(promise, xVar, b2);
                return;
            }
        }
        Log.e(TAG, "link:onComplete:failure", exception);
        promiseRejectAuthException(promise, exception);
    }

    public void lambda$linkWithProvider$35(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "linkWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$linkWithProvider$36(Promise promise, Exception exc) {
        Log.d(TAG, "linkWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$linkWithProvider$37(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "linkWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$linkWithProvider$38(Promise promise, Exception exc) {
        Log.d(TAG, "linkWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$reauthenticateWithCredential$40(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "reauthenticate:onComplete:success");
            promiseWithAuthResult((com.google.firebase.auth.i) task.getResult(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "reauthenticate:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$reauthenticateWithProvider$41(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "reauthenticateWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$reauthenticateWithProvider$42(Promise promise, Exception exc) {
        Log.d(TAG, "reauthenticateWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$reauthenticateWithProvider$43(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "reauthenticateWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$reauthenticateWithProvider$44(Promise promise, Exception exc) {
        Log.d(TAG, "reauthenticateWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$reload$15(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "reload:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "reload:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$resolveMultiFactorCredential$29(Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithAuthResult((com.google.firebase.auth.i) task.getResult(), promise);
        } else {
            promiseRejectAuthException(promise, task.getException());
        }
    }

    public void lambda$sendEmailVerification$16(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "sendEmailVerification:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "sendEmailVerification:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$sendPasswordResetEmail$12(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "sendPasswordResetEmail:onComplete:success");
            promiseNoUser(promise, Boolean.FALSE);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "sendPasswordResetEmail:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$sendSignInLinkToEmail$13(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "sendSignInLinkToEmail:onComplete:success");
            promiseNoUser(promise, Boolean.FALSE);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "sendSignInLinkToEmail:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$signInAnonymously$2(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInAnonymously:onComplete:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInAnonymously$3(Promise promise, Exception exc) {
        Log.e(TAG, "signInAnonymously:onComplete:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$signInWithCredential$22(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "signInWithCredential:onComplete:success");
            promiseWithAuthResult((com.google.firebase.auth.i) task.getResult(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "signInWithCredential:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$signInWithCustomToken$10(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInWithCustomToken:onComplete:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInWithCustomToken$11(Promise promise, Exception exc) {
        Log.e(TAG, "signInWithCustomToken:onComplete:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$signInWithEmailAndPassword$6(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInWithEmailAndPassword:onComplete:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInWithEmailAndPassword$7(Promise promise, Exception exc) {
        Log.e(TAG, "signInWithEmailAndPassword:onComplete:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$signInWithEmailLink$8(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInWithEmailLink:onComplete:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInWithEmailLink$9(Promise promise, Exception exc) {
        Log.e(TAG, "signInWithEmailLink:onComplete:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$signInWithProvider$23(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInWithProvider$24(Promise promise, Exception exc) {
        Log.d(TAG, "signInWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$signInWithProvider$25(Promise promise, com.google.firebase.auth.i iVar) {
        Log.d(TAG, "signInWithProvider:success");
        promiseWithAuthResult(iVar, promise);
    }

    public void lambda$signInWithProvider$26(Promise promise, Exception exc) {
        Log.d(TAG, "signInWithProvider:failure", exc);
        promiseRejectAuthException(promise, exc);
    }

    public void lambda$unlink$39(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            Log.e(TAG, "unlink:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        } else {
            Log.d(TAG, "unlink:onComplete:success");
            com.google.firebase.auth.i iVar = (com.google.firebase.auth.i) task.getResult();
            Objects.requireNonNull(iVar);
            promiseWithUser(iVar.f(), promise);
        }
    }

    public void lambda$updateEmail$18(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "updateEmail:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "updateEmail:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$updatePassword$19(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "updatePassword:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "updatePassword:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$updatePhoneNumber$20(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "updatePhoneNumber:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "updatePhoneNumber:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$updateProfile$21(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "updateProfile:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "updateProfile:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$verifyBeforeUpdateEmail$17(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "verifyBeforeUpdateEmail:onComplete:success");
            promiseWithUser(firebaseAuth.j(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "verifyBeforeUpdateEmail:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    public void lambda$verifyPasswordResetCode$48(Promise promise, Task task) {
        if (task.isSuccessful()) {
            Log.d(TAG, "verifyPasswordResetCode:onComplete:success");
            promise.resolve(task.getResult());
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "verifyPasswordResetCode:onComplete:failure", exception);
            promiseRejectAuthException(promise, exception);
        }
    }

    @ReactMethod
    private void linkWithCredential(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.h credentialForProvider = getCredentialForProvider(str2, str3, str4);
        if (credentialForProvider == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
            return;
        }
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "link");
        if (j != null) {
            j.k0(credentialForProvider).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithCredential$34(promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    private void linkWithProvider(String str, ReadableMap readableMap, final Promise promise) {
        ReadableMap map;
        ReadableArray array;
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (readableMap.getString("providerId") == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
            return;
        }
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "linkWithProvider");
        if (j == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        N.a e = com.google.firebase.auth.N.e(readableMap.getString("providerId"), firebaseAuth);
        if (readableMap.hasKey("scopes") && (array = readableMap.getArray("scopes")) != null) {
            ArrayList arrayList = new ArrayList();
            for (int i = 0; i < array.size(); i++) {
                arrayList.add(array.getString(i));
            }
            e.c(arrayList);
        }
        if (readableMap.hasKey("customParameters") && (map = readableMap.getMap("customParameters")) != null) {
            ReadableMapKeySetIterator keySetIterator = map.keySetIterator();
            while (keySetIterator.hasNextKey()) {
                String nextKey = keySetIterator.nextKey();
                e.a(nextKey, map.getString(nextKey));
            }
        }
        Task n = firebaseAuth.n();
        if (n != null) {
            n.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$35(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$36(promise, exc);
                }
            });
        } else {
            j.p0(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$37(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$38(promise, exc);
                }
            });
        }
    }

    private WritableMap multiFactorInfoToMap(com.google.firebase.auth.J j) {
        WritableMap createMap = Arguments.createMap();
        Date date = new Date(j.d0() * 1000);
        createMap.putString("displayName", j.r());
        createMap.putString("enrollmentTime", ISO_8601_FORMATTER.format(date));
        createMap.putString("factorId", j.e0());
        createMap.putString("uid", j.c());
        if (j.e0().equals("phone")) {
            createMap.putString("phoneNumber", ((com.google.firebase.auth.U) j).d());
        }
        return createMap;
    }

    private void promiseNoUser(Promise promise, Boolean bool) {
        if (bool.booleanValue()) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "no-current-user", "No user currently signed in.");
        } else {
            promise.resolve((Object) null);
        }
    }

    public void promiseRejectAuthException(Promise promise, Exception exc) {
        WritableMap jSError = getJSError(exc);
        String string = jSError.hasKey("sessionId") ? jSError.getString("sessionId") : null;
        com.google.firebase.auth.K k = this.mCachedResolvers.get(string);
        WritableMap createMap = Arguments.createMap();
        if (k != null) {
            createMap = resolverToMap(string, k);
        }
        ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, jSError.getString(RazorpayModule.MAP_KEY_ERROR_CODE), jSError.getString("message"), (ReadableMap) createMap);
    }

    private void promiseRejectLinkAuthException(Promise promise, Exception exc, com.google.firebase.auth.h hVar) {
        WritableMap jSError = getJSError(exc);
        String valueOf = String.valueOf(hVar.hashCode());
        WritableMap createMap = Arguments.createMap();
        createMap.putString("providerId", hVar.d0());
        createMap.putString("token", valueOf);
        createMap.putString("secret", (String) null);
        this.credentials.put(valueOf, hVar);
        WritableMap createMap2 = Arguments.createMap();
        createMap2.putString(RazorpayModule.MAP_KEY_ERROR_CODE, jSError.getString(RazorpayModule.MAP_KEY_ERROR_CODE));
        createMap2.putString("message", jSError.getString("message"));
        createMap2.putMap("authCredential", createMap);
        promise.reject(jSError.getString(RazorpayModule.MAP_KEY_ERROR_CODE), jSError.getString("message"), createMap2);
    }

    private void promiseWithAuthResult(com.google.firebase.auth.i iVar, Promise promise) {
        if (iVar == null || iVar.f() == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        WritableMap createMap = Arguments.createMap();
        WritableMap firebaseUserToMap = firebaseUserToMap(iVar.f());
        if (iVar.P() != null) {
            WritableMap createMap2 = Arguments.createMap();
            createMap2.putBoolean("isNewUser", iVar.P().z());
            if (iVar.P().R() != null) {
                Fh.m.g("profile", iVar.P().R(), createMap2);
            }
            if (iVar.P().i() != null) {
                createMap2.putString("providerId", iVar.P().i());
            }
            if (iVar.P().L() != null) {
                createMap2.putString("username", iVar.P().L());
            }
            createMap.putMap("additionalUserInfo", createMap2);
        }
        createMap.putMap("user", firebaseUserToMap);
        promise.resolve(createMap);
    }

    private void promiseWithUser(com.google.firebase.auth.A a2, Promise promise) {
        if (a2 != null) {
            promise.resolve(firebaseUserToMap(a2));
        } else {
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    private void reauthenticateWithCredential(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.h credentialForProvider = getCredentialForProvider(str2, str3, str4);
        if (credentialForProvider == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
            return;
        }
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "reauthenticate");
        if (j != null) {
            j.l0(credentialForProvider).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithCredential$40(promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    private void reauthenticateWithProvider(String str, ReadableMap readableMap, final Promise promise) {
        ReadableMap map;
        ReadableArray array;
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (readableMap.getString("providerId") == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
            return;
        }
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "reauthenticateWithProvider");
        if (j == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        N.a e = com.google.firebase.auth.N.e(readableMap.getString("providerId"), firebaseAuth);
        if (readableMap.hasKey("scopes") && (array = readableMap.getArray("scopes")) != null) {
            ArrayList arrayList = new ArrayList();
            for (int i = 0; i < array.size(); i++) {
                arrayList.add(array.getString(i));
            }
            e.c(arrayList);
        }
        if (readableMap.hasKey("customParameters") && (map = readableMap.getMap("customParameters")) != null) {
            ReadableMapKeySetIterator keySetIterator = map.keySetIterator();
            while (keySetIterator.hasNextKey()) {
                String nextKey = keySetIterator.nextKey();
                e.a(nextKey, map.getString(nextKey));
            }
        }
        Task n = firebaseAuth.n();
        if (n != null) {
            n.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$41(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$42(promise, exc);
                }
            });
        } else {
            j.q0(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$43(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$44(promise, exc);
                }
            });
        }
    }

    public void resolveMultiFactorCredential(com.google.firebase.auth.O o, String str, final Promise promise) {
        com.google.firebase.auth.S a2 = com.google.firebase.auth.T.a(o);
        com.google.firebase.auth.K k = this.mCachedResolvers.get(str);
        if (k == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-multi-factor-session", "No resolver for session found. Is the session id correct?");
        } else {
            k.g0(a2).addOnCompleteListener(new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$resolveMultiFactorCredential$29(promise, task);
                }
            });
        }
    }

    private WritableMap resolverToMap(String str, com.google.firebase.auth.K k) {
        WritableMap createMap = Arguments.createMap();
        WritableArray createArray = Arguments.createArray();
        Iterator it = k.e0().iterator();
        while (it.hasNext()) {
            createArray.pushMap(multiFactorInfoToMap((com.google.firebase.auth.J) it.next()));
        }
        createMap.putArray("hints", createArray);
        createMap.putString("session", str);
        return createMap;
    }

    public void sendPhoneStateEvent(String str, String str2, String str3, WritableMap writableMap) {
        WritableMap createMap = Arguments.createMap();
        Fh.g i = Fh.g.i();
        createMap.putString("appName", str);
        createMap.putString("requestKey", str2);
        createMap.putString("type", str3);
        createMap.putMap("state", writableMap);
        i.o(new Fh.b("phone_auth_state_changed", createMap, str));
    }

    @ReactMethod
    private void signInAnonymously(String str, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        Log.d(TAG, "signInAnonymously");
        firebaseAuth.z().addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInAnonymously$2(promise, (com.google.firebase.auth.i) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$signInAnonymously$3(promise, exc);
            }
        });
    }

    @ReactMethod
    private void signInWithCredential(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.h credentialForProvider = getCredentialForProvider(str2, str3, str4);
        if (credentialForProvider == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
        } else {
            Log.d(TAG, "signInWithCredential");
            firebaseAuth.A(credentialForProvider).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithCredential$22(promise, task);
                }
            });
        }
    }

    @ReactMethod
    private void signInWithCustomToken(String str, String str2, final Promise promise) {
        Log.d(TAG, "signInWithCustomToken");
        FirebaseAuth.getInstance(F9.g.p(str)).B(str2).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithCustomToken$10(promise, (com.google.firebase.auth.i) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithCustomToken$11(promise, exc);
            }
        });
    }

    @ReactMethod
    private void signInWithEmailAndPassword(String str, String str2, String str3, final Promise promise) {
        Log.d(TAG, "signInWithEmailAndPassword");
        FirebaseAuth.getInstance(F9.g.p(str)).C(str2, str3).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailAndPassword$6(promise, (com.google.firebase.auth.i) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailAndPassword$7(promise, exc);
            }
        });
    }

    @ReactMethod
    private void signInWithEmailLink(String str, String str2, String str3, final Promise promise) {
        Log.d(TAG, "signInWithEmailLink");
        FirebaseAuth.getInstance(F9.g.p(str)).D(str2, str3).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailLink$8(promise, (com.google.firebase.auth.i) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailLink$9(promise, exc);
            }
        });
    }

    @ReactMethod
    private void signInWithProvider(String str, ReadableMap readableMap, final Promise promise) {
        ReadableMap map;
        ReadableArray array;
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (readableMap.getString("providerId") == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
            return;
        }
        N.a e = com.google.firebase.auth.N.e(readableMap.getString("providerId"), firebaseAuth);
        if (readableMap.hasKey("scopes") && (array = readableMap.getArray("scopes")) != null) {
            ArrayList arrayList = new ArrayList();
            for (int i = 0; i < array.size(); i++) {
                arrayList.add(array.getString(i));
            }
            e.c(arrayList);
        }
        if (readableMap.hasKey("customParameters") && (map = readableMap.getMap("customParameters")) != null) {
            ReadableMapKeySetIterator keySetIterator = map.keySetIterator();
            while (keySetIterator.hasNextKey()) {
                String nextKey = keySetIterator.nextKey();
                e.a(nextKey, map.getString(nextKey));
            }
        }
        Task n = firebaseAuth.n();
        if (n != null) {
            n.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$23(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$24(promise, exc);
                }
            });
        } else {
            firebaseAuth.F(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$25(promise, (com.google.firebase.auth.i) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$26(promise, exc);
                }
            });
        }
    }

    @ReactMethod
    private void updatePhoneNumber(String str, String str2, String str3, String str4, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        if (!str2.equals("phone")) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential does not have a phone provider.");
        }
        com.google.firebase.auth.O phoneAuthCredential = getPhoneAuthCredential(str3, str4);
        if (phoneAuthCredential == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential is malformed, has expired or is not currently supported.");
        } else if (j == null) {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updatePhoneNumber:failure:noCurrentUser");
        } else {
            Log.d(TAG, "updatePhoneNumber");
            j.u0(phoneAuthCredential).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$updatePhoneNumber$20(firebaseAuth, promise, task);
                }
            });
        }
    }

    @ReactMethod
    public void addAuthStateListener(final String str) {
        Log.d(TAG, "addAuthStateListener");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (mAuthListeners.get(str) == null) {
            FirebaseAuth.a aVar = new FirebaseAuth.a() {
                public final void a(FirebaseAuth firebaseAuth2) {
                    ReactNativeFirebaseAuthModule.this.lambda$addAuthStateListener$0(str, firebaseAuth2);
                }
            };
            firebaseAuth.a(aVar);
            mAuthListeners.put(str, aVar);
        }
    }

    @ReactMethod
    public void addIdTokenListener(final String str) {
        Log.d(TAG, "addIdTokenListener");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (mIdTokenListeners.containsKey(str)) {
            return;
        }
        FirebaseAuth.b bVar = new FirebaseAuth.b() {
            public final void a(FirebaseAuth firebaseAuth2) {
                ReactNativeFirebaseAuthModule.this.lambda$addIdTokenListener$1(str, firebaseAuth2);
            }
        };
        firebaseAuth.b(bVar);
        mIdTokenListeners.put(str, bVar);
    }

    @ReactMethod
    public void applyActionCode(String str, String str2, final Promise promise) {
        Log.d(TAG, "applyActionCode");
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        firebaseAuth.c(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$applyActionCode$32(firebaseAuth, promise, task);
            }
        });
    }

    @ReactMethod
    public void checkActionCode(String str, String str2, final Promise promise) {
        Log.d(TAG, "checkActionCode");
        FirebaseAuth.getInstance(F9.g.p(str)).d(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$checkActionCode$33(promise, task);
            }
        });
    }

    @ReactMethod
    public void configureAuthDomain(String str) {
        Log.d(TAG, "configureAuthDomain");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        String str2 = ReactNativeFirebaseAppModule.authDomains.get(str);
        Log.d(TAG, "configureAuthDomain - app " + str + " domain? " + str2);
        if (str2 != null) {
            firebaseAuth.w(str2);
        }
    }

    @ReactMethod
    public void confirmPasswordReset(String str, String str2, String str3, final Promise promise) {
        Log.d(TAG, "confirmPasswordReset");
        FirebaseAuth.getInstance(F9.g.p(str)).e(str2, str3).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$confirmPasswordReset$31(promise, task);
            }
        });
    }

    @ReactMethod
    public void confirmationResultConfirm(String str, String str2, final Promise promise) {
        try {
            FirebaseAuth.getInstance(F9.g.p(str)).A(com.google.firebase.auth.Q.a(this.mVerificationId, str2)).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$confirmationResultConfirm$30(promise, task);
                }
            });
        } catch (Exception e) {
            Log.d(TAG, "confirmationResultConfirm::getCredential::failure", e);
            promiseRejectAuthException(promise, e);
        }
    }

    @ReactMethod
    public void delete(String str, final Promise promise) {
        com.google.firebase.auth.A j = FirebaseAuth.getInstance(F9.g.p(str)).j();
        Log.d(TAG, "delete");
        if (j != null) {
            j.d0().addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$delete$14(promise, task);
                }
            });
        } else {
            Log.e(TAG, "delete:failure:noCurrentUser");
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    public void fetchSignInMethodsForEmail(String str, String str2, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        Log.d(TAG, "fetchProvidersForEmail");
        firebaseAuth.g(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$fetchSignInMethodsForEmail$47(promise, task);
            }
        });
    }

    @ReactMethod
    public void finalizeMultiFactorEnrollment(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        firebaseAuth.j().g0().a(com.google.firebase.auth.T.a(com.google.firebase.auth.Q.a(str2, str3)), str4).addOnCompleteListener(new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$finalizeMultiFactorEnrollment$28(promise, task);
            }
        });
    }

    @ReactMethod
    public void forceRecaptchaFlowForTesting(String str, boolean z, Promise promise) {
        Log.d(TAG, "forceRecaptchaFlowForTesting");
        FirebaseAuth.getInstance(F9.g.p(str)).l().a(z);
        promise.resolve((Object) null);
    }

    @Override
    public Map<String, Object> getConstants() {
        HashMap hashMap = new HashMap();
        List n = F9.g.n(getReactApplicationContext());
        HashMap hashMap2 = new HashMap();
        HashMap hashMap3 = new HashMap();
        Iterator it = n.iterator();
        while (it.hasNext()) {
            String q = ((F9.g) it.next()).q();
            FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(q));
            com.google.firebase.auth.A j = firebaseAuth.j();
            hashMap2.put(q, firebaseAuth.m());
            if (j != null) {
                hashMap3.put(q, firebaseUserToMap(j));
            }
        }
        hashMap.put("APP_LANGUAGE", hashMap2);
        hashMap.put("APP_USER", hashMap3);
        return hashMap;
    }

    @ReactMethod
    public void getCustomAuthDomain(String str, Promise promise) {
        Log.d(TAG, "configureAuthDomain");
        promise.resolve(FirebaseAuth.getInstance(F9.g.p(str)).k());
    }

    @ReactMethod
    public void getIdToken(String str, Boolean bool, final Promise promise) {
        Log.d(TAG, "getIdToken");
        com.google.firebase.auth.A j = FirebaseAuth.getInstance(F9.g.p(str)).j();
        if (j == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            j.e0(bool.booleanValue()).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$getIdToken$45(promise, task);
                }
            });
        }
    }

    @ReactMethod
    public void getIdTokenResult(String str, Boolean bool, final Promise promise) {
        Log.d(TAG, "getIdTokenResult");
        com.google.firebase.auth.A j = FirebaseAuth.getInstance(F9.g.p(str)).j();
        if (j == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            j.e0(bool.booleanValue()).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$getIdTokenResult$46(promise, task);
                }
            });
        }
    }

    @ReactMethod
    public void getSession(String str, final Promise promise) {
        FirebaseAuth.getInstance(F9.g.p(str)).j().g0().c().addOnCompleteListener(new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$getSession$27(promise, task);
            }
        });
    }

    @Override
    public void initialize() {
        super.initialize();
        Log.d(TAG, "instance-initialized");
    }

    @Override
    public void invalidate() {
        super.invalidate();
        Log.d(TAG, "instance-destroyed");
        Iterator<Map.Entry<String, FirebaseAuth.a>> it = mAuthListeners.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, FirebaseAuth.a> next = it.next();
            FirebaseAuth.getInstance(F9.g.p(next.getKey())).r(next.getValue());
            it.remove();
        }
        Iterator<Map.Entry<String, FirebaseAuth.b>> it2 = mIdTokenListeners.entrySet().iterator();
        while (it2.hasNext()) {
            Map.Entry<String, FirebaseAuth.b> next2 = it2.next();
            FirebaseAuth.getInstance(F9.g.p(next2.getKey())).s(next2.getValue());
            it2.remove();
        }
        this.mCachedResolvers.clear();
        this.mMultiFactorSessions.clear();
    }

    @ReactMethod
    public void reload(String str, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "reload");
        if (j != null) {
            j.m0().addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$reload$15(firebaseAuth, promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "reload:failure:noCurrentUser");
        }
    }

    @ReactMethod
    public void removeAuthStateListener(String str) {
        Log.d(TAG, "removeAuthStateListener");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        FirebaseAuth.a aVar = mAuthListeners.get(str);
        if (aVar != null) {
            firebaseAuth.r(aVar);
            mAuthListeners.remove(str);
        }
    }

    @ReactMethod
    public void removeIdTokenListener(String str) {
        Log.d(TAG, "removeIdTokenListener");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        FirebaseAuth.b bVar = mIdTokenListeners.get(str);
        if (bVar != null) {
            firebaseAuth.s(bVar);
            mIdTokenListeners.remove(str);
        }
    }

    @ReactMethod
    public void resolveMultiFactorSignIn(String str, String str2, String str3, String str4, Promise promise) {
        resolveMultiFactorCredential(com.google.firebase.auth.Q.a(str3, str4), str2, promise);
    }

    @ReactMethod
    public void revokeToken(String str, String str2, Promise promise) {
        Log.d(TAG, "revokeToken");
        Log.e(TAG, "revokeToken:failure:noCurrentUser");
        promiseNoUser(promise, Boolean.FALSE);
    }

    @ReactMethod
    public void sendEmailVerification(String str, ReadableMap readableMap, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "sendEmailVerification");
        if (j == null) {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "sendEmailVerification:failure:noCurrentUser");
            return;
        }
        OnCompleteListener onCompleteListener = new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$sendEmailVerification$16(firebaseAuth, promise, task);
            }
        };
        if (readableMap == null) {
            j.n0().addOnCompleteListener(getExecutor(), onCompleteListener);
        } else {
            j.o0(buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), onCompleteListener);
        }
    }

    @ReactMethod
    public void sendPasswordResetEmail(String str, String str2, ReadableMap readableMap, final Promise promise) {
        Log.d(TAG, "sendPasswordResetEmail");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        OnCompleteListener onCompleteListener = new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$sendPasswordResetEmail$12(promise, task);
            }
        };
        if (readableMap == null) {
            firebaseAuth.t(str2).addOnCompleteListener(getExecutor(), onCompleteListener);
        } else {
            firebaseAuth.u(str2, buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), onCompleteListener);
        }
    }

    @ReactMethod
    public void sendSignInLinkToEmail(String str, String str2, ReadableMap readableMap, final Promise promise) {
        Log.d(TAG, "sendSignInLinkToEmail");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        firebaseAuth.v(str2, buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$sendSignInLinkToEmail$13(promise, task);
            }
        });
    }

    @ReactMethod
    public void setAppVerificationDisabledForTesting(String str, boolean z, Promise promise) {
        Log.d(TAG, "setAppVerificationDisabledForTesting");
        FirebaseAuth.getInstance(F9.g.p(str)).l().b(z);
        promise.resolve((Object) null);
    }

    @ReactMethod
    public void setAutoRetrievedSmsCodeForPhoneNumber(String str, String str2, String str3, Promise promise) {
        Log.d(TAG, "setAutoRetrievedSmsCodeForPhoneNumber");
        FirebaseAuth.getInstance(F9.g.p(str)).l().c(str2, str3);
        promise.resolve((Object) null);
    }

    @ReactMethod
    public void setLanguageCode(String str, String str2) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        if (str2 == null) {
            firebaseAuth.G();
        } else {
            firebaseAuth.x(str2);
        }
    }

    @ReactMethod
    public void setTenantId(String str, String str2) {
        FirebaseAuth.getInstance(F9.g.p(str)).y(str2);
    }

    @ReactMethod
    public void signInWithPhoneNumber(String str, String str2, boolean z, Promise promise) {
        Log.d(TAG, "signInWithPhoneNumber");
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        Activity currentActivity = getCurrentActivity();
        if (!str2.equals(this.mLastPhoneNumber)) {
            this.mForceResendingToken = null;
            this.mLastPhoneNumber = str2;
        }
        this.mVerificationId = null;
        a aVar = new a(firebaseAuth, promise);
        if (currentActivity != null) {
            if (!z || this.mForceResendingToken == null) {
                com.google.firebase.auth.Q.b(firebaseAuth).d(str2, 60L, TimeUnit.SECONDS, currentActivity, aVar);
            } else {
                com.google.firebase.auth.Q.b(firebaseAuth).e(str2, 60L, TimeUnit.SECONDS, currentActivity, aVar, this.mForceResendingToken);
            }
        }
    }

    @ReactMethod
    public void signOut(String str, Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        Log.d(TAG, "signOut");
        if (firebaseAuth == null || firebaseAuth.j() == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            firebaseAuth.E();
            promiseNoUser(promise, Boolean.FALSE);
        }
    }

    @ReactMethod
    public void unlink(String str, String str2, final Promise promise) {
        com.google.firebase.auth.A j = FirebaseAuth.getInstance(F9.g.p(str)).j();
        Log.d(TAG, "unlink");
        if (j != null) {
            j.r0(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$unlink$39(promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    public void updateEmail(String str, String str2, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "updateEmail");
        if (j != null) {
            j.s0(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$updateEmail$18(firebaseAuth, promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updateEmail:failure:noCurrentUser");
        }
    }

    @ReactMethod
    public void updatePassword(String str, String str2, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "updatePassword");
        if (j != null) {
            j.t0(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$updatePassword$19(firebaseAuth, promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updatePassword:failure:noCurrentUser");
        }
    }

    @ReactMethod
    public void updateProfile(String str, ReadableMap readableMap, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "updateProfile");
        if (j == null) {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updateProfile:failure:noCurrentUser");
            return;
        }
        c0.a aVar = new c0.a();
        if (readableMap.hasKey("displayName")) {
            aVar.b(readableMap.getString("displayName"));
        }
        if (readableMap.hasKey("photoURL")) {
            String string = readableMap.getString("photoURL");
            aVar.c(string == null ? null : Uri.parse(string));
        }
        j.v0(aVar.a()).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$updateProfile$21(firebaseAuth, promise, task);
            }
        });
    }

    @ReactMethod
    public void useDeviceLanguage(String str) {
        FirebaseAuth.getInstance(F9.g.p(str)).G();
    }

    @ReactMethod
    public void useEmulator(String str, String str2, int i) {
        if (emulatorConfigs.get(str) == null) {
            emulatorConfigs.put(str, "true");
            FirebaseAuth.getInstance(F9.g.p(str)).H(str2, i);
        }
    }

    @ReactMethod
    public void verifyBeforeUpdateEmail(String str, String str2, ReadableMap readableMap, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        com.google.firebase.auth.A j = firebaseAuth.j();
        Log.d(TAG, "verifyBeforeUpdateEmail");
        if (j == null) {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "verifyBeforeUpdateEmail:failure:noCurrentUser");
            return;
        }
        OnCompleteListener onCompleteListener = new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$verifyBeforeUpdateEmail$17(firebaseAuth, promise, task);
            }
        };
        if (readableMap == null) {
            j.w0(str2).addOnCompleteListener(getExecutor(), onCompleteListener);
        } else {
            j.x0(str2, buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), onCompleteListener);
        }
    }

    @ReactMethod
    public void verifyPasswordResetCode(String str, String str2, final Promise promise) {
        Log.d(TAG, "verifyPasswordResetCode");
        FirebaseAuth.getInstance(F9.g.p(str)).I(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$verifyPasswordResetCode$48(promise, task);
            }
        });
    }

    @ReactMethod
    public void verifyPhoneNumber(String str, String str2, String str3, int i, boolean z) {
        Log.d(TAG, "verifyPhoneNumber:" + str2);
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
        Activity currentActivity = getCurrentActivity();
        if (!str2.equals(this.mLastPhoneNumber)) {
            this.mForceResendingToken = null;
            this.mLastPhoneNumber = str2;
        }
        this.mCredential = null;
        d dVar = new d(str, str3);
        if (currentActivity != null) {
            if (!z || this.mForceResendingToken == null) {
                com.google.firebase.auth.Q.b(firebaseAuth).d(str2, i, TimeUnit.SECONDS, currentActivity, dVar);
            } else {
                com.google.firebase.auth.Q.b(firebaseAuth).e(str2, i, TimeUnit.SECONDS, currentActivity, dVar, this.mForceResendingToken);
            }
        }
    }

    @ReactMethod
    public void verifyPhoneNumberForMultiFactor(String str, String str2, String str3, Promise promise) {
        com.google.firebase.auth.L l = this.mMultiFactorSessions.get(str3);
        if (l == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-multi-factor-session", "can't find session for provided key");
        } else {
            com.google.firebase.auth.Q.c(com.google.firebase.auth.P.a(FirebaseAuth.getInstance(F9.g.p(str))).h(str2).c(getCurrentActivity()).i(30L, TimeUnit.SECONDS).g(l).b(true).d(new c(promise)).a());
        }
    }

    @ReactMethod
    public void verifyPhoneNumberWithMultiFactorInfo(String str, String str2, String str3, Promise promise) {
        com.google.firebase.auth.J j;
        com.google.firebase.auth.K k = this.mCachedResolvers.get(str3);
        if (k == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-multi-factor-session", "No resolver for session found. Is the session id correct?");
            return;
        }
        Iterator it = k.e0().iterator();
        while (true) {
            if (!it.hasNext()) {
                j = null;
                break;
            } else {
                j = (com.google.firebase.auth.J) it.next();
                if (str2.equals(j.c())) {
                    break;
                }
            }
        }
        if (j == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "multi-factor-info-not-found", "The user does not have a second factor matching the identifier provided.");
        } else {
            if (!"phone".equals(j.e0())) {
                ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "unknown", "Unsupported second factor. Only phone factors are supported.");
                return;
            }
            FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(F9.g.p(str));
            com.google.firebase.auth.Q.c(com.google.firebase.auth.P.a(firebaseAuth).c(getCurrentActivity()).f((com.google.firebase.auth.U) j).i(30L, TimeUnit.SECONDS).g(k.f0()).d(new b(promise, str3)).a());
        }
    }
}