Namma Yatri v3.3.7 - 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.ActionCodeSettings;
import com.google.firebase.auth.AuthCredential;
import com.google.firebase.auth.AuthResult;
import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;
import com.google.firebase.auth.MultiFactorInfo;
import com.google.firebase.auth.MultiFactorResolver;
import com.google.firebase.auth.MultiFactorSession;
import com.google.firebase.auth.PhoneAuthCredential;
import com.google.firebase.auth.PhoneAuthProvider;
import com.google.firebase.auth.PhoneMultiFactorInfo;
import com.google.firebase.auth.UserProfileChangeRequest;
import com.google.firebase.auth.z;
import com.microsoft.clarity.reactnative.ClarityEmitter;
import in.juspay.hyper.constants.LogSubCategory;
import in.juspay.hypersdk.core.PaymentConstants;
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, AuthCredential> credentials;
    private final HashMap<String, MultiFactorResolver> mCachedResolvers;
    private PhoneAuthCredential mCredential;
    private PhoneAuthProvider.ForceResendingToken mForceResendingToken;
    private String mLastPhoneNumber;
    private final HashMap<String, MultiFactorSession> 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 PhoneAuthProvider.a {
        private boolean a = false;
        final FirebaseAuth b;
        final Promise c;

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

        public void b(PhoneAuthCredential phoneAuthCredential, 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.lambda$signInWithProvider$26(promise, exception);
                return;
            }
            if (this.a) {
                return;
            }
            WritableMap createMap = Arguments.createMap();
            Parcel obtain = Parcel.obtain();
            phoneAuthCredential.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, PhoneAuthProvider.ForceResendingToken forceResendingToken) {
            ReactNativeFirebaseAuthModule.this.mVerificationId = str;
            ReactNativeFirebaseAuthModule.this.mForceResendingToken = forceResendingToken;
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            this.c.resolve(createMap);
            this.a = true;
        }

        public void onVerificationCompleted(final PhoneAuthCredential phoneAuthCredential) {
            Task D = this.b.D(phoneAuthCredential);
            ExecutorService executor = ReactNativeFirebaseAuthModule.this.getExecutor();
            final Promise promise = this.c;
            D.addOnCompleteListener(executor, new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.a.this.b(phoneAuthCredential, promise, task);
                }
            });
        }

        public void onVerificationFailed(N8.m mVar) {
            ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$26(this.c, mVar);
        }
    }

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

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

        public void onCodeSent(String str, PhoneAuthProvider.ForceResendingToken forceResendingToken) {
            this.a.resolve(str);
        }

        public void onVerificationCompleted(PhoneAuthCredential phoneAuthCredential) {
            ReactNativeFirebaseAuthModule.this.resolveMultiFactorCredential(phoneAuthCredential, this.b, this.a);
        }

        public void onVerificationFailed(N8.m mVar) {
            ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$26(this.a, mVar);
        }
    }

    class c extends PhoneAuthProvider.a {
        final Promise a;

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

        public void onCodeSent(String str, PhoneAuthProvider.ForceResendingToken forceResendingToken) {
            this.a.resolve(str);
        }

        public void onVerificationCompleted(PhoneAuthCredential phoneAuthCredential) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(this.a, "not-implemented", "This is currently not supported.");
        }

        public void onVerificationFailed(N8.m mVar) {
            ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$26(this.a, mVar);
        }
    }

    class d extends PhoneAuthProvider.a {
        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);
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onCodeAutoRetrievalTimeout", createMap);
        }

        public void onCodeSent(String str, PhoneAuthProvider.ForceResendingToken forceResendingToken) {
            ReactNativeFirebaseAuthModule.this.mForceResendingToken = forceResendingToken;
            WritableMap createMap = Arguments.createMap();
            createMap.putString("verificationId", str);
            createMap.putString("verificationId", str);
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onCodeSent", createMap);
        }

        public void onVerificationCompleted(PhoneAuthCredential phoneAuthCredential) {
            ReactNativeFirebaseAuthModule.this.mCredential = phoneAuthCredential;
            WritableMap createMap = Arguments.createMap();
            Parcel obtain = Parcel.obtain();
            phoneAuthCredential.writeToParcel(obtain, 0);
            obtain.setDataPosition(16);
            String readString = obtain.readString();
            obtain.setDataPosition(obtain.dataPosition() + 8);
            createMap.putString("code", obtain.readString());
            createMap.putString("verificationId", readString);
            obtain.recycle();
            ReactNativeFirebaseAuthModule.this.sendPhoneStateEvent(this.a, this.b, "onVerificationComplete", createMap);
        }

        public void onVerificationFailed(N8.m mVar) {
            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 ActionCodeSettings buildActionCodeSettings(ReadableMap readableMap) {
        ActionCodeSettings.a t0 = ActionCodeSettings.t0();
        String string = readableMap.getString(PaymentConstants.URL);
        Objects.requireNonNull(string);
        ActionCodeSettings.a g = t0.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(LogSubCategory.LifeCycle.ANDROID)) {
            ReadableMap map = readableMap.getMap(LogSubCategory.LifeCycle.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 com.google.firebase.auth.G> list, FirebaseUser firebaseUser) {
        WritableArray createArray = Arguments.createArray();
        Iterator it = new ArrayList(list).iterator();
        while (it.hasNext()) {
            com.google.firebase.auth.G g = (com.google.firebase.auth.G) it.next();
            if (!"firebase".equals(g.k())) {
                WritableMap createMap = Arguments.createMap();
                createMap.putString("providerId", g.k());
                createMap.putString("uid", g.c());
                createMap.putString("displayName", g.A());
                Uri K = g.K();
                if (K == null || "".equals(K.toString())) {
                    createMap.putNull("photoURL");
                } else {
                    createMap.putString("photoURL", K.toString());
                }
                String t = g.t();
                if ("phone".equals(g.k()) && (g.t() == null || "".equals(g.t()))) {
                    createMap.putString("phoneNumber", firebaseUser.t());
                } else if (t == null || "".equals(t)) {
                    createMap.putNull("phoneNumber");
                } else {
                    createMap.putString("phoneNumber", t);
                }
                if ("password".equals(g.k()) && (g.d0() == null || "".equals(g.d0()))) {
                    createMap.putString("email", g.c());
                } else if (g.d0() == null || "".equals(g.d0())) {
                    createMap.putNull("email");
                } else {
                    createMap.putString("email", g.d0());
                }
                createArray.pushMap(createMap);
            }
        }
        return createArray;
    }

    @ReactMethod
    private void createUserWithEmailAndPassword(String str, String str2, String str3, final Promise promise) {
        FirebaseAuth.getInstance(N8.g.p(str)).j(str2, str3).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$createUserWithEmailAndPassword$4(promise, (AuthResult) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                ReactNativeFirebaseAuthModule.this.lambda$createUserWithEmailAndPassword$5(promise, exc);
            }
        });
    }

    private WritableMap firebaseUserToMap(FirebaseUser firebaseUser) {
        WritableMap createMap = Arguments.createMap();
        String c2 = firebaseUser.c();
        String d0 = firebaseUser.d0();
        Uri K = firebaseUser.K();
        String A = firebaseUser.A();
        String k = firebaseUser.k();
        boolean L = firebaseUser.L();
        String t = firebaseUser.t();
        String q0 = firebaseUser.q0();
        createMap.putString("uid", c2);
        createMap.putString("providerId", k);
        createMap.putBoolean("emailVerified", L);
        createMap.putBoolean("isAnonymous", firebaseUser.s0());
        if (d0 == null || "".equals(d0)) {
            createMap.putNull("email");
        } else {
            createMap.putString("email", d0);
        }
        if (A == null || "".equals(A)) {
            createMap.putNull("displayName");
        } else {
            createMap.putString("displayName", A);
        }
        if (K == null || "".equals(K.toString())) {
            createMap.putNull("photoURL");
        } else {
            createMap.putString("photoURL", K.toString());
        }
        if (t == null || "".equals(t)) {
            createMap.putNull("phoneNumber");
        } else {
            createMap.putString("phoneNumber", t);
        }
        if (q0 == null || "".equals(q0)) {
            createMap.putNull("tenantId");
        } else {
            createMap.putString("tenantId", q0);
        }
        createMap.putArray("providerData", convertProviderData(firebaseUser.p0(), firebaseUser));
        WritableMap createMap2 = Arguments.createMap();
        if (firebaseUser.n0() != null) {
            createMap2.putDouble("creationTime", r2.w());
            createMap2.putDouble("lastSignInTime", r2.B());
        }
        createMap.putMap("metadata", createMap2);
        WritableArray createArray = Arguments.createArray();
        Iterator it = firebaseUser.o0().b().iterator();
        while (it.hasNext()) {
            createArray.pushMap(multiFactorInfoToMap((MultiFactorInfo) it.next()));
        }
        WritableMap createMap3 = Arguments.createMap();
        createMap3.putArray("enrolledFactors", createArray);
        createMap.putMap("multiFactor", createMap3);
        return createMap;
    }

    private AuthCredential getCredentialForProvider(String str, String str2, String str3) {
        if (str.startsWith("oidc.")) {
            return com.google.firebase.auth.z.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.z.f(str).c(str2, str3).a();
            case "twitter.com":
                return com.google.firebase.auth.F.a(str2, str3);
            case "google.com":
                return com.google.firebase.auth.w.a(str2, str3);
            case "facebook.com":
                return com.google.firebase.auth.g.a(str2);
            case "oauth":
                return com.google.firebase.auth.z.d(str, str2, str3);
            case "phone":
                return getPhoneAuthCredential(str2, str3);
            case "password":
                return com.google.firebase.auth.f.a(str2, str3);
            case "github.com":
                return com.google.firebase.auth.v.a(str2);
            case "emailLink":
                return com.google.firebase.auth.f.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 PhoneAuthCredential getPhoneAuthCredential(String str, String str2) {
        PhoneAuthCredential phoneAuthCredential;
        if (str == null && (phoneAuthCredential = this.mCredential) != null) {
            this.mCredential = null;
            return phoneAuthCredential;
        }
        if (str != null) {
            return PhoneAuthProvider.a(str, str2);
        }
        return null;
    }

    public void lambda$addAuthStateListener$0(String str, FirebaseAuth firebaseAuth) {
        FirebaseUser m = firebaseAuth.m();
        WritableMap createMap = Arguments.createMap();
        Sc.g i = Sc.g.i();
        if (m != null) {
            createMap.putString("appName", str);
            createMap.putMap(LogSubCategory.Action.USER, firebaseUserToMap(m));
        } else {
            createMap.putString("appName", str);
        }
        StringBuilder sb2 = new StringBuilder();
        sb2.append("addAuthStateListener:eventBody ");
        sb2.append(createMap.toString());
        i.o(new Sc.b("auth_state_changed", createMap, str));
    }

    public void lambda$addIdTokenListener$1(String str, FirebaseAuth firebaseAuth) {
        FirebaseUser m = firebaseAuth.m();
        Sc.g i = Sc.g.i();
        WritableMap createMap = Arguments.createMap();
        if (m != null) {
            createMap.putBoolean("authenticated", true);
            createMap.putString("appName", str);
            createMap.putMap(LogSubCategory.Action.USER, firebaseUserToMap(m));
        } else {
            createMap.putString("appName", str);
            createMap.putBoolean("authenticated", false);
        }
        i.o(new Sc.b("auth_id_token_changed", createMap, str));
    }

    public void lambda$applyActionCode$32(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "applyActionCode:onComplete:failure", exception);
        lambda$signInWithProvider$26(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);
            lambda$signInWithProvider$26(promise, exception);
            return;
        }
        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()) {
            promiseNoUser(promise, Boolean.FALSE);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "confirmPasswordReset:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$confirmationResultConfirm$30(Promise promise, Task task) {
        if (task.isSuccessful()) {
            AuthResult authResult = (AuthResult) task.getResult();
            Objects.requireNonNull(authResult);
            lambda$signInWithProvider$25(authResult, promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "confirmationResultConfirm:signInWithCredential:onComplete:failure", exception);
            lambda$signInWithProvider$26(promise, exception);
        }
    }

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

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

    public void lambda$fetchSignInMethodsForEmail$47(Promise promise, Task task) {
        if (!task.isSuccessful()) {
            lambda$signInWithProvider$26(promise, task.getException());
            return;
        }
        com.google.firebase.auth.D d2 = (com.google.firebase.auth.D) task.getResult();
        Objects.requireNonNull(d2);
        List a2 = d2.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()) {
            promise.resolve((Object) null);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "finalizeMultiFactorEnrollment:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

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

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

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

    public void lambda$linkWithCredential$34(Promise promise, Task task) {
        com.google.firebase.auth.r rVar;
        AuthCredential b2;
        if (task.isSuccessful()) {
            lambda$signInWithProvider$25((AuthResult) task.getResult(), promise);
            return;
        }
        com.google.firebase.auth.r exception = task.getException();
        if ((exception instanceof com.google.firebase.auth.r) && (b2 = (rVar = exception).b()) != null) {
            promiseRejectLinkAuthException(promise, rVar, b2);
        } else {
            Log.e(TAG, "link:onComplete:failure", exception);
            lambda$signInWithProvider$26(promise, exception);
        }
    }

    public void lambda$reauthenticateWithCredential$40(Promise promise, Task task) {
        if (task.isSuccessful()) {
            lambda$signInWithProvider$25((AuthResult) task.getResult(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "reauthenticate:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$reload$15(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "reload:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$resolveMultiFactorCredential$29(Promise promise, Task task) {
        if (task.isSuccessful()) {
            lambda$signInWithProvider$25((AuthResult) task.getResult(), promise);
        } else {
            lambda$signInWithProvider$26(promise, task.getException());
        }
    }

    public void lambda$sendEmailVerification$16(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "sendEmailVerification:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

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

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

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

    public void lambda$signInWithCredential$22(Promise promise, Task task) {
        if (task.isSuccessful()) {
            lambda$signInWithProvider$25((AuthResult) task.getResult(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "signInWithCredential:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

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

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

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

    public void lambda$unlink$39(Promise promise, Task task) {
        if (task.isSuccessful()) {
            AuthResult authResult = (AuthResult) task.getResult();
            Objects.requireNonNull(authResult);
            promiseWithUser(authResult.i(), promise);
        } else {
            Exception exception = task.getException();
            Log.e(TAG, "unlink:onComplete:failure", exception);
            lambda$signInWithProvider$26(promise, exception);
        }
    }

    public void lambda$updateEmail$18(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "updateEmail:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$updatePassword$19(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "updatePassword:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$updatePhoneNumber$20(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "updatePhoneNumber:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$updateProfile$21(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "updateProfile:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

    public void lambda$verifyBeforeUpdateEmail$17(FirebaseAuth firebaseAuth, Promise promise, Task task) {
        if (task.isSuccessful()) {
            promiseWithUser(firebaseAuth.m(), promise);
            return;
        }
        Exception exception = task.getException();
        Log.e(TAG, "verifyBeforeUpdateEmail:onComplete:failure", exception);
        lambda$signInWithProvider$26(promise, exception);
    }

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

    @ReactMethod
    private void linkWithCredential(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        AuthCredential 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;
        }
        FirebaseUser m = firebaseAuth.m();
        if (m != null) {
            m.t0(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(N8.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;
        }
        FirebaseUser m = firebaseAuth.m();
        if (m == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        z.a e = com.google.firebase.auth.z.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 q = firebaseAuth.q();
        if (q != null) {
            q.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$35(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$36(promise, exc);
                }
            });
        } else {
            m.y0(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$37(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$linkWithProvider$38(promise, exc);
                }
            });
        }
    }

    private WritableMap multiFactorInfoToMap(MultiFactorInfo multiFactorInfo) {
        WritableMap createMap = Arguments.createMap();
        Date date = new Date(multiFactorInfo.e0() * 1000);
        createMap.putString("displayName", multiFactorInfo.A());
        createMap.putString("enrollmentTime", ISO_8601_FORMATTER.format(date));
        createMap.putString("factorId", multiFactorInfo.k0());
        createMap.putString("uid", multiFactorInfo.c());
        if (multiFactorInfo.k0().equals("phone")) {
            createMap.putString("phoneNumber", ((PhoneMultiFactorInfo) multiFactorInfo).t());
        }
        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 lambda$signInWithProvider$26(Promise promise, Exception exc) {
        WritableMap jSError = getJSError(exc);
        String string = jSError.hasKey(ClarityEmitter.CLARITY_SESSION_ID_PARAMETER) ? jSError.getString(ClarityEmitter.CLARITY_SESSION_ID_PARAMETER) : null;
        MultiFactorResolver multiFactorResolver = this.mCachedResolvers.get(string);
        WritableMap createMap = Arguments.createMap();
        if (multiFactorResolver != null) {
            createMap = resolverToMap(string, multiFactorResolver);
        }
        ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, jSError.getString("code"), jSError.getString("message"), (ReadableMap) createMap);
    }

    private void promiseRejectLinkAuthException(Promise promise, Exception exc, AuthCredential authCredential) {
        WritableMap jSError = getJSError(exc);
        String valueOf = String.valueOf(authCredential.hashCode());
        WritableMap createMap = Arguments.createMap();
        createMap.putString("providerId", authCredential.e0());
        createMap.putString("token", valueOf);
        createMap.putString("secret", (String) null);
        this.credentials.put(valueOf, authCredential);
        WritableMap createMap2 = Arguments.createMap();
        createMap2.putString("code", jSError.getString("code"));
        createMap2.putString("message", jSError.getString("message"));
        createMap2.putMap("authCredential", createMap);
        promise.reject(jSError.getString("code"), jSError.getString("message"), createMap2);
    }

    public void lambda$signInWithProvider$25(AuthResult authResult, Promise promise) {
        if (authResult == null || authResult.i() == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        WritableMap createMap = Arguments.createMap();
        WritableMap firebaseUserToMap = firebaseUserToMap(authResult.i());
        if (authResult.b0() != null) {
            WritableMap createMap2 = Arguments.createMap();
            createMap2.putBoolean("isNewUser", authResult.b0().J());
            if (authResult.b0().c0() != null) {
                Sc.m.g("profile", authResult.b0().c0(), createMap2);
            }
            if (authResult.b0().k() != null) {
                createMap2.putString("providerId", authResult.b0().k());
            }
            if (authResult.b0().S() != null) {
                createMap2.putString("username", authResult.b0().S());
            }
            createMap.putMap("additionalUserInfo", createMap2);
        }
        createMap.putMap(LogSubCategory.Action.USER, firebaseUserToMap);
        promise.resolve(createMap);
    }

    private void promiseWithUser(FirebaseUser firebaseUser, Promise promise) {
        if (firebaseUser != null) {
            promise.resolve(firebaseUserToMap(firebaseUser));
        } else {
            promiseNoUser(promise, Boolean.TRUE);
        }
    }

    @ReactMethod
    private void reauthenticateWithCredential(String str, String str2, String str3, String str4, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        AuthCredential 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;
        }
        FirebaseUser m = firebaseAuth.m();
        if (m != null) {
            m.u0(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(N8.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;
        }
        FirebaseUser m = firebaseAuth.m();
        if (m == null) {
            promiseNoUser(promise, Boolean.TRUE);
            return;
        }
        z.a e = com.google.firebase.auth.z.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 q = firebaseAuth.q();
        if (q != null) {
            q.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$41(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$42(promise, exc);
                }
            });
        } else {
            m.z0(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$43(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$reauthenticateWithProvider$44(promise, exc);
                }
            });
        }
    }

    public void resolveMultiFactorCredential(PhoneAuthCredential phoneAuthCredential, String str, final Promise promise) {
        com.google.firebase.auth.B a2 = com.google.firebase.auth.C.a(phoneAuthCredential);
        MultiFactorResolver multiFactorResolver = this.mCachedResolvers.get(str);
        if (multiFactorResolver == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-multi-factor-session", "No resolver for session found. Is the session id correct?");
        } else {
            multiFactorResolver.o0(a2).addOnCompleteListener(new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$resolveMultiFactorCredential$29(promise, task);
                }
            });
        }
    }

    private WritableMap resolverToMap(String str, MultiFactorResolver multiFactorResolver) {
        WritableMap createMap = Arguments.createMap();
        WritableArray createArray = Arguments.createArray();
        Iterator it = multiFactorResolver.k0().iterator();
        while (it.hasNext()) {
            createArray.pushMap(multiFactorInfoToMap((MultiFactorInfo) 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();
        Sc.g i = Sc.g.i();
        createMap.putString("appName", str);
        createMap.putString("requestKey", str2);
        createMap.putString("type", str3);
        createMap.putMap("state", writableMap);
        i.o(new Sc.b("phone_auth_state_changed", createMap, str));
    }

    @ReactMethod
    private void signInAnonymously(String str, final Promise promise) {
        FirebaseAuth.getInstance(N8.g.p(str)).C().addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInAnonymously$2(promise, (AuthResult) 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(N8.g.p(str));
        AuthCredential 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 {
            firebaseAuth.D(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) {
        FirebaseAuth.getInstance(N8.g.p(str)).E(str2).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithCustomToken$10(promise, (AuthResult) 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) {
        FirebaseAuth.getInstance(N8.g.p(str)).F(str2, str3).addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailAndPassword$6(promise, (AuthResult) 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) {
        try {
            FirebaseAuth.getInstance(N8.g.p(str)).G(str2, str3).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailLink$8(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithEmailLink$9(promise, exc);
                }
            });
        } catch (Exception e) {
            Log.e(TAG, "signInWithEmailLink:onComplete:totalfailure", e);
            lambda$signInWithProvider$26(promise, e);
        }
    }

    @ReactMethod
    private void signInWithProvider(String str, ReadableMap readableMap, final Promise promise) {
        ReadableMap map;
        ReadableArray array;
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.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;
        }
        z.a e = com.google.firebase.auth.z.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 q = firebaseAuth.q();
        if (q != null) {
            q.addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$23(promise, (AuthResult) obj);
                }
            }).addOnFailureListener(new OnFailureListener() {
                public final void onFailure(Exception exc) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$24(promise, exc);
                }
            });
        } else {
            firebaseAuth.I(getCurrentActivity(), e.b()).addOnSuccessListener(new OnSuccessListener() {
                public final void onSuccess(Object obj) {
                    ReactNativeFirebaseAuthModule.this.lambda$signInWithProvider$25(promise, (AuthResult) 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(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (!str2.equals("phone")) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-credential", "The supplied auth credential does not have a phone provider.");
        }
        PhoneAuthCredential 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 (m != null) {
            m.D0(phoneAuthCredential).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$updatePhoneNumber$20(firebaseAuth, promise, task);
                }
            });
        } else {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updatePhoneNumber:failure:noCurrentUser");
        }
    }

    @ReactMethod
    public void addAuthStateListener(final String str) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.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) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.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) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        firebaseAuth.g(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) {
        FirebaseAuth.getInstance(N8.g.p(str)).h(str2).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$checkActionCode$33(promise, task);
            }
        });
    }

    @ReactMethod
    public void configureAuthDomain(String str) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        String str2 = ReactNativeFirebaseAppModule.authDomains.get(str);
        StringBuilder sb2 = new StringBuilder();
        sb2.append("configureAuthDomain - app ");
        sb2.append(str);
        sb2.append(" domain? ");
        sb2.append(str2);
        if (str2 != null) {
            firebaseAuth.z(str2);
        }
    }

    @ReactMethod
    public void confirmPasswordReset(String str, String str2, String str3, final Promise promise) {
        FirebaseAuth.getInstance(N8.g.p(str)).i(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(N8.g.p(str)).D(PhoneAuthProvider.a(this.mVerificationId, str2)).addOnCompleteListener(getExecutor(), new OnCompleteListener() {
                public final void onComplete(Task task) {
                    ReactNativeFirebaseAuthModule.this.lambda$confirmationResultConfirm$30(promise, task);
                }
            });
        } catch (Exception e) {
            lambda$signInWithProvider$26(promise, e);
        }
    }

    @ReactMethod
    public void delete(String str, final Promise promise) {
        FirebaseUser m = FirebaseAuth.getInstance(N8.g.p(str)).m();
        if (m != null) {
            m.e0().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.getInstance(N8.g.p(str)).k(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(N8.g.p(str));
        firebaseAuth.m().o0().a(com.google.firebase.auth.C.a(PhoneAuthProvider.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) {
        FirebaseAuth.getInstance(N8.g.p(str)).o().a(z);
        promise.resolve((Object) null);
    }

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

    @ReactMethod
    public void getCustomAuthDomain(String str, Promise promise) {
        promise.resolve(FirebaseAuth.getInstance(N8.g.p(str)).n());
    }

    @ReactMethod
    public void getIdToken(String str, Boolean bool, final Promise promise) {
        FirebaseUser m = FirebaseAuth.getInstance(N8.g.p(str)).m();
        if (m == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            m.k0(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) {
        FirebaseUser m = FirebaseAuth.getInstance(N8.g.p(str)).m();
        if (m == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            m.k0(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(N8.g.p(str)).m().o0().c().addOnCompleteListener(new OnCompleteListener() {
            public final void onComplete(Task task) {
                ReactNativeFirebaseAuthModule.this.lambda$getSession$27(promise, task);
            }
        });
    }

    @Override
    public void initialize() {
        super.initialize();
    }

    @Override
    public void invalidate() {
        super.invalidate();
        Iterator<Map.Entry<String, FirebaseAuth.a>> it = mAuthListeners.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, FirebaseAuth.a> next = it.next();
            FirebaseAuth.getInstance(N8.g.p(next.getKey())).u(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(N8.g.p(next2.getKey())).v(next2.getValue());
            it2.remove();
        }
        this.mCachedResolvers.clear();
        this.mMultiFactorSessions.clear();
    }

    @ReactMethod
    public void isSignInWithEmailLink(String str, String str2, Promise promise) {
        promise.resolve(Boolean.valueOf(FirebaseAuth.getInstance(N8.g.p(str)).t(str2)));
    }

    @ReactMethod
    public void reload(String str, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m != null) {
            m.v0().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) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        FirebaseAuth.a aVar = mAuthListeners.get(str);
        if (aVar != null) {
            firebaseAuth.u(aVar);
            mAuthListeners.remove(str);
        }
    }

    @ReactMethod
    public void removeIdTokenListener(String str) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        FirebaseAuth.b bVar = mIdTokenListeners.get(str);
        if (bVar != null) {
            firebaseAuth.v(bVar);
            mIdTokenListeners.remove(str);
        }
    }

    @ReactMethod
    public void resolveMultiFactorSignIn(String str, String str2, String str3, String str4, Promise promise) {
        resolveMultiFactorCredential(PhoneAuthProvider.a(str3, str4), str2, promise);
    }

    @ReactMethod
    public void revokeToken(String str, String str2, Promise promise) {
        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(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m == 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) {
            m.w0().addOnCompleteListener(getExecutor(), onCompleteListener);
        } else {
            m.x0(buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), onCompleteListener);
        }
    }

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

    @ReactMethod
    public void sendSignInLinkToEmail(String str, String str2, ReadableMap readableMap, final Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        firebaseAuth.y(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) {
        FirebaseAuth.getInstance(N8.g.p(str)).o().b(z);
        promise.resolve((Object) null);
    }

    @ReactMethod
    public void setAutoRetrievedSmsCodeForPhoneNumber(String str, String str2, String str3, Promise promise) {
        FirebaseAuth.getInstance(N8.g.p(str)).o().c(str2, str3);
        promise.resolve((Object) null);
    }

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

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

    @ReactMethod
    public void signInWithPhoneNumber(String str, String str2, boolean z, Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.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) {
                PhoneAuthProvider.b(firebaseAuth).d(str2, 60L, TimeUnit.SECONDS, currentActivity, aVar);
            } else {
                PhoneAuthProvider.b(firebaseAuth).e(str2, 60L, TimeUnit.SECONDS, currentActivity, aVar, this.mForceResendingToken);
            }
        }
    }

    @ReactMethod
    public void signOut(String str, Promise promise) {
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        if (firebaseAuth == null || firebaseAuth.m() == null) {
            promiseNoUser(promise, Boolean.TRUE);
        } else {
            firebaseAuth.H();
            promiseNoUser(promise, Boolean.FALSE);
        }
    }

    @ReactMethod
    public void unlink(String str, String str2, final Promise promise) {
        FirebaseUser m = FirebaseAuth.getInstance(N8.g.p(str)).m();
        if (m != null) {
            m.A0(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(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m != null) {
            m.B0(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(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m != null) {
            m.C0(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(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m == null) {
            promiseNoUser(promise, Boolean.FALSE);
            Log.e(TAG, "updateProfile:failure:noCurrentUser");
            return;
        }
        UserProfileChangeRequest.a aVar = new UserProfileChangeRequest.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));
        }
        m.E0(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(N8.g.p(str)).J();
    }

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

    @ReactMethod
    public void verifyBeforeUpdateEmail(String str, String str2, ReadableMap readableMap, final Promise promise) {
        final FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
        FirebaseUser m = firebaseAuth.m();
        if (m == 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) {
            m.F0(str2).addOnCompleteListener(getExecutor(), onCompleteListener);
        } else {
            m.G0(str2, buildActionCodeSettings(readableMap)).addOnCompleteListener(getExecutor(), onCompleteListener);
        }
    }

    @ReactMethod
    public void verifyPasswordResetCode(String str, String str2, final Promise promise) {
        FirebaseAuth.getInstance(N8.g.p(str)).L(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) {
        StringBuilder sb2 = new StringBuilder();
        sb2.append("verifyPhoneNumber:");
        sb2.append(str2);
        FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.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) {
                PhoneAuthProvider.b(firebaseAuth).d(str2, i, TimeUnit.SECONDS, currentActivity, dVar);
            } else {
                PhoneAuthProvider.b(firebaseAuth).e(str2, i, TimeUnit.SECONDS, currentActivity, dVar, this.mForceResendingToken);
            }
        }
    }

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

    @ReactMethod
    public void verifyPhoneNumberWithMultiFactorInfo(String str, String str2, String str3, Promise promise) {
        MultiFactorInfo multiFactorInfo;
        MultiFactorResolver multiFactorResolver = this.mCachedResolvers.get(str3);
        if (multiFactorResolver == null) {
            ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "invalid-multi-factor-session", "No resolver for session found. Is the session id correct?");
            return;
        }
        Iterator it = multiFactorResolver.k0().iterator();
        while (true) {
            if (!it.hasNext()) {
                multiFactorInfo = null;
                break;
            } else {
                multiFactorInfo = (MultiFactorInfo) it.next();
                if (str2.equals(multiFactorInfo.c())) {
                    break;
                }
            }
        }
        if (multiFactorInfo == 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(multiFactorInfo.k0())) {
                ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "unknown", "Unsupported second factor. Only phone factors are supported.");
                return;
            }
            FirebaseAuth firebaseAuth = FirebaseAuth.getInstance(N8.g.p(str));
            PhoneAuthProvider.c(com.google.firebase.auth.A.a(firebaseAuth).c(getCurrentActivity()).f((PhoneMultiFactorInfo) multiFactorInfo).i(30L, TimeUnit.SECONDS).g(multiFactorResolver.n0()).d(new b(promise, str3)).a());
        }
    }
}