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/ml/ModelManager.java

@@ -0,0 +1,784 @@
+package com.facebook.appevents.ml;
+
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.RestrictTo;
+import com.facebook.GraphRequest;
+import com.facebook.appevents.AppEventsConstants;
+import com.facebook.appevents.integrity.IntegrityManager;
+import com.facebook.appevents.internal.FileDownloadTask;
+import com.facebook.appevents.ml.ModelManager;
+import com.facebook.appevents.suggestedevents.SuggestedEventsManager;
+import com.facebook.internal.FeatureManager;
+import com.facebook.internal.Utility;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes2.dex */
+public final class ModelManager {
+    private static final String ASSET_URI_KEY = "asset_uri";
+    private static final String CACHE_KEY_MODELS = "models";
+    private static final String CACHE_KEY_REQUEST_TIMESTAMP = "model_request_timestamp";
+    private static final String MODEL_ASSERT_STORE = "com.facebook.internal.MODEL_STORE";
+    public static final int MODEL_REQUEST_INTERVAL_MILLISECONDS = 259200000;
+    private static final List<String> MTML_INTEGRITY_DETECT_PREDICTION;
+    private static final List<String> MTML_SUGGESTED_EVENTS_PREDICTION;
+    private static final String MTML_USE_CASE = "MTML";
+    private static final String RULES_URI_KEY = "rules_uri";
+    private static final String THRESHOLD_KEY = "thresholds";
+    private static final String USE_CASE_KEY = "use_case";
+    private static final String VERSION_ID_KEY = "version_id";
+    public static final ModelManager INSTANCE = new ModelManager();
+    private static final Map<String, TaskHandler> taskHandlers = new ConcurrentHashMap();
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[Task.valuesCustom().length];
+            iArr[Task.MTML_APP_EVENT_PREDICTION.ordinal()] = 1;
+            iArr[Task.MTML_INTEGRITY_DETECT.ordinal()] = 2;
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    private ModelManager() {
+    }
+
+    public static final /* synthetic */ float[] access$parseJsonArray(ModelManager modelManager, JSONArray jSONArray) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            return modelManager.parseJsonArray(jSONArray);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    public enum Task {
+        MTML_INTEGRITY_DETECT,
+        MTML_APP_EVENT_PREDICTION;
+
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[Task.valuesCustom().length];
+                iArr[Task.MTML_INTEGRITY_DETECT.ordinal()] = 1;
+                iArr[Task.MTML_APP_EVENT_PREDICTION.ordinal()] = 2;
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        public final String toKey() {
+            int i = WhenMappings.$EnumSwitchMapping$0[ordinal()];
+            if (i == 1) {
+                return "integrity_detect";
+            }
+            if (i == 2) {
+                return "app_event_pred";
+            }
+            throw new NoWhenBranchMatchedException();
+        }
+
+        public final String toUseCase() {
+            int i = WhenMappings.$EnumSwitchMapping$0[ordinal()];
+            if (i == 1) {
+                return "MTML_INTEGRITY_DETECT";
+            }
+            if (i == 2) {
+                return "MTML_APP_EVENT_PRED";
+            }
+            throw new NoWhenBranchMatchedException();
+        }
+
+        /* renamed from: values, reason: to resolve conflict with enum method */
+        public static Task[] valuesCustom() {
+            Task[] valuesCustom = values();
+            return (Task[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+        }
+    }
+
+    static {
+        List<String> listOf;
+        List<String> listOf2;
+        listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new String[]{"other", AppEventsConstants.EVENT_NAME_COMPLETED_REGISTRATION, AppEventsConstants.EVENT_NAME_ADDED_TO_CART, AppEventsConstants.EVENT_NAME_PURCHASED, AppEventsConstants.EVENT_NAME_INITIATED_CHECKOUT});
+        MTML_SUGGESTED_EVENTS_PREDICTION = listOf;
+        listOf2 = CollectionsKt__CollectionsKt.listOf((Object[]) new String[]{"none", IntegrityManager.INTEGRITY_TYPE_ADDRESS, IntegrityManager.INTEGRITY_TYPE_HEALTH});
+        MTML_INTEGRITY_DETECT_PREDICTION = listOf2;
+    }
+
+    public static final void enable() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            Utility utility = Utility.INSTANCE;
+            Utility.runOnNonUiThread(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ModelManager.m513enable$lambda0();
+                }
+            });
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x0059 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x005a A[Catch: all -> 0x002c, Exception -> 0x007d, TryCatch #2 {Exception -> 0x007d, all -> 0x002c, blocks: (B:6:0x000d, B:8:0x001f, B:11:0x0026, B:12:0x0033, B:14:0x0043, B:16:0x0049, B:18:0x0071, B:21:0x0051, B:24:0x005a, B:25:0x002e), top: B:5:0x000d }] */
+    /* renamed from: enable$lambda-0, reason: not valid java name */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final void m513enable$lambda0() {
+        /*
+            java.lang.String r0 = "model_request_timestamp"
+            java.lang.String r1 = "models"
+            java.lang.Class<com.facebook.appevents.ml.ModelManager> r2 = com.facebook.appevents.ml.ModelManager.class
+            boolean r3 = com.facebook.internal.instrument.crashshield.CrashShieldHandler.isObjectCrashing(r2)
+            if (r3 == 0) goto Ld
+            return
+        Ld:
+            android.content.Context r3 = com.facebook.FacebookSdk.getApplicationContext()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            java.lang.String r4 = "com.facebook.internal.MODEL_STORE"
+            r5 = 0
+            android.content.SharedPreferences r3 = r3.getSharedPreferences(r4, r5)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r4 = 0
+            java.lang.String r4 = r3.getString(r1, r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L2e
+            int r5 = r4.length()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r5 != 0) goto L26
+            goto L2e
+        L26:
+            org.json.JSONObject r5 = new org.json.JSONObject     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r5.<init>(r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            goto L33
+        L2c:
+            r0 = move-exception
+            goto L7a
+        L2e:
+            org.json.JSONObject r5 = new org.json.JSONObject     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r5.<init>()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+        L33:
+            r6 = 0
+            long r6 = r3.getLong(r0, r6)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            com.facebook.internal.FeatureManager r4 = com.facebook.internal.FeatureManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            com.facebook.internal.FeatureManager$Feature r4 = com.facebook.internal.FeatureManager.Feature.ModelRequest     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            boolean r4 = com.facebook.internal.FeatureManager.isEnabled(r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L51
+            int r4 = r5.length()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L51
+            com.facebook.appevents.ml.ModelManager r4 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            boolean r4 = r4.isValidTimestamp(r6)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 != 0) goto L71
+        L51:
+            com.facebook.appevents.ml.ModelManager r4 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            org.json.JSONObject r5 = r4.fetchModels()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r5 != 0) goto L5a
+            return
+        L5a:
+            android.content.SharedPreferences$Editor r3 = r3.edit()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            java.lang.String r4 = r5.toString()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            android.content.SharedPreferences$Editor r1 = r3.putString(r1, r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            long r3 = java.lang.System.currentTimeMillis()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            android.content.SharedPreferences$Editor r0 = r1.putLong(r0, r3)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.apply()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+        L71:
+            com.facebook.appevents.ml.ModelManager r0 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.addModels(r5)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.enableMTML()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            goto L7d
+        L7a:
+            com.facebook.internal.instrument.crashshield.CrashShieldHandler.handleThrowable(r0, r2)
+        L7d:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.facebook.appevents.ml.ModelManager.m513enable$lambda0():void");
+    }
+
+    private final boolean isValidTimestamp(long j) {
+        if (CrashShieldHandler.isObjectCrashing(this) || j == 0) {
+            return false;
+        }
+        try {
+            return System.currentTimeMillis() - j < 259200000;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return false;
+        }
+    }
+
+    private final void addModels(JSONObject jSONObject) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                try {
+                    TaskHandler build = TaskHandler.Companion.build(jSONObject.getJSONObject(keys.next()));
+                    if (build != null) {
+                        taskHandlers.put(build.getUseCase(), build);
+                    }
+                } catch (JSONException unused) {
+                    return;
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    private final JSONObject parseRawJsonObject(JSONObject jSONObject) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            try {
+                JSONArray jSONArray = jSONObject.getJSONArray("data");
+                int length = jSONArray.length();
+                if (length <= 0) {
+                    return jSONObject2;
+                }
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    JSONObject jSONObject3 = jSONArray.getJSONObject(i);
+                    JSONObject jSONObject4 = new JSONObject();
+                    jSONObject4.put(VERSION_ID_KEY, jSONObject3.getString(VERSION_ID_KEY));
+                    jSONObject4.put(USE_CASE_KEY, jSONObject3.getString(USE_CASE_KEY));
+                    jSONObject4.put(THRESHOLD_KEY, jSONObject3.getJSONArray(THRESHOLD_KEY));
+                    jSONObject4.put(ASSET_URI_KEY, jSONObject3.getString(ASSET_URI_KEY));
+                    if (jSONObject3.has(RULES_URI_KEY)) {
+                        jSONObject4.put(RULES_URI_KEY, jSONObject3.getString(RULES_URI_KEY));
+                    }
+                    jSONObject2.put(jSONObject3.getString(USE_CASE_KEY), jSONObject4);
+                    if (i2 >= length) {
+                        return jSONObject2;
+                    }
+                    i = i2;
+                }
+            } catch (JSONException unused) {
+                return new JSONObject();
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final JSONObject fetchModels() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            String[] strArr = {USE_CASE_KEY, VERSION_ID_KEY, ASSET_URI_KEY, RULES_URI_KEY, THRESHOLD_KEY};
+            Bundle bundle = new Bundle();
+            bundle.putString(GraphRequest.FIELDS_PARAM, TextUtils.join(",", strArr));
+            GraphRequest newGraphPathRequest = GraphRequest.Companion.newGraphPathRequest(null, "app/model_asset", null);
+            newGraphPathRequest.setParameters(bundle);
+            JSONObject jSONObject = newGraphPathRequest.executeAndWait().getJSONObject();
+            if (jSONObject == null) {
+                return null;
+            }
+            return parseRawJsonObject(jSONObject);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final void enableMTML() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            ArrayList arrayList = new ArrayList();
+            String str = null;
+            int i = 0;
+            for (Map.Entry<String, TaskHandler> entry : taskHandlers.entrySet()) {
+                String key = entry.getKey();
+                TaskHandler value = entry.getValue();
+                if (Intrinsics.areEqual(key, Task.MTML_APP_EVENT_PREDICTION.toUseCase())) {
+                    String assetUri = value.getAssetUri();
+                    int max = Math.max(i, value.getVersionId());
+                    FeatureManager featureManager = FeatureManager.INSTANCE;
+                    if (FeatureManager.isEnabled(FeatureManager.Feature.SuggestedEvents) && isLocaleEnglish()) {
+                        arrayList.add(value.setOnPostExecute(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda1
+                            @Override // java.lang.Runnable
+                            public final void run() {
+                                ModelManager.m514enableMTML$lambda1();
+                            }
+                        }));
+                    }
+                    str = assetUri;
+                    i = max;
+                }
+                if (Intrinsics.areEqual(key, Task.MTML_INTEGRITY_DETECT.toUseCase())) {
+                    str = value.getAssetUri();
+                    i = Math.max(i, value.getVersionId());
+                    FeatureManager featureManager2 = FeatureManager.INSTANCE;
+                    if (FeatureManager.isEnabled(FeatureManager.Feature.IntelligentIntegrity)) {
+                        arrayList.add(value.setOnPostExecute(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda2
+                            @Override // java.lang.Runnable
+                            public final void run() {
+                                ModelManager.m515enableMTML$lambda2();
+                            }
+                        }));
+                    }
+                }
+            }
+            if (str == null || i <= 0 || arrayList.isEmpty()) {
+                return;
+            }
+            TaskHandler.Companion.execute(new TaskHandler(MTML_USE_CASE, str, null, i, null), arrayList);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: enableMTML$lambda-1, reason: not valid java name */
+    public static final void m514enableMTML$lambda1() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            SuggestedEventsManager.enable();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: enableMTML$lambda-2, reason: not valid java name */
+    public static final void m515enableMTML$lambda2() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            IntegrityManager.enable();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    private final boolean isLocaleEnglish() {
+        boolean contains$default;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return false;
+        }
+        try {
+            Locale resourceLocale = Utility.getResourceLocale();
+            if (resourceLocale != null) {
+                String language = resourceLocale.getLanguage();
+                Intrinsics.checkNotNullExpressionValue(language, "locale.language");
+                contains$default = StringsKt__StringsKt.contains$default(language, "en", false, 2, null);
+                if (!contains$default) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return false;
+        }
+    }
+
+    private final float[] parseJsonArray(JSONArray jSONArray) {
+        if (CrashShieldHandler.isObjectCrashing(this) || jSONArray == null) {
+            return null;
+        }
+        try {
+            float[] fArr = new float[jSONArray.length()];
+            int length = jSONArray.length();
+            if (length > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    try {
+                        String string = jSONArray.getString(i);
+                        Intrinsics.checkNotNullExpressionValue(string, "jsonArray.getString(i)");
+                        fArr[i] = Float.parseFloat(string);
+                    } catch (JSONException unused) {
+                    }
+                    if (i2 >= length) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            return fArr;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final File getRuleFile(Task task) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(task, "task");
+            TaskHandler taskHandler = taskHandlers.get(task.toUseCase());
+            if (taskHandler == null) {
+                return null;
+            }
+            return taskHandler.getRuleFile();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    public static final String[] predict(Task task, float[][] denses, String[] texts) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(task, "task");
+            Intrinsics.checkNotNullParameter(denses, "denses");
+            Intrinsics.checkNotNullParameter(texts, "texts");
+            TaskHandler taskHandler = taskHandlers.get(task.toUseCase());
+            Model model = taskHandler == null ? null : taskHandler.getModel();
+            if (model == null) {
+                return null;
+            }
+            float[] thresholds = taskHandler.getThresholds();
+            int length = texts.length;
+            int length2 = denses[0].length;
+            MTensor mTensor = new MTensor(new int[]{length, length2});
+            if (length > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    System.arraycopy(denses[i], 0, mTensor.getData(), i * length2, length2);
+                    if (i2 >= length) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            MTensor predictOnMTML = model.predictOnMTML(mTensor, texts, task.toKey());
+            if (predictOnMTML != null && thresholds != null && predictOnMTML.getData().length != 0 && thresholds.length != 0) {
+                int i3 = WhenMappings.$EnumSwitchMapping$0[task.ordinal()];
+                if (i3 == 1) {
+                    return INSTANCE.processSuggestedEventResult(predictOnMTML, thresholds);
+                }
+                if (i3 == 2) {
+                    return INSTANCE.processIntegrityDetectionResult(predictOnMTML, thresholds);
+                }
+                throw new NoWhenBranchMatchedException();
+            }
+            return null;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    private final String[] processSuggestedEventResult(MTensor mTensor, float[] fArr) {
+        IntRange until;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            int shape = mTensor.getShape(0);
+            int shape2 = mTensor.getShape(1);
+            float[] data = mTensor.getData();
+            if (shape2 != fArr.length) {
+                return null;
+            }
+            until = RangesKt___RangesKt.until(0, shape);
+            ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(until, 10));
+            Iterator it = until.iterator();
+            while (it.hasNext()) {
+                int nextInt = ((IntIterator) it).nextInt();
+                String str = "other";
+                int length = fArr.length;
+                int i = 0;
+                int i2 = 0;
+                while (i < length) {
+                    int i3 = i2 + 1;
+                    if (data[(nextInt * shape2) + i2] >= fArr[i]) {
+                        str = MTML_SUGGESTED_EVENTS_PREDICTION.get(i2);
+                    }
+                    i++;
+                    i2 = i3;
+                }
+                arrayList.add(str);
+            }
+            Object[] array = arrayList.toArray(new String[0]);
+            if (array != null) {
+                return (String[]) array;
+            }
+            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final String[] processIntegrityDetectionResult(MTensor mTensor, float[] fArr) {
+        IntRange until;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            int shape = mTensor.getShape(0);
+            int shape2 = mTensor.getShape(1);
+            float[] data = mTensor.getData();
+            if (shape2 != fArr.length) {
+                return null;
+            }
+            until = RangesKt___RangesKt.until(0, shape);
+            ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(until, 10));
+            Iterator it = until.iterator();
+            while (it.hasNext()) {
+                int nextInt = ((IntIterator) it).nextInt();
+                String str = "none";
+                int length = fArr.length;
+                int i = 0;
+                int i2 = 0;
+                while (i < length) {
+                    int i3 = i2 + 1;
+                    if (data[(nextInt * shape2) + i2] >= fArr[i]) {
+                        str = MTML_INTEGRITY_DETECT_PREDICTION.get(i2);
+                    }
+                    i++;
+                    i2 = i3;
+                }
+                arrayList.add(str);
+            }
+            Object[] array = arrayList.toArray(new String[0]);
+            if (array != null) {
+                return (String[]) array;
+            }
+            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final class TaskHandler {
+        public static final Companion Companion = new Companion(null);
+        private String assetUri;
+        private Model model;
+        private Runnable onPostExecute;
+        private File ruleFile;
+        private String ruleUri;
+        private float[] thresholds;
+        private String useCase;
+        private int versionId;
+
+        public final String getAssetUri() {
+            return this.assetUri;
+        }
+
+        public final Model getModel() {
+            return this.model;
+        }
+
+        public final File getRuleFile() {
+            return this.ruleFile;
+        }
+
+        public final String getRuleUri() {
+            return this.ruleUri;
+        }
+
+        public final float[] getThresholds() {
+            return this.thresholds;
+        }
+
+        public final String getUseCase() {
+            return this.useCase;
+        }
+
+        public final int getVersionId() {
+            return this.versionId;
+        }
+
+        public final void setAssetUri(String str) {
+            Intrinsics.checkNotNullParameter(str, "<set-?>");
+            this.assetUri = str;
+        }
+
+        public final void setModel(Model model) {
+            this.model = model;
+        }
+
+        public final TaskHandler setOnPostExecute(Runnable runnable) {
+            this.onPostExecute = runnable;
+            return this;
+        }
+
+        public final void setRuleFile(File file) {
+            this.ruleFile = file;
+        }
+
+        public final void setRuleUri(String str) {
+            this.ruleUri = str;
+        }
+
+        public final void setThresholds(float[] fArr) {
+            this.thresholds = fArr;
+        }
+
+        public final void setUseCase(String str) {
+            Intrinsics.checkNotNullParameter(str, "<set-?>");
+            this.useCase = str;
+        }
+
+        public final void setVersionId(int i) {
+            this.versionId = i;
+        }
+
+        public TaskHandler(String useCase, String assetUri, String str, int i, float[] fArr) {
+            Intrinsics.checkNotNullParameter(useCase, "useCase");
+            Intrinsics.checkNotNullParameter(assetUri, "assetUri");
+            this.useCase = useCase;
+            this.assetUri = assetUri;
+            this.ruleUri = str;
+            this.versionId = i;
+            this.thresholds = fArr;
+        }
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+
+            public final TaskHandler build(JSONObject jSONObject) {
+                if (jSONObject == null) {
+                    return null;
+                }
+                try {
+                    String useCase = jSONObject.getString(ModelManager.USE_CASE_KEY);
+                    String assetUri = jSONObject.getString(ModelManager.ASSET_URI_KEY);
+                    String optString = jSONObject.optString(ModelManager.RULES_URI_KEY, null);
+                    int i = jSONObject.getInt(ModelManager.VERSION_ID_KEY);
+                    float[] access$parseJsonArray = ModelManager.access$parseJsonArray(ModelManager.INSTANCE, jSONObject.getJSONArray(ModelManager.THRESHOLD_KEY));
+                    Intrinsics.checkNotNullExpressionValue(useCase, "useCase");
+                    Intrinsics.checkNotNullExpressionValue(assetUri, "assetUri");
+                    return new TaskHandler(useCase, assetUri, optString, i, access$parseJsonArray);
+                } catch (Exception unused) {
+                    return null;
+                }
+            }
+
+            public final void execute(TaskHandler handler) {
+                Intrinsics.checkNotNullParameter(handler, "handler");
+                execute(handler, CollectionsKt__CollectionsJVMKt.listOf(handler));
+            }
+
+            public final void execute(TaskHandler master, final List<TaskHandler> slaves) {
+                Intrinsics.checkNotNullParameter(master, "master");
+                Intrinsics.checkNotNullParameter(slaves, "slaves");
+                deleteOldFiles(master.getUseCase(), master.getVersionId());
+                download(master.getAssetUri(), master.getUseCase() + '_' + master.getVersionId(), new FileDownloadTask.Callback() { // from class: com.facebook.appevents.ml.ModelManager$TaskHandler$Companion$$ExternalSyntheticLambda0
+                    @Override // com.facebook.appevents.internal.FileDownloadTask.Callback
+                    public final void onComplete(File file) {
+                        ModelManager.TaskHandler.Companion.m517execute$lambda1(slaves, file);
+                    }
+                });
+            }
+
+            /* JADX INFO: Access modifiers changed from: private */
+            /* renamed from: execute$lambda-1, reason: not valid java name */
+            public static final void m517execute$lambda1(List slaves, File file) {
+                Intrinsics.checkNotNullParameter(slaves, "$slaves");
+                Intrinsics.checkNotNullParameter(file, "file");
+                final Model build = Model.Companion.build(file);
+                if (build != null) {
+                    Iterator it = slaves.iterator();
+                    while (it.hasNext()) {
+                        final TaskHandler taskHandler = (TaskHandler) it.next();
+                        TaskHandler.Companion.download(taskHandler.getRuleUri(), taskHandler.getUseCase() + '_' + taskHandler.getVersionId() + "_rule", new FileDownloadTask.Callback() { // from class: com.facebook.appevents.ml.ModelManager$TaskHandler$Companion$$ExternalSyntheticLambda1
+                            @Override // com.facebook.appevents.internal.FileDownloadTask.Callback
+                            public final void onComplete(File file2) {
+                                ModelManager.TaskHandler.Companion.m518execute$lambda1$lambda0(ModelManager.TaskHandler.this, build, file2);
+                            }
+                        });
+                    }
+                }
+            }
+
+            /* JADX INFO: Access modifiers changed from: private */
+            /* renamed from: execute$lambda-1$lambda-0, reason: not valid java name */
+            public static final void m518execute$lambda1$lambda0(TaskHandler slave, Model model, File file) {
+                Intrinsics.checkNotNullParameter(slave, "$slave");
+                Intrinsics.checkNotNullParameter(file, "file");
+                slave.setModel(model);
+                slave.setRuleFile(file);
+                Runnable runnable = slave.onPostExecute;
+                if (runnable == null) {
+                    return;
+                }
+                runnable.run();
+            }
+
+            private final void deleteOldFiles(String str, int i) {
+                File[] listFiles;
+                File mlDir = Utils.getMlDir();
+                if (mlDir == null || (listFiles = mlDir.listFiles()) == null || listFiles.length == 0) {
+                    return;
+                }
+                String str2 = str + '_' + i;
+                int length = listFiles.length;
+                int i2 = 0;
+                while (i2 < length) {
+                    File file = listFiles[i2];
+                    i2++;
+                    String name = file.getName();
+                    Intrinsics.checkNotNullExpressionValue(name, "name");
+                    if (StringsKt__StringsJVMKt.startsWith$default(name, str, false, 2, null) && !StringsKt__StringsJVMKt.startsWith$default(name, str2, false, 2, null)) {
+                        file.delete();
+                    }
+                }
+            }
+
+            private final void download(String str, String str2, FileDownloadTask.Callback callback) {
+                File file = new File(Utils.getMlDir(), str2);
+                if (str == null || file.exists()) {
+                    callback.onComplete(file);
+                } else {
+                    new FileDownloadTask(str, file, callback).execute(new String[0]);
+                }
+            }
+        }
+    }
+}