Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/firebase/AutoValue_StartupTime.java

@@ -0,0 +1,52 @@
+package com.google.firebase;
+
+/* loaded from: classes3.dex */
+public final class AutoValue_StartupTime extends StartupTime {
+    public final long elapsedRealtime;
+    public final long epochMillis;
+    public final long uptimeMillis;
+
+    @Override // com.google.firebase.StartupTime
+    public long getElapsedRealtime() {
+        return this.elapsedRealtime;
+    }
+
+    @Override // com.google.firebase.StartupTime
+    public long getEpochMillis() {
+        return this.epochMillis;
+    }
+
+    @Override // com.google.firebase.StartupTime
+    public long getUptimeMillis() {
+        return this.uptimeMillis;
+    }
+
+    public int hashCode() {
+        long j = this.epochMillis;
+        long j2 = this.elapsedRealtime;
+        int i = (((((int) (j ^ (j >>> 32))) ^ 1000003) * 1000003) ^ ((int) (j2 ^ (j2 >>> 32)))) * 1000003;
+        long j3 = this.uptimeMillis;
+        return i ^ ((int) ((j3 >>> 32) ^ j3));
+    }
+
+    public AutoValue_StartupTime(long j, long j2, long j3) {
+        this.epochMillis = j;
+        this.elapsedRealtime = j2;
+        this.uptimeMillis = j3;
+    }
+
+    public String toString() {
+        return "StartupTime{epochMillis=" + this.epochMillis + ", elapsedRealtime=" + this.elapsedRealtime + ", uptimeMillis=" + this.uptimeMillis + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof StartupTime)) {
+            return false;
+        }
+        StartupTime startupTime = (StartupTime) obj;
+        return this.epochMillis == startupTime.getEpochMillis() && this.elapsedRealtime == startupTime.getElapsedRealtime() && this.uptimeMillis == startupTime.getUptimeMillis();
+    }
+}

decompiled/sources/com/google/firebase/DataCollectionDefaultChange.java

@@ -0,0 +1,5 @@
+package com.google.firebase;
+
+/* loaded from: classes3.dex */
+public abstract class DataCollectionDefaultChange {
+}

decompiled/sources/com/google/firebase/Firebase.java

@@ -0,0 +1,6 @@
+package com.google.firebase;
+
+/* loaded from: classes3.dex */
+public final class Firebase {
+    public static final Firebase INSTANCE = new Firebase();
+}

decompiled/sources/com/google/firebase/FirebaseApp.java

@@ -0,0 +1,325 @@
+package com.google.firebase;
+
+import android.app.Application;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.util.Log;
+import androidx.collection.ArrayMap;
+import androidx.core.os.UserManagerCompat;
+import androidx.lifecycle.LifecycleKt$$ExternalSyntheticBackportWithForwarding0;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.google.android.gms.common.api.internal.BackgroundDetector;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.Base64Utils;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.common.util.ProcessUtils;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentDiscovery;
+import com.google.firebase.components.ComponentDiscoveryService;
+import com.google.firebase.components.ComponentRuntime;
+import com.google.firebase.components.Lazy;
+import com.google.firebase.concurrent.ExecutorsRegistrar;
+import com.google.firebase.concurrent.UiExecutor;
+import com.google.firebase.events.Publisher;
+import com.google.firebase.heartbeatinfo.DefaultHeartBeatController;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.internal.DataCollectionConfigStorage;
+import com.google.firebase.provider.FirebaseInitProvider;
+import com.google.firebase.tracing.ComponentMonitor;
+import com.google.firebase.tracing.FirebaseTrace;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes3.dex */
+public class FirebaseApp {
+    public final Context applicationContext;
+    public final ComponentRuntime componentRuntime;
+    public final Lazy dataCollectionConfigStorage;
+    public final Provider defaultHeartBeatController;
+    public final String name;
+    public final FirebaseOptions options;
+    public static final Object LOCK = new Object();
+    public static final Map INSTANCES = new ArrayMap();
+    public final AtomicBoolean automaticResourceManagementEnabled = new AtomicBoolean(false);
+    public final AtomicBoolean deleted = new AtomicBoolean();
+    public final List backgroundStateChangeListeners = new CopyOnWriteArrayList();
+    public final List lifecycleListeners = new CopyOnWriteArrayList();
+
+    public interface BackgroundStateChangeListener {
+        void onBackgroundStateChanged(boolean z);
+    }
+
+    public Context getApplicationContext() {
+        checkNotDeleted();
+        return this.applicationContext;
+    }
+
+    public String getName() {
+        checkNotDeleted();
+        return this.name;
+    }
+
+    public FirebaseOptions getOptions() {
+        checkNotDeleted();
+        return this.options;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof FirebaseApp) {
+            return this.name.equals(((FirebaseApp) obj).getName());
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return this.name.hashCode();
+    }
+
+    public String toString() {
+        return Objects.toStringHelper(this).add("name", this.name).add(SDKConstants.PARAM_GAME_REQUESTS_OPTIONS, this.options).toString();
+    }
+
+    public static FirebaseApp getInstance() {
+        FirebaseApp firebaseApp;
+        synchronized (LOCK) {
+            try {
+                firebaseApp = (FirebaseApp) INSTANCES.get("[DEFAULT]");
+                if (firebaseApp == null) {
+                    throw new IllegalStateException("Default FirebaseApp is not initialized in this process " + ProcessUtils.getMyProcessName() + ". Make sure to call FirebaseApp.initializeApp(Context) first.");
+                }
+                ((DefaultHeartBeatController) firebaseApp.defaultHeartBeatController.get()).registerHeartBeat();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return firebaseApp;
+    }
+
+    public static FirebaseApp initializeApp(Context context) {
+        synchronized (LOCK) {
+            try {
+                if (INSTANCES.containsKey("[DEFAULT]")) {
+                    return getInstance();
+                }
+                FirebaseOptions fromResource = FirebaseOptions.fromResource(context);
+                if (fromResource == null) {
+                    Log.w("FirebaseApp", "Default FirebaseApp failed to initialize because no default options were found. This usually means that com.google.gms:google-services was not applied to your gradle project.");
+                    return null;
+                }
+                return initializeApp(context, fromResource);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static FirebaseApp initializeApp(Context context, FirebaseOptions firebaseOptions) {
+        return initializeApp(context, firebaseOptions, "[DEFAULT]");
+    }
+
+    public static FirebaseApp initializeApp(Context context, FirebaseOptions firebaseOptions, String str) {
+        FirebaseApp firebaseApp;
+        GlobalBackgroundStateListener.ensureBackgroundStateListenerRegistered(context);
+        String normalize = normalize(str);
+        if (context.getApplicationContext() != null) {
+            context = context.getApplicationContext();
+        }
+        synchronized (LOCK) {
+            Map map = INSTANCES;
+            Preconditions.checkState(!map.containsKey(normalize), "FirebaseApp name " + normalize + " already exists!");
+            Preconditions.checkNotNull(context, "Application context cannot be null.");
+            firebaseApp = new FirebaseApp(context, normalize, firebaseOptions);
+            map.put(normalize, firebaseApp);
+        }
+        firebaseApp.initializeAllApis();
+        return firebaseApp;
+    }
+
+    public Object get(Class cls) {
+        checkNotDeleted();
+        return this.componentRuntime.get(cls);
+    }
+
+    public boolean isDataCollectionDefaultEnabled() {
+        checkNotDeleted();
+        return ((DataCollectionConfigStorage) this.dataCollectionConfigStorage.get()).isEnabled();
+    }
+
+    public FirebaseApp(final Context context, String str, FirebaseOptions firebaseOptions) {
+        this.applicationContext = (Context) Preconditions.checkNotNull(context);
+        this.name = Preconditions.checkNotEmpty(str);
+        this.options = (FirebaseOptions) Preconditions.checkNotNull(firebaseOptions);
+        StartupTime startupTime = FirebaseInitProvider.getStartupTime();
+        FirebaseTrace.pushTrace("Firebase");
+        FirebaseTrace.pushTrace("ComponentDiscovery");
+        List discoverLazy = ComponentDiscovery.forContext(context, ComponentDiscoveryService.class).discoverLazy();
+        FirebaseTrace.popTrace();
+        FirebaseTrace.pushTrace("Runtime");
+        ComponentRuntime.Builder processor = ComponentRuntime.builder(UiExecutor.INSTANCE).addLazyComponentRegistrars(discoverLazy).addComponentRegistrar(new FirebaseCommonRegistrar()).addComponentRegistrar(new ExecutorsRegistrar()).addComponent(Component.of(context, Context.class, new Class[0])).addComponent(Component.of(this, FirebaseApp.class, new Class[0])).addComponent(Component.of(firebaseOptions, FirebaseOptions.class, new Class[0])).setProcessor(new ComponentMonitor());
+        if (UserManagerCompat.isUserUnlocked(context) && FirebaseInitProvider.isCurrentlyInitializing()) {
+            processor.addComponent(Component.of(startupTime, StartupTime.class, new Class[0]));
+        }
+        ComponentRuntime build = processor.build();
+        this.componentRuntime = build;
+        FirebaseTrace.popTrace();
+        this.dataCollectionConfigStorage = new Lazy(new Provider() { // from class: com.google.firebase.FirebaseApp$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.inject.Provider
+            public final Object get() {
+                DataCollectionConfigStorage lambda$new$0;
+                lambda$new$0 = FirebaseApp.this.lambda$new$0(context);
+                return lambda$new$0;
+            }
+        });
+        this.defaultHeartBeatController = build.getProvider(DefaultHeartBeatController.class);
+        addBackgroundStateChangeListener(new BackgroundStateChangeListener() { // from class: com.google.firebase.FirebaseApp$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.FirebaseApp.BackgroundStateChangeListener
+            public final void onBackgroundStateChanged(boolean z) {
+                FirebaseApp.this.lambda$new$1(z);
+            }
+        });
+        FirebaseTrace.popTrace();
+    }
+
+    public final /* synthetic */ DataCollectionConfigStorage lambda$new$0(Context context) {
+        return new DataCollectionConfigStorage(context, getPersistenceKey(), (Publisher) this.componentRuntime.get(Publisher.class));
+    }
+
+    public final /* synthetic */ void lambda$new$1(boolean z) {
+        if (z) {
+            return;
+        }
+        ((DefaultHeartBeatController) this.defaultHeartBeatController.get()).registerHeartBeat();
+    }
+
+    public final void checkNotDeleted() {
+        Preconditions.checkState(!this.deleted.get(), "FirebaseApp was deleted");
+    }
+
+    public boolean isDefaultApp() {
+        return "[DEFAULT]".equals(getName());
+    }
+
+    public final void notifyBackgroundStateChangeListeners(boolean z) {
+        Iterator it = this.backgroundStateChangeListeners.iterator();
+        while (it.hasNext()) {
+            ((BackgroundStateChangeListener) it.next()).onBackgroundStateChanged(z);
+        }
+    }
+
+    public void addBackgroundStateChangeListener(BackgroundStateChangeListener backgroundStateChangeListener) {
+        checkNotDeleted();
+        if (this.automaticResourceManagementEnabled.get() && BackgroundDetector.getInstance().isInBackground()) {
+            backgroundStateChangeListener.onBackgroundStateChanged(true);
+        }
+        this.backgroundStateChangeListeners.add(backgroundStateChangeListener);
+    }
+
+    public String getPersistenceKey() {
+        return Base64Utils.encodeUrlSafeNoPadding(getName().getBytes(Charset.defaultCharset())) + "+" + Base64Utils.encodeUrlSafeNoPadding(getOptions().getApplicationId().getBytes(Charset.defaultCharset()));
+    }
+
+    public void addLifecycleEventListener(FirebaseAppLifecycleListener firebaseAppLifecycleListener) {
+        checkNotDeleted();
+        Preconditions.checkNotNull(firebaseAppLifecycleListener);
+        this.lifecycleListeners.add(firebaseAppLifecycleListener);
+    }
+
+    public final void initializeAllApis() {
+        if (!UserManagerCompat.isUserUnlocked(this.applicationContext)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Device in Direct Boot Mode: postponing initialization of Firebase APIs for app ");
+            sb.append(getName());
+            UserUnlockReceiver.ensureReceiverRegistered(this.applicationContext);
+            return;
+        }
+        StringBuilder sb2 = new StringBuilder();
+        sb2.append("Device unlocked: initializing all Firebase APIs for app ");
+        sb2.append(getName());
+        this.componentRuntime.initializeEagerComponents(isDefaultApp());
+        ((DefaultHeartBeatController) this.defaultHeartBeatController.get()).registerHeartBeat();
+    }
+
+    public static String normalize(String str) {
+        return str.trim();
+    }
+
+    public static class UserUnlockReceiver extends BroadcastReceiver {
+        public static AtomicReference INSTANCE = new AtomicReference();
+        public final Context applicationContext;
+
+        public UserUnlockReceiver(Context context) {
+            this.applicationContext = context;
+        }
+
+        public static void ensureReceiverRegistered(Context context) {
+            if (INSTANCE.get() == null) {
+                UserUnlockReceiver userUnlockReceiver = new UserUnlockReceiver(context);
+                if (LifecycleKt$$ExternalSyntheticBackportWithForwarding0.m(INSTANCE, null, userUnlockReceiver)) {
+                    context.registerReceiver(userUnlockReceiver, new IntentFilter("android.intent.action.USER_UNLOCKED"));
+                }
+            }
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            synchronized (FirebaseApp.LOCK) {
+                try {
+                    Iterator it = FirebaseApp.INSTANCES.values().iterator();
+                    while (it.hasNext()) {
+                        ((FirebaseApp) it.next()).initializeAllApis();
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            unregister();
+        }
+
+        public void unregister() {
+            this.applicationContext.unregisterReceiver(this);
+        }
+    }
+
+    public static class GlobalBackgroundStateListener implements BackgroundDetector.BackgroundStateChangeListener {
+        public static AtomicReference INSTANCE = new AtomicReference();
+
+        public static void ensureBackgroundStateListenerRegistered(Context context) {
+            if (PlatformVersion.isAtLeastIceCreamSandwich() && (context.getApplicationContext() instanceof Application)) {
+                Application application = (Application) context.getApplicationContext();
+                if (INSTANCE.get() == null) {
+                    GlobalBackgroundStateListener globalBackgroundStateListener = new GlobalBackgroundStateListener();
+                    if (LifecycleKt$$ExternalSyntheticBackportWithForwarding0.m(INSTANCE, null, globalBackgroundStateListener)) {
+                        BackgroundDetector.initialize(application);
+                        BackgroundDetector.getInstance().addListener(globalBackgroundStateListener);
+                    }
+                }
+            }
+        }
+
+        @Override // com.google.android.gms.common.api.internal.BackgroundDetector.BackgroundStateChangeListener
+        public void onBackgroundStateChanged(boolean z) {
+            synchronized (FirebaseApp.LOCK) {
+                try {
+                    Iterator it = new ArrayList(FirebaseApp.INSTANCES.values()).iterator();
+                    while (it.hasNext()) {
+                        FirebaseApp firebaseApp = (FirebaseApp) it.next();
+                        if (firebaseApp.automaticResourceManagementEnabled.get()) {
+                            firebaseApp.notifyBackgroundStateChangeListeners(z);
+                        }
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/FirebaseAppLifecycleListener.java

@@ -0,0 +1,5 @@
+package com.google.firebase;
+
+/* loaded from: classes3.dex */
+public interface FirebaseAppLifecycleListener {
+}

decompiled/sources/com/google/firebase/FirebaseCommonKtxRegistrar.java

@@ -0,0 +1,68 @@
+package com.google.firebase;
+
+import androidx.annotation.Keep;
+import com.google.firebase.annotations.concurrent.Background;
+import com.google.firebase.annotations.concurrent.Blocking;
+import com.google.firebase.annotations.concurrent.Lightweight;
+import com.google.firebase.annotations.concurrent.UiThread;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Dependency;
+import com.google.firebase.components.Qualified;
+import java.util.List;
+import java.util.concurrent.Executor;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.CoroutineDispatcher;
+import kotlinx.coroutines.ExecutorsKt;
+
+@Keep
+@SourceDebugExtension({"SMAP\nFirebase.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Firebase.kt\ncom/google/firebase/FirebaseCommonKtxRegistrar\n+ 2 Firebase.kt\ncom/google/firebase/FirebaseKt\n*L\n1#1,82:1\n76#2,6:83\n76#2,6:89\n76#2,6:95\n76#2,6:101\n*S KotlinDebug\n*F\n+ 1 Firebase.kt\ncom/google/firebase/FirebaseCommonKtxRegistrar\n*L\n67#1:83,6\n68#1:89,6\n69#1:95,6\n70#1:101,6\n*E\n"})
+/* loaded from: classes3.dex */
+public final class FirebaseCommonKtxRegistrar implements ComponentRegistrar {
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List<Component> getComponents() {
+        List<Component> listOf;
+        Component build = Component.builder(Qualified.qualified(Background.class, CoroutineDispatcher.class)).add(Dependency.required(Qualified.qualified(Background.class, Executor.class))).factory(new ComponentFactory() { // from class: com.google.firebase.FirebaseCommonKtxRegistrar$getComponents$$inlined$coroutineDispatcher$1
+            @Override // com.google.firebase.components.ComponentFactory
+            public final CoroutineDispatcher create(ComponentContainer componentContainer) {
+                Object obj = componentContainer.get(Qualified.qualified(Background.class, Executor.class));
+                Intrinsics.checkNotNullExpressionValue(obj, "c.get(Qualified.qualifie…a, Executor::class.java))");
+                return ExecutorsKt.from((Executor) obj);
+            }
+        }).build();
+        Intrinsics.checkNotNullExpressionValue(build, "builder(Qualified.qualif…cher()\n    }\n    .build()");
+        Component build2 = Component.builder(Qualified.qualified(Lightweight.class, CoroutineDispatcher.class)).add(Dependency.required(Qualified.qualified(Lightweight.class, Executor.class))).factory(new ComponentFactory() { // from class: com.google.firebase.FirebaseCommonKtxRegistrar$getComponents$$inlined$coroutineDispatcher$2
+            @Override // com.google.firebase.components.ComponentFactory
+            public final CoroutineDispatcher create(ComponentContainer componentContainer) {
+                Object obj = componentContainer.get(Qualified.qualified(Lightweight.class, Executor.class));
+                Intrinsics.checkNotNullExpressionValue(obj, "c.get(Qualified.qualifie…a, Executor::class.java))");
+                return ExecutorsKt.from((Executor) obj);
+            }
+        }).build();
+        Intrinsics.checkNotNullExpressionValue(build2, "builder(Qualified.qualif…cher()\n    }\n    .build()");
+        Component build3 = Component.builder(Qualified.qualified(Blocking.class, CoroutineDispatcher.class)).add(Dependency.required(Qualified.qualified(Blocking.class, Executor.class))).factory(new ComponentFactory() { // from class: com.google.firebase.FirebaseCommonKtxRegistrar$getComponents$$inlined$coroutineDispatcher$3
+            @Override // com.google.firebase.components.ComponentFactory
+            public final CoroutineDispatcher create(ComponentContainer componentContainer) {
+                Object obj = componentContainer.get(Qualified.qualified(Blocking.class, Executor.class));
+                Intrinsics.checkNotNullExpressionValue(obj, "c.get(Qualified.qualifie…a, Executor::class.java))");
+                return ExecutorsKt.from((Executor) obj);
+            }
+        }).build();
+        Intrinsics.checkNotNullExpressionValue(build3, "builder(Qualified.qualif…cher()\n    }\n    .build()");
+        Component build4 = Component.builder(Qualified.qualified(UiThread.class, CoroutineDispatcher.class)).add(Dependency.required(Qualified.qualified(UiThread.class, Executor.class))).factory(new ComponentFactory() { // from class: com.google.firebase.FirebaseCommonKtxRegistrar$getComponents$$inlined$coroutineDispatcher$4
+            @Override // com.google.firebase.components.ComponentFactory
+            public final CoroutineDispatcher create(ComponentContainer componentContainer) {
+                Object obj = componentContainer.get(Qualified.qualified(UiThread.class, Executor.class));
+                Intrinsics.checkNotNullExpressionValue(obj, "c.get(Qualified.qualifie…a, Executor::class.java))");
+                return ExecutorsKt.from((Executor) obj);
+            }
+        }).build();
+        Intrinsics.checkNotNullExpressionValue(build4, "builder(Qualified.qualif…cher()\n    }\n    .build()");
+        listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new Component[]{build, build2, build3, build4});
+        return listOf;
+    }
+}

decompiled/sources/com/google/firebase/FirebaseCommonRegistrar.java

@@ -0,0 +1,87 @@
+package com.google.firebase;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.os.Build;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.heartbeatinfo.DefaultHeartBeatController;
+import com.google.firebase.platforminfo.DefaultUserAgentPublisher;
+import com.google.firebase.platforminfo.KotlinDetector;
+import com.google.firebase.platforminfo.LibraryVersionComponent;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class FirebaseCommonRegistrar implements ComponentRegistrar {
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List getComponents() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(DefaultUserAgentPublisher.component());
+        arrayList.add(DefaultHeartBeatController.component());
+        arrayList.add(LibraryVersionComponent.create("fire-android", String.valueOf(Build.VERSION.SDK_INT)));
+        arrayList.add(LibraryVersionComponent.create("fire-core", "21.0.0"));
+        arrayList.add(LibraryVersionComponent.create("device-name", safeValue(Build.PRODUCT)));
+        arrayList.add(LibraryVersionComponent.create("device-model", safeValue(Build.DEVICE)));
+        arrayList.add(LibraryVersionComponent.create("device-brand", safeValue(Build.BRAND)));
+        arrayList.add(LibraryVersionComponent.fromContext("android-target-sdk", new LibraryVersionComponent.VersionExtractor() { // from class: com.google.firebase.FirebaseCommonRegistrar$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.platforminfo.LibraryVersionComponent.VersionExtractor
+            public final String extract(Object obj) {
+                String lambda$getComponents$0;
+                lambda$getComponents$0 = FirebaseCommonRegistrar.lambda$getComponents$0((Context) obj);
+                return lambda$getComponents$0;
+            }
+        }));
+        arrayList.add(LibraryVersionComponent.fromContext("android-min-sdk", new LibraryVersionComponent.VersionExtractor() { // from class: com.google.firebase.FirebaseCommonRegistrar$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.platforminfo.LibraryVersionComponent.VersionExtractor
+            public final String extract(Object obj) {
+                String lambda$getComponents$1;
+                lambda$getComponents$1 = FirebaseCommonRegistrar.lambda$getComponents$1((Context) obj);
+                return lambda$getComponents$1;
+            }
+        }));
+        arrayList.add(LibraryVersionComponent.fromContext("android-platform", new LibraryVersionComponent.VersionExtractor() { // from class: com.google.firebase.FirebaseCommonRegistrar$$ExternalSyntheticLambda2
+            @Override // com.google.firebase.platforminfo.LibraryVersionComponent.VersionExtractor
+            public final String extract(Object obj) {
+                String lambda$getComponents$2;
+                lambda$getComponents$2 = FirebaseCommonRegistrar.lambda$getComponents$2((Context) obj);
+                return lambda$getComponents$2;
+            }
+        }));
+        arrayList.add(LibraryVersionComponent.fromContext("android-installer", new LibraryVersionComponent.VersionExtractor() { // from class: com.google.firebase.FirebaseCommonRegistrar$$ExternalSyntheticLambda3
+            @Override // com.google.firebase.platforminfo.LibraryVersionComponent.VersionExtractor
+            public final String extract(Object obj) {
+                String lambda$getComponents$3;
+                lambda$getComponents$3 = FirebaseCommonRegistrar.lambda$getComponents$3((Context) obj);
+                return lambda$getComponents$3;
+            }
+        }));
+        String detectVersion = KotlinDetector.detectVersion();
+        if (detectVersion != null) {
+            arrayList.add(LibraryVersionComponent.create("kotlin", detectVersion));
+        }
+        return arrayList;
+    }
+
+    public static /* synthetic */ String lambda$getComponents$0(Context context) {
+        ApplicationInfo applicationInfo = context.getApplicationInfo();
+        return applicationInfo != null ? String.valueOf(applicationInfo.targetSdkVersion) : "";
+    }
+
+    public static /* synthetic */ String lambda$getComponents$1(Context context) {
+        ApplicationInfo applicationInfo = context.getApplicationInfo();
+        return applicationInfo != null ? String.valueOf(applicationInfo.minSdkVersion) : "";
+    }
+
+    public static /* synthetic */ String lambda$getComponents$2(Context context) {
+        return context.getPackageManager().hasSystemFeature("android.hardware.type.television") ? "tv" : context.getPackageManager().hasSystemFeature("android.hardware.type.watch") ? "watch" : context.getPackageManager().hasSystemFeature("android.hardware.type.automotive") ? "auto" : context.getPackageManager().hasSystemFeature("android.hardware.type.embedded") ? "embedded" : "";
+    }
+
+    public static /* synthetic */ String lambda$getComponents$3(Context context) {
+        String installerPackageName = context.getPackageManager().getInstallerPackageName(context.getPackageName());
+        return installerPackageName != null ? safeValue(installerPackageName) : "";
+    }
+
+    public static String safeValue(String str) {
+        return str.replace(' ', '_').replace('/', '_');
+    }
+}

decompiled/sources/com/google/firebase/FirebaseException.java

@@ -0,0 +1,21 @@
+package com.google.firebase;
+
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public abstract class FirebaseException extends Exception {
+    public FirebaseException() {
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FirebaseException(String str) {
+        super(str);
+        Preconditions.checkNotEmpty(str, "Detail message must not be empty");
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public FirebaseException(String str, Throwable th) {
+        super(str, th);
+        Preconditions.checkNotEmpty(str, "Detail message must not be empty");
+    }
+}

decompiled/sources/com/google/firebase/FirebaseKt.java

@@ -0,0 +1,13 @@
+package com.google.firebase;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class FirebaseKt {
+    public static final FirebaseApp getApp(Firebase firebase) {
+        Intrinsics.checkNotNullParameter(firebase, "<this>");
+        FirebaseApp firebaseApp = FirebaseApp.getInstance();
+        Intrinsics.checkNotNullExpressionValue(firebaseApp, "getInstance()");
+        return firebaseApp;
+    }
+}

decompiled/sources/com/google/firebase/FirebaseOptions.java

@@ -0,0 +1,115 @@
+package com.google.firebase;
+
+import android.content.Context;
+import android.text.TextUtils;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.StringResourceValueReader;
+import com.google.android.gms.common.util.Strings;
+
+/* loaded from: classes3.dex */
+public final class FirebaseOptions {
+    public final String apiKey;
+    public final String applicationId;
+    public final String databaseUrl;
+    public final String gaTrackingId;
+    public final String gcmSenderId;
+    public final String projectId;
+    public final String storageBucket;
+
+    public String getApiKey() {
+        return this.apiKey;
+    }
+
+    public String getApplicationId() {
+        return this.applicationId;
+    }
+
+    public String getGcmSenderId() {
+        return this.gcmSenderId;
+    }
+
+    public String getProjectId() {
+        return this.projectId;
+    }
+
+    public static final class Builder {
+        public String apiKey;
+        public String applicationId;
+        public String databaseUrl;
+        public String gaTrackingId;
+        public String gcmSenderId;
+        public String projectId;
+        public String storageBucket;
+
+        public Builder setDatabaseUrl(String str) {
+            this.databaseUrl = str;
+            return this;
+        }
+
+        public Builder setGcmSenderId(String str) {
+            this.gcmSenderId = str;
+            return this;
+        }
+
+        public Builder setProjectId(String str) {
+            this.projectId = str;
+            return this;
+        }
+
+        public Builder setStorageBucket(String str) {
+            this.storageBucket = str;
+            return this;
+        }
+
+        public Builder setApiKey(String str) {
+            this.apiKey = Preconditions.checkNotEmpty(str, "ApiKey must be set.");
+            return this;
+        }
+
+        public Builder setApplicationId(String str) {
+            this.applicationId = Preconditions.checkNotEmpty(str, "ApplicationId must be set.");
+            return this;
+        }
+
+        public FirebaseOptions build() {
+            return new FirebaseOptions(this.applicationId, this.apiKey, this.databaseUrl, this.gaTrackingId, this.gcmSenderId, this.storageBucket, this.projectId);
+        }
+    }
+
+    public FirebaseOptions(String str, String str2, String str3, String str4, String str5, String str6, String str7) {
+        Preconditions.checkState(!Strings.isEmptyOrWhitespace(str), "ApplicationId must be set.");
+        this.applicationId = str;
+        this.apiKey = str2;
+        this.databaseUrl = str3;
+        this.gaTrackingId = str4;
+        this.gcmSenderId = str5;
+        this.storageBucket = str6;
+        this.projectId = str7;
+    }
+
+    public static FirebaseOptions fromResource(Context context) {
+        StringResourceValueReader stringResourceValueReader = new StringResourceValueReader(context);
+        String string = stringResourceValueReader.getString("google_app_id");
+        if (TextUtils.isEmpty(string)) {
+            return null;
+        }
+        return new FirebaseOptions(string, stringResourceValueReader.getString("google_api_key"), stringResourceValueReader.getString("firebase_database_url"), stringResourceValueReader.getString("ga_trackingId"), stringResourceValueReader.getString("gcm_defaultSenderId"), stringResourceValueReader.getString("google_storage_bucket"), stringResourceValueReader.getString("project_id"));
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof FirebaseOptions)) {
+            return false;
+        }
+        FirebaseOptions firebaseOptions = (FirebaseOptions) obj;
+        return Objects.equal(this.applicationId, firebaseOptions.applicationId) && Objects.equal(this.apiKey, firebaseOptions.apiKey) && Objects.equal(this.databaseUrl, firebaseOptions.databaseUrl) && Objects.equal(this.gaTrackingId, firebaseOptions.gaTrackingId) && Objects.equal(this.gcmSenderId, firebaseOptions.gcmSenderId) && Objects.equal(this.storageBucket, firebaseOptions.storageBucket) && Objects.equal(this.projectId, firebaseOptions.projectId);
+    }
+
+    public int hashCode() {
+        return Objects.hashCode(this.applicationId, this.apiKey, this.databaseUrl, this.gaTrackingId, this.gcmSenderId, this.storageBucket, this.projectId);
+    }
+
+    public String toString() {
+        return Objects.toStringHelper(this).add("applicationId", this.applicationId).add("apiKey", this.apiKey).add("databaseUrl", this.databaseUrl).add("gcmSenderId", this.gcmSenderId).add("storageBucket", this.storageBucket).add("projectId", this.projectId).toString();
+    }
+}

decompiled/sources/com/google/firebase/R$raw.java

@@ -0,0 +1,6 @@
+package com.google.firebase;
+
+/* loaded from: classes3.dex */
+public final class R$raw {
+    public static int firebase_common_keep = 2131820548;
+}

decompiled/sources/com/google/firebase/StartupTime.java

@@ -0,0 +1,20 @@
+package com.google.firebase;
+
+import android.os.SystemClock;
+
+/* loaded from: classes3.dex */
+public abstract class StartupTime {
+    public abstract long getElapsedRealtime();
+
+    public abstract long getEpochMillis();
+
+    public abstract long getUptimeMillis();
+
+    public static StartupTime create(long j, long j2, long j3) {
+        return new AutoValue_StartupTime(j, j2, j3);
+    }
+
+    public static StartupTime now() {
+        return create(System.currentTimeMillis(), SystemClock.elapsedRealtime(), SystemClock.uptimeMillis());
+    }
+}

decompiled/sources/com/google/firebase/Timestamp.java

@@ -0,0 +1,102 @@
+package com.google.firebase;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import kotlin.comparisons.ComparisonsKt__ComparisonsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.PropertyReference1Impl;
+
+/* loaded from: classes3.dex */
+public final class Timestamp implements Comparable<Timestamp>, Parcelable {
+    public final int nanoseconds;
+    public final long seconds;
+    public static final Companion Companion = new Companion(null);
+    public static final Parcelable.Creator<Timestamp> CREATOR = new Parcelable.Creator() { // from class: com.google.firebase.Timestamp$Companion$CREATOR$1
+        @Override // android.os.Parcelable.Creator
+        public Timestamp createFromParcel(Parcel source) {
+            Intrinsics.checkNotNullParameter(source, "source");
+            return new Timestamp(source.readLong(), source.readInt());
+        }
+
+        @Override // android.os.Parcelable.Creator
+        public Timestamp[] newArray(int i) {
+            return new Timestamp[i];
+        }
+    };
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public final int getNanoseconds() {
+        return this.nanoseconds;
+    }
+
+    public final long getSeconds() {
+        return this.seconds;
+    }
+
+    public int hashCode() {
+        long j = this.seconds;
+        return (((((int) j) * 1369) + ((int) (j >> 32))) * 37) + this.nanoseconds;
+    }
+
+    public Timestamp(long j, int i) {
+        Companion.validateRange(j, i);
+        this.seconds = j;
+        this.nanoseconds = i;
+    }
+
+    @Override // java.lang.Comparable
+    public int compareTo(Timestamp other) {
+        int compareValuesBy;
+        Intrinsics.checkNotNullParameter(other, "other");
+        compareValuesBy = ComparisonsKt__ComparisonsKt.compareValuesBy(this, other, new PropertyReference1Impl() { // from class: com.google.firebase.Timestamp$compareTo$1
+            @Override // kotlin.jvm.internal.PropertyReference1Impl, kotlin.jvm.internal.PropertyReference1
+            public Object get(Object obj) {
+                return Long.valueOf(((Timestamp) obj).getSeconds());
+            }
+        }, new PropertyReference1Impl() { // from class: com.google.firebase.Timestamp$compareTo$2
+            @Override // kotlin.jvm.internal.PropertyReference1Impl, kotlin.jvm.internal.PropertyReference1
+            public Object get(Object obj) {
+                return Integer.valueOf(((Timestamp) obj).getNanoseconds());
+            }
+        });
+        return compareValuesBy;
+    }
+
+    public boolean equals(Object obj) {
+        return obj == this || ((obj instanceof Timestamp) && compareTo((Timestamp) obj) == 0);
+    }
+
+    public String toString() {
+        return "Timestamp(seconds=" + this.seconds + ", nanoseconds=" + this.nanoseconds + ')';
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        dest.writeLong(this.seconds);
+        dest.writeInt(this.nanoseconds);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        public final void validateRange(long j, int i) {
+            if (i < 0 || i >= 1000000000) {
+                throw new IllegalArgumentException(("Timestamp nanoseconds out of range: " + i).toString());
+            }
+            if (-62135596800L > j || j >= 253402300800L) {
+                throw new IllegalArgumentException(("Timestamp seconds out of range: " + j).toString());
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/abt/AbtException.java

@@ -0,0 +1,12 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public class AbtException extends Exception {
+    public AbtException(String str) {
+        super(str);
+    }
+
+    public AbtException(String str, Exception exc) {
+        super(str, exc);
+    }
+}

decompiled/sources/com/google/firebase/abt/AbtExperimentInfo.java

@@ -0,0 +1,87 @@
+package com.google.firebase.abt;
+
+import android.text.TextUtils;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public class AbtExperimentInfo {
+    public static final String[] ALL_REQUIRED_KEYS = {"experimentId", "experimentStartTime", "timeToLiveMillis", "triggerTimeoutMillis", "variantId"};
+    public static final DateFormat protoTimestampStringParser = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US);
+    public final String experimentId;
+    public final Date experimentStartTime;
+    public final long timeToLiveInMillis;
+    public final String triggerEventName;
+    public final long triggerTimeoutInMillis;
+    public final String variantId;
+
+    public String getExperimentId() {
+        return this.experimentId;
+    }
+
+    public String getVariantId() {
+        return this.variantId;
+    }
+
+    public AbtExperimentInfo(String str, String str2, String str3, Date date, long j, long j2) {
+        this.experimentId = str;
+        this.variantId = str2;
+        this.triggerEventName = str3;
+        this.experimentStartTime = date;
+        this.triggerTimeoutInMillis = j;
+        this.timeToLiveInMillis = j2;
+    }
+
+    public static AbtExperimentInfo fromMap(Map map) {
+        validateExperimentInfoMap(map);
+        try {
+            return new AbtExperimentInfo((String) map.get("experimentId"), (String) map.get("variantId"), map.containsKey("triggerEvent") ? (String) map.get("triggerEvent") : "", protoTimestampStringParser.parse((String) map.get("experimentStartTime")), Long.parseLong((String) map.get("triggerTimeoutMillis")), Long.parseLong((String) map.get("timeToLiveMillis")));
+        } catch (NumberFormatException e) {
+            throw new AbtException("Could not process experiment: one of the durations could not be converted into a long.", e);
+        } catch (ParseException e2) {
+            throw new AbtException("Could not process experiment: parsing experiment start time failed.", e2);
+        }
+    }
+
+    public long getStartTimeInMillisSinceEpoch() {
+        return this.experimentStartTime.getTime();
+    }
+
+    public static void validateExperimentInfoMap(Map map) {
+        ArrayList arrayList = new ArrayList();
+        for (String str : ALL_REQUIRED_KEYS) {
+            if (!map.containsKey(str)) {
+                arrayList.add(str);
+            }
+        }
+        if (!arrayList.isEmpty()) {
+            throw new AbtException(String.format("The following keys are missing from the experiment info map: %s", arrayList));
+        }
+    }
+
+    public AnalyticsConnector.ConditionalUserProperty toConditionalUserProperty(String str) {
+        AnalyticsConnector.ConditionalUserProperty conditionalUserProperty = new AnalyticsConnector.ConditionalUserProperty();
+        conditionalUserProperty.origin = str;
+        conditionalUserProperty.creationTimestamp = getStartTimeInMillisSinceEpoch();
+        conditionalUserProperty.name = this.experimentId;
+        conditionalUserProperty.value = this.variantId;
+        conditionalUserProperty.triggerEventName = TextUtils.isEmpty(this.triggerEventName) ? null : this.triggerEventName;
+        conditionalUserProperty.triggerTimeout = this.triggerTimeoutInMillis;
+        conditionalUserProperty.timeToLive = this.timeToLiveInMillis;
+        return conditionalUserProperty;
+    }
+
+    public static AbtExperimentInfo fromConditionalUserProperty(AnalyticsConnector.ConditionalUserProperty conditionalUserProperty) {
+        String str = conditionalUserProperty.triggerEventName;
+        if (str == null) {
+            str = "";
+        }
+        return new AbtExperimentInfo(conditionalUserProperty.name, String.valueOf(conditionalUserProperty.value), str, new Date(conditionalUserProperty.creationTimestamp), conditionalUserProperty.triggerTimeout, conditionalUserProperty.timeToLive);
+    }
+}

decompiled/sources/com/google/firebase/abt/FirebaseABTesting.java

@@ -0,0 +1,150 @@
+package com.google.firebase.abt;
+
+import android.content.Context;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.inject.Provider;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public class FirebaseABTesting {
+    public final Provider analyticsConnector;
+    public Integer maxUserProperties = null;
+    public final String originService;
+
+    public FirebaseABTesting(Context context, Provider provider, String str) {
+        this.analyticsConnector = provider;
+        this.originService = str;
+    }
+
+    public void replaceAllExperiments(List list) {
+        throwAbtExceptionIfAnalyticsIsNull();
+        if (list == null) {
+            throw new IllegalArgumentException("The replacementExperiments list is null.");
+        }
+        replaceAllExperimentsWith(convertMapsToExperimentInfos(list));
+    }
+
+    public void removeAllExperiments() {
+        throwAbtExceptionIfAnalyticsIsNull();
+        removeExperiments(getAllExperimentsInAnalytics());
+    }
+
+    public List getAllExperiments() {
+        throwAbtExceptionIfAnalyticsIsNull();
+        List allExperimentsInAnalytics = getAllExperimentsInAnalytics();
+        ArrayList arrayList = new ArrayList();
+        Iterator it = allExperimentsInAnalytics.iterator();
+        while (it.hasNext()) {
+            arrayList.add(AbtExperimentInfo.fromConditionalUserProperty((AnalyticsConnector.ConditionalUserProperty) it.next()));
+        }
+        return arrayList;
+    }
+
+    public final void replaceAllExperimentsWith(List list) {
+        if (list.isEmpty()) {
+            removeAllExperiments();
+            return;
+        }
+        List allExperiments = getAllExperiments();
+        removeExperiments(getExperimentsToRemove(allExperiments, list));
+        addExperiments(getExperimentsToAdd(list, allExperiments));
+    }
+
+    public final ArrayList getExperimentsToRemove(List list, List list2) {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            AbtExperimentInfo abtExperimentInfo = (AbtExperimentInfo) it.next();
+            if (!experimentsListContainsExperiment(list2, abtExperimentInfo)) {
+                arrayList.add(abtExperimentInfo.toConditionalUserProperty(this.originService));
+            }
+        }
+        return arrayList;
+    }
+
+    public final ArrayList getExperimentsToAdd(List list, List list2) {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            AbtExperimentInfo abtExperimentInfo = (AbtExperimentInfo) it.next();
+            if (!experimentsListContainsExperiment(list2, abtExperimentInfo)) {
+                arrayList.add(abtExperimentInfo);
+            }
+        }
+        return arrayList;
+    }
+
+    public final boolean experimentsListContainsExperiment(List list, AbtExperimentInfo abtExperimentInfo) {
+        String experimentId = abtExperimentInfo.getExperimentId();
+        String variantId = abtExperimentInfo.getVariantId();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            AbtExperimentInfo abtExperimentInfo2 = (AbtExperimentInfo) it.next();
+            if (abtExperimentInfo2.getExperimentId().equals(experimentId) && abtExperimentInfo2.getVariantId().equals(variantId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final void addExperiments(List list) {
+        ArrayDeque arrayDeque = new ArrayDeque(getAllExperimentsInAnalytics());
+        int maxUserPropertiesInAnalytics = getMaxUserPropertiesInAnalytics();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            AbtExperimentInfo abtExperimentInfo = (AbtExperimentInfo) it.next();
+            while (arrayDeque.size() >= maxUserPropertiesInAnalytics) {
+                removeExperimentFromAnalytics(((AnalyticsConnector.ConditionalUserProperty) arrayDeque.pollFirst()).name);
+            }
+            AnalyticsConnector.ConditionalUserProperty conditionalUserProperty = abtExperimentInfo.toConditionalUserProperty(this.originService);
+            addExperimentToAnalytics(conditionalUserProperty);
+            arrayDeque.offer(conditionalUserProperty);
+        }
+    }
+
+    public final void removeExperiments(Collection collection) {
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            removeExperimentFromAnalytics(((AnalyticsConnector.ConditionalUserProperty) it.next()).name);
+        }
+    }
+
+    public static List convertMapsToExperimentInfos(List list) {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            arrayList.add(AbtExperimentInfo.fromMap((Map) it.next()));
+        }
+        return arrayList;
+    }
+
+    public final void addExperimentToAnalytics(AnalyticsConnector.ConditionalUserProperty conditionalUserProperty) {
+        ((AnalyticsConnector) this.analyticsConnector.get()).setConditionalUserProperty(conditionalUserProperty);
+    }
+
+    public final void throwAbtExceptionIfAnalyticsIsNull() {
+        if (this.analyticsConnector.get() == null) {
+            throw new AbtException("The Analytics SDK is not available. Please check that the Analytics SDK is included in your app dependencies.");
+        }
+    }
+
+    public final void removeExperimentFromAnalytics(String str) {
+        ((AnalyticsConnector) this.analyticsConnector.get()).clearConditionalUserProperty(str, null, null);
+    }
+
+    public final int getMaxUserPropertiesInAnalytics() {
+        if (this.maxUserProperties == null) {
+            this.maxUserProperties = Integer.valueOf(((AnalyticsConnector) this.analyticsConnector.get()).getMaxUserProperties(this.originService));
+        }
+        return this.maxUserProperties.intValue();
+    }
+
+    public final List getAllExperimentsInAnalytics() {
+        return ((AnalyticsConnector) this.analyticsConnector.get()).getConditionalUserProperties(this.originService, "");
+    }
+}

decompiled/sources/com/google/firebase/abt/R$attr.java

@@ -0,0 +1,26 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$attr {
+    public static int alpha = 2130968661;
+    public static int coordinatorLayoutStyle = 2130968755;
+    public static int font = 2130968792;
+    public static int fontProviderAuthority = 2130968794;
+    public static int fontProviderCerts = 2130968795;
+    public static int fontProviderFetchStrategy = 2130968797;
+    public static int fontProviderFetchTimeout = 2130968798;
+    public static int fontProviderPackage = 2130968799;
+    public static int fontProviderQuery = 2130968800;
+    public static int fontStyle = 2130968802;
+    public static int fontVariationSettings = 2130968803;
+    public static int fontWeight = 2130968804;
+    public static int keylines = 2130968825;
+    public static int layout_anchor = 2130968830;
+    public static int layout_anchorGravity = 2130968831;
+    public static int layout_behavior = 2130968832;
+    public static int layout_dodgeInsetEdges = 2130968833;
+    public static int layout_insetEdge = 2130968834;
+    public static int layout_keyline = 2130968835;
+    public static int statusBarBackground = 2130968933;
+    public static int ttcIndex = 2130968988;
+}

decompiled/sources/com/google/firebase/abt/R$color.java

@@ -0,0 +1,9 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$color {
+    public static int notification_action_color_filter = 2131099879;
+    public static int notification_icon_bg_color = 2131099880;
+    public static int ripple_material_light = 2131099891;
+    public static int secondary_text_default_material_light = 2131099893;
+}

decompiled/sources/com/google/firebase/abt/R$dimen.java

@@ -0,0 +1,27 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$dimen {
+    public static int compat_button_inset_horizontal_material = 2131165333;
+    public static int compat_button_inset_vertical_material = 2131165334;
+    public static int compat_button_padding_horizontal_material = 2131165335;
+    public static int compat_button_padding_vertical_material = 2131165336;
+    public static int compat_control_corner_material = 2131165337;
+    public static int compat_notification_large_icon_max_height = 2131165338;
+    public static int compat_notification_large_icon_max_width = 2131165339;
+    public static int notification_action_icon_size = 2131165445;
+    public static int notification_action_text_size = 2131165446;
+    public static int notification_big_circle_margin = 2131165447;
+    public static int notification_content_margin_start = 2131165448;
+    public static int notification_large_icon_height = 2131165449;
+    public static int notification_large_icon_width = 2131165450;
+    public static int notification_main_column_padding_top = 2131165451;
+    public static int notification_media_narrow_margin = 2131165452;
+    public static int notification_right_icon_size = 2131165453;
+    public static int notification_right_side_padding_top = 2131165454;
+    public static int notification_small_icon_background_padding = 2131165455;
+    public static int notification_small_icon_size_as_large = 2131165456;
+    public static int notification_subtext_size = 2131165457;
+    public static int notification_top_pad = 2131165458;
+    public static int notification_top_pad_large_text = 2131165459;
+}

decompiled/sources/com/google/firebase/abt/R$drawable.java

@@ -0,0 +1,17 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$drawable {
+    public static int notification_action_background = 2131231297;
+    public static int notification_bg = 2131231298;
+    public static int notification_bg_low = 2131231299;
+    public static int notification_bg_low_normal = 2131231300;
+    public static int notification_bg_low_pressed = 2131231301;
+    public static int notification_bg_normal = 2131231302;
+    public static int notification_bg_normal_pressed = 2131231303;
+    public static int notification_icon_background = 2131231304;
+    public static int notification_template_icon_bg = 2131231306;
+    public static int notification_template_icon_low_bg = 2131231307;
+    public static int notification_tile_bg = 2131231308;
+    public static int notify_panel_notification_icon_bg = 2131231309;
+}

decompiled/sources/com/google/firebase/abt/R$id.java

@@ -0,0 +1,79 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$id {
+    public static int accessibility_action_clickable_span = 2131361801;
+    public static int accessibility_custom_action_0 = 2131361802;
+    public static int accessibility_custom_action_1 = 2131361803;
+    public static int accessibility_custom_action_10 = 2131361804;
+    public static int accessibility_custom_action_11 = 2131361805;
+    public static int accessibility_custom_action_12 = 2131361806;
+    public static int accessibility_custom_action_13 = 2131361807;
+    public static int accessibility_custom_action_14 = 2131361808;
+    public static int accessibility_custom_action_15 = 2131361809;
+    public static int accessibility_custom_action_16 = 2131361810;
+    public static int accessibility_custom_action_17 = 2131361811;
+    public static int accessibility_custom_action_18 = 2131361812;
+    public static int accessibility_custom_action_19 = 2131361813;
+    public static int accessibility_custom_action_2 = 2131361814;
+    public static int accessibility_custom_action_20 = 2131361815;
+    public static int accessibility_custom_action_21 = 2131361816;
+    public static int accessibility_custom_action_22 = 2131361817;
+    public static int accessibility_custom_action_23 = 2131361818;
+    public static int accessibility_custom_action_24 = 2131361819;
+    public static int accessibility_custom_action_25 = 2131361820;
+    public static int accessibility_custom_action_26 = 2131361821;
+    public static int accessibility_custom_action_27 = 2131361822;
+    public static int accessibility_custom_action_28 = 2131361823;
+    public static int accessibility_custom_action_29 = 2131361824;
+    public static int accessibility_custom_action_3 = 2131361825;
+    public static int accessibility_custom_action_30 = 2131361826;
+    public static int accessibility_custom_action_31 = 2131361827;
+    public static int accessibility_custom_action_4 = 2131361828;
+    public static int accessibility_custom_action_5 = 2131361829;
+    public static int accessibility_custom_action_6 = 2131361830;
+    public static int accessibility_custom_action_7 = 2131361831;
+    public static int accessibility_custom_action_8 = 2131361832;
+    public static int accessibility_custom_action_9 = 2131361833;
+    public static int action_container = 2131361842;
+    public static int action_divider = 2131361844;
+    public static int action_image = 2131361845;
+    public static int action_text = 2131361852;
+    public static int actions = 2131361853;
+    public static int async = 2131361928;
+    public static int blocking = 2131361937;
+    public static int bottom = 2131361938;
+    public static int chronometer = 2131361958;
+    public static int dialog_button = 2131361985;
+    public static int end = 2131361992;
+    public static int forever = 2131362055;
+    public static int icon = 2131362122;
+    public static int icon_group = 2131362123;
+    public static int info = 2131362129;
+    public static int italic = 2131362134;
+    public static int left = 2131362139;
+    public static int line1 = 2131362141;
+    public static int line3 = 2131362142;
+    public static int none = 2131362350;
+    public static int normal = 2131362351;
+    public static int notification_background = 2131362352;
+    public static int notification_main_column = 2131362353;
+    public static int notification_main_column_container = 2131362354;
+    public static int right = 2131362375;
+    public static int right_icon = 2131362376;
+    public static int right_side = 2131362377;
+    public static int start = 2131362408;
+    public static int tag_accessibility_actions = 2131362416;
+    public static int tag_accessibility_clickable_spans = 2131362417;
+    public static int tag_accessibility_heading = 2131362418;
+    public static int tag_accessibility_pane_title = 2131362419;
+    public static int tag_screen_reader_focusable = 2131362423;
+    public static int tag_transition_group = 2131362425;
+    public static int tag_unhandled_key_event_manager = 2131362426;
+    public static int tag_unhandled_key_listeners = 2131362427;
+    public static int text = 2131362429;
+    public static int text2 = 2131362430;
+    public static int time = 2131362435;
+    public static int title = 2131362436;
+    public static int top = 2131362439;
+}

decompiled/sources/com/google/firebase/abt/R$integer.java

@@ -0,0 +1,7 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$integer {
+    public static int google_play_services_version = 2131427343;
+    public static int status_bar_notification_info_maxnum = 2131427348;
+}

decompiled/sources/com/google/firebase/abt/R$layout.java

@@ -0,0 +1,12 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$layout {
+    public static int custom_dialog = 2131558451;
+    public static int notification_action = 2131558559;
+    public static int notification_action_tombstone = 2131558560;
+    public static int notification_template_custom_big = 2131558567;
+    public static int notification_template_icon_group = 2131558568;
+    public static int notification_template_part_chronometer = 2131558572;
+    public static int notification_template_part_time = 2131558573;
+}

decompiled/sources/com/google/firebase/abt/R$raw.java

@@ -0,0 +1,6 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$raw {
+    public static int firebase_common_keep = 2131820548;
+}

decompiled/sources/com/google/firebase/abt/R$string.java

@@ -0,0 +1,7 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$string {
+    public static int common_google_play_services_unknown_issue = 2131886247;
+    public static int status_bar_notification_info_overflow = 2131886471;
+}

decompiled/sources/com/google/firebase/abt/R$style.java

@@ -0,0 +1,13 @@
+package com.google.firebase.abt;
+
+/* loaded from: classes3.dex */
+public final class R$style {
+    public static int TextAppearance_Compat_Notification = 2131951943;
+    public static int TextAppearance_Compat_Notification_Info = 2131951944;
+    public static int TextAppearance_Compat_Notification_Line2 = 2131951946;
+    public static int TextAppearance_Compat_Notification_Time = 2131951949;
+    public static int TextAppearance_Compat_Notification_Title = 2131951951;
+    public static int Widget_Compat_NotificationActionContainer = 2131952065;
+    public static int Widget_Compat_NotificationActionText = 2131952066;
+    public static int Widget_Support_CoordinatorLayout = 2131952067;
+}

decompiled/sources/com/google/firebase/abt/R$styleable.java

@@ -0,0 +1,60 @@
+package com.google.firebase.abt;
+
+import android.R;
+
+/* loaded from: classes3.dex */
+public final class R$styleable {
+    public static int ColorStateListItem_alpha = 3;
+    public static int ColorStateListItem_android_alpha = 1;
+    public static int ColorStateListItem_android_color = 0;
+    public static int ColorStateListItem_android_lStar = 2;
+    public static int ColorStateListItem_lStar = 4;
+    public static int CoordinatorLayout_Layout_android_layout_gravity = 0;
+    public static int CoordinatorLayout_Layout_layout_anchor = 1;
+    public static int CoordinatorLayout_Layout_layout_anchorGravity = 2;
+    public static int CoordinatorLayout_Layout_layout_behavior = 3;
+    public static int CoordinatorLayout_Layout_layout_dodgeInsetEdges = 4;
+    public static int CoordinatorLayout_Layout_layout_insetEdge = 5;
+    public static int CoordinatorLayout_Layout_layout_keyline = 6;
+    public static int CoordinatorLayout_keylines = 0;
+    public static int CoordinatorLayout_statusBarBackground = 1;
+    public static int FontFamilyFont_android_font = 0;
+    public static int FontFamilyFont_android_fontStyle = 2;
+    public static int FontFamilyFont_android_fontVariationSettings = 4;
+    public static int FontFamilyFont_android_fontWeight = 1;
+    public static int FontFamilyFont_android_ttcIndex = 3;
+    public static int FontFamilyFont_font = 5;
+    public static int FontFamilyFont_fontStyle = 6;
+    public static int FontFamilyFont_fontVariationSettings = 7;
+    public static int FontFamilyFont_fontWeight = 8;
+    public static int FontFamilyFont_ttcIndex = 9;
+    public static int FontFamily_fontProviderAuthority = 0;
+    public static int FontFamily_fontProviderCerts = 1;
+    public static int FontFamily_fontProviderFallbackQuery = 2;
+    public static int FontFamily_fontProviderFetchStrategy = 3;
+    public static int FontFamily_fontProviderFetchTimeout = 4;
+    public static int FontFamily_fontProviderPackage = 5;
+    public static int FontFamily_fontProviderQuery = 6;
+    public static int FontFamily_fontProviderSystemFontFamily = 7;
+    public static int GradientColorItem_android_color = 0;
+    public static int GradientColorItem_android_offset = 1;
+    public static int GradientColor_android_centerColor = 7;
+    public static int GradientColor_android_centerX = 3;
+    public static int GradientColor_android_centerY = 4;
+    public static int GradientColor_android_endColor = 1;
+    public static int GradientColor_android_endX = 10;
+    public static int GradientColor_android_endY = 11;
+    public static int GradientColor_android_gradientRadius = 5;
+    public static int GradientColor_android_startColor = 0;
+    public static int GradientColor_android_startX = 8;
+    public static int GradientColor_android_startY = 9;
+    public static int GradientColor_android_tileMode = 6;
+    public static int GradientColor_android_type = 2;
+    public static int[] ColorStateListItem = {R.attr.color, R.attr.alpha, R.attr.lStar, com.ea.games.r3_row.R.attr.alpha, com.ea.games.r3_row.R.attr.lStar};
+    public static int[] CoordinatorLayout = {com.ea.games.r3_row.R.attr.keylines, com.ea.games.r3_row.R.attr.statusBarBackground};
+    public static int[] CoordinatorLayout_Layout = {R.attr.layout_gravity, com.ea.games.r3_row.R.attr.layout_anchor, com.ea.games.r3_row.R.attr.layout_anchorGravity, com.ea.games.r3_row.R.attr.layout_behavior, com.ea.games.r3_row.R.attr.layout_dodgeInsetEdges, com.ea.games.r3_row.R.attr.layout_insetEdge, com.ea.games.r3_row.R.attr.layout_keyline};
+    public static int[] FontFamily = {com.ea.games.r3_row.R.attr.fontProviderAuthority, com.ea.games.r3_row.R.attr.fontProviderCerts, com.ea.games.r3_row.R.attr.fontProviderFallbackQuery, com.ea.games.r3_row.R.attr.fontProviderFetchStrategy, com.ea.games.r3_row.R.attr.fontProviderFetchTimeout, com.ea.games.r3_row.R.attr.fontProviderPackage, com.ea.games.r3_row.R.attr.fontProviderQuery, com.ea.games.r3_row.R.attr.fontProviderSystemFontFamily};
+    public static int[] FontFamilyFont = {R.attr.font, R.attr.fontWeight, R.attr.fontStyle, R.attr.ttcIndex, R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.font, com.ea.games.r3_row.R.attr.fontStyle, com.ea.games.r3_row.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.fontWeight, com.ea.games.r3_row.R.attr.ttcIndex};
+    public static int[] GradientColor = {R.attr.startColor, R.attr.endColor, R.attr.type, R.attr.centerX, R.attr.centerY, R.attr.gradientRadius, R.attr.tileMode, R.attr.centerColor, R.attr.startX, R.attr.startY, R.attr.endX, R.attr.endY};
+    public static int[] GradientColorItem = {R.attr.color, R.attr.offset};
+}

decompiled/sources/com/google/firebase/abt/component/AbtComponent.java

@@ -0,0 +1,34 @@
+package com.google.firebase.abt.component;
+
+import android.content.Context;
+import com.google.firebase.abt.FirebaseABTesting;
+import com.google.firebase.inject.Provider;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public class AbtComponent {
+    public final Map abtOriginInstances = new HashMap();
+    public final Provider analyticsConnector;
+    public final Context appContext;
+
+    public AbtComponent(Context context, Provider provider) {
+        this.appContext = context;
+        this.analyticsConnector = provider;
+    }
+
+    public synchronized FirebaseABTesting get(String str) {
+        try {
+            if (!this.abtOriginInstances.containsKey(str)) {
+                this.abtOriginInstances.put(str, createAbtInstance(str));
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return (FirebaseABTesting) this.abtOriginInstances.get(str);
+    }
+
+    public FirebaseABTesting createAbtInstance(String str) {
+        return new FirebaseABTesting(this.appContext, this.analyticsConnector, str);
+    }
+}

decompiled/sources/com/google/firebase/abt/component/AbtRegistrar.java

@@ -0,0 +1,36 @@
+package com.google.firebase.abt.component;
+
+import android.content.Context;
+import androidx.annotation.Keep;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Dependency;
+import com.google.firebase.platforminfo.LibraryVersionComponent;
+import java.util.Arrays;
+import java.util.List;
+
+@Keep
+/* loaded from: classes3.dex */
+public class AbtRegistrar implements ComponentRegistrar {
+    private static final String LIBRARY_NAME = "fire-abt";
+
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List<Component> getComponents() {
+        return Arrays.asList(Component.builder(AbtComponent.class).name(LIBRARY_NAME).add(Dependency.required(Context.class)).add(Dependency.optionalProvider(AnalyticsConnector.class)).factory(new ComponentFactory() { // from class: com.google.firebase.abt.component.AbtRegistrar$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                AbtComponent lambda$getComponents$0;
+                lambda$getComponents$0 = AbtRegistrar.lambda$getComponents$0(componentContainer);
+                return lambda$getComponents$0;
+            }
+        }).build(), LibraryVersionComponent.create(LIBRARY_NAME, "21.1.1"));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ AbtComponent lambda$getComponents$0(ComponentContainer componentContainer) {
+        return new AbtComponent((Context) componentContainer.get(Context.class), componentContainer.getProvider(AnalyticsConnector.class));
+    }
+}

decompiled/sources/com/google/firebase/analytics/FirebaseAnalytics.java

@@ -0,0 +1,95 @@
+package com.google.firebase.analytics;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresPermission;
+import androidx.annotation.Size;
+import androidx.work.WorkRequest;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.internal.measurement.zzdn;
+import com.google.android.gms.measurement.internal.zzkk;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.installations.FirebaseInstallations;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public final class FirebaseAnalytics {
+    public static volatile FirebaseAnalytics zza;
+    public final zzdn zzb;
+
+    @Nullable
+    @Keep
+    public static zzkk getScionFrontendApiImplementation(Context context, @Nullable Bundle bundle) {
+        zzdn zza2 = zzdn.zza(context, (String) null, (String) null, (String) null, bundle);
+        if (zza2 == null) {
+            return null;
+        }
+        return new zzd(zza2);
+    }
+
+    @NonNull
+    @RequiresPermission(allOf = {"android.permission.INTERNET", "android.permission.ACCESS_NETWORK_STATE", "android.permission.WAKE_LOCK"})
+    @Keep
+    public static FirebaseAnalytics getInstance(@NonNull Context context) {
+        if (zza == null) {
+            synchronized (FirebaseAnalytics.class) {
+                try {
+                    if (zza == null) {
+                        zza = new FirebaseAnalytics(zzdn.zza(context));
+                    }
+                } finally {
+                }
+            }
+        }
+        return zza;
+    }
+
+    @NonNull
+    @Keep
+    public final String getFirebaseInstanceId() {
+        try {
+            return (String) Tasks.await(FirebaseInstallations.getInstance().getId(), WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+        } catch (ExecutionException e2) {
+            throw new IllegalStateException(e2.getCause());
+        } catch (TimeoutException unused) {
+            throw new IllegalThreadStateException("Firebase Installations getId Task has timed out.");
+        }
+    }
+
+    public FirebaseAnalytics(zzdn zzdnVar) {
+        Preconditions.checkNotNull(zzdnVar);
+        this.zzb = zzdnVar;
+    }
+
+    public final void logEvent(String str, Bundle bundle) {
+        this.zzb.zza(str, bundle);
+    }
+
+    public final void setAnalyticsCollectionEnabled(boolean z) {
+        this.zzb.zza(Boolean.valueOf(z));
+    }
+
+    @Keep
+    @MainThread
+    @Deprecated
+    public final void setCurrentScreen(@NonNull Activity activity, @Nullable @Size(max = 36, min = 1) String str, @Nullable @Size(max = 36, min = 1) String str2) {
+        this.zzb.zza(activity, str, str2);
+    }
+
+    public final void setUserId(String str) {
+        this.zzb.zzd(str);
+    }
+
+    public final void setUserProperty(String str, String str2) {
+        this.zzb.zzb(str, str2);
+    }
+}

decompiled/sources/com/google/firebase/analytics/GoogleAnalyticsServerPreviewActivity.java

@@ -0,0 +1,15 @@
+package com.google.firebase.analytics;
+
+import android.app.Activity;
+import android.os.Bundle;
+import com.google.android.gms.internal.measurement.zzdn;
+
+/* loaded from: classes3.dex */
+public class GoogleAnalyticsServerPreviewActivity extends Activity {
+    @Override // android.app.Activity
+    public void onCreate(Bundle bundle) {
+        super.onCreate(bundle);
+        zzdn.zza(this).zza(getIntent());
+        finish();
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/AnalyticsConnector.java

@@ -0,0 +1,50 @@
+package com.google.firebase.analytics.connector;
+
+import android.os.Bundle;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public interface AnalyticsConnector {
+
+    public interface AnalyticsConnectorHandle {
+    }
+
+    public interface AnalyticsConnectorListener {
+        void onMessageTriggered(int i, Bundle bundle);
+    }
+
+    public static class ConditionalUserProperty {
+        public boolean active;
+        public long creationTimestamp;
+        public String expiredEventName;
+        public Bundle expiredEventParams;
+        public String name;
+        public String origin;
+        public long timeToLive;
+        public String timedOutEventName;
+        public Bundle timedOutEventParams;
+        public String triggerEventName;
+        public long triggerTimeout;
+        public String triggeredEventName;
+        public Bundle triggeredEventParams;
+        public long triggeredTimestamp;
+        public Object value;
+    }
+
+    void clearConditionalUserProperty(String str, String str2, Bundle bundle);
+
+    List getConditionalUserProperties(String str, String str2);
+
+    int getMaxUserProperties(String str);
+
+    Map getUserProperties(boolean z);
+
+    void logEvent(String str, String str2, Bundle bundle);
+
+    AnalyticsConnectorHandle registerAnalyticsConnectorListener(String str, AnalyticsConnectorListener analyticsConnectorListener);
+
+    void setConditionalUserProperty(ConditionalUserProperty conditionalUserProperty);
+
+    void setUserProperty(String str, String str2, Object obj);
+}

decompiled/sources/com/google/firebase/analytics/connector/AnalyticsConnectorImpl.java

@@ -0,0 +1,149 @@
+package com.google.firebase.analytics.connector;
+
+import android.content.Context;
+import android.os.Bundle;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.internal.measurement.zzdn;
+import com.google.android.gms.measurement.AppMeasurement;
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.firebase.DataCollectionDefaultChange;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.analytics.connector.internal.zze;
+import com.google.firebase.analytics.connector.internal.zzg;
+import com.google.firebase.events.Event;
+import com.google.firebase.events.EventHandler;
+import com.google.firebase.events.Subscriber;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class AnalyticsConnectorImpl implements AnalyticsConnector {
+    public static volatile AnalyticsConnector zzb;
+    public final Map zza;
+    public final AppMeasurementSdk zzc;
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public int getMaxUserProperties(String str) {
+        return this.zzc.getMaxUserProperties(str);
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public AnalyticsConnector.AnalyticsConnectorHandle registerAnalyticsConnectorListener(final String str, AnalyticsConnector.AnalyticsConnectorListener analyticsConnectorListener) {
+        Preconditions.checkNotNull(analyticsConnectorListener);
+        if (!com.google.firebase.analytics.connector.internal.zzb.zzf(str) || zza(str)) {
+            return null;
+        }
+        AppMeasurementSdk appMeasurementSdk = this.zzc;
+        Object zzeVar = AppMeasurement.FIAM_ORIGIN.equals(str) ? new zze(appMeasurementSdk, analyticsConnectorListener) : "clx".equals(str) ? new zzg(appMeasurementSdk, analyticsConnectorListener) : null;
+        if (zzeVar == null) {
+            return null;
+        }
+        this.zza.put(str, zzeVar);
+        return new AnalyticsConnector.AnalyticsConnectorHandle(this) { // from class: com.google.firebase.analytics.connector.AnalyticsConnectorImpl.1
+            public final /* synthetic */ AnalyticsConnectorImpl zzb;
+
+            {
+                this.zzb = this;
+            }
+        };
+    }
+
+    public static AnalyticsConnector getInstance(FirebaseApp firebaseApp, Context context, Subscriber subscriber) {
+        Preconditions.checkNotNull(firebaseApp);
+        Preconditions.checkNotNull(context);
+        Preconditions.checkNotNull(subscriber);
+        Preconditions.checkNotNull(context.getApplicationContext());
+        if (zzb == null) {
+            synchronized (AnalyticsConnectorImpl.class) {
+                try {
+                    if (zzb == null) {
+                        Bundle bundle = new Bundle(1);
+                        if (firebaseApp.isDefaultApp()) {
+                            subscriber.subscribe(DataCollectionDefaultChange.class, new Executor() { // from class: com.google.firebase.analytics.connector.zza
+                                @Override // java.util.concurrent.Executor
+                                public final void execute(Runnable runnable) {
+                                    runnable.run();
+                                }
+                            }, new EventHandler() { // from class: com.google.firebase.analytics.connector.zzb
+                                @Override // com.google.firebase.events.EventHandler
+                                public final void handle(Event event) {
+                                    AnalyticsConnectorImpl.zza(event);
+                                }
+                            });
+                            bundle.putBoolean("dataCollectionDefaultEnabled", firebaseApp.isDataCollectionDefaultEnabled());
+                        }
+                        zzb = new AnalyticsConnectorImpl(zzdn.zza(context, (String) null, (String) null, (String) null, bundle).zzb());
+                    }
+                } finally {
+                }
+            }
+        }
+        return zzb;
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public List getConditionalUserProperties(String str, String str2) {
+        ArrayList arrayList = new ArrayList();
+        Iterator<Bundle> it = this.zzc.getConditionalUserProperties(str, str2).iterator();
+        while (it.hasNext()) {
+            arrayList.add(com.google.firebase.analytics.connector.internal.zzb.zza(it.next()));
+        }
+        return arrayList;
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public Map getUserProperties(boolean z) {
+        return this.zzc.getUserProperties(null, null, z);
+    }
+
+    public AnalyticsConnectorImpl(AppMeasurementSdk appMeasurementSdk) {
+        Preconditions.checkNotNull(appMeasurementSdk);
+        this.zzc = appMeasurementSdk;
+        this.zza = new ConcurrentHashMap();
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public void clearConditionalUserProperty(String str, String str2, Bundle bundle) {
+        if (str2 == null || com.google.firebase.analytics.connector.internal.zzb.zza(str2, bundle)) {
+            this.zzc.clearConditionalUserProperty(str, str2, bundle);
+        }
+    }
+
+    public static /* synthetic */ void zza(Event event) {
+        throw null;
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public void logEvent(String str, String str2, Bundle bundle) {
+        if (bundle == null) {
+            bundle = new Bundle();
+        }
+        if (com.google.firebase.analytics.connector.internal.zzb.zzf(str) && com.google.firebase.analytics.connector.internal.zzb.zza(str2, bundle) && com.google.firebase.analytics.connector.internal.zzb.zzb(str, str2, bundle)) {
+            com.google.firebase.analytics.connector.internal.zzb.zza(str, str2, bundle);
+            this.zzc.logEvent(str, str2, bundle);
+        }
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public void setConditionalUserProperty(AnalyticsConnector.ConditionalUserProperty conditionalUserProperty) {
+        if (com.google.firebase.analytics.connector.internal.zzb.zzb(conditionalUserProperty)) {
+            this.zzc.setConditionalUserProperty(com.google.firebase.analytics.connector.internal.zzb.zza(conditionalUserProperty));
+        }
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector
+    public void setUserProperty(String str, String str2, Object obj) {
+        if (com.google.firebase.analytics.connector.internal.zzb.zzf(str) && com.google.firebase.analytics.connector.internal.zzb.zza(str, str2)) {
+            this.zzc.setUserProperty(str, str2, obj);
+        }
+    }
+
+    public final boolean zza(String str) {
+        return (str.isEmpty() || !this.zza.containsKey(str) || this.zza.get(str) == null) ? false : true;
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/AnalyticsConnectorRegistrar.java

@@ -0,0 +1,40 @@
+package com.google.firebase.analytics.connector.internal;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import androidx.annotation.Keep;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.analytics.connector.AnalyticsConnectorImpl;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Dependency;
+import com.google.firebase.events.Subscriber;
+import com.google.firebase.platforminfo.LibraryVersionComponent;
+import java.util.Arrays;
+import java.util.List;
+
+@Keep
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class AnalyticsConnectorRegistrar implements ComponentRegistrar {
+    @Override // com.google.firebase.components.ComponentRegistrar
+    @NonNull
+    @Keep
+    @SuppressLint({"MissingPermission"})
+    @KeepForSdk
+    public List<Component> getComponents() {
+        return Arrays.asList(Component.builder(AnalyticsConnector.class).add(Dependency.required(FirebaseApp.class)).add(Dependency.required(Context.class)).add(Dependency.required(Subscriber.class)).factory(new ComponentFactory() { // from class: com.google.firebase.analytics.connector.internal.zzc
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                AnalyticsConnector analyticsConnectorImpl;
+                analyticsConnectorImpl = AnalyticsConnectorImpl.getInstance((FirebaseApp) componentContainer.get(FirebaseApp.class), (Context) componentContainer.get(Context.class), (Subscriber) componentContainer.get(Subscriber.class));
+                return analyticsConnectorImpl;
+            }
+        }).eagerInDefaultApp().build(), LibraryVersionComponent.create("fire-analytics", "22.0.1"));
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/zzb.java

@@ -0,0 +1,214 @@
+package com.google.firebase.analytics.connector.internal;
+
+import android.os.Bundle;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.measurement.AppMeasurement;
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.android.gms.measurement.internal.zzio;
+import com.google.android.gms.measurement.internal.zzir;
+import com.google.android.gms.measurement.internal.zzis;
+import com.google.android.gms.measurement.internal.zzkq;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.mbridge.msdk.MBridgeConstans;
+
+/* loaded from: classes3.dex */
+public abstract class zzb {
+    public static final ImmutableSet zza = ImmutableSet.of((Object) "_in", (Object) "_xa", (Object) "_xu", (Object) "_aq", (Object) "_aa", (Object) "_ai", (Object[]) new String[]{"_ac", "campaign_details", "_ug", "_iapx", "_exp_set", "_exp_clear", "_exp_activate", "_exp_timeout", "_exp_expire"});
+    public static final ImmutableList zzb = ImmutableList.of((Object) "_e", (Object) "_f", (Object) "_iap", (Object) "_s", (Object) "_au", (Object) "_ui", (Object) "_cd");
+    public static final ImmutableList zzc = ImmutableList.of((Object) "auto", (Object) MBridgeConstans.DYNAMIC_VIEW_WX_APP, (Object) "am");
+    public static final ImmutableList zzd = ImmutableList.of((Object) "_r", (Object) "_dbg");
+    public static final ImmutableList zze = new ImmutableList.Builder().add((Object[]) zzis.zza).add((Object[]) zzis.zzb).build();
+    public static final ImmutableList zzf = ImmutableList.of((Object) "^_ltv_[A-Z]{3}$", (Object) "^_cc[1-5]{1}$");
+
+    public static Bundle zza(AnalyticsConnector.ConditionalUserProperty conditionalUserProperty) {
+        Bundle bundle = new Bundle();
+        String str = conditionalUserProperty.origin;
+        if (str != null) {
+            bundle.putString("origin", str);
+        }
+        String str2 = conditionalUserProperty.name;
+        if (str2 != null) {
+            bundle.putString("name", str2);
+        }
+        Object obj = conditionalUserProperty.value;
+        if (obj != null) {
+            zzio.zza(bundle, obj);
+        }
+        String str3 = conditionalUserProperty.triggerEventName;
+        if (str3 != null) {
+            bundle.putString(AppMeasurementSdk.ConditionalUserProperty.TRIGGER_EVENT_NAME, str3);
+        }
+        bundle.putLong(AppMeasurementSdk.ConditionalUserProperty.TRIGGER_TIMEOUT, conditionalUserProperty.triggerTimeout);
+        String str4 = conditionalUserProperty.timedOutEventName;
+        if (str4 != null) {
+            bundle.putString(AppMeasurementSdk.ConditionalUserProperty.TIMED_OUT_EVENT_NAME, str4);
+        }
+        Bundle bundle2 = conditionalUserProperty.timedOutEventParams;
+        if (bundle2 != null) {
+            bundle.putBundle(AppMeasurementSdk.ConditionalUserProperty.TIMED_OUT_EVENT_PARAMS, bundle2);
+        }
+        String str5 = conditionalUserProperty.triggeredEventName;
+        if (str5 != null) {
+            bundle.putString(AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_EVENT_NAME, str5);
+        }
+        Bundle bundle3 = conditionalUserProperty.triggeredEventParams;
+        if (bundle3 != null) {
+            bundle.putBundle(AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_EVENT_PARAMS, bundle3);
+        }
+        bundle.putLong(AppMeasurementSdk.ConditionalUserProperty.TIME_TO_LIVE, conditionalUserProperty.timeToLive);
+        String str6 = conditionalUserProperty.expiredEventName;
+        if (str6 != null) {
+            bundle.putString(AppMeasurementSdk.ConditionalUserProperty.EXPIRED_EVENT_NAME, str6);
+        }
+        Bundle bundle4 = conditionalUserProperty.expiredEventParams;
+        if (bundle4 != null) {
+            bundle.putBundle(AppMeasurementSdk.ConditionalUserProperty.EXPIRED_EVENT_PARAMS, bundle4);
+        }
+        bundle.putLong(AppMeasurementSdk.ConditionalUserProperty.CREATION_TIMESTAMP, conditionalUserProperty.creationTimestamp);
+        bundle.putBoolean(AppMeasurementSdk.ConditionalUserProperty.ACTIVE, conditionalUserProperty.active);
+        bundle.putLong(AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_TIMESTAMP, conditionalUserProperty.triggeredTimestamp);
+        return bundle;
+    }
+
+    public static AnalyticsConnector.ConditionalUserProperty zza(Bundle bundle) {
+        Preconditions.checkNotNull(bundle);
+        AnalyticsConnector.ConditionalUserProperty conditionalUserProperty = new AnalyticsConnector.ConditionalUserProperty();
+        conditionalUserProperty.origin = (String) Preconditions.checkNotNull((String) zzio.zza(bundle, "origin", String.class, null));
+        conditionalUserProperty.name = (String) Preconditions.checkNotNull((String) zzio.zza(bundle, "name", String.class, null));
+        conditionalUserProperty.value = zzio.zza(bundle, "value", Object.class, null);
+        conditionalUserProperty.triggerEventName = (String) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TRIGGER_EVENT_NAME, String.class, null);
+        conditionalUserProperty.triggerTimeout = ((Long) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TRIGGER_TIMEOUT, Long.class, 0L)).longValue();
+        conditionalUserProperty.timedOutEventName = (String) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TIMED_OUT_EVENT_NAME, String.class, null);
+        conditionalUserProperty.timedOutEventParams = (Bundle) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TIMED_OUT_EVENT_PARAMS, Bundle.class, null);
+        conditionalUserProperty.triggeredEventName = (String) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_EVENT_NAME, String.class, null);
+        conditionalUserProperty.triggeredEventParams = (Bundle) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_EVENT_PARAMS, Bundle.class, null);
+        conditionalUserProperty.timeToLive = ((Long) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TIME_TO_LIVE, Long.class, 0L)).longValue();
+        conditionalUserProperty.expiredEventName = (String) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.EXPIRED_EVENT_NAME, String.class, null);
+        conditionalUserProperty.expiredEventParams = (Bundle) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.EXPIRED_EVENT_PARAMS, Bundle.class, null);
+        conditionalUserProperty.active = ((Boolean) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.ACTIVE, Boolean.class, Boolean.FALSE)).booleanValue();
+        conditionalUserProperty.creationTimestamp = ((Long) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.CREATION_TIMESTAMP, Long.class, 0L)).longValue();
+        conditionalUserProperty.triggeredTimestamp = ((Long) zzio.zza(bundle, AppMeasurementSdk.ConditionalUserProperty.TRIGGERED_TIMESTAMP, Long.class, 0L)).longValue();
+        return conditionalUserProperty;
+    }
+
+    public static String zza(String str) {
+        String zza2 = zzir.zza(str);
+        return zza2 != null ? zza2 : str;
+    }
+
+    public static void zza(String str, String str2, Bundle bundle) {
+        if ("clx".equals(str) && "_ae".equals(str2)) {
+            bundle.putLong("_r", 1L);
+        }
+    }
+
+    public static boolean zzb(String str, String str2, Bundle bundle) {
+        if (!"_cmp".equals(str2)) {
+            return true;
+        }
+        if (!zzf(str) || bundle == null) {
+            return false;
+        }
+        ImmutableList immutableList = zzd;
+        int size = immutableList.size();
+        int i = 0;
+        while (i < size) {
+            Object obj = immutableList.get(i);
+            i++;
+            if (bundle.containsKey((String) obj)) {
+                return false;
+            }
+        }
+        str.hashCode();
+        switch (str) {
+            case "fcm":
+                bundle.putString("_cis", "fcm_integration");
+                return true;
+            case "fdl":
+                bundle.putString("_cis", "fdl_integration");
+                return true;
+            case "fiam":
+                bundle.putString("_cis", "fiam_integration");
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public static boolean zzb(AnalyticsConnector.ConditionalUserProperty conditionalUserProperty) {
+        String str;
+        if (conditionalUserProperty == null || (str = conditionalUserProperty.origin) == null || str.isEmpty()) {
+            return false;
+        }
+        Object obj = conditionalUserProperty.value;
+        if ((obj != null && zzkq.zza(obj) == null) || !zzf(str) || !zza(str, conditionalUserProperty.name)) {
+            return false;
+        }
+        String str2 = conditionalUserProperty.expiredEventName;
+        if (str2 != null && (!zza(str2, conditionalUserProperty.expiredEventParams) || !zzb(str, conditionalUserProperty.expiredEventName, conditionalUserProperty.expiredEventParams))) {
+            return false;
+        }
+        String str3 = conditionalUserProperty.triggeredEventName;
+        if (str3 != null && (!zza(str3, conditionalUserProperty.triggeredEventParams) || !zzb(str, conditionalUserProperty.triggeredEventName, conditionalUserProperty.triggeredEventParams))) {
+            return false;
+        }
+        String str4 = conditionalUserProperty.timedOutEventName;
+        if (str4 != null) {
+            return zza(str4, conditionalUserProperty.timedOutEventParams) && zzb(str, conditionalUserProperty.timedOutEventName, conditionalUserProperty.timedOutEventParams);
+        }
+        return true;
+    }
+
+    public static boolean zza(String str, Bundle bundle) {
+        if (zzb.contains(str)) {
+            return false;
+        }
+        if (bundle == null) {
+            return true;
+        }
+        ImmutableList immutableList = zzd;
+        int size = immutableList.size();
+        int i = 0;
+        while (i < size) {
+            Object obj = immutableList.get(i);
+            i++;
+            if (bundle.containsKey((String) obj)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean zze(String str) {
+        return !zza.contains(str);
+    }
+
+    public static boolean zzf(String str) {
+        return !zzc.contains(str);
+    }
+
+    public static boolean zza(String str, String str2) {
+        if ("_ce1".equals(str2) || "_ce2".equals(str2)) {
+            return str.equals(AppMeasurement.FCM_ORIGIN) || str.equals("frc");
+        }
+        if ("_ln".equals(str2)) {
+            return str.equals(AppMeasurement.FCM_ORIGIN) || str.equals(AppMeasurement.FIAM_ORIGIN);
+        }
+        if (zze.contains(str2)) {
+            return false;
+        }
+        ImmutableList immutableList = zzf;
+        int size = immutableList.size();
+        int i = 0;
+        while (i < size) {
+            Object obj = immutableList.get(i);
+            i++;
+            if (str2.matches((String) obj)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/zzd.java

@@ -0,0 +1,25 @@
+package com.google.firebase.analytics.connector.internal;
+
+import android.os.Bundle;
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+
+/* loaded from: classes3.dex */
+public final class zzd implements AppMeasurementSdk.OnEventListener {
+    public final /* synthetic */ zze zza;
+
+    public zzd(zze zzeVar) {
+        this.zza = zzeVar;
+    }
+
+    @Override // com.google.android.gms.measurement.api.AppMeasurementSdk.OnEventListener, com.google.android.gms.measurement.internal.zziu
+    public final void onEvent(String str, String str2, Bundle bundle, long j) {
+        AnalyticsConnector.AnalyticsConnectorListener analyticsConnectorListener;
+        if (this.zza.zza.contains(str2)) {
+            Bundle bundle2 = new Bundle();
+            bundle2.putString("events", zzb.zza(str2));
+            analyticsConnectorListener = this.zza.zzb;
+            analyticsConnectorListener.onMessageTriggered(2, bundle2);
+        }
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/zze.java

@@ -0,0 +1,23 @@
+package com.google.firebase.analytics.connector.internal;
+
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class zze {
+    public Set zza;
+    public AnalyticsConnector.AnalyticsConnectorListener zzb;
+    public AppMeasurementSdk zzc;
+    public zzd zzd;
+
+    public zze(AppMeasurementSdk appMeasurementSdk, AnalyticsConnector.AnalyticsConnectorListener analyticsConnectorListener) {
+        this.zzb = analyticsConnectorListener;
+        this.zzc = appMeasurementSdk;
+        zzd zzdVar = new zzd(this);
+        this.zzd = zzdVar;
+        this.zzc.registerOnMeasurementEventListener(zzdVar);
+        this.zza = new HashSet();
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/zzf.java

@@ -0,0 +1,28 @@
+package com.google.firebase.analytics.connector.internal;
+
+import android.os.Bundle;
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+
+/* loaded from: classes3.dex */
+public final class zzf implements AppMeasurementSdk.OnEventListener {
+    public final /* synthetic */ zzg zza;
+
+    public zzf(zzg zzgVar) {
+        this.zza = zzgVar;
+    }
+
+    @Override // com.google.android.gms.measurement.api.AppMeasurementSdk.OnEventListener, com.google.android.gms.measurement.internal.zziu
+    public final void onEvent(String str, String str2, Bundle bundle, long j) {
+        AnalyticsConnector.AnalyticsConnectorListener analyticsConnectorListener;
+        if (str == null || !zzb.zze(str2)) {
+            return;
+        }
+        Bundle bundle2 = new Bundle();
+        bundle2.putString("name", str2);
+        bundle2.putLong("timestampInMillis", j);
+        bundle2.putBundle("params", bundle);
+        analyticsConnectorListener = this.zza.zza;
+        analyticsConnectorListener.onMessageTriggered(3, bundle2);
+    }
+}

decompiled/sources/com/google/firebase/analytics/connector/internal/zzg.java

@@ -0,0 +1,19 @@
+package com.google.firebase.analytics.connector.internal;
+
+import com.google.android.gms.measurement.api.AppMeasurementSdk;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+
+/* loaded from: classes3.dex */
+public final class zzg {
+    public AnalyticsConnector.AnalyticsConnectorListener zza;
+    public AppMeasurementSdk zzb;
+    public zzf zzc;
+
+    public zzg(AppMeasurementSdk appMeasurementSdk, AnalyticsConnector.AnalyticsConnectorListener analyticsConnectorListener) {
+        this.zza = analyticsConnectorListener;
+        this.zzb = appMeasurementSdk;
+        zzf zzfVar = new zzf(this);
+        this.zzc = zzfVar;
+        this.zzb.registerOnMeasurementEventListener(zzfVar);
+    }
+}

decompiled/sources/com/google/firebase/analytics/zzd.java

@@ -0,0 +1,108 @@
+package com.google.firebase.analytics;
+
+import android.os.Bundle;
+import com.google.android.gms.internal.measurement.zzdn;
+import com.google.android.gms.measurement.internal.zziu;
+import com.google.android.gms.measurement.internal.zziv;
+import com.google.android.gms.measurement.internal.zzkk;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public final class zzd implements zzkk {
+    public final /* synthetic */ zzdn zza;
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final int zza(String str) {
+        return this.zza.zza(str);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final long zza() {
+        return this.zza.zza();
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final Object zza(int i) {
+        return this.zza.zza(i);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final String zzf() {
+        return this.zza.zzf();
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final String zzg() {
+        return this.zza.zzg();
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final String zzh() {
+        return this.zza.zzh();
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final String zzi() {
+        return this.zza.zzi();
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final List zza(String str, String str2) {
+        return this.zza.zza(str, str2);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final Map zza(String str, String str2, boolean z) {
+        return this.zza.zza(str, str2, z);
+    }
+
+    public zzd(zzdn zzdnVar) {
+        this.zza = zzdnVar;
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zzb(String str) {
+        this.zza.zzb(str);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zza(String str, String str2, Bundle bundle) {
+        this.zza.zza(str, str2, bundle);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zzc(String str) {
+        this.zza.zzc(str);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zzb(String str, String str2, Bundle bundle) {
+        this.zza.zzb(str, str2, bundle);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zza(String str, String str2, Bundle bundle, long j) {
+        this.zza.zza(str, str2, bundle, j);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zza(zziu zziuVar) {
+        this.zza.zza(zziuVar);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zza(Bundle bundle) {
+        this.zza.zza(bundle);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zza(zziv zzivVar) {
+        this.zza.zza(zzivVar);
+    }
+
+    @Override // com.google.android.gms.measurement.internal.zzkk
+    public final void zzb(zziu zziuVar) {
+        this.zza.zzb(zziuVar);
+    }
+}

decompiled/sources/com/google/firebase/annotations/concurrent/Background.java

@@ -0,0 +1,5 @@
+package com.google.firebase.annotations.concurrent;
+
+/* loaded from: classes3.dex */
+public @interface Background {
+}

decompiled/sources/com/google/firebase/annotations/concurrent/Blocking.java

@@ -0,0 +1,5 @@
+package com.google.firebase.annotations.concurrent;
+
+/* loaded from: classes3.dex */
+public @interface Blocking {
+}

decompiled/sources/com/google/firebase/annotations/concurrent/Lightweight.java

@@ -0,0 +1,5 @@
+package com.google.firebase.annotations.concurrent;
+
+/* loaded from: classes3.dex */
+public @interface Lightweight {
+}

decompiled/sources/com/google/firebase/annotations/concurrent/UiThread.java

@@ -0,0 +1,5 @@
+package com.google.firebase.annotations.concurrent;
+
+/* loaded from: classes3.dex */
+public @interface UiThread {
+}

decompiled/sources/com/google/firebase/components/Component.java

@@ -0,0 +1,204 @@
+package com.google.firebase.components;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class Component {
+    public final Set dependencies;
+    public final ComponentFactory factory;
+    public final int instantiation;
+    public final String name;
+    public final Set providedInterfaces;
+    public final Set publishedEvents;
+    public final int type;
+
+    public static /* synthetic */ Object lambda$intoSet$3(Object obj, ComponentContainer componentContainer) {
+        return obj;
+    }
+
+    public static /* synthetic */ Object lambda$of$1(Object obj, ComponentContainer componentContainer) {
+        return obj;
+    }
+
+    public Set getDependencies() {
+        return this.dependencies;
+    }
+
+    public ComponentFactory getFactory() {
+        return this.factory;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public Set getProvidedInterfaces() {
+        return this.providedInterfaces;
+    }
+
+    public Set getPublishedEvents() {
+        return this.publishedEvents;
+    }
+
+    public boolean isAlwaysEager() {
+        return this.instantiation == 1;
+    }
+
+    public boolean isEagerInDefaultApp() {
+        return this.instantiation == 2;
+    }
+
+    public boolean isValue() {
+        return this.type == 0;
+    }
+
+    public Component(String str, Set set, Set set2, int i, int i2, ComponentFactory componentFactory, Set set3) {
+        this.name = str;
+        this.providedInterfaces = Collections.unmodifiableSet(set);
+        this.dependencies = Collections.unmodifiableSet(set2);
+        this.instantiation = i;
+        this.type = i2;
+        this.factory = componentFactory;
+        this.publishedEvents = Collections.unmodifiableSet(set3);
+    }
+
+    public Component withFactory(ComponentFactory componentFactory) {
+        return new Component(this.name, this.providedInterfaces, this.dependencies, this.instantiation, this.type, componentFactory, this.publishedEvents);
+    }
+
+    public String toString() {
+        return "Component<" + Arrays.toString(this.providedInterfaces.toArray()) + ">{" + this.instantiation + ", type=" + this.type + ", deps=" + Arrays.toString(this.dependencies.toArray()) + "}";
+    }
+
+    public static Builder builder(Class cls) {
+        return new Builder(cls, new Class[0]);
+    }
+
+    public static Builder builder(Class cls, Class... clsArr) {
+        return new Builder(cls, clsArr);
+    }
+
+    public static Builder builder(Qualified qualified) {
+        return new Builder(qualified, new Qualified[0]);
+    }
+
+    public static Builder builder(Qualified qualified, Qualified... qualifiedArr) {
+        return new Builder(qualified, qualifiedArr);
+    }
+
+    public static Component of(final Object obj, Class cls, Class... clsArr) {
+        return builder(cls, clsArr).factory(new ComponentFactory() { // from class: com.google.firebase.components.Component$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                Object lambda$of$1;
+                lambda$of$1 = Component.lambda$of$1(obj, componentContainer);
+                return lambda$of$1;
+            }
+        }).build();
+    }
+
+    public static Builder intoSetBuilder(Class cls) {
+        return builder(cls).intoSet();
+    }
+
+    public static Component intoSet(final Object obj, Class cls) {
+        return intoSetBuilder(cls).factory(new ComponentFactory() { // from class: com.google.firebase.components.Component$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                Object lambda$intoSet$3;
+                lambda$intoSet$3 = Component.lambda$intoSet$3(obj, componentContainer);
+                return lambda$intoSet$3;
+            }
+        }).build();
+    }
+
+    public static class Builder {
+        public final Set dependencies;
+        public ComponentFactory factory;
+        public int instantiation;
+        public String name;
+        public final Set providedInterfaces;
+        public final Set publishedEvents;
+        public int type;
+
+        public final Builder intoSet() {
+            this.type = 1;
+            return this;
+        }
+
+        public Builder name(String str) {
+            this.name = str;
+            return this;
+        }
+
+        public Builder(Class cls, Class... clsArr) {
+            this.name = null;
+            HashSet hashSet = new HashSet();
+            this.providedInterfaces = hashSet;
+            this.dependencies = new HashSet();
+            this.instantiation = 0;
+            this.type = 0;
+            this.publishedEvents = new HashSet();
+            Preconditions.checkNotNull(cls, "Null interface");
+            hashSet.add(Qualified.unqualified(cls));
+            for (Class cls2 : clsArr) {
+                Preconditions.checkNotNull(cls2, "Null interface");
+                this.providedInterfaces.add(Qualified.unqualified(cls2));
+            }
+        }
+
+        public Builder(Qualified qualified, Qualified... qualifiedArr) {
+            this.name = null;
+            HashSet hashSet = new HashSet();
+            this.providedInterfaces = hashSet;
+            this.dependencies = new HashSet();
+            this.instantiation = 0;
+            this.type = 0;
+            this.publishedEvents = new HashSet();
+            Preconditions.checkNotNull(qualified, "Null interface");
+            hashSet.add(qualified);
+            for (Qualified qualified2 : qualifiedArr) {
+                Preconditions.checkNotNull(qualified2, "Null interface");
+            }
+            Collections.addAll(this.providedInterfaces, qualifiedArr);
+        }
+
+        public Builder add(Dependency dependency) {
+            Preconditions.checkNotNull(dependency, "Null dependency");
+            validateInterface(dependency.getInterface());
+            this.dependencies.add(dependency);
+            return this;
+        }
+
+        public Builder alwaysEager() {
+            return setInstantiation(1);
+        }
+
+        public Builder eagerInDefaultApp() {
+            return setInstantiation(2);
+        }
+
+        public final Builder setInstantiation(int i) {
+            Preconditions.checkState(this.instantiation == 0, "Instantiation type has already been set.");
+            this.instantiation = i;
+            return this;
+        }
+
+        public final void validateInterface(Qualified qualified) {
+            Preconditions.checkArgument(!this.providedInterfaces.contains(qualified), "Components are not allowed to depend on interfaces they themselves provide.");
+        }
+
+        public Builder factory(ComponentFactory componentFactory) {
+            this.factory = (ComponentFactory) Preconditions.checkNotNull(componentFactory, "Null factory");
+            return this;
+        }
+
+        public Component build() {
+            Preconditions.checkState(this.factory != null, "Missing required property: factory.");
+            return new Component(this.name, new HashSet(this.providedInterfaces), new HashSet(this.dependencies), this.instantiation, this.type, this.factory, this.publishedEvents);
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/ComponentContainer.java

@@ -0,0 +1,42 @@
+package com.google.firebase.components;
+
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public interface ComponentContainer {
+    Deferred getDeferred(Qualified qualified);
+
+    Provider getProvider(Qualified qualified);
+
+    Provider setOfProvider(Qualified qualified);
+
+    default Object get(Class cls) {
+        return get(Qualified.unqualified(cls));
+    }
+
+    default Provider getProvider(Class cls) {
+        return getProvider(Qualified.unqualified(cls));
+    }
+
+    default Deferred getDeferred(Class cls) {
+        return getDeferred(Qualified.unqualified(cls));
+    }
+
+    default Set setOf(Class cls) {
+        return setOf(Qualified.unqualified(cls));
+    }
+
+    default Object get(Qualified qualified) {
+        Provider provider = getProvider(qualified);
+        if (provider == null) {
+            return null;
+        }
+        return provider.get();
+    }
+
+    default Set setOf(Qualified qualified) {
+        return (Set) setOfProvider(qualified).get();
+    }
+}

decompiled/sources/com/google/firebase/components/ComponentDiscovery.java

@@ -0,0 +1,111 @@
+package com.google.firebase.components;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.os.Bundle;
+import android.util.Log;
+import com.google.firebase.inject.Provider;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class ComponentDiscovery {
+    public final Object context;
+    public final RegistrarNameRetriever retriever;
+
+    public interface RegistrarNameRetriever {
+        List retrieve(Object obj);
+    }
+
+    public static ComponentDiscovery forContext(Context context, Class cls) {
+        return new ComponentDiscovery(context, new MetadataRegistrarNameRetriever(cls));
+    }
+
+    public ComponentDiscovery(Object obj, RegistrarNameRetriever registrarNameRetriever) {
+        this.context = obj;
+        this.retriever = registrarNameRetriever;
+    }
+
+    public List discoverLazy() {
+        ArrayList arrayList = new ArrayList();
+        for (final String str : this.retriever.retrieve(this.context)) {
+            arrayList.add(new Provider() { // from class: com.google.firebase.components.ComponentDiscovery$$ExternalSyntheticLambda0
+                @Override // com.google.firebase.inject.Provider
+                public final Object get() {
+                    ComponentRegistrar instantiate;
+                    instantiate = ComponentDiscovery.instantiate(str);
+                    return instantiate;
+                }
+            });
+        }
+        return arrayList;
+    }
+
+    public static ComponentRegistrar instantiate(String str) {
+        try {
+            Class<?> cls = Class.forName(str);
+            if (!ComponentRegistrar.class.isAssignableFrom(cls)) {
+                throw new InvalidRegistrarException(String.format("Class %s is not an instance of %s", str, "com.google.firebase.components.ComponentRegistrar"));
+            }
+            return (ComponentRegistrar) cls.getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (ClassNotFoundException unused) {
+            Log.w("ComponentDiscovery", String.format("Class %s is not an found.", str));
+            return null;
+        } catch (IllegalAccessException e) {
+            throw new InvalidRegistrarException(String.format("Could not instantiate %s.", str), e);
+        } catch (InstantiationException e2) {
+            throw new InvalidRegistrarException(String.format("Could not instantiate %s.", str), e2);
+        } catch (NoSuchMethodException e3) {
+            throw new InvalidRegistrarException(String.format("Could not instantiate %s", str), e3);
+        } catch (InvocationTargetException e4) {
+            throw new InvalidRegistrarException(String.format("Could not instantiate %s", str), e4);
+        }
+    }
+
+    public static class MetadataRegistrarNameRetriever implements RegistrarNameRetriever {
+        public final Class discoveryService;
+
+        public MetadataRegistrarNameRetriever(Class cls) {
+            this.discoveryService = cls;
+        }
+
+        @Override // com.google.firebase.components.ComponentDiscovery.RegistrarNameRetriever
+        public List retrieve(Context context) {
+            Bundle metadata = getMetadata(context);
+            if (metadata == null) {
+                Log.w("ComponentDiscovery", "Could not retrieve metadata, returning empty list of registrars.");
+                return Collections.emptyList();
+            }
+            ArrayList arrayList = new ArrayList();
+            for (String str : metadata.keySet()) {
+                if ("com.google.firebase.components.ComponentRegistrar".equals(metadata.get(str)) && str.startsWith("com.google.firebase.components:")) {
+                    arrayList.add(str.substring(31));
+                }
+            }
+            return arrayList;
+        }
+
+        public final Bundle getMetadata(Context context) {
+            try {
+                PackageManager packageManager = context.getPackageManager();
+                if (packageManager == null) {
+                    Log.w("ComponentDiscovery", "Context has no PackageManager.");
+                    return null;
+                }
+                ServiceInfo serviceInfo = packageManager.getServiceInfo(new ComponentName(context, (Class<?>) this.discoveryService), 128);
+                if (serviceInfo == null) {
+                    Log.w("ComponentDiscovery", this.discoveryService + " has no service info.");
+                    return null;
+                }
+                return serviceInfo.metaData;
+            } catch (PackageManager.NameNotFoundException unused) {
+                Log.w("ComponentDiscovery", "Application info not found.");
+                return null;
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/ComponentDiscoveryService.java

@@ -0,0 +1,13 @@
+package com.google.firebase.components;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+/* loaded from: classes3.dex */
+public class ComponentDiscoveryService extends Service {
+    @Override // android.app.Service
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}

decompiled/sources/com/google/firebase/components/ComponentFactory.java

@@ -0,0 +1,6 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public interface ComponentFactory {
+    Object create(ComponentContainer componentContainer);
+}

decompiled/sources/com/google/firebase/components/ComponentRegistrar.java

@@ -0,0 +1,8 @@
+package com.google.firebase.components;
+
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public interface ComponentRegistrar {
+    List getComponents();
+}

decompiled/sources/com/google/firebase/components/ComponentRegistrarProcessor.java

@@ -0,0 +1,15 @@
+package com.google.firebase.components;
+
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public interface ComponentRegistrarProcessor {
+    public static final ComponentRegistrarProcessor NOOP = new ComponentRegistrarProcessor() { // from class: com.google.firebase.components.ComponentRegistrarProcessor$$ExternalSyntheticLambda0
+        @Override // com.google.firebase.components.ComponentRegistrarProcessor
+        public final List processRegistrar(ComponentRegistrar componentRegistrar) {
+            return componentRegistrar.getComponents();
+        }
+    };
+
+    List processRegistrar(ComponentRegistrar componentRegistrar);
+}

decompiled/sources/com/google/firebase/components/ComponentRuntime.java

@@ -0,0 +1,322 @@
+package com.google.firebase.components;
+
+import android.util.Log;
+import androidx.lifecycle.LifecycleKt$$ExternalSyntheticBackportWithForwarding0;
+import com.google.firebase.components.ComponentRuntime;
+import com.google.firebase.dynamicloading.ComponentLoader;
+import com.google.firebase.events.Publisher;
+import com.google.firebase.events.Subscriber;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes3.dex */
+public class ComponentRuntime implements ComponentContainer, ComponentLoader {
+    public static final Provider EMPTY_PROVIDER = new Provider() { // from class: com.google.firebase.components.ComponentRuntime$$ExternalSyntheticLambda1
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            return Collections.emptySet();
+        }
+    };
+    public final ComponentRegistrarProcessor componentRegistrarProcessor;
+    public final Map components;
+    public final AtomicReference eagerComponentsInitializedWith;
+    public final EventBus eventBus;
+    public final Map lazyInstanceMap;
+    public final Map lazySetMap;
+    public Set processedCoroutineDispatcherInterfaces;
+    public final List unprocessedRegistrarProviders;
+
+    public static Builder builder(Executor executor) {
+        return new Builder(executor);
+    }
+
+    public ComponentRuntime(Executor executor, Iterable iterable, Collection collection, ComponentRegistrarProcessor componentRegistrarProcessor) {
+        this.components = new HashMap();
+        this.lazyInstanceMap = new HashMap();
+        this.lazySetMap = new HashMap();
+        this.processedCoroutineDispatcherInterfaces = new HashSet();
+        this.eagerComponentsInitializedWith = new AtomicReference();
+        EventBus eventBus = new EventBus(executor);
+        this.eventBus = eventBus;
+        this.componentRegistrarProcessor = componentRegistrarProcessor;
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(Component.of(eventBus, EventBus.class, Subscriber.class, Publisher.class));
+        arrayList.add(Component.of(this, ComponentLoader.class, new Class[0]));
+        Iterator it = collection.iterator();
+        while (it.hasNext()) {
+            Component component = (Component) it.next();
+            if (component != null) {
+                arrayList.add(component);
+            }
+        }
+        this.unprocessedRegistrarProviders = iterableToList(iterable);
+        discoverComponents(arrayList);
+    }
+
+    public final void discoverComponents(List list) {
+        ArrayList arrayList = new ArrayList();
+        synchronized (this) {
+            Iterator it = this.unprocessedRegistrarProviders.iterator();
+            while (it.hasNext()) {
+                try {
+                    ComponentRegistrar componentRegistrar = (ComponentRegistrar) ((Provider) it.next()).get();
+                    if (componentRegistrar != null) {
+                        list.addAll(this.componentRegistrarProcessor.processRegistrar(componentRegistrar));
+                        it.remove();
+                    }
+                } catch (InvalidRegistrarException e) {
+                    it.remove();
+                    Log.w("ComponentDiscovery", "Invalid component registrar.", e);
+                }
+            }
+            Iterator it2 = list.iterator();
+            while (it2.hasNext()) {
+                Object[] array = ((Component) it2.next()).getProvidedInterfaces().toArray();
+                int length = array.length;
+                int i = 0;
+                while (true) {
+                    if (i < length) {
+                        Object obj = array[i];
+                        if (obj.toString().contains("kotlinx.coroutines.CoroutineDispatcher")) {
+                            if (this.processedCoroutineDispatcherInterfaces.contains(obj.toString())) {
+                                it2.remove();
+                                break;
+                            }
+                            this.processedCoroutineDispatcherInterfaces.add(obj.toString());
+                        }
+                        i++;
+                    }
+                }
+            }
+            if (this.components.isEmpty()) {
+                CycleDetector.detect(list);
+            } else {
+                ArrayList arrayList2 = new ArrayList(this.components.keySet());
+                arrayList2.addAll(list);
+                CycleDetector.detect(arrayList2);
+            }
+            Iterator it3 = list.iterator();
+            while (it3.hasNext()) {
+                final Component component = (Component) it3.next();
+                this.components.put(component, new Lazy(new Provider() { // from class: com.google.firebase.components.ComponentRuntime$$ExternalSyntheticLambda0
+                    @Override // com.google.firebase.inject.Provider
+                    public final Object get() {
+                        Object lambda$discoverComponents$0;
+                        lambda$discoverComponents$0 = ComponentRuntime.this.lambda$discoverComponents$0(component);
+                        return lambda$discoverComponents$0;
+                    }
+                }));
+            }
+            arrayList.addAll(processInstanceComponents(list));
+            arrayList.addAll(processSetComponents());
+            processDependencies();
+        }
+        Iterator it4 = arrayList.iterator();
+        while (it4.hasNext()) {
+            ((Runnable) it4.next()).run();
+        }
+        maybeInitializeEagerComponents();
+    }
+
+    public final /* synthetic */ Object lambda$discoverComponents$0(Component component) {
+        return component.getFactory().create(new RestrictedComponentContainer(component, this));
+    }
+
+    public final void maybeInitializeEagerComponents() {
+        Boolean bool = (Boolean) this.eagerComponentsInitializedWith.get();
+        if (bool != null) {
+            doInitializeEagerComponents(this.components, bool.booleanValue());
+        }
+    }
+
+    public static List iterableToList(Iterable iterable) {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = iterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(it.next());
+        }
+        return arrayList;
+    }
+
+    public final List processInstanceComponents(List list) {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            Component component = (Component) it.next();
+            if (component.isValue()) {
+                final Provider provider = (Provider) this.components.get(component);
+                for (Qualified qualified : component.getProvidedInterfaces()) {
+                    if (!this.lazyInstanceMap.containsKey(qualified)) {
+                        this.lazyInstanceMap.put(qualified, provider);
+                    } else {
+                        final OptionalProvider optionalProvider = (OptionalProvider) ((Provider) this.lazyInstanceMap.get(qualified));
+                        arrayList.add(new Runnable() { // from class: com.google.firebase.components.ComponentRuntime$$ExternalSyntheticLambda2
+                            @Override // java.lang.Runnable
+                            public final void run() {
+                                OptionalProvider.this.set(provider);
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    public final List processSetComponents() {
+        ArrayList arrayList = new ArrayList();
+        HashMap hashMap = new HashMap();
+        for (Map.Entry entry : this.components.entrySet()) {
+            Component component = (Component) entry.getKey();
+            if (!component.isValue()) {
+                Provider provider = (Provider) entry.getValue();
+                for (Qualified qualified : component.getProvidedInterfaces()) {
+                    if (!hashMap.containsKey(qualified)) {
+                        hashMap.put(qualified, new HashSet());
+                    }
+                    ((Set) hashMap.get(qualified)).add(provider);
+                }
+            }
+        }
+        for (Map.Entry entry2 : hashMap.entrySet()) {
+            if (!this.lazySetMap.containsKey(entry2.getKey())) {
+                this.lazySetMap.put((Qualified) entry2.getKey(), LazySet.fromCollection((Collection) entry2.getValue()));
+            } else {
+                final LazySet lazySet = (LazySet) this.lazySetMap.get(entry2.getKey());
+                for (final Provider provider2 : (Set) entry2.getValue()) {
+                    arrayList.add(new Runnable() { // from class: com.google.firebase.components.ComponentRuntime$$ExternalSyntheticLambda3
+                        @Override // java.lang.Runnable
+                        public final void run() {
+                            LazySet.this.add(provider2);
+                        }
+                    });
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public synchronized Provider getProvider(Qualified qualified) {
+        Preconditions.checkNotNull(qualified, "Null interface requested.");
+        return (Provider) this.lazyInstanceMap.get(qualified);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Deferred getDeferred(Qualified qualified) {
+        Provider provider = getProvider(qualified);
+        if (provider == null) {
+            return OptionalProvider.empty();
+        }
+        if (provider instanceof OptionalProvider) {
+            return (OptionalProvider) provider;
+        }
+        return OptionalProvider.of(provider);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public synchronized Provider setOfProvider(Qualified qualified) {
+        LazySet lazySet = (LazySet) this.lazySetMap.get(qualified);
+        if (lazySet != null) {
+            return lazySet;
+        }
+        return EMPTY_PROVIDER;
+    }
+
+    public void initializeEagerComponents(boolean z) {
+        HashMap hashMap;
+        if (LifecycleKt$$ExternalSyntheticBackportWithForwarding0.m(this.eagerComponentsInitializedWith, null, Boolean.valueOf(z))) {
+            synchronized (this) {
+                hashMap = new HashMap(this.components);
+            }
+            doInitializeEagerComponents(hashMap, z);
+        }
+    }
+
+    public final void doInitializeEagerComponents(Map map, boolean z) {
+        for (Map.Entry entry : map.entrySet()) {
+            Component component = (Component) entry.getKey();
+            Provider provider = (Provider) entry.getValue();
+            if (component.isAlwaysEager() || (component.isEagerInDefaultApp() && z)) {
+                provider.get();
+            }
+        }
+        this.eventBus.enablePublishingAndFlushPending();
+    }
+
+    public final void processDependencies() {
+        for (Component component : this.components.keySet()) {
+            for (Dependency dependency : component.getDependencies()) {
+                if (dependency.isSet() && !this.lazySetMap.containsKey(dependency.getInterface())) {
+                    this.lazySetMap.put(dependency.getInterface(), LazySet.fromCollection(Collections.emptySet()));
+                } else if (this.lazyInstanceMap.containsKey(dependency.getInterface())) {
+                    continue;
+                } else {
+                    if (dependency.isRequired()) {
+                        throw new MissingDependencyException(String.format("Unsatisfied dependency for component %s: %s", component, dependency.getInterface()));
+                    }
+                    if (!dependency.isSet()) {
+                        this.lazyInstanceMap.put(dependency.getInterface(), OptionalProvider.empty());
+                    }
+                }
+            }
+        }
+    }
+
+    public static final class Builder {
+        public final Executor defaultExecutor;
+        public final List lazyRegistrars = new ArrayList();
+        public final List additionalComponents = new ArrayList();
+        public ComponentRegistrarProcessor componentRegistrarProcessor = ComponentRegistrarProcessor.NOOP;
+
+        public static /* synthetic */ ComponentRegistrar lambda$addComponentRegistrar$0(ComponentRegistrar componentRegistrar) {
+            return componentRegistrar;
+        }
+
+        public Builder setProcessor(ComponentRegistrarProcessor componentRegistrarProcessor) {
+            this.componentRegistrarProcessor = componentRegistrarProcessor;
+            return this;
+        }
+
+        public Builder(Executor executor) {
+            this.defaultExecutor = executor;
+        }
+
+        public Builder addLazyComponentRegistrars(Collection collection) {
+            this.lazyRegistrars.addAll(collection);
+            return this;
+        }
+
+        public Builder addComponentRegistrar(final ComponentRegistrar componentRegistrar) {
+            this.lazyRegistrars.add(new Provider() { // from class: com.google.firebase.components.ComponentRuntime$Builder$$ExternalSyntheticLambda0
+                @Override // com.google.firebase.inject.Provider
+                public final Object get() {
+                    ComponentRegistrar lambda$addComponentRegistrar$0;
+                    lambda$addComponentRegistrar$0 = ComponentRuntime.Builder.lambda$addComponentRegistrar$0(ComponentRegistrar.this);
+                    return lambda$addComponentRegistrar$0;
+                }
+            });
+            return this;
+        }
+
+        public Builder addComponent(Component component) {
+            this.additionalComponents.add(component);
+            return this;
+        }
+
+        public ComponentRuntime build() {
+            return new ComponentRuntime(this.defaultExecutor, this.lazyRegistrars, this.additionalComponents, this.componentRegistrarProcessor);
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/CycleDetector.java

@@ -0,0 +1,154 @@
+package com.google.firebase.components;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public abstract class CycleDetector {
+
+    public static class Dep {
+        public final Qualified anInterface;
+        public final boolean set;
+
+        public Dep(Qualified qualified, boolean z) {
+            this.anInterface = qualified;
+            this.set = z;
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof Dep)) {
+                return false;
+            }
+            Dep dep = (Dep) obj;
+            return dep.anInterface.equals(this.anInterface) && dep.set == this.set;
+        }
+
+        public int hashCode() {
+            return ((this.anInterface.hashCode() ^ 1000003) * 1000003) ^ Boolean.valueOf(this.set).hashCode();
+        }
+    }
+
+    public static class ComponentNode {
+        public final Component component;
+        public final Set dependencies = new HashSet();
+        public final Set dependents = new HashSet();
+
+        public Component getComponent() {
+            return this.component;
+        }
+
+        public Set getDependencies() {
+            return this.dependencies;
+        }
+
+        public ComponentNode(Component component) {
+            this.component = component;
+        }
+
+        public void addDependency(ComponentNode componentNode) {
+            this.dependencies.add(componentNode);
+        }
+
+        public void addDependent(ComponentNode componentNode) {
+            this.dependents.add(componentNode);
+        }
+
+        public void removeDependent(ComponentNode componentNode) {
+            this.dependents.remove(componentNode);
+        }
+
+        public boolean isRoot() {
+            return this.dependents.isEmpty();
+        }
+
+        public boolean isLeaf() {
+            return this.dependencies.isEmpty();
+        }
+    }
+
+    public static void detect(List list) {
+        Set<ComponentNode> graph = toGraph(list);
+        Set roots = getRoots(graph);
+        int i = 0;
+        while (!roots.isEmpty()) {
+            ComponentNode componentNode = (ComponentNode) roots.iterator().next();
+            roots.remove(componentNode);
+            i++;
+            for (ComponentNode componentNode2 : componentNode.getDependencies()) {
+                componentNode2.removeDependent(componentNode);
+                if (componentNode2.isRoot()) {
+                    roots.add(componentNode2);
+                }
+            }
+        }
+        if (i == list.size()) {
+            return;
+        }
+        ArrayList arrayList = new ArrayList();
+        for (ComponentNode componentNode3 : graph) {
+            if (!componentNode3.isRoot() && !componentNode3.isLeaf()) {
+                arrayList.add(componentNode3.getComponent());
+            }
+        }
+        throw new DependencyCycleException(arrayList);
+    }
+
+    public static Set toGraph(List list) {
+        Set<ComponentNode> set;
+        HashMap hashMap = new HashMap(list.size());
+        Iterator it = list.iterator();
+        while (true) {
+            if (it.hasNext()) {
+                Component component = (Component) it.next();
+                ComponentNode componentNode = new ComponentNode(component);
+                for (Qualified qualified : component.getProvidedInterfaces()) {
+                    Dep dep = new Dep(qualified, !component.isValue());
+                    if (!hashMap.containsKey(dep)) {
+                        hashMap.put(dep, new HashSet());
+                    }
+                    Set set2 = (Set) hashMap.get(dep);
+                    if (!set2.isEmpty() && !dep.set) {
+                        throw new IllegalArgumentException(String.format("Multiple components provide %s.", qualified));
+                    }
+                    set2.add(componentNode);
+                }
+            } else {
+                Iterator it2 = hashMap.values().iterator();
+                while (it2.hasNext()) {
+                    for (ComponentNode componentNode2 : (Set) it2.next()) {
+                        for (Dependency dependency : componentNode2.getComponent().getDependencies()) {
+                            if (dependency.isDirectInjection() && (set = (Set) hashMap.get(new Dep(dependency.getInterface(), dependency.isSet()))) != null) {
+                                for (ComponentNode componentNode3 : set) {
+                                    componentNode2.addDependency(componentNode3);
+                                    componentNode3.addDependent(componentNode2);
+                                }
+                            }
+                        }
+                    }
+                }
+                HashSet hashSet = new HashSet();
+                Iterator it3 = hashMap.values().iterator();
+                while (it3.hasNext()) {
+                    hashSet.addAll((Set) it3.next());
+                }
+                return hashSet;
+            }
+        }
+    }
+
+    public static Set getRoots(Set set) {
+        HashSet hashSet = new HashSet();
+        Iterator it = set.iterator();
+        while (it.hasNext()) {
+            ComponentNode componentNode = (ComponentNode) it.next();
+            if (componentNode.isRoot()) {
+                hashSet.add(componentNode);
+            }
+        }
+        return hashSet;
+    }
+}

decompiled/sources/com/google/firebase/components/Dependency.java

@@ -0,0 +1,114 @@
+package com.google.firebase.components;
+
+import com.google.android.gms.fido.fido2.api.common.DevicePublicKeyStringDef;
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+
+/* loaded from: classes3.dex */
+public final class Dependency {
+    public final Qualified anInterface;
+    public final int injection;
+    public final int type;
+
+    public Qualified getInterface() {
+        return this.anInterface;
+    }
+
+    public boolean isDeferred() {
+        return this.injection == 2;
+    }
+
+    public boolean isDirectInjection() {
+        return this.injection == 0;
+    }
+
+    public boolean isRequired() {
+        return this.type == 1;
+    }
+
+    public boolean isSet() {
+        return this.type == 2;
+    }
+
+    public Dependency(Class cls, int i, int i2) {
+        this(Qualified.unqualified(cls), i, i2);
+    }
+
+    public Dependency(Qualified qualified, int i, int i2) {
+        this.anInterface = (Qualified) Preconditions.checkNotNull(qualified, "Null dependency anInterface.");
+        this.type = i;
+        this.injection = i2;
+    }
+
+    public static Dependency optional(Class cls) {
+        return new Dependency(cls, 0, 0);
+    }
+
+    public static Dependency deferred(Class cls) {
+        return new Dependency(cls, 0, 2);
+    }
+
+    public static Dependency required(Class cls) {
+        return new Dependency(cls, 1, 0);
+    }
+
+    public static Dependency required(Qualified qualified) {
+        return new Dependency(qualified, 1, 0);
+    }
+
+    public static Dependency setOf(Class cls) {
+        return new Dependency(cls, 2, 0);
+    }
+
+    public static Dependency optionalProvider(Class cls) {
+        return new Dependency(cls, 0, 1);
+    }
+
+    public static Dependency optionalProvider(Qualified qualified) {
+        return new Dependency(qualified, 0, 1);
+    }
+
+    public static Dependency requiredProvider(Class cls) {
+        return new Dependency(cls, 1, 1);
+    }
+
+    public static Dependency requiredProvider(Qualified qualified) {
+        return new Dependency(qualified, 1, 1);
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Dependency)) {
+            return false;
+        }
+        Dependency dependency = (Dependency) obj;
+        return this.anInterface.equals(dependency.anInterface) && this.type == dependency.type && this.injection == dependency.injection;
+    }
+
+    public int hashCode() {
+        return ((((this.anInterface.hashCode() ^ 1000003) * 1000003) ^ this.type) * 1000003) ^ this.injection;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder("Dependency{anInterface=");
+        sb.append(this.anInterface);
+        sb.append(", type=");
+        int i = this.type;
+        sb.append(i == 1 ? "required" : i == 0 ? "optional" : "set");
+        sb.append(", injection=");
+        sb.append(describeInjection(this.injection));
+        sb.append("}");
+        return sb.toString();
+    }
+
+    public static String describeInjection(int i) {
+        if (i == 0) {
+            return DevicePublicKeyStringDef.DIRECT;
+        }
+        if (i == 1) {
+            return IronSourceConstants.EVENTS_PROVIDER;
+        }
+        if (i == 2) {
+            return "deferred";
+        }
+        throw new AssertionError("Unsupported injection: " + i);
+    }
+}

decompiled/sources/com/google/firebase/components/DependencyCycleException.java

@@ -0,0 +1,14 @@
+package com.google.firebase.components;
+
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class DependencyCycleException extends DependencyException {
+    public final List componentsInCycle;
+
+    public DependencyCycleException(List list) {
+        super("Dependency cycle detected: " + Arrays.toString(list.toArray()));
+        this.componentsInCycle = list;
+    }
+}

decompiled/sources/com/google/firebase/components/DependencyException.java

@@ -0,0 +1,8 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public class DependencyException extends RuntimeException {
+    public DependencyException(String str) {
+        super(str);
+    }
+}

decompiled/sources/com/google/firebase/components/EventBus.java

@@ -0,0 +1,102 @@
+package com.google.firebase.components;
+
+import com.amazonaws.handlers.HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0;
+import com.google.firebase.events.Event;
+import com.google.firebase.events.EventHandler;
+import com.google.firebase.events.Publisher;
+import com.google.firebase.events.Subscriber;
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class EventBus implements Subscriber, Publisher {
+    public final Executor defaultExecutor;
+    public final Map handlerMap = new HashMap();
+    public Queue pendingEvents = new ArrayDeque();
+
+    public EventBus(Executor executor) {
+        this.defaultExecutor = executor;
+    }
+
+    public void publish(final Event event) {
+        Preconditions.checkNotNull(event);
+        synchronized (this) {
+            try {
+                Queue queue = this.pendingEvents;
+                if (queue != null) {
+                    queue.add(event);
+                    return;
+                }
+                for (final Map.Entry entry : getHandlers(event)) {
+                    ((Executor) entry.getValue()).execute(new Runnable(entry, event) { // from class: com.google.firebase.components.EventBus$$ExternalSyntheticLambda0
+                        public final /* synthetic */ Map.Entry f$0;
+
+                        @Override // java.lang.Runnable
+                        public final void run() {
+                            EventBus.lambda$publish$0(this.f$0, null);
+                        }
+                    });
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static /* synthetic */ void lambda$publish$0(Map.Entry entry, Event event) {
+        ((EventHandler) entry.getKey()).handle(event);
+    }
+
+    public final synchronized Set getHandlers(Event event) {
+        throw null;
+    }
+
+    @Override // com.google.firebase.events.Subscriber
+    public synchronized void subscribe(Class cls, Executor executor, EventHandler eventHandler) {
+        try {
+            Preconditions.checkNotNull(cls);
+            Preconditions.checkNotNull(eventHandler);
+            Preconditions.checkNotNull(executor);
+            if (!this.handlerMap.containsKey(cls)) {
+                this.handlerMap.put(cls, new ConcurrentHashMap());
+            }
+            ((ConcurrentHashMap) this.handlerMap.get(cls)).put(eventHandler, executor);
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.google.firebase.events.Subscriber
+    public void subscribe(Class cls, EventHandler eventHandler) {
+        subscribe(cls, this.defaultExecutor, eventHandler);
+    }
+
+    public void enablePublishingAndFlushPending() {
+        Queue queue;
+        synchronized (this) {
+            try {
+                queue = this.pendingEvents;
+                if (queue != null) {
+                    this.pendingEvents = null;
+                } else {
+                    queue = null;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (queue != null) {
+            Iterator it = queue.iterator();
+            while (it.hasNext()) {
+                HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0.m(it.next());
+                publish(null);
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/InvalidRegistrarException.java

@@ -0,0 +1,12 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public class InvalidRegistrarException extends RuntimeException {
+    public InvalidRegistrarException(String str) {
+        super(str);
+    }
+
+    public InvalidRegistrarException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/google/firebase/components/Lazy.java

@@ -0,0 +1,34 @@
+package com.google.firebase.components;
+
+import com.google.firebase.inject.Provider;
+
+/* loaded from: classes3.dex */
+public class Lazy implements Provider {
+    public static final Object UNINITIALIZED = new Object();
+    public volatile Object instance = UNINITIALIZED;
+    public volatile Provider provider;
+
+    public Lazy(Provider provider) {
+        this.provider = provider;
+    }
+
+    @Override // com.google.firebase.inject.Provider
+    public Object get() {
+        Object obj = this.instance;
+        Object obj2 = UNINITIALIZED;
+        if (obj == obj2) {
+            synchronized (this) {
+                try {
+                    obj = this.instance;
+                    if (obj == obj2) {
+                        obj = this.provider.get();
+                        this.instance = obj;
+                        this.provider = null;
+                    }
+                } finally {
+                }
+            }
+        }
+        return obj;
+    }
+}

decompiled/sources/com/google/firebase/components/LazySet.java

@@ -0,0 +1,62 @@
+package com.google.firebase.components;
+
+import com.google.firebase.inject.Provider;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes3.dex */
+public class LazySet implements Provider {
+    public volatile Set actualSet = null;
+    public volatile Set providers = Collections.newSetFromMap(new ConcurrentHashMap());
+
+    public LazySet(Collection collection) {
+        this.providers.addAll(collection);
+    }
+
+    public static LazySet fromCollection(Collection collection) {
+        return new LazySet((Set) collection);
+    }
+
+    @Override // com.google.firebase.inject.Provider
+    public Set get() {
+        if (this.actualSet == null) {
+            synchronized (this) {
+                try {
+                    if (this.actualSet == null) {
+                        this.actualSet = Collections.newSetFromMap(new ConcurrentHashMap());
+                        updateSet();
+                    }
+                } finally {
+                }
+            }
+        }
+        return Collections.unmodifiableSet(this.actualSet);
+    }
+
+    public synchronized void add(Provider provider) {
+        try {
+            if (this.actualSet == null) {
+                this.providers.add(provider);
+            } else {
+                this.actualSet.add(provider.get());
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public final synchronized void updateSet() {
+        try {
+            Iterator it = this.providers.iterator();
+            while (it.hasNext()) {
+                this.actualSet.add(((Provider) it.next()).get());
+            }
+            this.providers = null;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/MissingDependencyException.java

@@ -0,0 +1,8 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public class MissingDependencyException extends DependencyException {
+    public MissingDependencyException(String str) {
+        super(str);
+    }
+}

decompiled/sources/com/google/firebase/components/OptionalProvider.java

@@ -0,0 +1,97 @@
+package com.google.firebase.components;
+
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+
+/* loaded from: classes3.dex */
+public class OptionalProvider implements Provider, Deferred {
+    public volatile Provider delegate;
+    public Deferred.DeferredHandler handler;
+    public static final Deferred.DeferredHandler NOOP_HANDLER = new Deferred.DeferredHandler() { // from class: com.google.firebase.components.OptionalProvider$$ExternalSyntheticLambda0
+        @Override // com.google.firebase.inject.Deferred.DeferredHandler
+        public final void handle(Provider provider) {
+            OptionalProvider.lambda$static$0(provider);
+        }
+    };
+    public static final Provider EMPTY_PROVIDER = new Provider() { // from class: com.google.firebase.components.OptionalProvider$$ExternalSyntheticLambda1
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            Object lambda$static$1;
+            lambda$static$1 = OptionalProvider.lambda$static$1();
+            return lambda$static$1;
+        }
+    };
+
+    public static /* synthetic */ void lambda$static$0(Provider provider) {
+    }
+
+    public static /* synthetic */ Object lambda$static$1() {
+        return null;
+    }
+
+    public OptionalProvider(Deferred.DeferredHandler deferredHandler, Provider provider) {
+        this.handler = deferredHandler;
+        this.delegate = provider;
+    }
+
+    public static OptionalProvider empty() {
+        return new OptionalProvider(NOOP_HANDLER, EMPTY_PROVIDER);
+    }
+
+    public static OptionalProvider of(Provider provider) {
+        return new OptionalProvider(null, provider);
+    }
+
+    @Override // com.google.firebase.inject.Provider
+    public Object get() {
+        return this.delegate.get();
+    }
+
+    public void set(Provider provider) {
+        Deferred.DeferredHandler deferredHandler;
+        if (this.delegate != EMPTY_PROVIDER) {
+            throw new IllegalStateException("provide() can be called only once.");
+        }
+        synchronized (this) {
+            deferredHandler = this.handler;
+            this.handler = null;
+            this.delegate = provider;
+        }
+        deferredHandler.handle(provider);
+    }
+
+    @Override // com.google.firebase.inject.Deferred
+    public void whenAvailable(final Deferred.DeferredHandler deferredHandler) {
+        Provider provider;
+        Provider provider2;
+        Provider provider3 = this.delegate;
+        Provider provider4 = EMPTY_PROVIDER;
+        if (provider3 != provider4) {
+            deferredHandler.handle(provider3);
+            return;
+        }
+        synchronized (this) {
+            provider = this.delegate;
+            if (provider != provider4) {
+                provider2 = provider;
+            } else {
+                final Deferred.DeferredHandler deferredHandler2 = this.handler;
+                this.handler = new Deferred.DeferredHandler() { // from class: com.google.firebase.components.OptionalProvider$$ExternalSyntheticLambda2
+                    @Override // com.google.firebase.inject.Deferred.DeferredHandler
+                    public final void handle(Provider provider5) {
+                        OptionalProvider.lambda$whenAvailable$2(Deferred.DeferredHandler.this, deferredHandler, provider5);
+                    }
+                };
+                provider2 = null;
+            }
+        }
+        if (provider2 != null) {
+            deferredHandler.handle(provider);
+        }
+    }
+
+    public static /* synthetic */ void lambda$whenAvailable$2(Deferred.DeferredHandler deferredHandler, Deferred.DeferredHandler deferredHandler2, Provider provider) {
+        deferredHandler.handle(provider);
+        deferredHandler2.handle(provider);
+    }
+}

decompiled/sources/com/google/firebase/components/Preconditions.java

@@ -0,0 +1,28 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public abstract class Preconditions {
+    public static void checkArgument(boolean z, String str) {
+        if (!z) {
+            throw new IllegalArgumentException(str);
+        }
+    }
+
+    public static Object checkNotNull(Object obj) {
+        obj.getClass();
+        return obj;
+    }
+
+    public static Object checkNotNull(Object obj, String str) {
+        if (obj != null) {
+            return obj;
+        }
+        throw new NullPointerException(str);
+    }
+
+    public static void checkState(boolean z, String str) {
+        if (!z) {
+            throw new IllegalStateException(str);
+        }
+    }
+}

decompiled/sources/com/google/firebase/components/Qualified.java

@@ -0,0 +1,48 @@
+package com.google.firebase.components;
+
+/* loaded from: classes3.dex */
+public final class Qualified {
+    public final Class qualifier;
+    public final Class type;
+
+    public @interface Unqualified {
+    }
+
+    public Qualified(Class cls, Class cls2) {
+        this.qualifier = cls;
+        this.type = cls2;
+    }
+
+    public static Qualified unqualified(Class cls) {
+        return new Qualified(Unqualified.class, cls);
+    }
+
+    public static Qualified qualified(Class cls, Class cls2) {
+        return new Qualified(cls, cls2);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || Qualified.class != obj.getClass()) {
+            return false;
+        }
+        Qualified qualified = (Qualified) obj;
+        if (this.type.equals(qualified.type)) {
+            return this.qualifier.equals(qualified.qualifier);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return (this.type.hashCode() * 31) + this.qualifier.hashCode();
+    }
+
+    public String toString() {
+        if (this.qualifier == Unqualified.class) {
+            return this.type.getName();
+        }
+        return "@" + this.qualifier.getName() + " " + this.type.getName();
+    }
+}

decompiled/sources/com/google/firebase/components/RestrictedComponentContainer.java

@@ -0,0 +1,121 @@
+package com.google.firebase.components;
+
+import com.google.firebase.events.Publisher;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class RestrictedComponentContainer implements ComponentContainer {
+    public final Set allowedDeferredInterfaces;
+    public final Set allowedDirectInterfaces;
+    public final Set allowedProviderInterfaces;
+    public final Set allowedPublishedEvents;
+    public final Set allowedSetDirectInterfaces;
+    public final Set allowedSetProviderInterfaces;
+    public final ComponentContainer delegateContainer;
+
+    public RestrictedComponentContainer(Component component, ComponentContainer componentContainer) {
+        HashSet hashSet = new HashSet();
+        HashSet hashSet2 = new HashSet();
+        HashSet hashSet3 = new HashSet();
+        HashSet hashSet4 = new HashSet();
+        HashSet hashSet5 = new HashSet();
+        for (Dependency dependency : component.getDependencies()) {
+            if (dependency.isDirectInjection()) {
+                if (dependency.isSet()) {
+                    hashSet4.add(dependency.getInterface());
+                } else {
+                    hashSet.add(dependency.getInterface());
+                }
+            } else if (dependency.isDeferred()) {
+                hashSet3.add(dependency.getInterface());
+            } else if (dependency.isSet()) {
+                hashSet5.add(dependency.getInterface());
+            } else {
+                hashSet2.add(dependency.getInterface());
+            }
+        }
+        if (!component.getPublishedEvents().isEmpty()) {
+            hashSet.add(Qualified.unqualified(Publisher.class));
+        }
+        this.allowedDirectInterfaces = Collections.unmodifiableSet(hashSet);
+        this.allowedProviderInterfaces = Collections.unmodifiableSet(hashSet2);
+        this.allowedDeferredInterfaces = Collections.unmodifiableSet(hashSet3);
+        this.allowedSetDirectInterfaces = Collections.unmodifiableSet(hashSet4);
+        this.allowedSetProviderInterfaces = Collections.unmodifiableSet(hashSet5);
+        this.allowedPublishedEvents = component.getPublishedEvents();
+        this.delegateContainer = componentContainer;
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Object get(Class cls) {
+        if (!this.allowedDirectInterfaces.contains(Qualified.unqualified(cls))) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency %s.", cls));
+        }
+        Object obj = this.delegateContainer.get(cls);
+        return !cls.equals(Publisher.class) ? obj : new RestrictedPublisher(this.allowedPublishedEvents, (Publisher) obj);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Object get(Qualified qualified) {
+        if (!this.allowedDirectInterfaces.contains(qualified)) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency %s.", qualified));
+        }
+        return this.delegateContainer.get(qualified);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Provider getProvider(Class cls) {
+        return getProvider(Qualified.unqualified(cls));
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Deferred getDeferred(Class cls) {
+        return getDeferred(Qualified.unqualified(cls));
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Provider getProvider(Qualified qualified) {
+        if (!this.allowedProviderInterfaces.contains(qualified)) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency Provider<%s>.", qualified));
+        }
+        return this.delegateContainer.getProvider(qualified);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Deferred getDeferred(Qualified qualified) {
+        if (!this.allowedDeferredInterfaces.contains(qualified)) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency Deferred<%s>.", qualified));
+        }
+        return this.delegateContainer.getDeferred(qualified);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Provider setOfProvider(Qualified qualified) {
+        if (!this.allowedSetProviderInterfaces.contains(qualified)) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency Provider<Set<%s>>.", qualified));
+        }
+        return this.delegateContainer.setOfProvider(qualified);
+    }
+
+    @Override // com.google.firebase.components.ComponentContainer
+    public Set setOf(Qualified qualified) {
+        if (!this.allowedSetDirectInterfaces.contains(qualified)) {
+            throw new DependencyException(String.format("Attempting to request an undeclared dependency Set<%s>.", qualified));
+        }
+        return this.delegateContainer.setOf(qualified);
+    }
+
+    public static class RestrictedPublisher implements Publisher {
+        public final Set allowedPublishedEvents;
+        public final Publisher delegate;
+
+        public RestrictedPublisher(Set set, Publisher publisher) {
+            this.allowedPublishedEvents = set;
+            this.delegate = publisher;
+        }
+    }
+}

decompiled/sources/com/google/firebase/concurrent/CustomThreadFactory.java

@@ -0,0 +1,44 @@
+package com.google.firebase.concurrent;
+
+import android.os.Process;
+import android.os.StrictMode;
+import java.util.Locale;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes3.dex */
+public class CustomThreadFactory implements ThreadFactory {
+    public static final ThreadFactory DEFAULT = Executors.defaultThreadFactory();
+    public final String namePrefix;
+    public final StrictMode.ThreadPolicy policy;
+    public final int priority;
+    public final AtomicLong threadCount = new AtomicLong();
+
+    public CustomThreadFactory(String str, int i, StrictMode.ThreadPolicy threadPolicy) {
+        this.namePrefix = str;
+        this.priority = i;
+        this.policy = threadPolicy;
+    }
+
+    @Override // java.util.concurrent.ThreadFactory
+    public Thread newThread(final Runnable runnable) {
+        Thread newThread = DEFAULT.newThread(new Runnable() { // from class: com.google.firebase.concurrent.CustomThreadFactory$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                CustomThreadFactory.this.lambda$newThread$0(runnable);
+            }
+        });
+        newThread.setName(String.format(Locale.ROOT, "%s Thread #%d", this.namePrefix, Long.valueOf(this.threadCount.getAndIncrement())));
+        return newThread;
+    }
+
+    public final /* synthetic */ void lambda$newThread$0(Runnable runnable) {
+        Process.setThreadPriority(this.priority);
+        StrictMode.ThreadPolicy threadPolicy = this.policy;
+        if (threadPolicy != null) {
+            StrictMode.setThreadPolicy(threadPolicy);
+        }
+        runnable.run();
+    }
+}

decompiled/sources/com/google/firebase/concurrent/DelegatingScheduledExecutorService.java

@@ -0,0 +1,243 @@
+package com.google.firebase.concurrent;
+
+import com.google.firebase.concurrent.DelegatingScheduledFuture;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class DelegatingScheduledExecutorService implements ScheduledExecutorService {
+    public final ExecutorService delegate;
+    public final ScheduledExecutorService scheduler;
+
+    public DelegatingScheduledExecutorService(ExecutorService executorService, ScheduledExecutorService scheduledExecutorService) {
+        this.delegate = executorService;
+        this.scheduler = scheduledExecutorService;
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public void shutdown() {
+        throw new UnsupportedOperationException("Shutting down is not allowed.");
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public List shutdownNow() {
+        throw new UnsupportedOperationException("Shutting down is not allowed.");
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public boolean isShutdown() {
+        return this.delegate.isShutdown();
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public boolean isTerminated() {
+        return this.delegate.isTerminated();
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public boolean awaitTermination(long j, TimeUnit timeUnit) {
+        return this.delegate.awaitTermination(j, timeUnit);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public Future submit(Callable callable) {
+        return this.delegate.submit(callable);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public Future submit(Runnable runnable, Object obj) {
+        return this.delegate.submit(runnable, obj);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public Future submit(Runnable runnable) {
+        return this.delegate.submit(runnable);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public List invokeAll(Collection collection) {
+        return this.delegate.invokeAll(collection);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public List invokeAll(Collection collection, long j, TimeUnit timeUnit) {
+        return this.delegate.invokeAll(collection, j, timeUnit);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public Object invokeAny(Collection collection) {
+        return this.delegate.invokeAny(collection);
+    }
+
+    @Override // java.util.concurrent.ExecutorService
+    public Object invokeAny(Collection collection, long j, TimeUnit timeUnit) {
+        return this.delegate.invokeAny(collection, j, timeUnit);
+    }
+
+    @Override // java.util.concurrent.Executor
+    public void execute(Runnable runnable) {
+        this.delegate.execute(runnable);
+    }
+
+    @Override // java.util.concurrent.ScheduledExecutorService
+    public ScheduledFuture schedule(final Runnable runnable, final long j, final TimeUnit timeUnit) {
+        return new DelegatingScheduledFuture(new DelegatingScheduledFuture.Resolver() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Resolver
+            public final ScheduledFuture addCompleter(DelegatingScheduledFuture.Completer completer) {
+                ScheduledFuture lambda$schedule$2;
+                lambda$schedule$2 = DelegatingScheduledExecutorService.this.lambda$schedule$2(runnable, j, timeUnit, completer);
+                return lambda$schedule$2;
+            }
+        });
+    }
+
+    public final /* synthetic */ ScheduledFuture lambda$schedule$2(final Runnable runnable, long j, TimeUnit timeUnit, final DelegatingScheduledFuture.Completer completer) {
+        return this.scheduler.schedule(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda6
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.this.lambda$schedule$1(runnable, completer);
+            }
+        }, j, timeUnit);
+    }
+
+    public final /* synthetic */ void lambda$schedule$1(final Runnable runnable, final DelegatingScheduledFuture.Completer completer) {
+        this.delegate.execute(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda10
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.lambda$schedule$0(runnable, completer);
+            }
+        });
+    }
+
+    public static /* synthetic */ void lambda$schedule$0(Runnable runnable, DelegatingScheduledFuture.Completer completer) {
+        try {
+            runnable.run();
+            completer.set(null);
+        } catch (Exception e) {
+            completer.setException(e);
+        }
+    }
+
+    @Override // java.util.concurrent.ScheduledExecutorService
+    public ScheduledFuture schedule(final Callable callable, final long j, final TimeUnit timeUnit) {
+        return new DelegatingScheduledFuture(new DelegatingScheduledFuture.Resolver() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Resolver
+            public final ScheduledFuture addCompleter(DelegatingScheduledFuture.Completer completer) {
+                ScheduledFuture lambda$schedule$5;
+                lambda$schedule$5 = DelegatingScheduledExecutorService.this.lambda$schedule$5(callable, j, timeUnit, completer);
+                return lambda$schedule$5;
+            }
+        });
+    }
+
+    public final /* synthetic */ ScheduledFuture lambda$schedule$5(final Callable callable, long j, TimeUnit timeUnit, final DelegatingScheduledFuture.Completer completer) {
+        return this.scheduler.schedule(new Callable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda7
+            @Override // java.util.concurrent.Callable
+            public final Object call() {
+                Future lambda$schedule$4;
+                lambda$schedule$4 = DelegatingScheduledExecutorService.this.lambda$schedule$4(callable, completer);
+                return lambda$schedule$4;
+            }
+        }, j, timeUnit);
+    }
+
+    public final /* synthetic */ Future lambda$schedule$4(final Callable callable, final DelegatingScheduledFuture.Completer completer) {
+        return this.delegate.submit(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda8
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.lambda$schedule$3(callable, completer);
+            }
+        });
+    }
+
+    public static /* synthetic */ void lambda$schedule$3(Callable callable, DelegatingScheduledFuture.Completer completer) {
+        try {
+            completer.set(callable.call());
+        } catch (Exception e) {
+            completer.setException(e);
+        }
+    }
+
+    @Override // java.util.concurrent.ScheduledExecutorService
+    public ScheduledFuture scheduleAtFixedRate(final Runnable runnable, final long j, final long j2, final TimeUnit timeUnit) {
+        return new DelegatingScheduledFuture(new DelegatingScheduledFuture.Resolver() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda3
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Resolver
+            public final ScheduledFuture addCompleter(DelegatingScheduledFuture.Completer completer) {
+                ScheduledFuture lambda$scheduleAtFixedRate$8;
+                lambda$scheduleAtFixedRate$8 = DelegatingScheduledExecutorService.this.lambda$scheduleAtFixedRate$8(runnable, j, j2, timeUnit, completer);
+                return lambda$scheduleAtFixedRate$8;
+            }
+        });
+    }
+
+    public final /* synthetic */ ScheduledFuture lambda$scheduleAtFixedRate$8(final Runnable runnable, long j, long j2, TimeUnit timeUnit, final DelegatingScheduledFuture.Completer completer) {
+        return this.scheduler.scheduleAtFixedRate(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda4
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.this.lambda$scheduleAtFixedRate$7(runnable, completer);
+            }
+        }, j, j2, timeUnit);
+    }
+
+    public final /* synthetic */ void lambda$scheduleAtFixedRate$7(final Runnable runnable, final DelegatingScheduledFuture.Completer completer) {
+        this.delegate.execute(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda9
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.lambda$scheduleAtFixedRate$6(runnable, completer);
+            }
+        });
+    }
+
+    public static /* synthetic */ void lambda$scheduleAtFixedRate$6(Runnable runnable, DelegatingScheduledFuture.Completer completer) {
+        try {
+            runnable.run();
+        } catch (Exception e) {
+            completer.setException(e);
+            throw e;
+        }
+    }
+
+    @Override // java.util.concurrent.ScheduledExecutorService
+    public ScheduledFuture scheduleWithFixedDelay(final Runnable runnable, final long j, final long j2, final TimeUnit timeUnit) {
+        return new DelegatingScheduledFuture(new DelegatingScheduledFuture.Resolver() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda2
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Resolver
+            public final ScheduledFuture addCompleter(DelegatingScheduledFuture.Completer completer) {
+                ScheduledFuture lambda$scheduleWithFixedDelay$11;
+                lambda$scheduleWithFixedDelay$11 = DelegatingScheduledExecutorService.this.lambda$scheduleWithFixedDelay$11(runnable, j, j2, timeUnit, completer);
+                return lambda$scheduleWithFixedDelay$11;
+            }
+        });
+    }
+
+    public final /* synthetic */ ScheduledFuture lambda$scheduleWithFixedDelay$11(final Runnable runnable, long j, long j2, TimeUnit timeUnit, final DelegatingScheduledFuture.Completer completer) {
+        return this.scheduler.scheduleWithFixedDelay(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda5
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.this.lambda$scheduleWithFixedDelay$10(runnable, completer);
+            }
+        }, j, j2, timeUnit);
+    }
+
+    public final /* synthetic */ void lambda$scheduleWithFixedDelay$10(final Runnable runnable, final DelegatingScheduledFuture.Completer completer) {
+        this.delegate.execute(new Runnable() { // from class: com.google.firebase.concurrent.DelegatingScheduledExecutorService$$ExternalSyntheticLambda11
+            @Override // java.lang.Runnable
+            public final void run() {
+                DelegatingScheduledExecutorService.lambda$scheduleWithFixedDelay$9(runnable, completer);
+            }
+        });
+    }
+
+    public static /* synthetic */ void lambda$scheduleWithFixedDelay$9(Runnable runnable, DelegatingScheduledFuture.Completer completer) {
+        try {
+            runnable.run();
+        } catch (Exception e) {
+            completer.setException(e);
+        }
+    }
+}

decompiled/sources/com/google/firebase/concurrent/DelegatingScheduledFuture.java

@@ -0,0 +1,50 @@
+package com.google.firebase.concurrent;
+
+import androidx.concurrent.futures.AbstractResolvableFuture;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class DelegatingScheduledFuture extends AbstractResolvableFuture implements ScheduledFuture {
+    public final ScheduledFuture upstreamFuture;
+
+    public interface Completer {
+        void set(Object obj);
+
+        void setException(Throwable th);
+    }
+
+    public interface Resolver {
+        ScheduledFuture addCompleter(Completer completer);
+    }
+
+    public DelegatingScheduledFuture(Resolver resolver) {
+        this.upstreamFuture = resolver.addCompleter(new Completer() { // from class: com.google.firebase.concurrent.DelegatingScheduledFuture.1
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Completer
+            public void set(Object obj) {
+                DelegatingScheduledFuture.this.set(obj);
+            }
+
+            @Override // com.google.firebase.concurrent.DelegatingScheduledFuture.Completer
+            public void setException(Throwable th) {
+                DelegatingScheduledFuture.this.setException(th);
+            }
+        });
+    }
+
+    @Override // androidx.concurrent.futures.AbstractResolvableFuture
+    public void afterDone() {
+        this.upstreamFuture.cancel(wasInterrupted());
+    }
+
+    @Override // java.util.concurrent.Delayed
+    public long getDelay(TimeUnit timeUnit) {
+        return this.upstreamFuture.getDelay(timeUnit);
+    }
+
+    @Override // java.lang.Comparable
+    public int compareTo(Delayed delayed) {
+        return this.upstreamFuture.compareTo(delayed);
+    }
+}

decompiled/sources/com/google/firebase/concurrent/ExecutorsRegistrar.java

@@ -0,0 +1,147 @@
+package com.google.firebase.concurrent;
+
+import android.annotation.SuppressLint;
+import android.os.StrictMode;
+import com.google.firebase.annotations.concurrent.Background;
+import com.google.firebase.annotations.concurrent.Blocking;
+import com.google.firebase.annotations.concurrent.Lightweight;
+import com.google.firebase.annotations.concurrent.UiThread;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Lazy;
+import com.google.firebase.components.Qualified;
+import com.google.firebase.inject.Provider;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+
+@SuppressLint({"ThreadPoolCreation"})
+/* loaded from: classes3.dex */
+public class ExecutorsRegistrar implements ComponentRegistrar {
+    public static final Lazy BG_EXECUTOR = new Lazy(new Provider() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda0
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            ScheduledExecutorService lambda$static$0;
+            lambda$static$0 = ExecutorsRegistrar.lambda$static$0();
+            return lambda$static$0;
+        }
+    });
+    public static final Lazy LITE_EXECUTOR = new Lazy(new Provider() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda1
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            ScheduledExecutorService lambda$static$1;
+            lambda$static$1 = ExecutorsRegistrar.lambda$static$1();
+            return lambda$static$1;
+        }
+    });
+    public static final Lazy BLOCKING_EXECUTOR = new Lazy(new Provider() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda2
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            ScheduledExecutorService lambda$static$2;
+            lambda$static$2 = ExecutorsRegistrar.lambda$static$2();
+            return lambda$static$2;
+        }
+    });
+    public static final Lazy SCHEDULER = new Lazy(new Provider() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda3
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            ScheduledExecutorService lambda$static$3;
+            lambda$static$3 = ExecutorsRegistrar.lambda$static$3();
+            return lambda$static$3;
+        }
+    });
+
+    public static /* synthetic */ ScheduledExecutorService lambda$static$0() {
+        return scheduled(Executors.newFixedThreadPool(4, factory("Firebase Background", 10, bgPolicy())));
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$static$1() {
+        return scheduled(Executors.newFixedThreadPool(Math.max(2, Runtime.getRuntime().availableProcessors()), factory("Firebase Lite", 0, litePolicy())));
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$static$2() {
+        return scheduled(Executors.newCachedThreadPool(factory("Firebase Blocking", 11)));
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$static$3() {
+        return Executors.newSingleThreadScheduledExecutor(factory("Firebase Scheduler", 0));
+    }
+
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List getComponents() {
+        return Arrays.asList(Component.builder(Qualified.qualified(Background.class, ScheduledExecutorService.class), Qualified.qualified(Background.class, ExecutorService.class), Qualified.qualified(Background.class, Executor.class)).factory(new ComponentFactory() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda4
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                ScheduledExecutorService lambda$getComponents$4;
+                lambda$getComponents$4 = ExecutorsRegistrar.lambda$getComponents$4(componentContainer);
+                return lambda$getComponents$4;
+            }
+        }).build(), Component.builder(Qualified.qualified(Blocking.class, ScheduledExecutorService.class), Qualified.qualified(Blocking.class, ExecutorService.class), Qualified.qualified(Blocking.class, Executor.class)).factory(new ComponentFactory() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda5
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                ScheduledExecutorService lambda$getComponents$5;
+                lambda$getComponents$5 = ExecutorsRegistrar.lambda$getComponents$5(componentContainer);
+                return lambda$getComponents$5;
+            }
+        }).build(), Component.builder(Qualified.qualified(Lightweight.class, ScheduledExecutorService.class), Qualified.qualified(Lightweight.class, ExecutorService.class), Qualified.qualified(Lightweight.class, Executor.class)).factory(new ComponentFactory() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda6
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                ScheduledExecutorService lambda$getComponents$6;
+                lambda$getComponents$6 = ExecutorsRegistrar.lambda$getComponents$6(componentContainer);
+                return lambda$getComponents$6;
+            }
+        }).build(), Component.builder(Qualified.qualified(UiThread.class, Executor.class)).factory(new ComponentFactory() { // from class: com.google.firebase.concurrent.ExecutorsRegistrar$$ExternalSyntheticLambda7
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                Executor lambda$getComponents$7;
+                lambda$getComponents$7 = ExecutorsRegistrar.lambda$getComponents$7(componentContainer);
+                return lambda$getComponents$7;
+            }
+        }).build());
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$getComponents$4(ComponentContainer componentContainer) {
+        return (ScheduledExecutorService) BG_EXECUTOR.get();
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$getComponents$5(ComponentContainer componentContainer) {
+        return (ScheduledExecutorService) BLOCKING_EXECUTOR.get();
+    }
+
+    public static /* synthetic */ ScheduledExecutorService lambda$getComponents$6(ComponentContainer componentContainer) {
+        return (ScheduledExecutorService) LITE_EXECUTOR.get();
+    }
+
+    public static /* synthetic */ Executor lambda$getComponents$7(ComponentContainer componentContainer) {
+        return UiExecutor.INSTANCE;
+    }
+
+    public static ScheduledExecutorService scheduled(ExecutorService executorService) {
+        return new DelegatingScheduledExecutorService(executorService, (ScheduledExecutorService) SCHEDULER.get());
+    }
+
+    public static ThreadFactory factory(String str, int i) {
+        return new CustomThreadFactory(str, i, null);
+    }
+
+    public static ThreadFactory factory(String str, int i, StrictMode.ThreadPolicy threadPolicy) {
+        return new CustomThreadFactory(str, i, threadPolicy);
+    }
+
+    public static StrictMode.ThreadPolicy bgPolicy() {
+        StrictMode.ThreadPolicy.Builder detectNetwork = new StrictMode.ThreadPolicy.Builder().detectNetwork();
+        detectNetwork.detectResourceMismatches();
+        detectNetwork.detectUnbufferedIo();
+        return detectNetwork.penaltyLog().build();
+    }
+
+    public static StrictMode.ThreadPolicy litePolicy() {
+        return new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().build();
+    }
+}

decompiled/sources/com/google/firebase/concurrent/FirebaseExecutors.java

@@ -0,0 +1,23 @@
+package com.google.firebase.concurrent;
+
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public abstract class FirebaseExecutors {
+    public static Executor newSequentialExecutor(Executor executor) {
+        return new SequentialExecutor(executor);
+    }
+
+    public static Executor directExecutor() {
+        return DirectExecutor.INSTANCE;
+    }
+
+    public enum DirectExecutor implements Executor {
+        INSTANCE;
+
+        @Override // java.util.concurrent.Executor
+        public void execute(Runnable runnable) {
+            runnable.run();
+        }
+    }
+}

decompiled/sources/com/google/firebase/concurrent/SequentialExecutor.java

@@ -0,0 +1,299 @@
+package com.google.firebase.concurrent;
+
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+/* loaded from: classes3.dex */
+public final class SequentialExecutor implements Executor {
+    public static final Logger log = Logger.getLogger(SequentialExecutor.class.getName());
+    public final Executor executor;
+    public final Deque queue = new ArrayDeque();
+    public WorkerRunningState workerRunningState = WorkerRunningState.IDLE;
+    public long workerRunCount = 0;
+    public final QueueWorker worker = new QueueWorker();
+
+    public enum WorkerRunningState {
+        IDLE,
+        QUEUING,
+        QUEUED,
+        RUNNING
+    }
+
+    public static /* synthetic */ long access$308(SequentialExecutor sequentialExecutor) {
+        long j = sequentialExecutor.workerRunCount;
+        sequentialExecutor.workerRunCount = 1 + j;
+        return j;
+    }
+
+    public SequentialExecutor(Executor executor) {
+        this.executor = (Executor) Preconditions.checkNotNull(executor);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:45:0x0066 A[ADDED_TO_REGION] */
+    @Override // java.util.concurrent.Executor
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void execute(final java.lang.Runnable r8) {
+        /*
+            r7 = this;
+            com.google.android.gms.common.internal.Preconditions.checkNotNull(r8)
+            java.util.Deque r0 = r7.queue
+            monitor-enter(r0)
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r1 = r7.workerRunningState     // Catch: java.lang.Throwable -> L6d
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r2 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.RUNNING     // Catch: java.lang.Throwable -> L6d
+            if (r1 == r2) goto L6f
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r2 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.QUEUED     // Catch: java.lang.Throwable -> L6d
+            if (r1 != r2) goto L11
+            goto L6f
+        L11:
+            long r3 = r7.workerRunCount     // Catch: java.lang.Throwable -> L6d
+            com.google.firebase.concurrent.SequentialExecutor$1 r1 = new com.google.firebase.concurrent.SequentialExecutor$1     // Catch: java.lang.Throwable -> L6d
+            r1.<init>()     // Catch: java.lang.Throwable -> L6d
+            java.util.Deque r8 = r7.queue     // Catch: java.lang.Throwable -> L6d
+            r8.add(r1)     // Catch: java.lang.Throwable -> L6d
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r8 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.QUEUING     // Catch: java.lang.Throwable -> L6d
+            r7.workerRunningState = r8     // Catch: java.lang.Throwable -> L6d
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L6d
+            java.util.concurrent.Executor r0 = r7.executor     // Catch: java.lang.Error -> L44 java.lang.RuntimeException -> L46
+            com.google.firebase.concurrent.SequentialExecutor$QueueWorker r5 = r7.worker     // Catch: java.lang.Error -> L44 java.lang.RuntimeException -> L46
+            r0.execute(r5)     // Catch: java.lang.Error -> L44 java.lang.RuntimeException -> L46
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r0 = r7.workerRunningState
+            if (r0 == r8) goto L2e
+            return
+        L2e:
+            java.util.Deque r0 = r7.queue
+            monitor-enter(r0)
+            long r5 = r7.workerRunCount     // Catch: java.lang.Throwable -> L3e
+            int r1 = (r5 > r3 ? 1 : (r5 == r3 ? 0 : -1))
+            if (r1 != 0) goto L40
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r1 = r7.workerRunningState     // Catch: java.lang.Throwable -> L3e
+            if (r1 != r8) goto L40
+            r7.workerRunningState = r2     // Catch: java.lang.Throwable -> L3e
+            goto L40
+        L3e:
+            r8 = move-exception
+            goto L42
+        L40:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L3e
+            return
+        L42:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L3e
+            throw r8
+        L44:
+            r8 = move-exception
+            goto L47
+        L46:
+            r8 = move-exception
+        L47:
+            java.util.Deque r2 = r7.queue
+            monitor-enter(r2)
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r0 = r7.workerRunningState     // Catch: java.lang.Throwable -> L55
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r3 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.IDLE     // Catch: java.lang.Throwable -> L55
+            if (r0 == r3) goto L57
+            com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r3 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.QUEUING     // Catch: java.lang.Throwable -> L55
+            if (r0 != r3) goto L61
+            goto L57
+        L55:
+            r8 = move-exception
+            goto L6b
+        L57:
+            java.util.Deque r0 = r7.queue     // Catch: java.lang.Throwable -> L55
+            boolean r0 = r0.removeLastOccurrence(r1)     // Catch: java.lang.Throwable -> L55
+            if (r0 == 0) goto L61
+            r0 = 1
+            goto L62
+        L61:
+            r0 = 0
+        L62:
+            boolean r1 = r8 instanceof java.util.concurrent.RejectedExecutionException     // Catch: java.lang.Throwable -> L55
+            if (r1 == 0) goto L6a
+            if (r0 != 0) goto L6a
+            monitor-exit(r2)     // Catch: java.lang.Throwable -> L55
+            return
+        L6a:
+            throw r8     // Catch: java.lang.Throwable -> L55
+        L6b:
+            monitor-exit(r2)     // Catch: java.lang.Throwable -> L55
+            throw r8
+        L6d:
+            r8 = move-exception
+            goto L76
+        L6f:
+            java.util.Deque r1 = r7.queue     // Catch: java.lang.Throwable -> L6d
+            r1.add(r8)     // Catch: java.lang.Throwable -> L6d
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L6d
+            return
+        L76:
+            monitor-exit(r0)     // Catch: java.lang.Throwable -> L6d
+            throw r8
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.concurrent.SequentialExecutor.execute(java.lang.Runnable):void");
+    }
+
+    public final class QueueWorker implements Runnable {
+        public Runnable task;
+
+        public QueueWorker() {
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                workOnQueue();
+            } catch (Error e) {
+                synchronized (SequentialExecutor.this.queue) {
+                    SequentialExecutor.this.workerRunningState = WorkerRunningState.IDLE;
+                    throw e;
+                }
+            }
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:10:0x0054, code lost:
+        
+            r1 = r1 | java.lang.Thread.interrupted();
+            r2 = null;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:12:0x0056, code lost:
+        
+            r8.task.run();
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:16:0x0060, code lost:
+        
+            r0 = move-exception;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:17:0x0080, code lost:
+        
+            r8.task = null;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:18:0x0082, code lost:
+        
+            throw r0;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:20:0x0062, code lost:
+        
+            r3 = move-exception;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:21:0x0063, code lost:
+        
+            com.google.firebase.concurrent.SequentialExecutor.log.log(java.util.logging.Level.SEVERE, "Exception while executing runnable " + r8.task, (java.lang.Throwable) r3);
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:28:0x004e, code lost:
+        
+            return;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:29:?, code lost:
+        
+            return;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final void workOnQueue() {
+            /*
+                r8 = this;
+                r0 = 0
+                r1 = r0
+            L2:
+                com.google.firebase.concurrent.SequentialExecutor r2 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L5e
+                java.util.Deque r2 = com.google.firebase.concurrent.SequentialExecutor.access$100(r2)     // Catch: java.lang.Throwable -> L5e
+                monitor-enter(r2)     // Catch: java.lang.Throwable -> L5e
+                if (r0 != 0) goto L2d
+                com.google.firebase.concurrent.SequentialExecutor r0 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r0 = com.google.firebase.concurrent.SequentialExecutor.access$200(r0)     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r3 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.RUNNING     // Catch: java.lang.Throwable -> L20
+                if (r0 != r3) goto L22
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L20
+                if (r1 == 0) goto L1f
+                java.lang.Thread r0 = java.lang.Thread.currentThread()
+                r0.interrupt()
+            L1f:
+                return
+            L20:
+                r0 = move-exception
+                goto L83
+            L22:
+                com.google.firebase.concurrent.SequentialExecutor r0 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor.access$308(r0)     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor r0 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor.access$202(r0, r3)     // Catch: java.lang.Throwable -> L20
+                r0 = 1
+            L2d:
+                com.google.firebase.concurrent.SequentialExecutor r3 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L20
+                java.util.Deque r3 = com.google.firebase.concurrent.SequentialExecutor.access$100(r3)     // Catch: java.lang.Throwable -> L20
+                java.lang.Object r3 = r3.poll()     // Catch: java.lang.Throwable -> L20
+                java.lang.Runnable r3 = (java.lang.Runnable) r3     // Catch: java.lang.Throwable -> L20
+                r8.task = r3     // Catch: java.lang.Throwable -> L20
+                if (r3 != 0) goto L4f
+                com.google.firebase.concurrent.SequentialExecutor r0 = com.google.firebase.concurrent.SequentialExecutor.this     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor$WorkerRunningState r3 = com.google.firebase.concurrent.SequentialExecutor.WorkerRunningState.IDLE     // Catch: java.lang.Throwable -> L20
+                com.google.firebase.concurrent.SequentialExecutor.access$202(r0, r3)     // Catch: java.lang.Throwable -> L20
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L20
+                if (r1 == 0) goto L4e
+                java.lang.Thread r0 = java.lang.Thread.currentThread()
+                r0.interrupt()
+            L4e:
+                return
+            L4f:
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L20
+                boolean r2 = java.lang.Thread.interrupted()     // Catch: java.lang.Throwable -> L5e
+                r1 = r1 | r2
+                r2 = 0
+                java.lang.Runnable r3 = r8.task     // Catch: java.lang.Throwable -> L60 java.lang.RuntimeException -> L62
+                r3.run()     // Catch: java.lang.Throwable -> L60 java.lang.RuntimeException -> L62
+            L5b:
+                r8.task = r2     // Catch: java.lang.Throwable -> L5e
+                goto L2
+            L5e:
+                r0 = move-exception
+                goto L85
+            L60:
+                r0 = move-exception
+                goto L80
+            L62:
+                r3 = move-exception
+                java.util.logging.Logger r4 = com.google.firebase.concurrent.SequentialExecutor.access$400()     // Catch: java.lang.Throwable -> L60
+                java.util.logging.Level r5 = java.util.logging.Level.SEVERE     // Catch: java.lang.Throwable -> L60
+                java.lang.StringBuilder r6 = new java.lang.StringBuilder     // Catch: java.lang.Throwable -> L60
+                r6.<init>()     // Catch: java.lang.Throwable -> L60
+                java.lang.String r7 = "Exception while executing runnable "
+                r6.append(r7)     // Catch: java.lang.Throwable -> L60
+                java.lang.Runnable r7 = r8.task     // Catch: java.lang.Throwable -> L60
+                r6.append(r7)     // Catch: java.lang.Throwable -> L60
+                java.lang.String r6 = r6.toString()     // Catch: java.lang.Throwable -> L60
+                r4.log(r5, r6, r3)     // Catch: java.lang.Throwable -> L60
+                goto L5b
+            L80:
+                r8.task = r2     // Catch: java.lang.Throwable -> L5e
+                throw r0     // Catch: java.lang.Throwable -> L5e
+            L83:
+                monitor-exit(r2)     // Catch: java.lang.Throwable -> L20
+                throw r0     // Catch: java.lang.Throwable -> L5e
+            L85:
+                if (r1 == 0) goto L8e
+                java.lang.Thread r1 = java.lang.Thread.currentThread()
+                r1.interrupt()
+            L8e:
+                throw r0
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.concurrent.SequentialExecutor.QueueWorker.workOnQueue():void");
+        }
+
+        public String toString() {
+            Runnable runnable = this.task;
+            if (runnable != null) {
+                return "SequentialExecutorWorker{running=" + runnable + "}";
+            }
+            return "SequentialExecutorWorker{state=" + SequentialExecutor.this.workerRunningState + "}";
+        }
+    }
+
+    public String toString() {
+        return "SequentialExecutor@" + System.identityHashCode(this) + "{" + this.executor + "}";
+    }
+}

decompiled/sources/com/google/firebase/concurrent/UiExecutor.java

@@ -0,0 +1,20 @@
+package com.google.firebase.concurrent;
+
+import android.annotation.SuppressLint;
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public enum UiExecutor implements Executor {
+    INSTANCE;
+
+
+    @SuppressLint({"ThreadPoolCreation"})
+    private static final Handler HANDLER = new Handler(Looper.getMainLooper());
+
+    @Override // java.util.concurrent.Executor
+    public void execute(Runnable runnable) {
+        HANDLER.post(runnable);
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/AnalyticsDeferredProxy.java

@@ -0,0 +1,123 @@
+package com.google.firebase.crashlytics;
+
+import android.os.Bundle;
+import com.google.android.gms.measurement.AppMeasurement;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.analytics.BlockingAnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.analytics.BreadcrumbAnalyticsEventReceiver;
+import com.google.firebase.crashlytics.internal.analytics.CrashlyticsOriginAnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.analytics.UnavailableAnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbHandler;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource;
+import com.google.firebase.crashlytics.internal.breadcrumbs.DisabledBreadcrumbSource;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class AnalyticsDeferredProxy {
+    public final Deferred analyticsConnectorDeferred;
+    public volatile AnalyticsEventLogger analyticsEventLogger;
+    public final List breadcrumbHandlerList;
+    public volatile BreadcrumbSource breadcrumbSource;
+
+    public AnalyticsDeferredProxy(Deferred deferred) {
+        this(deferred, new DisabledBreadcrumbSource(), new UnavailableAnalyticsEventLogger());
+    }
+
+    public AnalyticsDeferredProxy(Deferred deferred, BreadcrumbSource breadcrumbSource, AnalyticsEventLogger analyticsEventLogger) {
+        this.analyticsConnectorDeferred = deferred;
+        this.breadcrumbSource = breadcrumbSource;
+        this.breadcrumbHandlerList = new ArrayList();
+        this.analyticsEventLogger = analyticsEventLogger;
+        init();
+    }
+
+    public BreadcrumbSource getDeferredBreadcrumbSource() {
+        return new BreadcrumbSource() { // from class: com.google.firebase.crashlytics.AnalyticsDeferredProxy$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource
+            public final void registerBreadcrumbHandler(BreadcrumbHandler breadcrumbHandler) {
+                AnalyticsDeferredProxy.this.lambda$getDeferredBreadcrumbSource$0(breadcrumbHandler);
+            }
+        };
+    }
+
+    public final /* synthetic */ void lambda$getDeferredBreadcrumbSource$0(BreadcrumbHandler breadcrumbHandler) {
+        synchronized (this) {
+            try {
+                if (this.breadcrumbSource instanceof DisabledBreadcrumbSource) {
+                    this.breadcrumbHandlerList.add(breadcrumbHandler);
+                }
+                this.breadcrumbSource.registerBreadcrumbHandler(breadcrumbHandler);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public AnalyticsEventLogger getAnalyticsEventLogger() {
+        return new AnalyticsEventLogger() { // from class: com.google.firebase.crashlytics.AnalyticsDeferredProxy$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger
+            public final void logEvent(String str, Bundle bundle) {
+                AnalyticsDeferredProxy.this.lambda$getAnalyticsEventLogger$1(str, bundle);
+            }
+        };
+    }
+
+    public final /* synthetic */ void lambda$getAnalyticsEventLogger$1(String str, Bundle bundle) {
+        this.analyticsEventLogger.logEvent(str, bundle);
+    }
+
+    public final void init() {
+        this.analyticsConnectorDeferred.whenAvailable(new Deferred.DeferredHandler() { // from class: com.google.firebase.crashlytics.AnalyticsDeferredProxy$$ExternalSyntheticLambda2
+            @Override // com.google.firebase.inject.Deferred.DeferredHandler
+            public final void handle(Provider provider) {
+                AnalyticsDeferredProxy.this.lambda$init$2(provider);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$init$2(Provider provider) {
+        Logger.getLogger().d("AnalyticsConnector now available.");
+        AnalyticsConnector analyticsConnector = (AnalyticsConnector) provider.get();
+        CrashlyticsOriginAnalyticsEventLogger crashlyticsOriginAnalyticsEventLogger = new CrashlyticsOriginAnalyticsEventLogger(analyticsConnector);
+        CrashlyticsAnalyticsListener crashlyticsAnalyticsListener = new CrashlyticsAnalyticsListener();
+        if (subscribeToAnalyticsEvents(analyticsConnector, crashlyticsAnalyticsListener) != null) {
+            Logger.getLogger().d("Registered Firebase Analytics listener.");
+            BreadcrumbAnalyticsEventReceiver breadcrumbAnalyticsEventReceiver = new BreadcrumbAnalyticsEventReceiver();
+            BlockingAnalyticsEventLogger blockingAnalyticsEventLogger = new BlockingAnalyticsEventLogger(crashlyticsOriginAnalyticsEventLogger, 500, TimeUnit.MILLISECONDS);
+            synchronized (this) {
+                try {
+                    Iterator it = this.breadcrumbHandlerList.iterator();
+                    while (it.hasNext()) {
+                        breadcrumbAnalyticsEventReceiver.registerBreadcrumbHandler((BreadcrumbHandler) it.next());
+                    }
+                    crashlyticsAnalyticsListener.setBreadcrumbEventReceiver(breadcrumbAnalyticsEventReceiver);
+                    crashlyticsAnalyticsListener.setCrashlyticsOriginEventReceiver(blockingAnalyticsEventLogger);
+                    this.breadcrumbSource = breadcrumbAnalyticsEventReceiver;
+                    this.analyticsEventLogger = blockingAnalyticsEventLogger;
+                } finally {
+                }
+            }
+            return;
+        }
+        Logger.getLogger().w("Could not register Firebase Analytics listener; a listener is already registered.");
+    }
+
+    public static AnalyticsConnector.AnalyticsConnectorHandle subscribeToAnalyticsEvents(AnalyticsConnector analyticsConnector, CrashlyticsAnalyticsListener crashlyticsAnalyticsListener) {
+        AnalyticsConnector.AnalyticsConnectorHandle registerAnalyticsConnectorListener = analyticsConnector.registerAnalyticsConnectorListener("clx", crashlyticsAnalyticsListener);
+        if (registerAnalyticsConnectorListener == null) {
+            Logger.getLogger().d("Could not register AnalyticsConnectorListener with Crashlytics origin.");
+            registerAnalyticsConnectorListener = analyticsConnector.registerAnalyticsConnectorListener(AppMeasurement.CRASH_ORIGIN, crashlyticsAnalyticsListener);
+            if (registerAnalyticsConnectorListener != null) {
+                Logger.getLogger().w("A new version of the Google Analytics for Firebase SDK is now available. For improved performance and compatibility with Crashlytics, please update to the latest version.");
+            }
+        }
+        return registerAnalyticsConnectorListener;
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/CrashlyticsAnalyticsListener.java

@@ -0,0 +1,46 @@
+package com.google.firebase.crashlytics;
+
+import android.os.Bundle;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.analytics.AnalyticsEventReceiver;
+import java.util.Locale;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsAnalyticsListener implements AnalyticsConnector.AnalyticsConnectorListener {
+    public AnalyticsEventReceiver breadcrumbEventReceiver;
+    public AnalyticsEventReceiver crashlyticsOriginEventReceiver;
+
+    public void setBreadcrumbEventReceiver(AnalyticsEventReceiver analyticsEventReceiver) {
+        this.breadcrumbEventReceiver = analyticsEventReceiver;
+    }
+
+    public void setCrashlyticsOriginEventReceiver(AnalyticsEventReceiver analyticsEventReceiver) {
+        this.crashlyticsOriginEventReceiver = analyticsEventReceiver;
+    }
+
+    @Override // com.google.firebase.analytics.connector.AnalyticsConnector.AnalyticsConnectorListener
+    public void onMessageTriggered(int i, Bundle bundle) {
+        String string;
+        Logger.getLogger().v(String.format(Locale.US, "Analytics listener received message. ID: %d, Extras: %s", Integer.valueOf(i), bundle));
+        if (bundle == null || (string = bundle.getString("name")) == null) {
+            return;
+        }
+        Bundle bundle2 = bundle.getBundle("params");
+        if (bundle2 == null) {
+            bundle2 = new Bundle();
+        }
+        notifyEventReceivers(string, bundle2);
+    }
+
+    public final void notifyEventReceivers(String str, Bundle bundle) {
+        notifyEventReceiver("clx".equals(bundle.getString("_o")) ? this.crashlyticsOriginEventReceiver : this.breadcrumbEventReceiver, str, bundle);
+    }
+
+    public static void notifyEventReceiver(AnalyticsEventReceiver analyticsEventReceiver, String str, Bundle bundle) {
+        if (analyticsEventReceiver == null) {
+            return;
+        }
+        analyticsEventReceiver.onEvent(str, bundle);
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/CrashlyticsRegistrar.java

@@ -0,0 +1,40 @@
+package com.google.firebase.crashlytics;
+
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Dependency;
+import com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.platforminfo.LibraryVersionComponent;
+import com.google.firebase.remoteconfig.interop.FirebaseRemoteConfigInterop;
+import com.google.firebase.sessions.api.FirebaseSessionsDependencies;
+import com.google.firebase.sessions.api.SessionSubscriber;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsRegistrar implements ComponentRegistrar {
+    static {
+        FirebaseSessionsDependencies.addDependency(SessionSubscriber.Name.CRASHLYTICS);
+    }
+
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List getComponents() {
+        return Arrays.asList(Component.builder(FirebaseCrashlytics.class).name("fire-cls").add(Dependency.required(FirebaseApp.class)).add(Dependency.required(FirebaseInstallationsApi.class)).add(Dependency.deferred(CrashlyticsNativeComponent.class)).add(Dependency.deferred(AnalyticsConnector.class)).add(Dependency.deferred(FirebaseRemoteConfigInterop.class)).factory(new ComponentFactory() { // from class: com.google.firebase.crashlytics.CrashlyticsRegistrar$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                FirebaseCrashlytics buildCrashlytics;
+                buildCrashlytics = CrashlyticsRegistrar.this.buildCrashlytics(componentContainer);
+                return buildCrashlytics;
+            }
+        }).eagerInDefaultApp().build(), LibraryVersionComponent.create("fire-cls", "19.0.1"));
+    }
+
+    public final FirebaseCrashlytics buildCrashlytics(ComponentContainer componentContainer) {
+        return FirebaseCrashlytics.init((FirebaseApp) componentContainer.get(FirebaseApp.class), (FirebaseInstallationsApi) componentContainer.get(FirebaseInstallationsApi.class), componentContainer.getDeferred(CrashlyticsNativeComponent.class), componentContainer.getDeferred(AnalyticsConnector.class), componentContainer.getDeferred(FirebaseRemoteConfigInterop.class));
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/CustomKeysAndValues.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics;
+
+/* loaded from: classes3.dex */
+public abstract class CustomKeysAndValues {
+}

decompiled/sources/com/google/firebase/crashlytics/FirebaseCrashlytics.java

@@ -0,0 +1,171 @@
+package com.google.firebase.crashlytics;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.crashlytics.internal.CrashlyticsNativeComponentDeferredProxy;
+import com.google.firebase.crashlytics.internal.DevelopmentPlatformProvider;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.RemoteConfigDeferredProxy;
+import com.google.firebase.crashlytics.internal.common.AppData;
+import com.google.firebase.crashlytics.internal.common.BuildIdInfo;
+import com.google.firebase.crashlytics.internal.common.CommonUtils;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsAppQualitySessionsSubscriber;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsCore;
+import com.google.firebase.crashlytics.internal.common.DataCollectionArbiter;
+import com.google.firebase.crashlytics.internal.common.ExecutorUtils;
+import com.google.firebase.crashlytics.internal.common.IdManager;
+import com.google.firebase.crashlytics.internal.network.HttpRequestFactory;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import com.google.firebase.crashlytics.internal.settings.SettingsController;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.sessions.api.FirebaseSessionsDependencies;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes3.dex */
+public class FirebaseCrashlytics {
+    public final CrashlyticsCore core;
+
+    public static FirebaseCrashlytics init(FirebaseApp firebaseApp, FirebaseInstallationsApi firebaseInstallationsApi, Deferred deferred, Deferred deferred2, Deferred deferred3) {
+        Context applicationContext = firebaseApp.getApplicationContext();
+        String packageName = applicationContext.getPackageName();
+        Logger.getLogger().i("Initializing Firebase Crashlytics " + CrashlyticsCore.getVersion() + " for " + packageName);
+        FileStore fileStore = new FileStore(applicationContext);
+        DataCollectionArbiter dataCollectionArbiter = new DataCollectionArbiter(firebaseApp);
+        IdManager idManager = new IdManager(applicationContext, packageName, firebaseInstallationsApi, dataCollectionArbiter);
+        CrashlyticsNativeComponentDeferredProxy crashlyticsNativeComponentDeferredProxy = new CrashlyticsNativeComponentDeferredProxy(deferred);
+        AnalyticsDeferredProxy analyticsDeferredProxy = new AnalyticsDeferredProxy(deferred2);
+        ExecutorService buildSingleThreadExecutorService = ExecutorUtils.buildSingleThreadExecutorService("Crashlytics Exception Handler");
+        CrashlyticsAppQualitySessionsSubscriber crashlyticsAppQualitySessionsSubscriber = new CrashlyticsAppQualitySessionsSubscriber(dataCollectionArbiter, fileStore);
+        FirebaseSessionsDependencies.register(crashlyticsAppQualitySessionsSubscriber);
+        final CrashlyticsCore crashlyticsCore = new CrashlyticsCore(firebaseApp, idManager, crashlyticsNativeComponentDeferredProxy, dataCollectionArbiter, analyticsDeferredProxy.getDeferredBreadcrumbSource(), analyticsDeferredProxy.getAnalyticsEventLogger(), fileStore, buildSingleThreadExecutorService, crashlyticsAppQualitySessionsSubscriber, new RemoteConfigDeferredProxy(deferred3));
+        String applicationId = firebaseApp.getOptions().getApplicationId();
+        String mappingFileId = CommonUtils.getMappingFileId(applicationContext);
+        List<BuildIdInfo> buildIdInfo = CommonUtils.getBuildIdInfo(applicationContext);
+        Logger.getLogger().d("Mapping file ID is: " + mappingFileId);
+        for (BuildIdInfo buildIdInfo2 : buildIdInfo) {
+            Logger.getLogger().d(String.format("Build id for %s on %s: %s", buildIdInfo2.getLibraryName(), buildIdInfo2.getArch(), buildIdInfo2.getBuildId()));
+        }
+        try {
+            AppData create = AppData.create(applicationContext, idManager, applicationId, mappingFileId, buildIdInfo, new DevelopmentPlatformProvider(applicationContext));
+            Logger.getLogger().v("Installer package name is: " + create.installerPackageName);
+            ExecutorService buildSingleThreadExecutorService2 = ExecutorUtils.buildSingleThreadExecutorService("com.google.firebase.crashlytics.startup");
+            final SettingsController create2 = SettingsController.create(applicationContext, applicationId, idManager, new HttpRequestFactory(), create.versionCode, create.versionName, fileStore, dataCollectionArbiter);
+            create2.loadSettingsData(buildSingleThreadExecutorService2).continueWith(buildSingleThreadExecutorService2, new Continuation() { // from class: com.google.firebase.crashlytics.FirebaseCrashlytics.1
+                @Override // com.google.android.gms.tasks.Continuation
+                public Object then(Task task) {
+                    if (task.isSuccessful()) {
+                        return null;
+                    }
+                    Logger.getLogger().e("Error fetching settings.", task.getException());
+                    return null;
+                }
+            });
+            final boolean onPreExecute = crashlyticsCore.onPreExecute(create, create2);
+            Tasks.call(buildSingleThreadExecutorService2, new Callable() { // from class: com.google.firebase.crashlytics.FirebaseCrashlytics.2
+                @Override // java.util.concurrent.Callable
+                public Void call() {
+                    if (!onPreExecute) {
+                        return null;
+                    }
+                    crashlyticsCore.doBackgroundInitializationAsync(create2);
+                    return null;
+                }
+            });
+            return new FirebaseCrashlytics(crashlyticsCore);
+        } catch (PackageManager.NameNotFoundException e) {
+            Logger.getLogger().e("Error retrieving app package info.", e);
+            return null;
+        }
+    }
+
+    public FirebaseCrashlytics(CrashlyticsCore crashlyticsCore) {
+        this.core = crashlyticsCore;
+    }
+
+    @NonNull
+    public static FirebaseCrashlytics getInstance() {
+        FirebaseCrashlytics firebaseCrashlytics = (FirebaseCrashlytics) FirebaseApp.getInstance().get(FirebaseCrashlytics.class);
+        if (firebaseCrashlytics != null) {
+            return firebaseCrashlytics;
+        }
+        throw new NullPointerException("FirebaseCrashlytics component is not present.");
+    }
+
+    public void recordException(@NonNull Throwable th) {
+        if (th == null) {
+            Logger.getLogger().w("A null value was passed to recordException. Ignoring.");
+        } else {
+            this.core.logException(th);
+        }
+    }
+
+    public void log(@NonNull String str) {
+        this.core.log(str);
+    }
+
+    public void setUserId(@NonNull String str) {
+        this.core.setUserId(str);
+    }
+
+    public void setCustomKey(@NonNull String str, boolean z) {
+        this.core.setCustomKey(str, Boolean.toString(z));
+    }
+
+    public void setCustomKey(@NonNull String str, double d) {
+        this.core.setCustomKey(str, Double.toString(d));
+    }
+
+    public void setCustomKey(@NonNull String str, float f) {
+        this.core.setCustomKey(str, Float.toString(f));
+    }
+
+    public void setCustomKey(@NonNull String str, int i) {
+        this.core.setCustomKey(str, Integer.toString(i));
+    }
+
+    public void setCustomKey(@NonNull String str, long j) {
+        this.core.setCustomKey(str, Long.toString(j));
+    }
+
+    public void setCustomKey(@NonNull String str, @NonNull String str2) {
+        this.core.setCustomKey(str, str2);
+    }
+
+    public void setCustomKeys(@NonNull CustomKeysAndValues customKeysAndValues) {
+        throw null;
+    }
+
+    @NonNull
+    public Task<Boolean> checkForUnsentReports() {
+        return this.core.checkForUnsentReports();
+    }
+
+    public void sendUnsentReports() {
+        this.core.sendUnsentReports();
+    }
+
+    public void deleteUnsentReports() {
+        this.core.deleteUnsentReports();
+    }
+
+    public boolean didCrashOnPreviousExecution() {
+        return this.core.didCrashOnPreviousExecution();
+    }
+
+    public void setCrashlyticsCollectionEnabled(boolean z) {
+        this.core.setCrashlyticsCollectionEnabled(Boolean.valueOf(z));
+    }
+
+    public void setCrashlyticsCollectionEnabled(@Nullable Boolean bool) {
+        this.core.setCrashlyticsCollectionEnabled(bool);
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/FirebaseCrashlyticsKtxRegistrar.java

@@ -0,0 +1,28 @@
+package com.google.firebase.crashlytics;
+
+import androidx.annotation.Keep;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentRegistrar;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+@Keep
+/* loaded from: classes3.dex */
+public final class FirebaseCrashlyticsKtxRegistrar implements ComponentRegistrar {
+    public static final Companion Companion = new Companion(null);
+
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List<Component> getComponents() {
+        return CollectionsKt__CollectionsKt.emptyList();
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/R$raw.java

@@ -0,0 +1,6 @@
+package com.google.firebase.crashlytics;
+
+/* loaded from: classes3.dex */
+public final class R$raw {
+    public static int firebase_crashlytics_keep = 2131820549;
+}

decompiled/sources/com/google/firebase/crashlytics/internal/CrashlyticsNativeComponent.java

@@ -0,0 +1,14 @@
+package com.google.firebase.crashlytics.internal;
+
+import com.google.firebase.crashlytics.internal.model.StaticSessionData;
+
+/* loaded from: classes3.dex */
+public interface CrashlyticsNativeComponent {
+    NativeSessionFileProvider getSessionFileProvider(String str);
+
+    boolean hasCrashDataForCurrentSession();
+
+    boolean hasCrashDataForSession(String str);
+
+    void prepareNativeSession(String str, String str2, long j, StaticSessionData staticSessionData);
+}

decompiled/sources/com/google/firebase/crashlytics/internal/CrashlyticsNativeComponentDeferredProxy.java

@@ -0,0 +1,103 @@
+package com.google.firebase.crashlytics.internal;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import com.google.firebase.crashlytics.internal.model.StaticSessionData;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import java.io.File;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes3.dex */
+public final class CrashlyticsNativeComponentDeferredProxy implements CrashlyticsNativeComponent {
+    public static final NativeSessionFileProvider MISSING_NATIVE_SESSION_FILE_PROVIDER = new MissingNativeSessionFileProvider();
+    public final AtomicReference availableNativeComponent = new AtomicReference(null);
+    public final Deferred deferredNativeComponent;
+
+    public CrashlyticsNativeComponentDeferredProxy(Deferred deferred) {
+        this.deferredNativeComponent = deferred;
+        deferred.whenAvailable(new Deferred.DeferredHandler() { // from class: com.google.firebase.crashlytics.internal.CrashlyticsNativeComponentDeferredProxy$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.inject.Deferred.DeferredHandler
+            public final void handle(Provider provider) {
+                CrashlyticsNativeComponentDeferredProxy.this.lambda$new$0(provider);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$new$0(Provider provider) {
+        Logger.getLogger().d("Crashlytics native component now available.");
+        this.availableNativeComponent.set((CrashlyticsNativeComponent) provider.get());
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent
+    public boolean hasCrashDataForCurrentSession() {
+        CrashlyticsNativeComponent crashlyticsNativeComponent = (CrashlyticsNativeComponent) this.availableNativeComponent.get();
+        return crashlyticsNativeComponent != null && crashlyticsNativeComponent.hasCrashDataForCurrentSession();
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent
+    public boolean hasCrashDataForSession(String str) {
+        CrashlyticsNativeComponent crashlyticsNativeComponent = (CrashlyticsNativeComponent) this.availableNativeComponent.get();
+        return crashlyticsNativeComponent != null && crashlyticsNativeComponent.hasCrashDataForSession(str);
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent
+    public void prepareNativeSession(final String str, final String str2, final long j, final StaticSessionData staticSessionData) {
+        Logger.getLogger().v("Deferring native open session: " + str);
+        this.deferredNativeComponent.whenAvailable(new Deferred.DeferredHandler() { // from class: com.google.firebase.crashlytics.internal.CrashlyticsNativeComponentDeferredProxy$$ExternalSyntheticLambda1
+            @Override // com.google.firebase.inject.Deferred.DeferredHandler
+            public final void handle(Provider provider) {
+                CrashlyticsNativeComponentDeferredProxy.lambda$prepareNativeSession$1(str, str2, j, staticSessionData, provider);
+            }
+        });
+    }
+
+    public static /* synthetic */ void lambda$prepareNativeSession$1(String str, String str2, long j, StaticSessionData staticSessionData, Provider provider) {
+        ((CrashlyticsNativeComponent) provider.get()).prepareNativeSession(str, str2, j, staticSessionData);
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent
+    public NativeSessionFileProvider getSessionFileProvider(String str) {
+        CrashlyticsNativeComponent crashlyticsNativeComponent = (CrashlyticsNativeComponent) this.availableNativeComponent.get();
+        return crashlyticsNativeComponent == null ? MISSING_NATIVE_SESSION_FILE_PROVIDER : crashlyticsNativeComponent.getSessionFileProvider(str);
+    }
+
+    public static final class MissingNativeSessionFileProvider implements NativeSessionFileProvider {
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getAppFile() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public CrashlyticsReport.ApplicationExitInfo getApplicationExitInto() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getDeviceFile() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getMetadataFile() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getMinidumpFile() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getOsFile() {
+            return null;
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.NativeSessionFileProvider
+        public File getSessionFile() {
+            return null;
+        }
+
+        public MissingNativeSessionFileProvider() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/CrashlyticsRemoteConfigListener.java

@@ -0,0 +1,34 @@
+package com.google.firebase.crashlytics.internal;
+
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.remoteconfig.interop.rollouts.RolloutAssignment;
+import com.google.firebase.remoteconfig.interop.rollouts.RolloutsState;
+import com.google.firebase.remoteconfig.interop.rollouts.RolloutsStateSubscriber;
+import java.util.ArrayList;
+import java.util.Set;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class CrashlyticsRemoteConfigListener implements RolloutsStateSubscriber {
+    public final UserMetadata userMetadata;
+
+    public CrashlyticsRemoteConfigListener(UserMetadata userMetadata) {
+        Intrinsics.checkNotNullParameter(userMetadata, "userMetadata");
+        this.userMetadata = userMetadata;
+    }
+
+    @Override // com.google.firebase.remoteconfig.interop.rollouts.RolloutsStateSubscriber
+    public void onRolloutsStateChanged(RolloutsState rolloutsState) {
+        Intrinsics.checkNotNullParameter(rolloutsState, "rolloutsState");
+        UserMetadata userMetadata = this.userMetadata;
+        Set<RolloutAssignment> rolloutAssignments = rolloutsState.getRolloutAssignments();
+        Intrinsics.checkNotNullExpressionValue(rolloutAssignments, "rolloutsState.rolloutAssignments");
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(rolloutAssignments, 10));
+        for (RolloutAssignment rolloutAssignment : rolloutAssignments) {
+            arrayList.add(com.google.firebase.crashlytics.internal.metadata.RolloutAssignment.create(rolloutAssignment.getRolloutId(), rolloutAssignment.getParameterKey(), rolloutAssignment.getParameterValue(), rolloutAssignment.getVariantId(), rolloutAssignment.getTemplateVersion()));
+        }
+        userMetadata.updateRolloutsState(arrayList);
+        Logger.getLogger().d("Updated Crashlytics Rollout State");
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/DevelopmentPlatformProvider.java

@@ -0,0 +1,75 @@
+package com.google.firebase.crashlytics.internal;
+
+import android.content.Context;
+import com.google.firebase.crashlytics.internal.common.CommonUtils;
+import java.io.IOException;
+import java.io.InputStream;
+
+/* loaded from: classes3.dex */
+public class DevelopmentPlatformProvider {
+    public final Context context;
+    public DevelopmentPlatform developmentPlatform = null;
+
+    public DevelopmentPlatformProvider(Context context) {
+        this.context = context;
+    }
+
+    public String getDevelopmentPlatform() {
+        return initDevelopmentPlatform().developmentPlatform;
+    }
+
+    public String getDevelopmentPlatformVersion() {
+        return initDevelopmentPlatform().developmentPlatformVersion;
+    }
+
+    public static boolean isUnity(Context context) {
+        return CommonUtils.getResourcesIdentifier(context, "com.google.firebase.crashlytics.unity_version", "string") != 0;
+    }
+
+    public final boolean assetFileExists(String str) {
+        if (this.context.getAssets() == null) {
+            return false;
+        }
+        try {
+            InputStream open = this.context.getAssets().open(str);
+            if (open == null) {
+                return true;
+            }
+            open.close();
+            return true;
+        } catch (IOException unused) {
+            return false;
+        }
+    }
+
+    public final DevelopmentPlatform initDevelopmentPlatform() {
+        if (this.developmentPlatform == null) {
+            this.developmentPlatform = new DevelopmentPlatform();
+        }
+        return this.developmentPlatform;
+    }
+
+    public class DevelopmentPlatform {
+        public final String developmentPlatform;
+        public final String developmentPlatformVersion;
+
+        public DevelopmentPlatform() {
+            int resourcesIdentifier = CommonUtils.getResourcesIdentifier(DevelopmentPlatformProvider.this.context, "com.google.firebase.crashlytics.unity_version", "string");
+            if (resourcesIdentifier != 0) {
+                this.developmentPlatform = "Unity";
+                String string = DevelopmentPlatformProvider.this.context.getResources().getString(resourcesIdentifier);
+                this.developmentPlatformVersion = string;
+                Logger.getLogger().v("Unity Editor version is: " + string);
+                return;
+            }
+            if (!DevelopmentPlatformProvider.this.assetFileExists("flutter_assets/NOTICES.Z")) {
+                this.developmentPlatform = null;
+                this.developmentPlatformVersion = null;
+            } else {
+                this.developmentPlatform = "Flutter";
+                this.developmentPlatformVersion = null;
+                Logger.getLogger().v("Development platform is: Flutter");
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/Logger.java

@@ -0,0 +1,66 @@
+package com.google.firebase.crashlytics.internal;
+
+import android.util.Log;
+
+/* loaded from: classes3.dex */
+public class Logger {
+    public static final Logger DEFAULT_LOGGER = new Logger("FirebaseCrashlytics");
+    public int logLevel = 4;
+    public final String tag;
+
+    public static Logger getLogger() {
+        return DEFAULT_LOGGER;
+    }
+
+    public Logger(String str) {
+        this.tag = str;
+    }
+
+    public final boolean canLog(int i) {
+        return this.logLevel <= i || Log.isLoggable(this.tag, i);
+    }
+
+    public void d(String str, Throwable th) {
+        canLog(3);
+    }
+
+    public void v(String str, Throwable th) {
+        canLog(2);
+    }
+
+    public void i(String str, Throwable th) {
+        canLog(4);
+    }
+
+    public void w(String str, Throwable th) {
+        if (canLog(5)) {
+            Log.w(this.tag, str, th);
+        }
+    }
+
+    public void e(String str, Throwable th) {
+        if (canLog(6)) {
+            Log.e(this.tag, str, th);
+        }
+    }
+
+    public void d(String str) {
+        d(str, null);
+    }
+
+    public void v(String str) {
+        v(str, null);
+    }
+
+    public void i(String str) {
+        i(str, null);
+    }
+
+    public void w(String str) {
+        w(str, null);
+    }
+
+    public void e(String str) {
+        e(str, null);
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/NativeSessionFileProvider.java

@@ -0,0 +1,21 @@
+package com.google.firebase.crashlytics.internal;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+
+/* loaded from: classes3.dex */
+public interface NativeSessionFileProvider {
+    File getAppFile();
+
+    CrashlyticsReport.ApplicationExitInfo getApplicationExitInto();
+
+    File getDeviceFile();
+
+    File getMetadataFile();
+
+    File getMinidumpFile();
+
+    File getOsFile();
+
+    File getSessionFile();
+}

decompiled/sources/com/google/firebase/crashlytics/internal/ProcessDetailsProvider$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class ProcessDetailsProvider$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/ProcessDetailsProvider.java

@@ -0,0 +1,119 @@
+package com.google.firebase.crashlytics.internal;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.os.Process;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class ProcessDetailsProvider {
+    public static final ProcessDetailsProvider INSTANCE = new ProcessDetailsProvider();
+
+    public final CrashlyticsReport.Session.Event.Application.ProcessDetails buildProcessDetails(String processName, int i, int i2) {
+        Intrinsics.checkNotNullParameter(processName, "processName");
+        return buildProcessDetails$default(this, processName, i, i2, false, 8, null);
+    }
+
+    public final List getAppProcessDetails(Context context) {
+        List filterNotNull;
+        Intrinsics.checkNotNullParameter(context, "context");
+        int i = context.getApplicationInfo().uid;
+        String str = context.getApplicationInfo().processName;
+        Object systemService = context.getSystemService("activity");
+        ActivityManager activityManager = systemService instanceof ActivityManager ? (ActivityManager) systemService : null;
+        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = activityManager != null ? activityManager.getRunningAppProcesses() : null;
+        if (runningAppProcesses == null) {
+            runningAppProcesses = CollectionsKt__CollectionsKt.emptyList();
+        }
+        filterNotNull = CollectionsKt___CollectionsKt.filterNotNull(runningAppProcesses);
+        ArrayList<ActivityManager.RunningAppProcessInfo> arrayList = new ArrayList();
+        for (Object obj : filterNotNull) {
+            if (((ActivityManager.RunningAppProcessInfo) obj).uid == i) {
+                arrayList.add(obj);
+            }
+        }
+        ArrayList arrayList2 = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(arrayList, 10));
+        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : arrayList) {
+            arrayList2.add(CrashlyticsReport.Session.Event.Application.ProcessDetails.builder().setProcessName(runningAppProcessInfo.processName).setPid(runningAppProcessInfo.pid).setImportance(runningAppProcessInfo.importance).setDefaultProcess(Intrinsics.areEqual(runningAppProcessInfo.processName, str)).build());
+        }
+        return arrayList2;
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.ProcessDetails getCurrentProcessDetails(Context context) {
+        Object obj;
+        Intrinsics.checkNotNullParameter(context, "context");
+        int myPid = Process.myPid();
+        Iterator it = getAppProcessDetails(context).iterator();
+        while (true) {
+            if (!it.hasNext()) {
+                obj = null;
+                break;
+            }
+            obj = it.next();
+            if (((CrashlyticsReport.Session.Event.Application.ProcessDetails) obj).getPid() == myPid) {
+                break;
+            }
+        }
+        CrashlyticsReport.Session.Event.Application.ProcessDetails processDetails = (CrashlyticsReport.Session.Event.Application.ProcessDetails) obj;
+        return processDetails == null ? buildProcessDetails$default(this, getProcessName(), myPid, 0, false, 12, null) : processDetails;
+    }
+
+    public static /* synthetic */ CrashlyticsReport.Session.Event.Application.ProcessDetails buildProcessDetails$default(ProcessDetailsProvider processDetailsProvider, String str, int i, int i2, boolean z, int i3, Object obj) {
+        if ((i3 & 2) != 0) {
+            i = 0;
+        }
+        if ((i3 & 4) != 0) {
+            i2 = 0;
+        }
+        if ((i3 & 8) != 0) {
+            z = false;
+        }
+        return processDetailsProvider.buildProcessDetails(str, i, i2, z);
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.ProcessDetails buildProcessDetails(String processName, int i, int i2, boolean z) {
+        Intrinsics.checkNotNullParameter(processName, "processName");
+        CrashlyticsReport.Session.Event.Application.ProcessDetails build = CrashlyticsReport.Session.Event.Application.ProcessDetails.builder().setProcessName(processName).setPid(i).setImportance(i2).setDefaultProcess(z).build();
+        Intrinsics.checkNotNullExpressionValue(build, "builder()\n      .setProc…ltProcess)\n      .build()");
+        return build;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:8:0x0016, code lost:
+    
+        r0 = android.app.Application.getProcessName();
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.String getProcessName() {
+        /*
+            r3 = this;
+            int r0 = android.os.Build.VERSION.SDK_INT
+            r1 = 33
+            if (r0 < r1) goto L10
+            java.lang.String r0 = com.google.firebase.crashlytics.internal.ProcessDetailsProvider$$ExternalSyntheticApiModelOutline0.m()
+            java.lang.String r1 = "{\n      Process.myProcessName()\n    }"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r0, r1)
+            goto L1d
+        L10:
+            r1 = 28
+            java.lang.String r2 = ""
+            if (r0 < r1) goto L1c
+            java.lang.String r0 = com.google.android.gms.common.util.ProcessUtils$$ExternalSyntheticApiModelOutline0.m()
+            if (r0 != 0) goto L1d
+        L1c:
+            r0 = r2
+        L1d:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.crashlytics.internal.ProcessDetailsProvider.getProcessName():java.lang.String");
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/RemoteConfigDeferredProxy.java

@@ -0,0 +1,34 @@
+package com.google.firebase.crashlytics.internal;
+
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.inject.Deferred;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.remoteconfig.interop.FirebaseRemoteConfigInterop;
+
+/* loaded from: classes3.dex */
+public class RemoteConfigDeferredProxy {
+    public final Deferred remoteConfigInteropDeferred;
+
+    public RemoteConfigDeferredProxy(Deferred deferred) {
+        this.remoteConfigInteropDeferred = deferred;
+    }
+
+    public void setupListener(UserMetadata userMetadata) {
+        if (userMetadata == null) {
+            Logger.getLogger().w("Didn't successfully register with UserMetadata for rollouts listener");
+        } else {
+            final CrashlyticsRemoteConfigListener crashlyticsRemoteConfigListener = new CrashlyticsRemoteConfigListener(userMetadata);
+            this.remoteConfigInteropDeferred.whenAvailable(new Deferred.DeferredHandler() { // from class: com.google.firebase.crashlytics.internal.RemoteConfigDeferredProxy$$ExternalSyntheticLambda0
+                @Override // com.google.firebase.inject.Deferred.DeferredHandler
+                public final void handle(Provider provider) {
+                    RemoteConfigDeferredProxy.lambda$setupListener$0(CrashlyticsRemoteConfigListener.this, provider);
+                }
+            });
+        }
+    }
+
+    public static /* synthetic */ void lambda$setupListener$0(CrashlyticsRemoteConfigListener crashlyticsRemoteConfigListener, Provider provider) {
+        ((FirebaseRemoteConfigInterop) provider.get()).registerRolloutsStateSubscriber("firebase", crashlyticsRemoteConfigListener);
+        Logger.getLogger().d("Registering RemoteConfig Rollouts subscriber");
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/AnalyticsEventLogger.java

@@ -0,0 +1,8 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+
+/* loaded from: classes3.dex */
+public interface AnalyticsEventLogger {
+    void logEvent(String str, Bundle bundle);
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/AnalyticsEventReceiver.java

@@ -0,0 +1,8 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+
+/* loaded from: classes3.dex */
+public interface AnalyticsEventReceiver {
+    void onEvent(String str, Bundle bundle);
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/BlockingAnalyticsEventLogger.java

@@ -0,0 +1,56 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+import com.google.firebase.crashlytics.internal.Logger;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class BlockingAnalyticsEventLogger implements AnalyticsEventReceiver, AnalyticsEventLogger {
+    public final CrashlyticsOriginAnalyticsEventLogger baseAnalyticsEventLogger;
+    public CountDownLatch eventLatch;
+    public final TimeUnit timeUnit;
+    public final int timeout;
+    public final Object latchLock = new Object();
+    public boolean callbackReceived = false;
+
+    public BlockingAnalyticsEventLogger(CrashlyticsOriginAnalyticsEventLogger crashlyticsOriginAnalyticsEventLogger, int i, TimeUnit timeUnit) {
+        this.baseAnalyticsEventLogger = crashlyticsOriginAnalyticsEventLogger;
+        this.timeout = i;
+        this.timeUnit = timeUnit;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger
+    public void logEvent(String str, Bundle bundle) {
+        synchronized (this.latchLock) {
+            try {
+                Logger.getLogger().v("Logging event " + str + " to Firebase Analytics with params " + bundle);
+                this.eventLatch = new CountDownLatch(1);
+                this.callbackReceived = false;
+                this.baseAnalyticsEventLogger.logEvent(str, bundle);
+                Logger.getLogger().v("Awaiting app exception callback from Analytics...");
+                try {
+                    if (this.eventLatch.await(this.timeout, this.timeUnit)) {
+                        this.callbackReceived = true;
+                        Logger.getLogger().v("App exception callback received from Analytics listener.");
+                    } else {
+                        Logger.getLogger().w("Timeout exceeded while awaiting app exception callback from Analytics listener.");
+                    }
+                } catch (InterruptedException unused) {
+                    Logger.getLogger().e("Interrupted while awaiting app exception callback from Analytics listener.");
+                }
+                this.eventLatch = null;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventReceiver
+    public void onEvent(String str, Bundle bundle) {
+        CountDownLatch countDownLatch = this.eventLatch;
+        if (countDownLatch != null && "_ae".equals(str)) {
+            countDownLatch.countDown();
+        }
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/BreadcrumbAnalyticsEventReceiver.java

@@ -0,0 +1,42 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbHandler;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public class BreadcrumbAnalyticsEventReceiver implements AnalyticsEventReceiver, BreadcrumbSource {
+    public BreadcrumbHandler breadcrumbHandler;
+
+    @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventReceiver
+    public void onEvent(String str, Bundle bundle) {
+        BreadcrumbHandler breadcrumbHandler = this.breadcrumbHandler;
+        if (breadcrumbHandler != null) {
+            try {
+                breadcrumbHandler.handleBreadcrumb("$A$:" + serializeEvent(str, bundle));
+            } catch (JSONException unused) {
+                Logger.getLogger().w("Unable to serialize Firebase Analytics event to breadcrumb.");
+            }
+        }
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource
+    public void registerBreadcrumbHandler(BreadcrumbHandler breadcrumbHandler) {
+        this.breadcrumbHandler = breadcrumbHandler;
+        Logger.getLogger().d("Registered Firebase Analytics event receiver for breadcrumbs");
+    }
+
+    public static String serializeEvent(String str, Bundle bundle) {
+        JSONObject jSONObject = new JSONObject();
+        JSONObject jSONObject2 = new JSONObject();
+        for (String str2 : bundle.keySet()) {
+            jSONObject2.put(str2, bundle.get(str2));
+        }
+        jSONObject.put("name", str);
+        jSONObject.put("parameters", jSONObject2);
+        return jSONObject.toString();
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/CrashlyticsOriginAnalyticsEventLogger.java

@@ -0,0 +1,18 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsOriginAnalyticsEventLogger implements AnalyticsEventLogger {
+    public final AnalyticsConnector analyticsConnector;
+
+    public CrashlyticsOriginAnalyticsEventLogger(AnalyticsConnector analyticsConnector) {
+        this.analyticsConnector = analyticsConnector;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger
+    public void logEvent(String str, Bundle bundle) {
+        this.analyticsConnector.logEvent("clx", str, bundle);
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/analytics/UnavailableAnalyticsEventLogger.java

@@ -0,0 +1,12 @@
+package com.google.firebase.crashlytics.internal.analytics;
+
+import android.os.Bundle;
+import com.google.firebase.crashlytics.internal.Logger;
+
+/* loaded from: classes3.dex */
+public class UnavailableAnalyticsEventLogger implements AnalyticsEventLogger {
+    @Override // com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger
+    public void logEvent(String str, Bundle bundle) {
+        Logger.getLogger().d("Skipping logging Crashlytics event to Firebase, no Firebase Analytics");
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/breadcrumbs/BreadcrumbHandler.java

@@ -0,0 +1,6 @@
+package com.google.firebase.crashlytics.internal.breadcrumbs;
+
+/* loaded from: classes3.dex */
+public interface BreadcrumbHandler {
+    void handleBreadcrumb(String str);
+}

decompiled/sources/com/google/firebase/crashlytics/internal/breadcrumbs/BreadcrumbSource.java

@@ -0,0 +1,6 @@
+package com.google.firebase.crashlytics.internal.breadcrumbs;
+
+/* loaded from: classes3.dex */
+public interface BreadcrumbSource {
+    void registerBreadcrumbHandler(BreadcrumbHandler breadcrumbHandler);
+}

decompiled/sources/com/google/firebase/crashlytics/internal/breadcrumbs/DisabledBreadcrumbSource.java

@@ -0,0 +1,11 @@
+package com.google.firebase.crashlytics.internal.breadcrumbs;
+
+import com.google.firebase.crashlytics.internal.Logger;
+
+/* loaded from: classes3.dex */
+public class DisabledBreadcrumbSource implements BreadcrumbSource {
+    @Override // com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource
+    public void registerBreadcrumbHandler(BreadcrumbHandler breadcrumbHandler) {
+        Logger.getLogger().d("Could not register handler for breadcrumbs events.");
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/AppData.java

@@ -0,0 +1,51 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.os.Build;
+import com.google.firebase.crashlytics.internal.DevelopmentPlatformProvider;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class AppData {
+    public final String buildId;
+    public final List buildIdInfoList;
+    public final DevelopmentPlatformProvider developmentPlatformProvider;
+    public final String googleAppId;
+    public final String installerPackageName;
+    public final String packageName;
+    public final String versionCode;
+    public final String versionName;
+
+    public static AppData create(Context context, IdManager idManager, String str, String str2, List list, DevelopmentPlatformProvider developmentPlatformProvider) {
+        String packageName = context.getPackageName();
+        String installerPackageName = idManager.getInstallerPackageName();
+        PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
+        String appBuildVersion = getAppBuildVersion(packageInfo);
+        String str3 = packageInfo.versionName;
+        if (str3 == null) {
+            str3 = "0.0";
+        }
+        return new AppData(str, str2, list, installerPackageName, packageName, appBuildVersion, str3, developmentPlatformProvider);
+    }
+
+    public static String getAppBuildVersion(PackageInfo packageInfo) {
+        long longVersionCode;
+        if (Build.VERSION.SDK_INT >= 28) {
+            longVersionCode = packageInfo.getLongVersionCode();
+            return Long.toString(longVersionCode);
+        }
+        return Integer.toString(packageInfo.versionCode);
+    }
+
+    public AppData(String str, String str2, List list, String str3, String str4, String str5, String str6, DevelopmentPlatformProvider developmentPlatformProvider) {
+        this.googleAppId = str;
+        this.buildId = str2;
+        this.buildIdInfoList = list;
+        this.installerPackageName = str3;
+        this.packageName = str4;
+        this.versionCode = str5;
+        this.versionName = str6;
+        this.developmentPlatformProvider = developmentPlatformProvider;
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/AutoValue_CrashlyticsReportWithSessionId.java

@@ -0,0 +1,60 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+
+/* loaded from: classes3.dex */
+public final class AutoValue_CrashlyticsReportWithSessionId extends CrashlyticsReportWithSessionId {
+    public final CrashlyticsReport report;
+    public final File reportFile;
+    public final String sessionId;
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public CrashlyticsReport getReport() {
+        return this.report;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public File getReportFile() {
+        return this.reportFile;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public String getSessionId() {
+        return this.sessionId;
+    }
+
+    public AutoValue_CrashlyticsReportWithSessionId(CrashlyticsReport crashlyticsReport, String str, File file) {
+        if (crashlyticsReport == null) {
+            throw new NullPointerException("Null report");
+        }
+        this.report = crashlyticsReport;
+        if (str == null) {
+            throw new NullPointerException("Null sessionId");
+        }
+        this.sessionId = str;
+        if (file == null) {
+            throw new NullPointerException("Null reportFile");
+        }
+        this.reportFile = file;
+    }
+
+    public String toString() {
+        return "CrashlyticsReportWithSessionId{report=" + this.report + ", sessionId=" + this.sessionId + ", reportFile=" + this.reportFile + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof CrashlyticsReportWithSessionId)) {
+            return false;
+        }
+        CrashlyticsReportWithSessionId crashlyticsReportWithSessionId = (CrashlyticsReportWithSessionId) obj;
+        return this.report.equals(crashlyticsReportWithSessionId.getReport()) && this.sessionId.equals(crashlyticsReportWithSessionId.getSessionId()) && this.reportFile.equals(crashlyticsReportWithSessionId.getReportFile());
+    }
+
+    public int hashCode() {
+        return ((((this.report.hashCode() ^ 1000003) * 1000003) ^ this.sessionId.hashCode()) * 1000003) ^ this.reportFile.hashCode();
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/AutoValue_InstallIdProvider_InstallIds.java

@@ -0,0 +1,68 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.common.InstallIdProvider;
+
+/* loaded from: classes3.dex */
+public final class AutoValue_InstallIdProvider_InstallIds extends InstallIdProvider.InstallIds {
+    public final String crashlyticsInstallId;
+    public final String firebaseAuthenticationToken;
+    public final String firebaseInstallationId;
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getCrashlyticsInstallId() {
+        return this.crashlyticsInstallId;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getFirebaseAuthenticationToken() {
+        return this.firebaseAuthenticationToken;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getFirebaseInstallationId() {
+        return this.firebaseInstallationId;
+    }
+
+    public AutoValue_InstallIdProvider_InstallIds(String str, String str2, String str3) {
+        if (str == null) {
+            throw new NullPointerException("Null crashlyticsInstallId");
+        }
+        this.crashlyticsInstallId = str;
+        this.firebaseInstallationId = str2;
+        this.firebaseAuthenticationToken = str3;
+    }
+
+    public String toString() {
+        return "InstallIds{crashlyticsInstallId=" + this.crashlyticsInstallId + ", firebaseInstallationId=" + this.firebaseInstallationId + ", firebaseAuthenticationToken=" + this.firebaseAuthenticationToken + "}";
+    }
+
+    public boolean equals(Object obj) {
+        String str;
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof InstallIdProvider.InstallIds)) {
+            return false;
+        }
+        InstallIdProvider.InstallIds installIds = (InstallIdProvider.InstallIds) obj;
+        if (this.crashlyticsInstallId.equals(installIds.getCrashlyticsInstallId()) && ((str = this.firebaseInstallationId) != null ? str.equals(installIds.getFirebaseInstallationId()) : installIds.getFirebaseInstallationId() == null)) {
+            String str2 = this.firebaseAuthenticationToken;
+            if (str2 == null) {
+                if (installIds.getFirebaseAuthenticationToken() == null) {
+                    return true;
+                }
+            } else if (str2.equals(installIds.getFirebaseAuthenticationToken())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        int hashCode = (this.crashlyticsInstallId.hashCode() ^ 1000003) * 1000003;
+        String str = this.firebaseInstallationId;
+        int hashCode2 = (hashCode ^ (str == null ? 0 : str.hashCode())) * 1000003;
+        String str2 = this.firebaseAuthenticationToken;
+        return hashCode2 ^ (str2 != null ? str2.hashCode() : 0);
+    }
+}