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/csdk/starlightsecurity/R.java

@@ -0,0 +1,7 @@
+package csdk.starlightsecurity;
+
+/* loaded from: classes4.dex */
+public final class R {
+    private R() {
+    }
+}

decompiled-community/sources/csdk/starlightsecurity/eventbus/GluEventBus.java

@@ -0,0 +1,246 @@
+package csdk.starlightsecurity.eventbus;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import csdk.glucentralservices.eventbus.IServerEventBus;
+import csdk.glucentralservices.eventbus.IServerEventHandler;
+import csdk.glucentralservices.eventbus.ServerEventBus;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public abstract class GluEventBus {
+    public static final GluEventBus DISCONNECTED = new DisconnectedEventBus();
+    private static final String EVT_ACTION = "action";
+    private static final String EVT_CHANNEL = "channel";
+    private static final String EVT_DATA = "data";
+    private static final String EVT_SENDER = "sender";
+    public static final Object GLOBAL_TOKEN;
+    private static final Set<String> KEYS;
+    public static final GluEventBus SHARED;
+
+    public interface IEventHandler {
+        void handleEvent(GluEventBus gluEventBus, Object obj, String str, Event event) throws Exception;
+    }
+
+    public abstract Object globalToken();
+
+    public abstract boolean isConnected();
+
+    public abstract void publish(Object obj, Event event);
+
+    public abstract Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler);
+
+    public abstract void unsubscribe(Object obj);
+
+    static {
+        GluEventBus createEventBus = createEventBus();
+        SHARED = createEventBus;
+        GLOBAL_TOKEN = createEventBus.globalToken();
+        KEYS = createKeys();
+    }
+
+    private static GluEventBus createEventBus() {
+        try {
+            return new RealEventBus(ServerEventBus.getShared());
+        } catch (NoClassDefFoundError unused) {
+            return DISCONNECTED;
+        }
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add("channel");
+        hashSet.add("action");
+        hashSet.add(EVT_SENDER);
+        hashSet.add("data");
+        return hashSet;
+    }
+
+    public static class Event implements Map<String, Object> {
+        public String action;
+        public String channel;
+        public Map<String, Object> data;
+        public String sender;
+
+        public Event() {
+        }
+
+        public Event(String str, String str2, String str3, Map<String, Object> map) {
+            this.channel = str;
+            this.action = str2;
+            this.sender = str3;
+            this.data = map;
+        }
+
+        @Override // java.util.Map
+        public int size() {
+            return keySet().size();
+        }
+
+        @Override // java.util.Map
+        public boolean isEmpty() {
+            return size() == 0;
+        }
+
+        @Override // java.util.Map
+        public boolean containsKey(Object obj) {
+            return GluEventBus.KEYS.contains(obj);
+        }
+
+        @Override // java.util.Map
+        public boolean containsValue(Object obj) {
+            return values().contains(obj);
+        }
+
+        @Override // java.util.Map
+        public Object get(Object obj) {
+            if (obj == null) {
+                return null;
+            }
+            if (obj.equals("channel")) {
+                return this.channel;
+            }
+            if (obj.equals("action")) {
+                return this.action;
+            }
+            if (obj.equals(GluEventBus.EVT_SENDER)) {
+                return this.sender;
+            }
+            if (obj.equals("data")) {
+                return this.data;
+            }
+            return null;
+        }
+
+        @Override // java.util.Map
+        public Object put(String str, Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public Object remove(Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<String> keySet() {
+            return GluEventBus.KEYS;
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Collection<Object> values() {
+            return Arrays.asList(this.channel, this.action, this.sender, this.data);
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<Map.Entry<String, Object>> entrySet() {
+            HashSet hashSet = new HashSet();
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("channel", this.channel));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry(GluEventBus.EVT_SENDER, this.sender));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+            return hashSet;
+        }
+    }
+
+    public static class DisconnectedEventBus extends GluEventBus {
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public Object globalToken() {
+            return this;
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public boolean isConnected() {
+            return false;
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+        }
+
+        private DisconnectedEventBus() {
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler) {
+            if (iEventHandler != null) {
+                try {
+                    iEventHandler.handleEvent(this, obj, str, new Event("#me", "unsubscribed", "@eb.disconnected", null));
+                } catch (Exception e) {
+                    Log.e("DisconnectedEventBus", "Failed to destroy handler", e);
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class RealEventBus extends GluEventBus {
+        private final IServerEventBus mEventBus;
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public boolean isConnected() {
+            return true;
+        }
+
+        public RealEventBus(IServerEventBus iServerEventBus) {
+            this.mEventBus = iServerEventBus;
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, final IEventHandler iEventHandler) {
+            return this.mEventBus.subscribe(obj, str, collection, iEventHandler != null ? new IServerEventHandler() { // from class: csdk.starlightsecurity.eventbus.GluEventBus.RealEventBus.1
+                @Override // csdk.glucentralservices.eventbus.IServerEventHandler
+                public void handleEvent(IServerEventBus iServerEventBus, Object obj2, String str2, Map<String, Object> map) throws Exception {
+                    Event event;
+                    if (map != null) {
+                        event = new Event();
+                        event.channel = (String) map.get("channel");
+                        event.action = (String) map.get("action");
+                        event.sender = (String) map.get(GluEventBus.EVT_SENDER);
+                        event.data = (Map) map.get("data");
+                    } else {
+                        event = null;
+                    }
+                    iEventHandler.handleEvent(RealEventBus.this, obj2, str2, event);
+                }
+            } : null);
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+            this.mEventBus.unsubscribe(obj);
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+            this.mEventBus.publish(obj, event);
+        }
+
+        @Override // csdk.starlightsecurity.eventbus.GluEventBus
+        public Object globalToken() {
+            return this.mEventBus.globalToken();
+        }
+    }
+}

decompiled-community/sources/csdk/starlightsecurity/platform/AndroidPlatform.java

@@ -0,0 +1,185 @@
+package csdk.starlightsecurity.platform;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.widget.Toast;
+import com.ea.fuel.metrics.FuelMetrics;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import csdk.starlightsecurity.eventbus.GluEventBus;
+import csdk.starlightsecurity.util.ActivityLifecycleCallbacks;
+import csdk.starlightsecurity.util.Common;
+import csdk.starlightsecurity.util.IAction2;
+import csdk.starlightsecurity.util.StringStore;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class AndroidPlatform {
+    private final Activity mActivity;
+    private ActivityLifecycleCallbacks mActivityLifecycleCallbacks;
+    private final Context mContext;
+    private final GluEventBus mEventBus = GluEventBus.SHARED;
+    private final ScheduledExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();
+    private boolean mIsAvailable;
+
+    private native void onApplicationEvent(String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onHandleEvent(long j, Object obj, String str, String str2, String str3, String str4, String str5);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onTimerEvent(long j);
+
+    public AndroidPlatform(Activity activity) {
+        this.mActivity = activity;
+        this.mContext = activity.getApplicationContext();
+        StringStore.init();
+        this.mIsAvailable = true;
+    }
+
+    public void destroy() {
+        this.mIsAvailable = false;
+        this.mExecutor.shutdown();
+        StringStore.destroy();
+        ActivityLifecycleCallbacks activityLifecycleCallbacks = this.mActivityLifecycleCallbacks;
+        if (activityLifecycleCallbacks != null) {
+            activityLifecycleCallbacks.destroy();
+        }
+        FuelMetrics.Shutdown();
+    }
+
+    public void registerApplicationEvent() {
+        this.mActivityLifecycleCallbacks = new ActivityLifecycleCallbacks(this.mContext, new IAction2() { // from class: csdk.starlightsecurity.platform.AndroidPlatform$$ExternalSyntheticLambda0
+            @Override // csdk.starlightsecurity.util.IAction2
+            public final void apply(Object obj, Object obj2) {
+                AndroidPlatform.this.lambda$registerApplicationEvent$0((String) obj, (Activity) obj2);
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$registerApplicationEvent$0(String str, Activity activity) {
+        if (this.mIsAvailable) {
+            if ("onApplicationPaused".equals(str)) {
+                onApplicationEvent(CampaignEx.JSON_NATIVE_VIDEO_PAUSE);
+            } else if ("onApplicationResumed".equals(str)) {
+                onApplicationEvent(CampaignEx.JSON_NATIVE_VIDEO_RESUME);
+            }
+        }
+    }
+
+    public String getApplicationVersion() {
+        try {
+            return this.mContext.getPackageManager().getPackageInfo(this.mContext.getPackageName(), 0).versionName;
+        } catch (PackageManager.NameNotFoundException unused) {
+            return "";
+        }
+    }
+
+    public String getApplicationID() {
+        return this.mContext.getPackageName();
+    }
+
+    public String getFromStringStore(String str) {
+        return StringStore.get(str);
+    }
+
+    public boolean loadLibrary(String str) {
+        try {
+            System.loadLibrary(str);
+            if (!str.equals("fuelmetrics")) {
+                return true;
+            }
+            FuelMetrics.Startup(this.mContext);
+            return true;
+        } catch (UnsatisfiedLinkError e) {
+            e.toString();
+            return false;
+        }
+    }
+
+    public void presentToast(final String str) {
+        Common.runOnUIThread(new Runnable() { // from class: csdk.starlightsecurity.platform.AndroidPlatform.1
+            @Override // java.lang.Runnable
+            public void run() {
+                Toast.makeText(AndroidPlatform.this.mContext, str, 1).show();
+            }
+        });
+    }
+
+    public Object subscribe(String str, String[] strArr, final long j) {
+        return this.mEventBus.subscribe(GluEventBus.GLOBAL_TOKEN, str, Arrays.asList(strArr), new GluEventBus.IEventHandler() { // from class: csdk.starlightsecurity.platform.AndroidPlatform.2
+            @Override // csdk.starlightsecurity.eventbus.GluEventBus.IEventHandler
+            public void handleEvent(GluEventBus gluEventBus, Object obj, String str2, GluEventBus.Event event) {
+                String str3;
+                try {
+                    str3 = new JSONObject(event.data).toString();
+                } catch (Exception unused) {
+                    str3 = "";
+                }
+                AndroidPlatform.this.onHandleEvent(j, obj, str2, event.channel, event.action, event.sender, str3);
+            }
+        });
+    }
+
+    public void unsubscribe(Object obj) {
+        this.mEventBus.unsubscribe(obj);
+    }
+
+    public void publish(Object obj, String str, String str2, String str3, String str4) {
+        Map<String, Object> map;
+        try {
+            map = toMap(new JSONObject(str4));
+        } catch (Exception unused) {
+            map = null;
+        }
+        this.mEventBus.publish(obj, new GluEventBus.Event(str, str2, str3, map));
+    }
+
+    public void scheduleEvent(long j, final long j2) {
+        this.mExecutor.schedule(new Runnable() { // from class: csdk.starlightsecurity.platform.AndroidPlatform.3
+            @Override // java.lang.Runnable
+            public void run() {
+                AndroidPlatform.this.onTimerEvent(j2);
+            }
+        }, j, TimeUnit.MILLISECONDS);
+    }
+
+    public static Map<String, Object> toMap(JSONObject jSONObject) throws Exception {
+        HashMap hashMap = new HashMap();
+        Iterator<String> keys = jSONObject.keys();
+        while (keys.hasNext()) {
+            String next = keys.next();
+            hashMap.put(next, fromJson(jSONObject.get(next)));
+        }
+        return hashMap;
+    }
+
+    public static List toList(JSONArray jSONArray) throws Exception {
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < jSONArray.length(); i++) {
+            arrayList.add(fromJson(jSONArray.get(i)));
+        }
+        return arrayList;
+    }
+
+    private static Object fromJson(Object obj) throws Exception {
+        if (obj == JSONObject.NULL) {
+            return null;
+        }
+        if (obj instanceof JSONObject) {
+            return toMap((JSONObject) obj);
+        }
+        return obj instanceof JSONArray ? toList((JSONArray) obj) : obj;
+    }
+}

decompiled-community/sources/csdk/starlightsecurity/util/ActivityLifecycleCallbacks.java

@@ -0,0 +1,89 @@
+package csdk.starlightsecurity.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public class ActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    public static final String APPLICATION_PAUSE = "onApplicationPaused";
+    public static final String APPLICATION_RESUME = "onApplicationResumed";
+    private Set<Activity> mActivities;
+    private Application mApplication;
+    private IAction2<String, Activity> mOnActivityCallback;
+
+    public boolean isRunning() {
+        return this.mApplication != null;
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+    }
+
+    public ActivityLifecycleCallbacks(Context context, IAction2<String, Activity> iAction2) {
+        Context applicationContext = context.getApplicationContext();
+        if (applicationContext instanceof Application) {
+            this.mOnActivityCallback = iAction2;
+            this.mActivities = new HashSet();
+            Application application = (Application) applicationContext;
+            this.mApplication = application;
+            application.registerActivityLifecycleCallbacks(this);
+        }
+    }
+
+    public void destroy() {
+        Common.runOnUIThread(new Runnable() { // from class: csdk.starlightsecurity.util.ActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ActivityLifecycleCallbacks.this.mApplication != null) {
+                    ActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                ActivityLifecycleCallbacks.this.mApplication = null;
+                ActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                ActivityLifecycleCallbacks.this.mActivities = null;
+            }
+        });
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        if (this.mOnActivityCallback != null && addActivity(activity) && this.mActivities.size() == 1) {
+            this.mOnActivityCallback.apply("onApplicationResumed", activity);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        addActivity(activity);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        if (this.mOnActivityCallback != null && this.mActivities.remove(activity) && this.mActivities.size() == 0) {
+            this.mOnActivityCallback.apply("onApplicationPaused", activity);
+        }
+    }
+
+    private boolean addActivity(Activity activity) {
+        Set<Activity> set = this.mActivities;
+        if (set != null) {
+            return set.add(activity);
+        }
+        return false;
+    }
+}

decompiled-community/sources/csdk/starlightsecurity/util/Common.java

@@ -0,0 +1,42 @@
+package csdk.starlightsecurity.util;
+
+import android.os.Handler;
+import android.os.Looper;
+
+/* loaded from: classes4.dex */
+public class Common {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static void require(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void require(boolean z, String str) {
+        if (z) {
+            return;
+        }
+        if (str != null) {
+            throw new IllegalArgumentException(str);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static RuntimeException propagate(Throwable th) {
+        if (th instanceof Error) {
+            throw ((Error) th);
+        }
+        if (th instanceof RuntimeException) {
+            throw ((RuntimeException) th);
+        }
+        throw new RuntimeException(th);
+    }
+
+    public static void runOnUIThread(Runnable runnable) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.post(runnable)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+}

decompiled-community/sources/csdk/starlightsecurity/util/IAction2.java

@@ -0,0 +1,6 @@
+package csdk.starlightsecurity.util;
+
+/* loaded from: classes4.dex */
+public interface IAction2<T1, T2> {
+    void apply(T1 t1, T2 t2);
+}

decompiled-community/sources/csdk/starlightsecurity/util/StringStore.java

@@ -0,0 +1,46 @@
+package csdk.starlightsecurity.util;
+
+/* loaded from: classes4.dex */
+public class StringStore {
+    private static final String gcsClassName = "csdk.glucentralservices.kvstore.StringStore";
+    private static final String getMethodName = "get";
+    private static final String setMethodName = "set";
+
+    private static void log(String str) {
+    }
+
+    public static void init() {
+        set("*init", "starlightsecurity");
+    }
+
+    public static void destroy() {
+        set("*destroy", "starlightsecurity");
+    }
+
+    public static String get(String str) {
+        try {
+            return (String) csdk.glucentralservices.kvstore.StringStore.class.getMethod(getMethodName, String.class).invoke(null, str);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+            return null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static void set(String str, String str2) {
+        try {
+            csdk.glucentralservices.kvstore.StringStore.class.getMethod(setMethodName, String.class, String.class).invoke(null, str, str2);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String getOrDefault(String str, String str2) {
+        String str3 = get(str);
+        return (str3 == null || str3.isEmpty()) ? str2 : str3;
+    }
+}