package com.bytedance.sdk.openadsdk.utils;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Outline;
import android.graphics.Picture;
import android.graphics.Point;
import android.os.Build;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Pair;
import android.view.Display;
import android.view.DisplayCutout;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.ViewOutlineProvider;
import android.view.ViewParent;
import android.view.WindowInsets;
import android.view.WindowManager;
import android.webkit.WebView;
import android.widget.TextView;
import androidx.annotation.Nullable;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import tv.danmaku.ijk.media.player.IjkMediaPlayer;

/* JADX INFO: loaded from: classes2.dex */
public class zan {
    private static int ajl = -1;
    private static boolean dsz = true;
    private static final Object duv = new Object();

    /* JADX INFO: renamed from: ef, reason: collision with root package name */
    private static int f7574ef = -1;
    private static float fm = -1.0f;
    private static int jnr = -1;
    private static Boolean ku = null;

    /* JADX INFO: renamed from: lb, reason: collision with root package name */
    private static float f7575lb = -1.0f;
    private static int ro = -1;
    private static float vt = -1.0f;
    private static WindowManager wsy = null;
    private static ViewConfiguration wu = null;
    private static int yz = -1;

    public static int ajl(Context context) {
        if (context == null) {
            com.bytedance.sdk.openadsdk.core.gof.fm();
        }
        if (context == null) {
            return ajl;
        }
        if (context.getResources() != null && context.getResources().getConfiguration() != null) {
            ajl = context.getResources().getConfiguration().smallestScreenWidthDp;
        }
        return ajl;
    }

    public static int dsz(Context context) {
        return ((Integer) ku(context).first).intValue();
    }

    public static int duv(Context context) {
        return ((Integer) ku(context).second).intValue();
    }

    public static float ef(Context context) {
        fm(context);
        return f7575lb;
    }

    public static boolean fhx(Context context) {
        try {
            Class<?> clsLoadClass = context.getClassLoader().loadClass("android.util.FtFeature");
            return ((Boolean) clsLoadClass.getMethod("isFeatureSupport", Integer.TYPE).invoke(clsLoadClass, 32)).booleanValue();
        } catch (ClassNotFoundException | NoSuchMethodException | Exception unused) {
            return false;
        }
    }

    private static boolean fm(int i10) {
        return i10 == 0 || i10 == 8 || i10 == 4;
    }

    public static boolean gof(Context context) {
        return context.getPackageManager().hasSystemFeature("com.oppo.feature.screen.heteromorphism");
    }

    public static boolean irt(Context context) {
        String str = Build.MODEL;
        return str.equals("IN2010") || str.equals("IN2020") || str.equals("KB2000") || str.startsWith("ONEPLUS");
    }

    public static int jnr(Context context) {
        fm(context);
        return jnr;
    }

    public static Pair<Integer, Integer> ku(Context context) {
        if (context == null) {
            context = com.bytedance.sdk.openadsdk.core.gof.fm();
        }
        Display defaultDisplay = ((WindowManager) context.getSystemService("window")).getDefaultDisplay();
        Point point = new Point();
        defaultDisplay.getRealSize(point);
        return new Pair<>(Integer.valueOf(point.x), Integer.valueOf(point.y));
    }

    private static boolean lb() {
        return fm < 0.0f || ro < 0 || f7575lb < 0.0f || yz < 0 || jnr < 0;
    }

    public static boolean onz(Context context) {
        try {
            Class<?> clsLoadClass = context.getClassLoader().loadClass("com.huawei.android.util.HwNotchSizeUtil");
            return ((Boolean) clsLoadClass.getMethod("hasNotchInScreen", new Class[0]).invoke(clsLoadClass, new Object[0])).booleanValue();
        } catch (ClassNotFoundException | NoSuchMethodException | Exception unused) {
            return false;
        }
    }

    public static boolean qhl(Context context) {
        try {
            Resources resources = context.getResources();
            int identifier = resources.getIdentifier("config_mainBuiltInDisplayCutout", "string", "android");
            String string = identifier > 0 ? resources.getString(identifier) : null;
            if (string != null) {
                if (!TextUtils.isEmpty(string)) {
                    return true;
                }
            }
        } catch (Exception unused) {
        }
        return false;
    }

    public static boolean ro() {
        return dsz && Build.VERSION.SDK_INT >= 28;
    }

    public static int vt(Context context) {
        fm(context);
        return ro;
    }

    public static int wsy(Context context) {
        fm(context);
        return lb(context, jnr);
    }

    public static float wu(Context context) {
        fm(context, true);
        return fm;
    }

    public static int yz(Context context) {
        fm(context);
        return lb(context, yz);
    }

    public static void fm(Context context) {
        fm(context, false);
    }

    public static void jnr(View view) {
        if (view == null) {
            return;
        }
        final WeakReference weakReference = new WeakReference(view);
        ObjectAnimator objectAnimatorOfFloat = ObjectAnimator.ofFloat(view, "alpha", 1.0f, 0.0f);
        objectAnimatorOfFloat.addListener(new AnimatorListenerAdapter() { // from class: com.bytedance.sdk.openadsdk.utils.zan.1
            @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
            public void onAnimationEnd(Animator animator) {
                super.onAnimationEnd(animator);
                View view2 = (View) weakReference.get();
                if (view2 != null) {
                    zan.fm(view2, 8);
                    view2.setAlpha(1.0f);
                }
            }
        });
        objectAnimatorOfFloat.setDuration(800L);
        objectAnimatorOfFloat.start();
    }

    public static int lb(Context context, float f10) {
        fm(context, true);
        float fWu = wu(context);
        if (fWu <= 0.0f) {
            fWu = 1.0f;
        }
        return (int) ((f10 / fWu) + 0.5f);
    }

    public static void fm(Context context, boolean z10) {
        Context contextFm = context == null ? com.bytedance.sdk.openadsdk.core.gof.fm() : context;
        if (contextFm == null) {
            return;
        }
        wsy = (WindowManager) contextFm.getSystemService("window");
        if (lb() || z10) {
            DisplayMetrics displayMetrics = contextFm.getResources().getDisplayMetrics();
            fm = displayMetrics.density;
            ro = displayMetrics.densityDpi;
            f7575lb = displayMetrics.scaledDensity;
            yz = displayMetrics.widthPixels;
            jnr = displayMetrics.heightPixels;
        }
        if (context == null || context.getResources() == null || context.getResources().getConfiguration() == null) {
            return;
        }
        Configuration configuration = context.getResources().getConfiguration();
        if (configuration.orientation == 1) {
            int i10 = yz;
            int i11 = jnr;
            if (i10 > i11) {
                yz = i11;
                jnr = i10;
            }
        } else {
            int i12 = yz;
            int i13 = jnr;
            if (i12 < i13) {
                yz = i13;
                jnr = i12;
            }
        }
        ajl = configuration.smallestScreenWidthDp;
    }

    public static int ro(Context context, float f10) {
        if (f10 == 0.0f) {
            return 0;
        }
        return Float.valueOf(fm(context, f10, true)).intValue();
    }

    public static void wsy(View view) {
        if (view == null) {
            return;
        }
        ViewParent parent = view.getParent();
        if (parent instanceof ViewGroup) {
            ((ViewGroup) parent).removeView(view);
        }
    }

    public static boolean yz(View view) {
        return view != null && view.getVisibility() == 0;
    }

    public static int lb(Context context) {
        fm(context);
        return yz;
    }

    public static int[] ro(Context context) {
        if (context == null) {
            return null;
        }
        if (wsy == null) {
            wsy = (WindowManager) com.bytedance.sdk.openadsdk.core.gof.fm().getSystemService("window");
        }
        int[] iArr = new int[2];
        WindowManager windowManager = wsy;
        if (windowManager != null) {
            Display defaultDisplay = windowManager.getDefaultDisplay();
            DisplayMetrics displayMetrics = new DisplayMetrics();
            defaultDisplay.getMetrics(displayMetrics);
            int i10 = displayMetrics.widthPixels;
            int i11 = displayMetrics.heightPixels;
            try {
                Point point = new Point();
                Display.class.getMethod("getRealSize", Point.class).invoke(defaultDisplay, point);
                i10 = point.x;
                i11 = point.y;
            } catch (Exception unused) {
            }
            iArr[0] = i10;
            iArr[1] = i11;
        }
        if (iArr[0] <= 0 || iArr[1] <= 0) {
            DisplayMetrics displayMetrics2 = context.getResources().getDisplayMetrics();
            iArr[0] = displayMetrics2.widthPixels;
            iArr[1] = displayMetrics2.heightPixels;
        }
        return iArr;
    }

    public static boolean yz(Activity activity) {
        DisplayCutout displayCutout;
        if (Build.VERSION.SDK_INT < 28) {
            return false;
        }
        try {
            WindowInsets rootWindowInsets = activity.getWindow().getDecorView().getRootWindowInsets();
            if (rootWindowInsets != null) {
                displayCutout = rootWindowInsets.getDisplayCutout();
                dsz = false;
            } else {
                displayCutout = null;
            }
            return displayCutout != null;
        } catch (Exception e10) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e10.getMessage());
            return false;
        }
    }

    public static void ajl(View view) {
        if (view == null) {
            return;
        }
        fm(view, 0);
        ObjectAnimator objectAnimatorOfFloat = ObjectAnimator.ofFloat(view, "alpha", 0.0f, 1.0f);
        objectAnimatorOfFloat.addListener(new AnimatorListenerAdapter() { // from class: com.bytedance.sdk.openadsdk.utils.zan.2
            @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
            public void onAnimationStart(Animator animator) {
                onAnimationEnd(animator);
            }
        });
        objectAnimatorOfFloat.setDuration(300L);
        objectAnimatorOfFloat.start();
    }

    @Nullable
    public static int[] lb(View view) {
        if (view != null) {
            return new int[]{view.getWidth(), view.getHeight()};
        }
        return null;
    }

    public static boolean lb(Activity activity) {
        if (ku == null) {
            synchronized (duv) {
                try {
                    if (ku == null) {
                        String strFm = com.bytedance.sdk.openadsdk.hlt.jnr.fm("cutout_devices", "");
                        String str = Build.MODEL;
                        if (!TextUtils.isEmpty(strFm) && !TextUtils.isEmpty(str)) {
                            try {
                                JSONArray jSONArray = new JSONArray(strFm);
                                for (int i10 = 0; i10 < jSONArray.length(); i10++) {
                                    if (str.equals(jSONArray.getString(i10))) {
                                        ku = Boolean.TRUE;
                                        return true;
                                    }
                                }
                            } catch (Exception e10) {
                                com.bytedance.sdk.component.utils.wey.lb("UIUtils", e10.getMessage());
                            }
                        }
                        ku = Boolean.valueOf(yz(activity) || fm("ro.miui.notch", activity) == 1 || onz(activity) || gof(activity) || fhx(activity) || irt(activity) || qhl(activity));
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
        }
        return ku.booleanValue();
    }

    public static int[] ro(View view) {
        if (view == null) {
            return null;
        }
        int[] iArr = new int[2];
        view.getLocationOnScreen(iArr);
        return iArr;
    }

    public static void ro(Activity activity) {
        if (activity == null) {
            return;
        }
        try {
            activity.getWindow().getDecorView().setSystemUiVisibility(1792);
            activity.getWindow().clearFlags(1792);
        } catch (Exception unused) {
        }
    }

    public static float fm(Context context, float f10) {
        fm(context);
        return ef(context) * f10;
    }

    private static Bitmap ro(com.bytedance.sdk.component.ef.wsy wsyVar) {
        if (wsyVar == null) {
            return null;
        }
        try {
            Bitmap bitmapCreateBitmap = Bitmap.createBitmap(wsyVar.getWidth(), wsyVar.getHeight(), Bitmap.Config.RGB_565);
            wsyVar.draw(new Canvas(bitmapCreateBitmap));
            return bitmapCreateBitmap;
        } catch (Throwable unused) {
            return null;
        }
    }

    public static float fm(Context context, float f10, boolean z10) {
        fm(context);
        return (wu(context) * f10) + (z10 ? 0.5f : 0.0f);
    }

    @Nullable
    public static int[] fm(View view) {
        if (view == null || view.getVisibility() != 0) {
            return null;
        }
        int[] iArr = new int[2];
        view.getLocationOnScreen(iArr);
        return iArr;
    }

    public static void fm(View view, int i10) {
        if (view == null || view.getVisibility() == i10 || !fm(i10)) {
            return;
        }
        view.setVisibility(i10);
    }

    private static ArrayList<Integer> ro(Bitmap bitmap) {
        if (bitmap == null) {
            return null;
        }
        try {
            int width = bitmap.getWidth();
            int height = bitmap.getHeight();
            int i10 = width * height;
            int[] iArr = new int[i10];
            bitmap.getPixels(iArr, 0, width, 0, 0, width, height);
            ArrayList<Integer> arrayList = new ArrayList<>();
            for (int i11 = 0; i11 < i10; i11++) {
                int i12 = iArr[i11];
                arrayList.add(Integer.valueOf(Color.rgb((16711680 & i12) >> 16, (65280 & i12) >> 8, i12 & 255)));
            }
            return arrayList;
        } catch (Throwable unused) {
            return null;
        }
    }

    public static void fm(TextView textView, CharSequence charSequence) {
        if (textView == null || TextUtils.isEmpty(charSequence)) {
            return;
        }
        textView.setText(charSequence);
    }

    public static void fm(View view, int i10, int i11, int i12, int i13) {
        ViewGroup.LayoutParams layoutParams;
        if (view == null || (layoutParams = view.getLayoutParams()) == null || !(layoutParams instanceof ViewGroup.MarginLayoutParams)) {
            return;
        }
        fm(view, (ViewGroup.MarginLayoutParams) layoutParams, i10, i11, i12, i13);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void lb(final com.bytedance.sdk.openadsdk.core.model.lse lseVar, String str, String str2, final Bitmap bitmap, final String str3, final long j10) {
        if (bitmap != null) {
            try {
                if (bitmap.getWidth() > 0 && bitmap.getHeight() > 0 && !bitmap.isRecycled()) {
                    com.bytedance.sdk.openadsdk.yz.lb.fm(System.currentTimeMillis(), lseVar, str, str2, new com.bytedance.sdk.openadsdk.irt.ro.fm() { // from class: com.bytedance.sdk.openadsdk.utils.zan.4
                        @Override // com.bytedance.sdk.openadsdk.irt.ro.fm, com.bytedance.sdk.openadsdk.irt.ro.ro
                        public JSONObject lb() {
                            JSONObject jSONObject = new JSONObject();
                            try {
                                int iFm = zan.fm(bitmap);
                                jSONObject.put(IjkMediaPlayer.OnNativeInvokeListener.ARG_URL, str3);
                                long j11 = j10;
                                if (j11 != -1) {
                                    jSONObject.put("page_id", j11);
                                }
                                jSONObject.put("render_type", "h5");
                                jSONObject.put("render_type_2", 0);
                                jSONObject.put("is_blank", iFm == 100 ? 1 : 0);
                                jSONObject.put("is_playable", com.bytedance.sdk.openadsdk.core.model.ai.ro(lseVar) ? 1 : 0);
                                jSONObject.put("usecache", com.bytedance.sdk.openadsdk.core.fhx.lb.fm.fm().fm(lseVar) ? 1 : 0);
                            } catch (JSONException unused) {
                            }
                            return jSONObject;
                        }
                    });
                }
            } catch (Throwable th) {
                com.bytedance.sdk.component.utils.wey.lb("UIUtils", "(Developers can ignore this detection exception)checkWebViewIsTransparent->throwable ex>>>".concat(String.valueOf(th)));
            }
        }
    }

    private static void fm(View view, ViewGroup.MarginLayoutParams marginLayoutParams, int i10, int i11, int i12, int i13) {
        if (view == null || marginLayoutParams == null) {
            return;
        }
        if (marginLayoutParams.leftMargin == i10 && marginLayoutParams.topMargin == i11 && marginLayoutParams.rightMargin == i12 && marginLayoutParams.bottomMargin == i13) {
            return;
        }
        if (i10 != -3) {
            marginLayoutParams.leftMargin = i10;
        }
        if (i11 != -3) {
            marginLayoutParams.topMargin = i11;
        }
        if (i12 != -3) {
            marginLayoutParams.rightMargin = i12;
        }
        if (i13 != -3) {
            marginLayoutParams.bottomMargin = i13;
        }
        view.setLayoutParams(marginLayoutParams);
    }

    public static void ro(View view, final float f10) {
        if (view != null && f10 > 0.0f) {
            view.setOutlineProvider(new ViewOutlineProvider() { // from class: com.bytedance.sdk.openadsdk.utils.zan.5
                @Override // android.view.ViewOutlineProvider
                public void getOutline(View view2, Outline outline) {
                    if (outline == null) {
                        return;
                    }
                    outline.setRoundRect(0, 0, view2.getWidth(), view2.getHeight(), f10);
                }
            });
            view.setClipToOutline(true);
        }
    }

    private static Bitmap fm(WebView webView) {
        Bitmap bitmapCreateBitmap = null;
        try {
            Picture pictureCapturePicture = webView.capturePicture();
            bitmapCreateBitmap = Bitmap.createBitmap(pictureCapturePicture.getWidth(), pictureCapturePicture.getHeight(), Bitmap.Config.ARGB_8888);
            pictureCapturePicture.draw(new Canvas(bitmapCreateBitmap));
            return bitmapCreateBitmap;
        } catch (Throwable th) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", th.getMessage());
            return bitmapCreateBitmap;
        }
    }

    public static float fm() {
        float f10 = vt;
        if (f10 > 0.0f) {
            return f10;
        }
        Resources resources = com.bytedance.sdk.openadsdk.core.gof.fm().getResources();
        int identifier = resources.getIdentifier("status_bar_height", "dimen", "android");
        if (identifier <= 0) {
            return 0.0f;
        }
        float dimensionPixelSize = resources.getDimensionPixelSize(identifier);
        vt = dimensionPixelSize;
        return dimensionPixelSize;
    }

    public static void fm(Activity activity) {
        if (activity == null || activity.isFinishing()) {
            return;
        }
        try {
            activity.getWindow().getDecorView().setSystemUiVisibility(3846);
            activity.getWindow().addFlags(1792);
        } catch (Exception e10) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e10.getMessage());
        }
    }

    public static int fm(String str, Activity activity) {
        if (!gzf.ajl()) {
            return 0;
        }
        try {
            Class<?> clsLoadClass = activity.getClassLoader().loadClass("android.os.SystemProperties");
            return ((Integer) clsLoadClass.getMethod("getInt", String.class, Integer.TYPE).invoke(clsLoadClass, new String(str), 0)).intValue();
        } catch (ClassNotFoundException e10) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e10.getMessage());
            return 0;
        } catch (IllegalAccessException e11) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e11.getMessage());
            return 0;
        } catch (IllegalArgumentException e12) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e12.getMessage());
            return 0;
        } catch (NoSuchMethodException e13) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e13.getMessage());
            return 0;
        } catch (InvocationTargetException e14) {
            com.bytedance.sdk.component.utils.wey.lb("UIUtils", e14.getMessage());
            return 0;
        }
    }

    public static void fm(View view, View.OnClickListener onClickListener, String str) {
        if (view == null) {
            com.bytedance.sdk.component.utils.wey.lb("OnclickListener ", str + " is null , can not set OnClickListener !!!");
            return;
        }
        view.setOnClickListener(onClickListener);
    }

    public static void fm(View view, View.OnTouchListener onTouchListener, String str) {
        if (view == null) {
            com.bytedance.sdk.component.utils.wey.lb("OnTouchListener ", str + " is null , can not set OnTouchListener !!!");
            return;
        }
        view.setOnTouchListener(onTouchListener);
    }

    public static void fm(View view, float f10) {
        if (view == null) {
            return;
        }
        view.setAlpha(f10);
    }

    public static void fm(TextView textView, com.bytedance.sdk.openadsdk.core.widget.irt irtVar, com.bytedance.sdk.openadsdk.core.model.lse lseVar) {
        fm(textView, irtVar, lseVar, 14);
    }

    public static void fm(TextView textView, com.bytedance.sdk.openadsdk.core.widget.irt irtVar, com.bytedance.sdk.openadsdk.core.model.lse lseVar, int i10) {
        fm(textView, irtVar, (lseVar == null || lseVar.iat() == null) ? -1.0d : lseVar.iat().yz(), i10);
    }

    public static void fm(TextView textView, com.bytedance.sdk.openadsdk.core.widget.irt irtVar, double d10, int i10) {
        if (d10 == -1.0d) {
            if (textView != null) {
                textView.setVisibility(8);
            }
            irtVar.setVisibility(8);
        } else {
            if (textView != null) {
                textView.setText(String.format(Locale.getDefault(), "%.1f", Double.valueOf(d10)));
            }
            fm(irtVar, d10, i10);
        }
    }

    public static void fm(com.bytedance.sdk.openadsdk.core.widget.irt irtVar, double d10, int i10) {
        if (d10 < 0.0d) {
            irtVar.setVisibility(8);
        } else {
            irtVar.setVisibility(0);
            irtVar.fm(d10, i10);
        }
    }

    public static Bitmap fm(com.bytedance.sdk.component.ef.wsy wsyVar) {
        WebView webView = wsyVar.getWebView();
        int layerType = webView.getLayerType();
        webView.setLayerType(1, null);
        Bitmap bitmapRo = ro(wsyVar);
        if (bitmapRo == null) {
            bitmapRo = fm(webView);
        }
        webView.setLayerType(layerType, null);
        if (bitmapRo == null) {
            return null;
        }
        return com.bytedance.sdk.component.utils.yz.fm(bitmapRo, bitmapRo.getWidth() / 6, bitmapRo.getHeight() / 6);
    }

    public static void fm(final com.bytedance.sdk.openadsdk.core.model.lse lseVar, final String str, final String str2, final Bitmap bitmap, final String str3, final long j10) {
        xgn.ro(new com.bytedance.sdk.component.wu.ro.lb("startCheckPlayableStatusPercentage") { // from class: com.bytedance.sdk.openadsdk.utils.zan.3
            @Override // java.lang.Runnable
            public void run() {
                zan.lb(lseVar, str, str2, bitmap, str3, j10);
            }
        }, 10);
    }

    public static int fm(Bitmap bitmap) {
        try {
            ArrayList<Integer> arrayListRo = ro(bitmap);
            if (arrayListRo == null) {
                return -1;
            }
            HashMap map = new HashMap();
            for (Integer num : arrayListRo) {
                if (map.containsKey(num)) {
                    Integer numValueOf = Integer.valueOf(((Integer) map.get(num)).intValue() + 1);
                    map.remove(num);
                    map.put(num, numValueOf);
                } else {
                    map.put(num, 1);
                }
            }
            int iIntValue = 0;
            int i10 = 0;
            for (Map.Entry entry : map.entrySet()) {
                int iIntValue2 = ((Integer) entry.getValue()).intValue();
                if (i10 < iIntValue2) {
                    iIntValue = ((Integer) entry.getKey()).intValue();
                    i10 = iIntValue2;
                }
            }
            if (iIntValue == 0) {
                return -1;
            }
            return (int) ((i10 / ((bitmap.getWidth() * bitmap.getHeight()) * 1.0f)) * 100.0f);
        } catch (Throwable unused) {
            return -1;
        }
    }

    public static boolean fm(float f10, float f11, Context context) {
        if (f10 != -1.0f && f11 != -1.0f) {
            if (wu == null) {
                wu = ViewConfiguration.get(context);
            }
            if (f7574ef == -1) {
                f7574ef = wu.getScaledTouchSlop();
            }
            if (f10 - f11 > f7574ef) {
                return true;
            }
        }
        return false;
    }

    public static void fm(boolean z10) {
        ku = Boolean.valueOf(z10);
    }
}