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/github/anrwatchdog/ANRError$$.java

@@ -0,0 +1,26 @@
+package com.github.anrwatchdog;
+
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public class ANRError$$ implements Serializable {
+    public final String _name;
+    public final StackTraceElement[] _stackTrace;
+
+    public class _Thread extends Throwable {
+        public _Thread(_Thread _thread) {
+            super(ANRError$$.this._name, _thread);
+        }
+
+        @Override // java.lang.Throwable
+        public Throwable fillInStackTrace() {
+            setStackTrace(ANRError$$.this._stackTrace);
+            return this;
+        }
+    }
+
+    public ANRError$$(String str, StackTraceElement[] stackTraceElementArr) {
+        this._name = str;
+        this._stackTrace = stackTraceElementArr;
+    }
+}

decompiled-community/sources/com/github/anrwatchdog/ANRError.java

@@ -0,0 +1,66 @@
+package com.github.anrwatchdog;
+
+import android.os.Looper;
+import com.github.anrwatchdog.ANRError$$;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.TreeMap;
+
+/* loaded from: classes2.dex */
+public class ANRError extends Error {
+    private static final long serialVersionUID = 1;
+    public final long duration;
+
+    public ANRError(ANRError$$._Thread _thread, long j) {
+        super("Application Not Responding for at least " + j + " ms.", _thread);
+        this.duration = j;
+    }
+
+    @Override // java.lang.Throwable
+    public Throwable fillInStackTrace() {
+        setStackTrace(new StackTraceElement[0]);
+        return this;
+    }
+
+    public static ANRError New(long j, String str, boolean z) {
+        final Thread thread = Looper.getMainLooper().getThread();
+        TreeMap treeMap = new TreeMap(new Comparator() { // from class: com.github.anrwatchdog.ANRError.1
+            @Override // java.util.Comparator
+            public int compare(Thread thread2, Thread thread3) {
+                if (thread2 == thread3) {
+                    return 0;
+                }
+                Thread thread4 = thread;
+                if (thread2 == thread4) {
+                    return 1;
+                }
+                if (thread3 == thread4) {
+                    return -1;
+                }
+                return thread3.getName().compareTo(thread2.getName());
+            }
+        });
+        for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+            if (entry.getKey() == thread || (entry.getKey().getName().startsWith(str) && (z || entry.getValue().length > 0))) {
+                treeMap.put(entry.getKey(), entry.getValue());
+            }
+        }
+        if (!treeMap.containsKey(thread)) {
+            treeMap.put(thread, thread.getStackTrace());
+        }
+        ANRError$$._Thread _thread = null;
+        for (Map.Entry entry2 : treeMap.entrySet()) {
+            _thread = new ANRError$$._Thread(_thread);
+        }
+        return new ANRError(_thread, j);
+    }
+
+    public static ANRError NewMainOnly(long j) {
+        Thread thread = Looper.getMainLooper().getThread();
+        return new ANRError(new ANRError$$._Thread(null), j);
+    }
+
+    public static String getThreadTitle(Thread thread) {
+        return thread.getName() + " (state = " + thread.getState() + ")";
+    }
+}

decompiled-community/sources/com/github/anrwatchdog/ANRWatchDog.java

@@ -0,0 +1,127 @@
+package com.github.anrwatchdog;
+
+import android.os.Debug;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+/* loaded from: classes2.dex */
+public class ANRWatchDog extends Thread {
+    public ANRInterceptor _anrInterceptor;
+    public ANRListener _anrListener;
+    public boolean _ignoreDebugger;
+    public InterruptionListener _interruptionListener;
+    public boolean _logThreadsWithoutStackTrace;
+    public String _namePrefix;
+    public volatile boolean _reported;
+    public volatile long _tick;
+    public final Runnable _ticker;
+    public final int _timeoutInterval;
+    public final Handler _uiHandler;
+    public static final ANRListener DEFAULT_ANR_LISTENER = new ANRListener() { // from class: com.github.anrwatchdog.ANRWatchDog.1
+        @Override // com.github.anrwatchdog.ANRWatchDog.ANRListener
+        public void onAppNotResponding(ANRError aNRError) {
+            throw aNRError;
+        }
+    };
+    public static final ANRInterceptor DEFAULT_ANR_INTERCEPTOR = new ANRInterceptor() { // from class: com.github.anrwatchdog.ANRWatchDog.2
+        @Override // com.github.anrwatchdog.ANRWatchDog.ANRInterceptor
+        public long intercept(long j) {
+            return 0L;
+        }
+    };
+    public static final InterruptionListener DEFAULT_INTERRUPTION_LISTENER = new InterruptionListener() { // from class: com.github.anrwatchdog.ANRWatchDog.3
+        @Override // com.github.anrwatchdog.ANRWatchDog.InterruptionListener
+        public void onInterrupted(InterruptedException interruptedException) {
+            Log.w("ANRWatchdog", "Interrupted: " + interruptedException.getMessage());
+        }
+    };
+
+    public interface ANRInterceptor {
+        long intercept(long j);
+    }
+
+    public interface ANRListener {
+        void onAppNotResponding(ANRError aNRError);
+    }
+
+    public interface InterruptionListener {
+        void onInterrupted(InterruptedException interruptedException);
+    }
+
+    public ANRWatchDog setANRListener(ANRListener aNRListener) {
+        if (aNRListener == null) {
+            this._anrListener = DEFAULT_ANR_LISTENER;
+        } else {
+            this._anrListener = aNRListener;
+        }
+        return this;
+    }
+
+    public ANRWatchDog setIgnoreDebugger(boolean z) {
+        this._ignoreDebugger = z;
+        return this;
+    }
+
+    public ANRWatchDog() {
+        this(5000);
+    }
+
+    public ANRWatchDog(int i) {
+        this._anrListener = DEFAULT_ANR_LISTENER;
+        this._anrInterceptor = DEFAULT_ANR_INTERCEPTOR;
+        this._interruptionListener = DEFAULT_INTERRUPTION_LISTENER;
+        this._uiHandler = new Handler(Looper.getMainLooper());
+        this._namePrefix = "";
+        this._logThreadsWithoutStackTrace = false;
+        this._ignoreDebugger = false;
+        this._tick = 0L;
+        this._reported = false;
+        this._ticker = new Runnable() { // from class: com.github.anrwatchdog.ANRWatchDog.4
+            @Override // java.lang.Runnable
+            public void run() {
+                ANRWatchDog.this._tick = 0L;
+                ANRWatchDog.this._reported = false;
+            }
+        };
+        this._timeoutInterval = i;
+    }
+
+    @Override // java.lang.Thread, java.lang.Runnable
+    public void run() {
+        ANRError NewMainOnly;
+        setName("|ANR-WatchDog|");
+        long j = this._timeoutInterval;
+        while (!isInterrupted()) {
+            boolean z = this._tick == 0;
+            this._tick += j;
+            if (z) {
+                this._uiHandler.post(this._ticker);
+            }
+            try {
+                Thread.sleep(j);
+                if (this._tick != 0 && !this._reported) {
+                    if (!this._ignoreDebugger && (Debug.isDebuggerConnected() || Debug.waitingForDebugger())) {
+                        Log.w("ANRWatchdog", "An ANR was detected but ignored because the debugger is connected (you can prevent this with setIgnoreDebugger(true))");
+                        this._reported = true;
+                    } else {
+                        j = this._anrInterceptor.intercept(this._tick);
+                        if (j <= 0) {
+                            if (this._namePrefix != null) {
+                                NewMainOnly = ANRError.New(this._tick, this._namePrefix, this._logThreadsWithoutStackTrace);
+                            } else {
+                                NewMainOnly = ANRError.NewMainOnly(this._tick);
+                            }
+                            this._anrListener.onAppNotResponding(NewMainOnly);
+                            j = this._timeoutInterval;
+                            this._reported = true;
+                        }
+                    }
+                }
+            } catch (InterruptedException e) {
+                this._interruptionListener.onInterrupted(e);
+                return;
+            }
+        }
+    }
+}