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/messaging/FirebaseMessaging.java

@@ -0,0 +1,413 @@
+package com.google.firebase.messaging;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.Keep;
+import androidx.annotation.NonNull;
+import com.google.android.datatransport.TransportFactory;
+import com.google.android.gms.cloudmessaging.CloudMessage;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.SuccessContinuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.DataCollectionDefaultChange;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.events.Event;
+import com.google.firebase.events.EventHandler;
+import com.google.firebase.events.Subscriber;
+import com.google.firebase.iid.internal.FirebaseInstanceIdInternal;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.messaging.FirebaseMessaging;
+import com.google.firebase.messaging.RequestDeduplicator;
+import com.google.firebase.messaging.Store;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class FirebaseMessaging {
+    public static Store store;
+    public static ScheduledExecutorService syncExecutor;
+    public final AutoInit autoInit;
+    public final Context context;
+    public final Executor fileExecutor;
+    public final FirebaseApp firebaseApp;
+    public final GmsRpc gmsRpc;
+    public final Executor initExecutor;
+    public final Application.ActivityLifecycleCallbacks lifecycleCallbacks;
+    public final Metadata metadata;
+    public final RequestDeduplicator requestDeduplicator;
+    public boolean syncScheduledOrRunning;
+    public final Task topicsSubscriberTask;
+    public static final long MAX_DELAY_SEC = TimeUnit.HOURS.toSeconds(8);
+    public static Provider transportFactory = new Provider() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda0
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            TransportFactory lambda$static$0;
+            lambda$static$0 = FirebaseMessaging.lambda$static$0();
+            return lambda$static$0;
+        }
+    };
+
+    public static /* synthetic */ TransportFactory lambda$static$0() {
+        return null;
+    }
+
+    public Context getApplicationContext() {
+        return this.context;
+    }
+
+    public static synchronized FirebaseMessaging getInstance() {
+        FirebaseMessaging firebaseMessaging;
+        synchronized (FirebaseMessaging.class) {
+            firebaseMessaging = getInstance(FirebaseApp.getInstance());
+        }
+        return firebaseMessaging;
+    }
+
+    public static synchronized Store getStore(Context context) {
+        Store store2;
+        synchronized (FirebaseMessaging.class) {
+            try {
+                if (store == null) {
+                    store = new Store(context);
+                }
+                store2 = store;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return store2;
+    }
+
+    @NonNull
+    @Keep
+    public static synchronized FirebaseMessaging getInstance(@NonNull FirebaseApp firebaseApp) {
+        FirebaseMessaging firebaseMessaging;
+        synchronized (FirebaseMessaging.class) {
+            firebaseMessaging = (FirebaseMessaging) firebaseApp.get(FirebaseMessaging.class);
+            Preconditions.checkNotNull(firebaseMessaging, "Firebase Messaging component is not present");
+        }
+        return firebaseMessaging;
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi, Provider provider3, Subscriber subscriber) {
+        this(firebaseApp, firebaseInstanceIdInternal, provider, provider2, firebaseInstallationsApi, provider3, subscriber, new Metadata(firebaseApp.getApplicationContext()));
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi, Provider provider3, Subscriber subscriber, Metadata metadata) {
+        this(firebaseApp, firebaseInstanceIdInternal, provider3, subscriber, metadata, new GmsRpc(firebaseApp, metadata, provider, provider2, firebaseInstallationsApi), FcmExecutors.newTaskExecutor(), FcmExecutors.newInitExecutor(), FcmExecutors.newFileIOExecutor());
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Subscriber subscriber, Metadata metadata, GmsRpc gmsRpc, Executor executor, Executor executor2, Executor executor3) {
+        this.syncScheduledOrRunning = false;
+        transportFactory = provider;
+        this.firebaseApp = firebaseApp;
+        this.autoInit = new AutoInit(subscriber);
+        Context applicationContext = firebaseApp.getApplicationContext();
+        this.context = applicationContext;
+        FcmLifecycleCallbacks fcmLifecycleCallbacks = new FcmLifecycleCallbacks();
+        this.lifecycleCallbacks = fcmLifecycleCallbacks;
+        this.metadata = metadata;
+        this.gmsRpc = gmsRpc;
+        this.requestDeduplicator = new RequestDeduplicator(executor);
+        this.initExecutor = executor2;
+        this.fileExecutor = executor3;
+        Context applicationContext2 = firebaseApp.getApplicationContext();
+        if (applicationContext2 instanceof Application) {
+            ((Application) applicationContext2).registerActivityLifecycleCallbacks(fcmLifecycleCallbacks);
+        } else {
+            Log.w("FirebaseMessaging", "Context " + applicationContext2 + " was not an application, can't register for lifecycle callbacks. Some notification events may be dropped as a result.");
+        }
+        if (firebaseInstanceIdInternal != null) {
+            firebaseInstanceIdInternal.addNewTokenListener(new FirebaseInstanceIdInternal.NewTokenListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda1
+            });
+        }
+        executor2.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda2
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$new$2();
+            }
+        });
+        Task createInstance = TopicsSubscriber.createInstance(this, metadata, gmsRpc, applicationContext, FcmExecutors.newTopicsSyncExecutor());
+        this.topicsSubscriberTask = createInstance;
+        createInstance.addOnSuccessListener(executor2, new OnSuccessListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda3
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                FirebaseMessaging.this.lambda$new$3((TopicsSubscriber) obj);
+            }
+        });
+        executor2.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda4
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$new$4();
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$new$2() {
+        if (isAutoInitEnabled()) {
+            startSyncIfNecessary();
+        }
+    }
+
+    public final /* synthetic */ void lambda$new$3(TopicsSubscriber topicsSubscriber) {
+        if (isAutoInitEnabled()) {
+            topicsSubscriber.startTopicsSyncIfNecessary();
+        }
+    }
+
+    /* renamed from: initializeProxyNotifications, reason: merged with bridge method [inline-methods] */
+    public final void lambda$new$4() {
+        ProxyNotificationInitializer.initialize(this.context);
+        ProxyNotificationPreferences.setProxyRetention(this.context, this.gmsRpc, shouldRetainProxyNotifications());
+        if (shouldRetainProxyNotifications()) {
+            handleProxiedNotificationData();
+        }
+    }
+
+    public final boolean shouldRetainProxyNotifications() {
+        ProxyNotificationInitializer.initialize(this.context);
+        if (!ProxyNotificationInitializer.isProxyNotificationEnabled(this.context)) {
+            return false;
+        }
+        if (this.firebaseApp.get(AnalyticsConnector.class) != null) {
+            return true;
+        }
+        return MessagingAnalytics.deliveryMetricsExportToBigQueryEnabled() && transportFactory != null;
+    }
+
+    public final void handleProxiedNotificationData() {
+        this.gmsRpc.getProxyNotificationData().addOnSuccessListener(this.initExecutor, new OnSuccessListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda6
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                FirebaseMessaging.this.lambda$handleProxiedNotificationData$5((CloudMessage) obj);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$handleProxiedNotificationData$5(CloudMessage cloudMessage) {
+        if (cloudMessage != null) {
+            MessagingAnalytics.logNotificationReceived(cloudMessage.getIntent());
+            handleProxiedNotificationData();
+        }
+    }
+
+    public boolean isAutoInitEnabled() {
+        return this.autoInit.isEnabled();
+    }
+
+    public Task getToken() {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.initExecutor.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda5
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$getToken$7(taskCompletionSource);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    public final /* synthetic */ void lambda$getToken$7(TaskCompletionSource taskCompletionSource) {
+        try {
+            taskCompletionSource.setResult(blockingGetToken());
+        } catch (Exception e) {
+            taskCompletionSource.setException(e);
+        }
+    }
+
+    public static TransportFactory getTransportFactory() {
+        return (TransportFactory) transportFactory.get();
+    }
+
+    public boolean isGmsCorePresent() {
+        return this.metadata.isGmscorePresent();
+    }
+
+    public synchronized void setSyncScheduledOrRunning(boolean z) {
+        this.syncScheduledOrRunning = z;
+    }
+
+    public synchronized void syncWithDelaySecondsInternal(long j) {
+        enqueueTaskWithDelaySeconds(new SyncTask(this, Math.min(Math.max(30L, 2 * j), MAX_DELAY_SEC)), j);
+        this.syncScheduledOrRunning = true;
+    }
+
+    public void enqueueTaskWithDelaySeconds(Runnable runnable, long j) {
+        synchronized (FirebaseMessaging.class) {
+            try {
+                if (syncExecutor == null) {
+                    syncExecutor = new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("TAG"));
+                }
+                syncExecutor.schedule(runnable, j, TimeUnit.SECONDS);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void startSyncIfNecessary() {
+        if (tokenNeedsRefresh(getTokenWithoutTriggeringSync())) {
+            startSync();
+        }
+    }
+
+    public final synchronized void startSync() {
+        if (!this.syncScheduledOrRunning) {
+            syncWithDelaySecondsInternal(0L);
+        }
+    }
+
+    public Store.Token getTokenWithoutTriggeringSync() {
+        return getStore(this.context).getToken(getSubtype(), Metadata.getDefaultSenderId(this.firebaseApp));
+    }
+
+    public String blockingGetToken() {
+        final Store.Token tokenWithoutTriggeringSync = getTokenWithoutTriggeringSync();
+        if (!tokenNeedsRefresh(tokenWithoutTriggeringSync)) {
+            return tokenWithoutTriggeringSync.token;
+        }
+        final String defaultSenderId = Metadata.getDefaultSenderId(this.firebaseApp);
+        try {
+            return (String) Tasks.await(this.requestDeduplicator.getOrStartGetTokenRequest(defaultSenderId, new RequestDeduplicator.GetTokenRequest() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda7
+                @Override // com.google.firebase.messaging.RequestDeduplicator.GetTokenRequest
+                public final Task start() {
+                    Task lambda$blockingGetToken$14;
+                    lambda$blockingGetToken$14 = FirebaseMessaging.this.lambda$blockingGetToken$14(defaultSenderId, tokenWithoutTriggeringSync);
+                    return lambda$blockingGetToken$14;
+                }
+            }));
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+    }
+
+    public final /* synthetic */ Task lambda$blockingGetToken$14(final String str, final Store.Token token) {
+        return this.gmsRpc.getToken().onSuccessTask(this.fileExecutor, new SuccessContinuation() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda8
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public final Task then(Object obj) {
+                Task lambda$blockingGetToken$13;
+                lambda$blockingGetToken$13 = FirebaseMessaging.this.lambda$blockingGetToken$13(str, token, (String) obj);
+                return lambda$blockingGetToken$13;
+            }
+        });
+    }
+
+    public final /* synthetic */ Task lambda$blockingGetToken$13(String str, Store.Token token, String str2) {
+        getStore(this.context).saveToken(getSubtype(), str, str2, this.metadata.getAppVersionCode());
+        if (token == null || !str2.equals(token.token)) {
+            invokeOnTokenRefresh(str2);
+        }
+        return Tasks.forResult(str2);
+    }
+
+    public final String getSubtype() {
+        return "[DEFAULT]".equals(this.firebaseApp.getName()) ? "" : this.firebaseApp.getPersistenceKey();
+    }
+
+    public boolean tokenNeedsRefresh(Store.Token token) {
+        return token == null || token.needsRefresh(this.metadata.getAppVersionCode());
+    }
+
+    public final void invokeOnTokenRefresh(String str) {
+        if ("[DEFAULT]".equals(this.firebaseApp.getName())) {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Invoking onNewToken for app: ");
+                sb.append(this.firebaseApp.getName());
+            }
+            Intent intent = new Intent("com.google.firebase.messaging.NEW_TOKEN");
+            intent.putExtra("token", str);
+            new FcmBroadcastProcessor(this.context).process(intent);
+        }
+    }
+
+    public class AutoInit {
+        public Boolean autoInitEnabled;
+        public EventHandler dataCollectionDefaultChangeEventHandler;
+        public boolean initialized;
+        public final Subscriber subscriber;
+
+        public AutoInit(Subscriber subscriber) {
+            this.subscriber = subscriber;
+        }
+
+        public synchronized void initialize() {
+            try {
+                if (this.initialized) {
+                    return;
+                }
+                Boolean readEnabled = readEnabled();
+                this.autoInitEnabled = readEnabled;
+                if (readEnabled == null) {
+                    EventHandler eventHandler = new EventHandler() { // from class: com.google.firebase.messaging.FirebaseMessaging$AutoInit$$ExternalSyntheticLambda0
+                        @Override // com.google.firebase.events.EventHandler
+                        public final void handle(Event event) {
+                            FirebaseMessaging.AutoInit.this.lambda$initialize$0(event);
+                        }
+                    };
+                    this.dataCollectionDefaultChangeEventHandler = eventHandler;
+                    this.subscriber.subscribe(DataCollectionDefaultChange.class, eventHandler);
+                }
+                this.initialized = true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+
+        public final /* synthetic */ void lambda$initialize$0(Event event) {
+            if (isEnabled()) {
+                FirebaseMessaging.this.startSyncIfNecessary();
+            }
+        }
+
+        public synchronized boolean isEnabled() {
+            boolean isDataCollectionDefaultEnabled;
+            try {
+                initialize();
+                Boolean bool = this.autoInitEnabled;
+                if (bool == null) {
+                    isDataCollectionDefaultEnabled = FirebaseMessaging.this.firebaseApp.isDataCollectionDefaultEnabled();
+                } else {
+                    isDataCollectionDefaultEnabled = bool.booleanValue();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+            return isDataCollectionDefaultEnabled;
+        }
+
+        public final Boolean readEnabled() {
+            ApplicationInfo applicationInfo;
+            Bundle bundle;
+            Context applicationContext = FirebaseMessaging.this.firebaseApp.getApplicationContext();
+            SharedPreferences sharedPreferences = applicationContext.getSharedPreferences("com.google.firebase.messaging", 0);
+            if (sharedPreferences.contains("auto_init")) {
+                return Boolean.valueOf(sharedPreferences.getBoolean("auto_init", false));
+            }
+            try {
+                PackageManager packageManager = applicationContext.getPackageManager();
+                if (packageManager == null || (applicationInfo = packageManager.getApplicationInfo(applicationContext.getPackageName(), 128)) == null || (bundle = applicationInfo.metaData) == null || !bundle.containsKey("firebase_messaging_auto_init_enabled")) {
+                    return null;
+                }
+                return Boolean.valueOf(applicationInfo.metaData.getBoolean("firebase_messaging_auto_init_enabled"));
+            } catch (PackageManager.NameNotFoundException unused) {
+                return null;
+            }
+        }
+    }
+}