Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/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;
+                }
+            }
+        }
+    }
+}