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/facebook/appevents/aam/MetadataViewObserver.java

@@ -0,0 +1,402 @@
+package com.facebook.appevents.aam;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.EditText;
+import androidx.annotation.UiThread;
+import com.facebook.appevents.InternalAppEventsLogger;
+import com.facebook.appevents.internal.AppEventUtility;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Regex;
+import kotlin.text.StringsKt__StringsKt;
+
+/* loaded from: classes2.dex */
+public final class MetadataViewObserver implements ViewTreeObserver.OnGlobalFocusChangeListener {
+    private static final int MAX_TEXT_LENGTH = 100;
+    private final WeakReference<Activity> activityWeakReference;
+    private final AtomicBoolean isTracking;
+    private final Set<String> processedText;
+    private final Handler uiThreadHandler;
+    public static final Companion Companion = new Companion(null);
+    private static final Map<Integer, MetadataViewObserver> observers = new HashMap();
+
+    public /* synthetic */ MetadataViewObserver(Activity activity, DefaultConstructorMarker defaultConstructorMarker) {
+        this(activity);
+    }
+
+    @UiThread
+    public static final void startTrackingActivity(Activity activity) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return;
+        }
+        try {
+            Companion.startTrackingActivity(activity);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+        }
+    }
+
+    @UiThread
+    public static final void stopTrackingActivity(Activity activity) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return;
+        }
+        try {
+            Companion.stopTrackingActivity(activity);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+        }
+    }
+
+    private MetadataViewObserver(Activity activity) {
+        this.processedText = new LinkedHashSet();
+        this.uiThreadHandler = new Handler(Looper.getMainLooper());
+        this.activityWeakReference = new WeakReference<>(activity);
+        this.isTracking = new AtomicBoolean(false);
+    }
+
+    public static final /* synthetic */ Map access$getObservers$cp() {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return null;
+        }
+        try {
+            return observers;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+            return null;
+        }
+    }
+
+    public static final /* synthetic */ void access$startTracking(MetadataViewObserver metadataViewObserver) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return;
+        }
+        try {
+            metadataViewObserver.startTracking();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+        }
+    }
+
+    public static final /* synthetic */ void access$stopTracking(MetadataViewObserver metadataViewObserver) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return;
+        }
+        try {
+            metadataViewObserver.stopTracking();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+        }
+    }
+
+    private final void startTracking() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            if (this.isTracking.getAndSet(true)) {
+                return;
+            }
+            AppEventUtility appEventUtility = AppEventUtility.INSTANCE;
+            View rootView = AppEventUtility.getRootView(this.activityWeakReference.get());
+            if (rootView == null) {
+                return;
+            }
+            ViewTreeObserver viewTreeObserver = rootView.getViewTreeObserver();
+            if (viewTreeObserver.isAlive()) {
+                viewTreeObserver.addOnGlobalFocusChangeListener(this);
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    private final void stopTracking() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            if (this.isTracking.getAndSet(false)) {
+                AppEventUtility appEventUtility = AppEventUtility.INSTANCE;
+                View rootView = AppEventUtility.getRootView(this.activityWeakReference.get());
+                if (rootView == null) {
+                    return;
+                }
+                ViewTreeObserver viewTreeObserver = rootView.getViewTreeObserver();
+                if (viewTreeObserver.isAlive()) {
+                    viewTreeObserver.removeOnGlobalFocusChangeListener(this);
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    @Override // android.view.ViewTreeObserver.OnGlobalFocusChangeListener
+    public void onGlobalFocusChanged(View view, View view2) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        if (view != null) {
+            try {
+                process(view);
+            } catch (Throwable th) {
+                CrashShieldHandler.handleThrowable(th, this);
+                return;
+            }
+        }
+        if (view2 != null) {
+            process(view2);
+        }
+    }
+
+    private final void process(final View view) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            runOnUIThread(new Runnable() { // from class: com.facebook.appevents.aam.MetadataViewObserver$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    MetadataViewObserver.m480process$lambda0(view, this);
+                }
+            });
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: process$lambda-0, reason: not valid java name */
+    public static final void m480process$lambda0(View view, MetadataViewObserver this$0) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataViewObserver.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(view, "$view");
+            Intrinsics.checkNotNullParameter(this$0, "this$0");
+            if (view instanceof EditText) {
+                this$0.processEditText(view);
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataViewObserver.class);
+        }
+    }
+
+    private final void processEditText(View view) {
+        CharSequence trim;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            String obj = ((EditText) view).getText().toString();
+            if (obj == null) {
+                throw new NullPointerException("null cannot be cast to non-null type kotlin.CharSequence");
+            }
+            trim = StringsKt__StringsKt.trim(obj);
+            String obj2 = trim.toString();
+            if (obj2 == null) {
+                throw new NullPointerException("null cannot be cast to non-null type java.lang.String");
+            }
+            String lowerCase = obj2.toLowerCase();
+            Intrinsics.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase()");
+            if (lowerCase.length() != 0 && !this.processedText.contains(lowerCase) && lowerCase.length() <= 100) {
+                this.processedText.add(lowerCase);
+                HashMap hashMap = new HashMap();
+                List<String> currentViewIndicators = MetadataMatcher.getCurrentViewIndicators(view);
+                List<String> list = null;
+                for (MetadataRule metadataRule : MetadataRule.Companion.getRules()) {
+                    Companion companion = Companion;
+                    String preNormalize = companion.preNormalize(metadataRule.getName(), lowerCase);
+                    if (metadataRule.getValRule().length() > 0) {
+                        MetadataMatcher metadataMatcher = MetadataMatcher.INSTANCE;
+                        if (!MetadataMatcher.matchValue(preNormalize, metadataRule.getValRule())) {
+                        }
+                    }
+                    MetadataMatcher metadataMatcher2 = MetadataMatcher.INSTANCE;
+                    if (!MetadataMatcher.matchIndicator(currentViewIndicators, metadataRule.getKeyRules())) {
+                        if (list == null) {
+                            list = MetadataMatcher.getAroundViewIndicators(view);
+                        }
+                        if (MetadataMatcher.matchIndicator(list, metadataRule.getKeyRules())) {
+                            companion.putUserData(hashMap, metadataRule.getName(), preNormalize);
+                        }
+                    } else {
+                        companion.putUserData(hashMap, metadataRule.getName(), preNormalize);
+                    }
+                }
+                InternalAppEventsLogger.Companion.setInternalUserData(hashMap);
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    private final void runOnUIThread(Runnable runnable) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            if (Thread.currentThread() == Looper.getMainLooper().getThread()) {
+                runnable.run();
+            } else {
+                this.uiThreadHandler.post(runnable);
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        @UiThread
+        public final void startTrackingActivity(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            int hashCode = activity.hashCode();
+            Map access$getObservers$cp = MetadataViewObserver.access$getObservers$cp();
+            Integer valueOf = Integer.valueOf(hashCode);
+            Object obj = access$getObservers$cp.get(valueOf);
+            if (obj == null) {
+                obj = new MetadataViewObserver(activity, null);
+                access$getObservers$cp.put(valueOf, obj);
+            }
+            MetadataViewObserver.access$startTracking((MetadataViewObserver) obj);
+        }
+
+        @UiThread
+        public final void stopTrackingActivity(Activity activity) {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            MetadataViewObserver metadataViewObserver = (MetadataViewObserver) MetadataViewObserver.access$getObservers$cp().remove(Integer.valueOf(activity.hashCode()));
+            if (metadataViewObserver == null) {
+                return;
+            }
+            MetadataViewObserver.access$stopTracking(metadataViewObserver);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final String preNormalize(String str, String str2) {
+            return Intrinsics.areEqual("r2", str) ? new Regex("[^\\d.]").replace(str2, "") : str2;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+        /* JADX WARN: Code restructure failed: missing block: B:14:0x0044, code lost:
+        
+            if (r7.equals("r5") == false) goto L34;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:15:0x0050, code lost:
+        
+            r8 = new kotlin.text.Regex("[^a-z]+").replace(r8, "");
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:17:0x004d, code lost:
+        
+            if (r7.equals("r4") == false) goto L34;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final void putUserData(java.util.Map<java.lang.String, java.lang.String> r6, java.lang.String r7, java.lang.String r8) {
+            /*
+                r5 = this;
+                int r0 = r7.hashCode()
+                r1 = 0
+                r2 = 2
+                r3 = 0
+                switch(r0) {
+                    case 3585: goto L5e;
+                    case 3586: goto L47;
+                    case 3587: goto L3e;
+                    case 3588: goto Lc;
+                    default: goto La;
+                }
+            La:
+                goto L84
+            Lc:
+                java.lang.String r0 = "r6"
+                boolean r0 = r7.equals(r0)
+                if (r0 != 0) goto L16
+                goto L84
+            L16:
+                java.lang.String r0 = "-"
+                boolean r1 = kotlin.text.StringsKt.contains$default(r8, r0, r3, r2, r1)
+                if (r1 == 0) goto L84
+                kotlin.text.Regex r1 = new kotlin.text.Regex
+                r1.<init>(r0)
+                java.util.List r8 = r1.split(r8, r3)
+                java.util.Collection r8 = (java.util.Collection) r8
+                java.lang.String[] r0 = new java.lang.String[r3]
+                java.lang.Object[] r8 = r8.toArray(r0)
+                if (r8 == 0) goto L36
+                java.lang.String[] r8 = (java.lang.String[]) r8
+                r8 = r8[r3]
+                goto L84
+            L36:
+                java.lang.NullPointerException r6 = new java.lang.NullPointerException
+                java.lang.String r7 = "null cannot be cast to non-null type kotlin.Array<T>"
+                r6.<init>(r7)
+                throw r6
+            L3e:
+                java.lang.String r0 = "r5"
+                boolean r0 = r7.equals(r0)
+                if (r0 != 0) goto L50
+                goto L84
+            L47:
+                java.lang.String r0 = "r4"
+                boolean r0 = r7.equals(r0)
+                if (r0 != 0) goto L50
+                goto L84
+            L50:
+                kotlin.text.Regex r0 = new kotlin.text.Regex
+                java.lang.String r1 = "[^a-z]+"
+                r0.<init>(r1)
+                java.lang.String r1 = ""
+                java.lang.String r8 = r0.replace(r8, r1)
+                goto L84
+            L5e:
+                java.lang.String r0 = "r3"
+                boolean r0 = r7.equals(r0)
+                if (r0 != 0) goto L67
+                goto L84
+            L67:
+                java.lang.String r0 = "m"
+                boolean r4 = kotlin.text.StringsKt.startsWith$default(r8, r0, r3, r2, r1)
+                if (r4 != 0) goto L83
+                java.lang.String r4 = "b"
+                boolean r4 = kotlin.text.StringsKt.startsWith$default(r8, r4, r3, r2, r1)
+                if (r4 != 0) goto L83
+                java.lang.String r4 = "ge"
+                boolean r8 = kotlin.text.StringsKt.startsWith$default(r8, r4, r3, r2, r1)
+                if (r8 == 0) goto L80
+                goto L83
+            L80:
+                java.lang.String r8 = "f"
+                goto L84
+            L83:
+                r8 = r0
+            L84:
+                r6.put(r7, r8)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.facebook.appevents.aam.MetadataViewObserver.Companion.putUserData(java.util.Map, java.lang.String, java.lang.String):void");
+        }
+    }
+}