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/vungle/ads/internal/util/ActivityManager.java

@@ -0,0 +1,496 @@
+package com.vungle.ads.internal.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.VisibleForTesting;
+import com.vungle.ads.AnalyticsClient;
+import com.vungle.ads.internal.ui.PresenterAdOpenCallback;
+import com.vungle.ads.internal.util.ActivityManager;
+import com.vungle.ads.internal.util.Logger;
+import java.lang.ref.WeakReference;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class ActivityManager implements Application.ActivityLifecycleCallbacks {
+    private Handler handler;
+    private String lastStoppedActivityName;
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = ActivityManager.class.getSimpleName();
+    private static final ActivityManager instance = new ActivityManager();
+    private static final long TIMEOUT = 3000;
+    private static final long CONFIG_CHANGE_DELAY = 700;
+    private State state = State.UNKNOWN;
+    private AtomicBoolean isInitialized = new AtomicBoolean(false);
+    private final CopyOnWriteArraySet<String> startedActivities = new CopyOnWriteArraySet<>();
+    private final CopyOnWriteArraySet<String> resumedActivities = new CopyOnWriteArraySet<>();
+    private final CopyOnWriteArraySet<LifeCycleCallback> callbacks = new CopyOnWriteArraySet<>();
+    private final ConcurrentHashMap<LeftApplicationCallback, LifeCycleCallback> adLeftCallbacks = new ConcurrentHashMap<>();
+    private final Runnable configChangeRunnable = new Runnable() { // from class: com.vungle.ads.internal.util.ActivityManager$$ExternalSyntheticLambda0
+        @Override // java.lang.Runnable
+        public final void run() {
+            ActivityManager.m3987configChangeRunnable$lambda0(ActivityManager.this);
+        }
+    };
+
+    public interface LeftApplicationCallback {
+        void onLeftApplication();
+    }
+
+    public static class LifeCycleCallback {
+        public void onPause() {
+        }
+
+        public void onResume() {
+        }
+
+        public void onStart() {
+        }
+
+        public void onStop() {
+        }
+    }
+
+    public enum State {
+        STARTED,
+        RESUMED,
+        PAUSED,
+        STOPPED,
+        UNKNOWN
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        Intrinsics.checkNotNullParameter(outState, "outState");
+    }
+
+    private ActivityManager() {
+    }
+
+    private final int getStartedActivitiesCount() {
+        return this.startedActivities.size();
+    }
+
+    private final int getResumedActivitiesCount() {
+        return this.resumedActivities.size();
+    }
+
+    private final boolean isAppForeground() {
+        return !this.resumedActivities.isEmpty();
+    }
+
+    private final boolean getNoResumedActivities() {
+        return this.resumedActivities.isEmpty();
+    }
+
+    private final boolean getNoStartedActivities() {
+        return this.startedActivities.isEmpty();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: configChangeRunnable$lambda-0, reason: not valid java name */
+    public static final void m3987configChangeRunnable$lambda0(ActivityManager this$0) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        if (this$0.getNoResumedActivities()) {
+            State state = this$0.state;
+            State state2 = State.PAUSED;
+            if (state != state2) {
+                this$0.state = state2;
+                Iterator<LifeCycleCallback> it = this$0.callbacks.iterator();
+                while (it.hasNext()) {
+                    it.next().onPause();
+                }
+            }
+        }
+        if (this$0.getNoStartedActivities() && this$0.state == State.PAUSED) {
+            this$0.state = State.STOPPED;
+            Iterator<LifeCycleCallback> it2 = this$0.callbacks.iterator();
+            while (it2.hasNext()) {
+                it2.next().onStop();
+            }
+        }
+    }
+
+    public final void init(final Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        if (this.isInitialized.getAndSet(true)) {
+            return;
+        }
+        try {
+            Handler handler = new Handler(Looper.getMainLooper());
+            this.handler = handler;
+            handler.post(new Runnable() { // from class: com.vungle.ads.internal.util.ActivityManager$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ActivityManager.m3988init$lambda1(context, this);
+                }
+            });
+        } catch (Exception e) {
+            Logger.Companion companion = Logger.Companion;
+            String TAG2 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG2, "TAG");
+            companion.e(TAG2, "Error initializing ActivityManager", e);
+            this.isInitialized.set(false);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: init$lambda-1, reason: not valid java name */
+    public static final void m3988init$lambda1(Context context, ActivityManager this$0) {
+        Intrinsics.checkNotNullParameter(context, "$context");
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        Context applicationContext = context.getApplicationContext();
+        Intrinsics.checkNotNull(applicationContext, "null cannot be cast to non-null type android.app.Application");
+        ((Application) applicationContext).registerActivityLifecycleCallbacks(this$0);
+    }
+
+    @VisibleForTesting
+    public final void deInit(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Context applicationContext = context.getApplicationContext();
+        Intrinsics.checkNotNull(applicationContext, "null cannot be cast to non-null type android.app.Application");
+        ((Application) applicationContext).unregisterActivityLifecycleCallbacks(this);
+        this.startedActivities.clear();
+        this.resumedActivities.clear();
+        this.isInitialized.set(false);
+        this.callbacks.clear();
+        this.adLeftCallbacks.clear();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean inForeground() {
+        return !this.isInitialized.get() || this.lastStoppedActivityName == null || isAppForeground();
+    }
+
+    public final void addListener(LifeCycleCallback callback) {
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        this.callbacks.add(callback);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void removeListener(LifeCycleCallback lifeCycleCallback) {
+        this.callbacks.remove(lifeCycleCallback);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        List listOf;
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        this.startedActivities.add(activity.toString());
+        if (getStartedActivitiesCount() == 1) {
+            State state = State.STARTED;
+            listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new State[]{state, State.RESUMED});
+            if (listOf.contains(this.state)) {
+                return;
+            }
+            this.state = state;
+            Iterator<LifeCycleCallback> it = this.callbacks.iterator();
+            while (it.hasNext()) {
+                it.next().onStart();
+            }
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        Handler handler;
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        this.lastStoppedActivityName = activity.toString();
+        this.startedActivities.remove(activity.toString());
+        if (!getNoStartedActivities() || (handler = this.handler) == null) {
+            return;
+        }
+        handler.removeCallbacks(this.configChangeRunnable);
+        handler.postDelayed(this.configChangeRunnable, CONFIG_CHANGE_DELAY);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        boolean noResumedActivities = getNoResumedActivities();
+        this.resumedActivities.add(activity.toString());
+        if (getResumedActivitiesCount() == 1) {
+            if (noResumedActivities) {
+                State state = State.RESUMED;
+                if (!CollectionsKt__CollectionsJVMKt.listOf(state).contains(this.state)) {
+                    this.state = state;
+                    Iterator<LifeCycleCallback> it = this.callbacks.iterator();
+                    while (it.hasNext()) {
+                        it.next().onResume();
+                    }
+                    return;
+                }
+            }
+            Handler handler = this.handler;
+            if (handler != null) {
+                handler.removeCallbacks(this.configChangeRunnable);
+            }
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        Intrinsics.checkNotNullParameter(activity, "activity");
+        this.resumedActivities.remove(activity.toString());
+        if (getNoResumedActivities()) {
+            Handler handler = this.handler;
+            if (handler != null) {
+                handler.removeCallbacks(this.configChangeRunnable);
+            }
+            Handler handler2 = this.handler;
+            if (handler2 != null) {
+                handler2.postDelayed(this.configChangeRunnable, CONFIG_CHANGE_DELAY);
+            }
+        }
+    }
+
+    public final void addOnNextAppLeftCallback(LeftApplicationCallback leftApplicationCallback) {
+        if (leftApplicationCallback == null) {
+            return;
+        }
+        if (!this.isInitialized.get()) {
+            leftApplicationCallback.onLeftApplication();
+            return;
+        }
+        final WeakReference weakReference = new WeakReference(leftApplicationCallback);
+        final Runnable runnable = new Runnable() { // from class: com.vungle.ads.internal.util.ActivityManager$addOnNextAppLeftCallback$cancelRunnable$1
+            @Override // java.lang.Runnable
+            public void run() {
+                Handler handler;
+                handler = ActivityManager.this.handler;
+                if (handler != null) {
+                    handler.removeCallbacks(this);
+                }
+                ActivityManager.this.removeOnNextAppLeftCallback(weakReference.get());
+            }
+        };
+        LifeCycleCallback lifeCycleCallback = new LifeCycleCallback() { // from class: com.vungle.ads.internal.util.ActivityManager$addOnNextAppLeftCallback$callback$1
+            private boolean wasPaused;
+
+            public final boolean getWasPaused() {
+                return this.wasPaused;
+            }
+
+            public final void setWasPaused(boolean z) {
+                this.wasPaused = z;
+            }
+
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onStop() {
+                Handler handler;
+                ConcurrentHashMap concurrentHashMap;
+                super.onStop();
+                ActivityManager.LeftApplicationCallback leftApplicationCallback2 = weakReference.get();
+                if (this.wasPaused && leftApplicationCallback2 != null) {
+                    concurrentHashMap = this.adLeftCallbacks;
+                    if (concurrentHashMap.containsKey(leftApplicationCallback2)) {
+                        leftApplicationCallback2.onLeftApplication();
+                    }
+                }
+                this.removeOnNextAppLeftCallback(leftApplicationCallback2);
+                handler = this.handler;
+                if (handler != null) {
+                    handler.removeCallbacks(runnable);
+                }
+            }
+
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onResume() {
+                Handler handler;
+                super.onResume();
+                handler = this.handler;
+                if (handler != null) {
+                    handler.postDelayed(runnable, ActivityManager.Companion.getCONFIG_CHANGE_DELAY() * 2);
+                }
+            }
+
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onPause() {
+                Handler handler;
+                super.onPause();
+                this.wasPaused = true;
+                handler = this.handler;
+                if (handler != null) {
+                    handler.removeCallbacks(runnable);
+                }
+            }
+        };
+        this.adLeftCallbacks.put(leftApplicationCallback, lifeCycleCallback);
+        if (inForeground()) {
+            Handler handler = this.handler;
+            if (handler != null) {
+                handler.postDelayed(runnable, TIMEOUT);
+            }
+            addListener(lifeCycleCallback);
+            return;
+        }
+        instance.addListener(new LifeCycleCallback() { // from class: com.vungle.ads.internal.util.ActivityManager$addOnNextAppLeftCallback$1
+            @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+            public void onStart() {
+                ConcurrentHashMap concurrentHashMap;
+                Handler handler2;
+                ActivityManager.Companion companion = ActivityManager.Companion;
+                companion.getInstance$vungle_ads_release().removeListener(this);
+                concurrentHashMap = ActivityManager.this.adLeftCallbacks;
+                ActivityManager.LifeCycleCallback lifeCycleCallback2 = (ActivityManager.LifeCycleCallback) concurrentHashMap.get(weakReference.get());
+                if (lifeCycleCallback2 != null) {
+                    handler2 = ActivityManager.this.handler;
+                    if (handler2 != null) {
+                        handler2.postDelayed(runnable, companion.getTIMEOUT());
+                    }
+                    ActivityManager.this.addListener(lifeCycleCallback2);
+                }
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void removeOnNextAppLeftCallback(LeftApplicationCallback leftApplicationCallback) {
+        LifeCycleCallback remove;
+        if (leftApplicationCallback == null || (remove = this.adLeftCallbacks.remove(leftApplicationCallback)) == null) {
+            return;
+        }
+        removeListener(remove);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        @VisibleForTesting
+        public static /* synthetic */ void getCONFIG_CHANGE_DELAY$annotations() {
+        }
+
+        @VisibleForTesting(otherwise = 2)
+        public static /* synthetic */ void getInstance$vungle_ads_release$annotations() {
+        }
+
+        @VisibleForTesting
+        public static /* synthetic */ void getTIMEOUT$annotations() {
+        }
+
+        private Companion() {
+        }
+
+        public final String getTAG() {
+            return ActivityManager.TAG;
+        }
+
+        public final ActivityManager getInstance$vungle_ads_release() {
+            return ActivityManager.instance;
+        }
+
+        public final long getTIMEOUT() {
+            return ActivityManager.TIMEOUT;
+        }
+
+        public final long getCONFIG_CHANGE_DELAY() {
+            return ActivityManager.CONFIG_CHANGE_DELAY;
+        }
+
+        public final void startWhenForeground(Context context, final Intent intent, final Intent intent2, final LeftApplicationCallback leftApplicationCallback, final PresenterAdOpenCallback presenterAdOpenCallback) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            final WeakReference weakReference = new WeakReference(context);
+            if (getInstance$vungle_ads_release().inForeground()) {
+                if (startActivityHandleException(context, intent, intent2, presenterAdOpenCallback)) {
+                    getInstance$vungle_ads_release().addOnNextAppLeftCallback(leftApplicationCallback);
+                    return;
+                }
+                return;
+            }
+            getInstance$vungle_ads_release().addListener(new LifeCycleCallback() { // from class: com.vungle.ads.internal.util.ActivityManager$Companion$startWhenForeground$1
+                @Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
+                public void onStart() {
+                    boolean startActivityHandleException;
+                    super.onStart();
+                    ActivityManager.Companion companion = ActivityManager.Companion;
+                    companion.getInstance$vungle_ads_release().removeListener(this);
+                    Context context2 = weakReference.get();
+                    if (context2 != null) {
+                        startActivityHandleException = companion.startActivityHandleException(context2, intent, intent2, presenterAdOpenCallback);
+                        if (startActivityHandleException) {
+                            companion.getInstance$vungle_ads_release().addOnNextAppLeftCallback(leftApplicationCallback);
+                        }
+                    }
+                }
+            });
+        }
+
+        public final void startWhenForeground(Context context, Intent intent, Intent intent2, LeftApplicationCallback leftApplicationCallback) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            startWhenForeground(context, intent, intent2, leftApplicationCallback, null);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final boolean startActivityHandleException(Context context, Intent intent, Intent intent2, PresenterAdOpenCallback presenterAdOpenCallback) {
+            if (intent == null && intent2 == null) {
+                return false;
+            }
+            try {
+                if (intent != null) {
+                    context.startActivity(intent);
+                    if (presenterAdOpenCallback != null) {
+                        presenterAdOpenCallback.onDeeplinkClick(true);
+                    }
+                } else {
+                    context.startActivity(intent2);
+                }
+                return true;
+            } catch (Exception e) {
+                Logger.Companion companion = Logger.Companion;
+                String TAG = getTAG();
+                Intrinsics.checkNotNullExpressionValue(TAG, "TAG");
+                companion.e(TAG, "Cannot launch/find activity to handle the Implicit intent: " + e);
+                if (intent != null) {
+                    try {
+                        AnalyticsClient.INSTANCE.logError$vungle_ads_release(312, "Fail to open " + intent.getDataString(), (r13 & 4) != 0 ? null : "", (r13 & 8) != 0 ? null : null, (r13 & 16) != 0 ? null : null);
+                        if (presenterAdOpenCallback != null) {
+                            presenterAdOpenCallback.onDeeplinkClick(false);
+                        }
+                    } catch (Exception unused) {
+                        return false;
+                    }
+                }
+                if (intent != null && intent2 != null) {
+                    context.startActivity(intent2);
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        public final void init(Context context) {
+            Intrinsics.checkNotNullParameter(context, "context");
+            getInstance$vungle_ads_release().init(context);
+        }
+
+        public final void addLifecycleListener(LifeCycleCallback listener) {
+            Intrinsics.checkNotNullParameter(listener, "listener");
+            getInstance$vungle_ads_release().addListener(listener);
+        }
+    }
+}