Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/facebook/appevents/aam/MetadataIndexer.java

@@ -0,0 +1,96 @@
+package com.facebook.appevents.aam;
+
+import android.app.Activity;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.UiThread;
+import com.facebook.FacebookSdk;
+import com.facebook.internal.AttributionIdentifiers;
+import com.facebook.internal.FetchedAppSettings;
+import com.facebook.internal.FetchedAppSettingsManager;
+import com.facebook.internal.Utility;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes2.dex */
+public final class MetadataIndexer {
+    public static final MetadataIndexer INSTANCE = new MetadataIndexer();
+    private static final String TAG = MetadataIndexer.class.getCanonicalName();
+    private static boolean enabled;
+
+    private MetadataIndexer() {
+    }
+
+    @UiThread
+    public static final void onActivityResumed(Activity activity) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataIndexer.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(activity, "activity");
+            try {
+                if (enabled && !MetadataRule.Companion.getRules().isEmpty()) {
+                    MetadataViewObserver.Companion.startTrackingActivity(activity);
+                }
+            } catch (Exception unused) {
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataIndexer.class);
+        }
+    }
+
+    private final void updateRules() {
+        String rawAamRules;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            FetchedAppSettingsManager fetchedAppSettingsManager = FetchedAppSettingsManager.INSTANCE;
+            FetchedAppSettings queryAppSettings = FetchedAppSettingsManager.queryAppSettings(FacebookSdk.getApplicationId(), false);
+            if (queryAppSettings == null || (rawAamRules = queryAppSettings.getRawAamRules()) == null) {
+                return;
+            }
+            MetadataRule.Companion.updateRules(rawAamRules);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    public static final void enable() {
+        try {
+            if (CrashShieldHandler.isObjectCrashing(MetadataIndexer.class)) {
+                return;
+            }
+            try {
+                FacebookSdk.getExecutor().execute(new Runnable() { // from class: com.facebook.appevents.aam.MetadataIndexer$$ExternalSyntheticLambda0
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        MetadataIndexer.m478enable$lambda0();
+                    }
+                });
+            } catch (Exception e) {
+                Utility utility = Utility.INSTANCE;
+                Utility.logd(TAG, e);
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataIndexer.class);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: enable$lambda-0, reason: not valid java name */
+    public static final void m478enable$lambda0() {
+        if (CrashShieldHandler.isObjectCrashing(MetadataIndexer.class)) {
+            return;
+        }
+        try {
+            if (AttributionIdentifiers.Companion.isTrackingLimited(FacebookSdk.getApplicationContext())) {
+                return;
+            }
+            INSTANCE.updateRules();
+            enabled = true;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataIndexer.class);
+        }
+    }
+}

decompiled/sources/com/facebook/appevents/aam/MetadataMatcher.java

@@ -0,0 +1,175 @@
+package com.facebook.appevents.aam;
+
+import android.content.res.Resources;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.EditText;
+import android.widget.TextView;
+import com.facebook.appevents.codeless.internal.ViewHierarchy;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Regex;
+import kotlin.text.StringsKt__StringsKt;
+
+/* loaded from: classes2.dex */
+public final class MetadataMatcher {
+    public static final MetadataMatcher INSTANCE = new MetadataMatcher();
+    private static final int MAX_INDICATOR_LENGTH = 100;
+
+    private MetadataMatcher() {
+    }
+
+    public static final List<String> getCurrentViewIndicators(View view) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataMatcher.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(view, "view");
+            ArrayList<String> arrayList = new ArrayList();
+            arrayList.add(ViewHierarchy.getHintOfView(view));
+            Object tag = view.getTag();
+            if (tag != null) {
+                arrayList.add(tag.toString());
+            }
+            CharSequence contentDescription = view.getContentDescription();
+            if (contentDescription != null) {
+                arrayList.add(contentDescription.toString());
+            }
+            try {
+                if (view.getId() != -1) {
+                    String resourceName = view.getResources().getResourceName(view.getId());
+                    Intrinsics.checkNotNullExpressionValue(resourceName, "resourceName");
+                    Object[] array = new Regex("/").split(resourceName, 0).toArray(new String[0]);
+                    if (array == null) {
+                        throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+                    }
+                    String[] strArr = (String[]) array;
+                    if (strArr.length == 2) {
+                        arrayList.add(strArr[1]);
+                    }
+                }
+            } catch (Resources.NotFoundException unused) {
+            }
+            ArrayList arrayList2 = new ArrayList();
+            for (String str : arrayList) {
+                if (str.length() > 0 && str.length() <= 100) {
+                    String lowerCase = str.toLowerCase();
+                    Intrinsics.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase()");
+                    arrayList2.add(lowerCase);
+                }
+            }
+            return arrayList2;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataMatcher.class);
+            return null;
+        }
+    }
+
+    public static final List<String> getAroundViewIndicators(View view) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataMatcher.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(view, "view");
+            ArrayList arrayList = new ArrayList();
+            ViewGroup parentOfView = ViewHierarchy.getParentOfView(view);
+            if (parentOfView != null) {
+                for (View view2 : ViewHierarchy.getChildrenOfView(parentOfView)) {
+                    if (view != view2) {
+                        arrayList.addAll(INSTANCE.getTextIndicators(view2));
+                    }
+                }
+            }
+            return arrayList;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataMatcher.class);
+            return null;
+        }
+    }
+
+    public static final boolean matchIndicator(List<String> indicators, List<String> keys) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataMatcher.class)) {
+            return false;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(indicators, "indicators");
+            Intrinsics.checkNotNullParameter(keys, "keys");
+            Iterator<String> it = indicators.iterator();
+            while (it.hasNext()) {
+                if (INSTANCE.matchIndicator(it.next(), keys)) {
+                    return true;
+                }
+            }
+            return false;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataMatcher.class);
+            return false;
+        }
+    }
+
+    private final boolean matchIndicator(String str, List<String> list) {
+        boolean contains$default;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return false;
+        }
+        try {
+            Iterator<String> it = list.iterator();
+            while (it.hasNext()) {
+                contains$default = StringsKt__StringsKt.contains$default(str, it.next(), false, 2, null);
+                if (contains$default) {
+                    return true;
+                }
+            }
+            return false;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return false;
+        }
+    }
+
+    public static final boolean matchValue(String text, String rule) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataMatcher.class)) {
+            return false;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(text, "text");
+            Intrinsics.checkNotNullParameter(rule, "rule");
+            return new Regex(rule).matches(text);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataMatcher.class);
+            return false;
+        }
+    }
+
+    private final List<String> getTextIndicators(View view) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            ArrayList arrayList = new ArrayList();
+            if (view instanceof EditText) {
+                return arrayList;
+            }
+            if (view instanceof TextView) {
+                String obj = ((TextView) view).getText().toString();
+                if (obj.length() > 0 && obj.length() < 100) {
+                    String lowerCase = obj.toLowerCase();
+                    Intrinsics.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase()");
+                    arrayList.add(lowerCase);
+                }
+                return arrayList;
+            }
+            Iterator<View> it = ViewHierarchy.getChildrenOfView(view).iterator();
+            while (it.hasNext()) {
+                arrayList.addAll(getTextIndicators(it.next()));
+            }
+            return arrayList;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+}

decompiled/sources/com/facebook/appevents/aam/MetadataRule.java

@@ -0,0 +1,173 @@
+package com.facebook.appevents.aam;
+
+import androidx.annotation.RestrictTo;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsKt;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes2.dex */
+public final class MetadataRule {
+    private static final String FIELD_K = "k";
+    private static final String FIELD_K_DELIMITER = ",";
+    private static final String FIELD_V = "v";
+    private final List<String> keyRules;
+    private final String name;
+    private final String valRule;
+    public static final Companion Companion = new Companion(null);
+    private static final Set<MetadataRule> rules = new CopyOnWriteArraySet();
+
+    public /* synthetic */ MetadataRule(String str, List list, String str2, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, list, str2);
+    }
+
+    public static final Set<String> getEnabledRuleNames() {
+        if (CrashShieldHandler.isObjectCrashing(MetadataRule.class)) {
+            return null;
+        }
+        try {
+            return Companion.getEnabledRuleNames();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataRule.class);
+            return null;
+        }
+    }
+
+    public static final Set<MetadataRule> getRules() {
+        if (CrashShieldHandler.isObjectCrashing(MetadataRule.class)) {
+            return null;
+        }
+        try {
+            return Companion.getRules();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataRule.class);
+            return null;
+        }
+    }
+
+    public static final void updateRules(String str) {
+        if (CrashShieldHandler.isObjectCrashing(MetadataRule.class)) {
+            return;
+        }
+        try {
+            Companion.updateRules(str);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataRule.class);
+        }
+    }
+
+    private MetadataRule(String str, List<String> list, String str2) {
+        this.name = str;
+        this.valRule = str2;
+        this.keyRules = list;
+    }
+
+    public static final /* synthetic */ Set access$getRules$cp() {
+        if (CrashShieldHandler.isObjectCrashing(MetadataRule.class)) {
+            return null;
+        }
+        try {
+            return rules;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, MetadataRule.class);
+            return null;
+        }
+    }
+
+    public final String getName() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            return this.name;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public final String getValRule() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            return this.valRule;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Set<MetadataRule> getRules() {
+            return new HashSet(MetadataRule.access$getRules$cp());
+        }
+
+        public final void updateRules(String rulesFromServer) {
+            Intrinsics.checkNotNullParameter(rulesFromServer, "rulesFromServer");
+            try {
+                MetadataRule.access$getRules$cp().clear();
+                constructRules(new JSONObject(rulesFromServer));
+            } catch (JSONException unused) {
+            }
+        }
+
+        public final Set<String> getEnabledRuleNames() {
+            HashSet hashSet = new HashSet();
+            Iterator it = MetadataRule.access$getRules$cp().iterator();
+            while (it.hasNext()) {
+                hashSet.add(((MetadataRule) it.next()).getName());
+            }
+            return hashSet;
+        }
+
+        private final void constructRules(JSONObject jSONObject) {
+            List split$default;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String key = keys.next();
+                JSONObject optJSONObject = jSONObject.optJSONObject(key);
+                if (optJSONObject != null) {
+                    String k = optJSONObject.optString("k");
+                    String v = optJSONObject.optString("v");
+                    Intrinsics.checkNotNullExpressionValue(k, "k");
+                    if (k.length() != 0) {
+                        Set access$getRules$cp = MetadataRule.access$getRules$cp();
+                        Intrinsics.checkNotNullExpressionValue(key, "key");
+                        split$default = StringsKt__StringsKt.split$default((CharSequence) k, new String[]{MetadataRule.FIELD_K_DELIMITER}, false, 0, 6, (Object) null);
+                        Intrinsics.checkNotNullExpressionValue(v, "v");
+                        access$getRules$cp.add(new MetadataRule(key, split$default, v, null));
+                    }
+                }
+            }
+        }
+    }
+
+    public final List<String> getKeyRules() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            return new ArrayList(this.keyRules);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+}

decompiled/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");
+        }
+    }
+}