package com.bytedance.sdk.openadsdk.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageInfo;
import android.database.ContentObserver;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.os.PowerManager;
import android.os.SystemClock;
import android.provider.Settings;
import android.text.TextUtils;
import android.view.accessibility.AccessibilityManager;
import com.bytedance.sdk.openadsdk.core.settings.vt;
import com.bytedance.sdk.openadsdk.utils.wsy;
import com.pgl.ssdk.ces.out.PglSSConfig;
import com.pgl.ssdk.ces.out.PglSupport;
import defpackage.e;
import java.util.Iterator;
import java.util.Locale;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
import org.json.JSONException;
import org.json.JSONObject;
import tv.danmaku.ijk.media.player.IjkMediaMeta;

/* JADX INFO: loaded from: classes2.dex */
public class DeviceUtils {
    private static int dsz = 0;

    /* JADX INFO: renamed from: ef, reason: collision with root package name */
    private static int f7531ef = 0;
    private static int fhx = 0;
    public static String fm = "";
    private static int irt;
    private static int onz;
    private static int wu;
    private static volatile long ro = System.currentTimeMillis();

    /* JADX INFO: renamed from: lb, reason: collision with root package name */
    private static volatile boolean f7532lb = false;
    private static volatile boolean yz = false;
    private static volatile boolean jnr = false;
    private static volatile boolean ajl = true;
    private static long wsy = 0;
    private static String vt = "";
    private static int ku = 0;
    private static final AtomicBoolean duv = new AtomicBoolean(false);
    private static AtomicBoolean qhl = new AtomicBoolean(false);
    private static final Object gof = new Object();
    private static volatile String gqi = null;
    private static volatile String wey = null;

    public static class AudioInfoReceiver extends BroadcastReceiver {
        static final CopyOnWriteArrayList<com.bytedance.sdk.openadsdk.dsz.ef> fm = new CopyOnWriteArrayList<>();

        /* JADX INFO: Access modifiers changed from: private */
        public static void ro(Context context) {
            if (DeviceUtils.yz || context == null) {
                return;
            }
            try {
                IntentFilter intentFilter = new IntentFilter();
                intentFilter.addAction("android.media.VOLUME_CHANGED_ACTION");
                intentFilter.addAction("android.intent.action.HEADSET_PLUG");
                context.registerReceiver(new AudioInfoReceiver(), intentFilter, null, com.bytedance.sdk.component.utils.ef.fm());
                boolean unused = DeviceUtils.yz = true;
            } catch (Throwable unused2) {
            }
        }

        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if (intent == null) {
                return;
            }
            try {
                if (!"android.media.VOLUME_CHANGED_ACTION".equals(intent.getAction())) {
                    if ("android.intent.action.HEADSET_PLUG".equals(intent.getAction())) {
                        int unused = DeviceUtils.fhx = intent.getIntExtra("state", 0);
                    }
                } else if (intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1) == 3) {
                    int unused2 = DeviceUtils.dsz = intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_VALUE", 0);
                    if (!fm.isEmpty()) {
                        xgn.fm(new Runnable() { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.AudioInfoReceiver.1
                            @Override // java.lang.Runnable
                            public void run() {
                                Iterator<com.bytedance.sdk.openadsdk.dsz.ef> it = AudioInfoReceiver.fm.iterator();
                                while (it.hasNext()) {
                                    it.next().lb(DeviceUtils.dsz);
                                }
                            }
                        });
                    }
                    if (DeviceUtils.f7531ef != 0) {
                        int unused3 = DeviceUtils.onz = (int) ((((double) DeviceUtils.dsz) / ((double) DeviceUtils.f7531ef)) * 100.0d);
                    }
                }
            } catch (Exception unused4) {
            }
        }

        public static void fm(com.bytedance.sdk.openadsdk.dsz.ef efVar) {
            if (efVar != null) {
                CopyOnWriteArrayList<com.bytedance.sdk.openadsdk.dsz.ef> copyOnWriteArrayList = fm;
                if (copyOnWriteArrayList.contains(efVar)) {
                    return;
                }
                copyOnWriteArrayList.add(efVar);
            }
        }

        public static void ro(com.bytedance.sdk.openadsdk.dsz.ef efVar) {
            if (efVar == null) {
                return;
            }
            fm.remove(efVar);
        }
    }

    public static class fm extends BroadcastReceiver {
        private fm() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static void ro(Context context) {
            int i10 = Build.VERSION.SDK_INT;
            if (context != null) {
                IntentFilter intentFilter = new IntentFilter();
                intentFilter.addAction("android.os.action.POWER_SAVE_MODE_CHANGED");
                intentFilter.addAction("huawei.intent.action.POWER_MODE_CHANGED_ACTION");
                if (i10 >= 33) {
                    context.registerReceiver(new fm(), intentFilter, 2);
                } else {
                    context.registerReceiver(new fm(), intentFilter);
                }
            }
        }

        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if (intent == null || context == null) {
                return;
            }
            if ("android.os.action.POWER_SAVE_MODE_CHANGED".equals(intent.getAction())) {
                DeviceUtils.sds(context);
            } else if ("huawei.intent.action.POWER_MODE_CHANGED_ACTION".equals(intent.getAction())) {
                int unused = DeviceUtils.irt = intent.getIntExtra("state", 0) == 1 ? 1 : 0;
            }
        }
    }

    public static class ro extends BroadcastReceiver {
        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if ("android.intent.action.SCREEN_ON".equals(intent.getAction())) {
                boolean unused = DeviceUtils.ajl = true;
            } else if ("android.intent.action.SCREEN_OFF".equals(intent.getAction())) {
                boolean unused2 = DeviceUtils.ajl = false;
            } else if ("android.intent.action.USER_PRESENT".equals(intent.getAction())) {
                long unused3 = DeviceUtils.ro = System.currentTimeMillis();
            }
        }
    }

    public static int ajl(Context context) {
        if (!duv.get()) {
            fhx(context);
        }
        return ku;
    }

    public static void duv() {
        try {
            int ringerMode = ((AudioManager) com.bytedance.sdk.openadsdk.core.gof.fm().getSystemService("audio")).getRingerMode();
            if (ringerMode == 2) {
                wu = 1;
            } else if (ringerMode == 1) {
                wu = 2;
            } else {
                wu = 0;
            }
        } catch (Throwable unused) {
        }
    }

    public static int ef() {
        return f7531ef;
    }

    private static float gof(Context context) {
        return context.getResources().getDisplayMetrics().density;
    }

    private static int gqi(Context context) {
        return irt;
    }

    private static void hlt(Context context) {
        final Context applicationContext = context.getApplicationContext();
        if (applicationContext == null) {
            return;
        }
        context.getContentResolver().registerContentObserver(Uri.parse("content://settings/system/POWER_SAVE_MODE_OPEN"), false, new ContentObserver(null) { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.3
            @Override // android.database.ContentObserver
            public void onChange(boolean z10) {
                super.onChange(z10);
                DeviceUtils.sds(applicationContext);
            }
        });
    }

    public static String jnr(Context context) {
        if (!duv.get()) {
            fhx(context);
        }
        return vt;
    }

    public static void ku() {
        com.bytedance.sdk.openadsdk.core.settings.ku.fm(new vt.fm() { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.1
            @Override // com.bytedance.sdk.openadsdk.core.settings.vt.fm
            public void fm() {
                com.bytedance.sdk.openadsdk.sds.fm.ro.fm.fm().fm(true);
            }

            @Override // com.bytedance.sdk.openadsdk.core.settings.vt.fm
            public void ro() {
                com.bytedance.sdk.openadsdk.sds.fm.ro.fm.fm().fm(true);
                DeviceUtils.qhl();
            }
        });
        Context contextFm = com.bytedance.sdk.openadsdk.core.gof.fm();
        if (contextFm != null) {
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("cpu_count", vt.fm());
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("cpu_max_frequency", vt.fm(vt.fm()));
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("cpu_min_frequency", vt.ro(vt.fm()));
            String strKu = bx.ku();
            if (strKu != null) {
                com.bytedance.sdk.openadsdk.core.lb.fm().fm("total_memory", strKu);
            }
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("total_internal_storage", bx.duv());
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("free_internal_storage", com.bytedance.sdk.component.utils.qhl.fm());
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("total_sdcard_storage", bx.fhx());
            com.bytedance.sdk.openadsdk.core.lb.fm().fm("is_root", bx.qhl() ? 1 : 0);
            if (TextUtils.isEmpty(vt())) {
                try {
                    Class.forName("com.unity3d.player.UnityPlayer");
                    fm = "unity";
                } catch (ClassNotFoundException unused) {
                    fm = "native";
                }
                com.bytedance.sdk.openadsdk.core.lb.fm().fm("framework_name", fm);
            }
            duv();
            wey(contextFm);
            irt = maa(contextFm);
            wu.fm(contextFm);
            qhl();
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:7:0x0019  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static int lse(Context context) {
        try {
            String str = Build.MANUFACTURER;
            int i10 = 1;
            if (str.equalsIgnoreCase("XIAOMI")) {
                if (Settings.System.getInt(context.getContentResolver(), "POWER_SAVE_MODE_OPEN") != 1) {
                    i10 = 0;
                }
            } else {
                if (!str.equalsIgnoreCase("HUAWEI")) {
                    return 0;
                }
                if (Settings.System.getInt(context.getContentResolver(), "SmartModeStatus") != 4) {
                }
            }
            return i10;
        } catch (Throwable unused) {
            return -1;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static int maa(Context context) {
        if (context == null) {
            return 0;
        }
        try {
            String str = Build.MANUFACTURER;
            if (!str.equalsIgnoreCase("XIAOMI") && !str.equalsIgnoreCase("HUAWEI")) {
                return ((PowerManager) context.getSystemService("power")).isPowerSaveMode() ? 1 : 0;
            }
            return lse(context);
        } catch (Throwable unused) {
            return 0;
        }
    }

    private static int qhl(Context context) {
        return fhx;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void sds(Context context) {
        if (context == null) {
            return;
        }
        final Context applicationContext = context.getApplicationContext();
        xgn.lb((Runnable) new com.bytedance.sdk.component.wu.ro.lb("DeviceUtils_get_low_power_mode") { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.2
            @Override // java.lang.Runnable
            public void run() {
                int unused = DeviceUtils.irt = DeviceUtils.maa(applicationContext);
            }
        });
    }

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

    private static void wey(Context context) {
        try {
            AudioManager audioManager = (AudioManager) context.getSystemService("audio");
            f7531ef = audioManager.getStreamMaxVolume(3);
            int streamVolume = audioManager.getStreamVolume(3);
            dsz = streamVolume;
            onz = (int) ((((double) streamVolume) / ((double) f7531ef)) * 100.0d);
        } catch (Throwable unused) {
        }
    }

    public static int wsy() {
        return dsz;
    }

    public static int wu() {
        return onz;
    }

    public static int ef(Context context) {
        try {
            return Settings.Global.getInt(context.getContentResolver(), "airplane_mode_on", 0) != 0 ? 1 : 0;
        } catch (Throwable unused) {
            return -1;
        }
    }

    private static void fhx(Context context) {
        if (context == null || !duv.compareAndSet(false, true)) {
            return;
        }
        try {
            if (com.bytedance.sdk.openadsdk.hlt.jnr.fm("gp_v_enable", 0) == 1) {
                PackageInfo packageInfo = context.getPackageManager().getPackageInfo("com.android.vending", 0);
                vt = packageInfo.versionName;
                ku = packageInfo.versionCode;
            }
        } catch (Throwable unused) {
        }
    }

    public static long fm() {
        return ro;
    }

    private static String gof() {
        try {
            return wey == null ? com.bytedance.sdk.openadsdk.core.lb.fm().ro("bt_id", "") : wey;
        } catch (Throwable unused) {
            return "";
        }
    }

    private static String gqi() {
        try {
            if (gqi == null) {
                synchronized (gof) {
                    try {
                        if (gqi == null) {
                            gqi = fm(String.valueOf(System.currentTimeMillis() - SystemClock.elapsedRealtime()), com.bytedance.sdk.openadsdk.core.lb.fm().ro("bt_time", ""), "bt_time");
                        }
                    } catch (Throwable th) {
                        throw th;
                    }
                }
            }
        } catch (Throwable unused) {
            gqi = "";
        }
        return gqi;
    }

    private static int irt(Context context) {
        int i10;
        try {
            i10 = context.getApplicationContext().getResources().getConfiguration().uiMode & 48;
        } catch (Throwable unused) {
        }
        if (i10 == 32) {
            return 1;
        }
        return i10 == 16 ? 0 : -1;
    }

    public static boolean lb(Context context) {
        try {
            return (context.getResources().getConfiguration().uiMode & 15) == 4;
        } catch (Throwable unused) {
            return false;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void qhl() {
        if (com.bytedance.sdk.openadsdk.core.gof.yz().gzf("bt_id")) {
            try {
                if (wey == null) {
                    synchronized (gof) {
                        try {
                            if (wey == null) {
                                wey = fm(PglSupport.getBootid(), com.bytedance.sdk.openadsdk.core.lb.fm().ro("bt_id", ""), "bt_id");
                            }
                        } catch (Throwable th) {
                            throw th;
                        }
                    }
                }
            } catch (Throwable unused) {
                wey = "";
            }
        }
    }

    public static String vt() {
        if (TextUtils.isEmpty(fm)) {
            fm = com.bytedance.sdk.openadsdk.core.lb.fm().ro("framework_name", "");
        }
        return fm;
    }

    public static JSONObject wsy(Context context) {
        return fm(context, false);
    }

    public static int wu(Context context) {
        if (context == null) {
            return -1;
        }
        try {
            return Settings.Secure.getInt(context.getContentResolver(), "adb_enabled", -1);
        } catch (Throwable th) {
            com.bytedance.sdk.component.utils.wey.lb("TTAD.DeviceUtils", th.getMessage());
            return -1;
        }
    }

    public static int yz(Context context) {
        if (lb(context)) {
            return 3;
        }
        return ro(context) ? 2 : 1;
    }

    public static int ajl() {
        AccessibilityManager accessibilityManager = (AccessibilityManager) com.bytedance.sdk.openadsdk.core.gof.fm().getSystemService("accessibility");
        if (accessibilityManager == null) {
            return -1;
        }
        return accessibilityManager.isEnabled() ? 1 : 0;
    }

    public static void duv(Context context) {
        Context applicationContext;
        if (jnr || context == null || (applicationContext = context.getApplicationContext()) == null) {
            return;
        }
        try {
            if (!Build.MANUFACTURER.equalsIgnoreCase("XIAOMI")) {
                fm.ro(applicationContext);
            } else {
                hlt(applicationContext);
            }
            jnr = true;
        } catch (Throwable unused) {
        }
    }

    public static float jnr() {
        int i10 = -1;
        try {
            Context contextFm = com.bytedance.sdk.openadsdk.core.gof.fm();
            if (contextFm != null) {
                i10 = Settings.System.getInt(contextFm.getContentResolver(), "screen_brightness", -1);
            }
        } catch (Throwable th) {
            com.bytedance.sdk.component.utils.wey.lb("TTAD.DeviceUtils", th.getMessage());
        }
        if (i10 < 0) {
            return -1.0f;
        }
        return Math.round((i10 / 255.0f) * 10.0f) / 10.0f;
    }

    private static void lb(JSONObject jSONObject) throws JSONException {
        jSONObject.put("model", Build.MODEL);
        com.bytedance.sdk.openadsdk.sds.fm.ro.fm.fm().fm(jSONObject);
    }

    public static boolean ro() {
        if (SystemClock.elapsedRealtime() - wsy >= 20000) {
            wsy = SystemClock.elapsedRealtime();
            try {
                PowerManager powerManager = (PowerManager) com.bytedance.sdk.openadsdk.core.gof.fm().getSystemService("power");
                if (powerManager != null) {
                    ajl = powerManager.isInteractive();
                }
            } catch (Throwable th) {
                com.bytedance.sdk.component.utils.wey.lb("TTAD.DeviceUtils", th.getMessage());
            }
        }
        return ajl;
    }

    public static String yz() {
        String languageTag = Locale.getDefault().toLanguageTag();
        return !TextUtils.isEmpty(languageTag) ? languageTag : "";
    }

    public static void fm(Context context) {
        if (f7532lb) {
            return;
        }
        try {
            ro roVar = new ro();
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction("android.intent.action.SCREEN_ON");
            intentFilter.addAction("android.intent.action.SCREEN_OFF");
            intentFilter.addAction("android.intent.action.USER_PRESENT");
            context.getApplicationContext().registerReceiver(roVar, intentFilter);
            f7532lb = true;
        } catch (Throwable unused) {
        }
    }

    public static int lb() {
        return com.bytedance.sdk.openadsdk.core.lb.fm().ro("limit_ad_track", -1);
    }

    public static boolean ro(Context context) {
        try {
            return (context.getResources().getConfiguration().screenLayout & 15) >= 3;
        } catch (Throwable unused) {
            return false;
        }
    }

    private static void ro(JSONObject jSONObject) throws JSONException {
        lb(jSONObject);
    }

    public static JSONObject fm(Context context, boolean z10) {
        String strVt;
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("sys_adb_status", wu(context));
            ro(jSONObject);
            jSONObject.put("type", yz(context));
            jSONObject.put("os", 1);
            jSONObject.put("os_version", Build.VERSION.RELEASE);
            jSONObject.put("vendor", Build.MANUFACTURER);
            jSONObject.put("conn_type", bx.wu(context));
            jSONObject.put("app_set_id", com.bytedance.sdk.openadsdk.core.settings.yz.lb());
            jSONObject.put("app_set_id_scope", com.bytedance.sdk.openadsdk.core.settings.yz.ro());
            jSONObject.put("installed_source", com.bytedance.sdk.openadsdk.core.settings.yz.yz());
            jSONObject.put("screen_scale", zan.ajl(context));
            jSONObject.put("density", zan.wu(context));
            jSONObject.put("screen_width", zan.lb(context));
            jSONObject.put("screen_height", zan.jnr(context));
            jSONObject.put("sec_did", com.bytedance.sdk.openadsdk.core.duv.lb.ajl());
            com.bytedance.sdk.openadsdk.core.settings.ku kuVarYz = com.bytedance.sdk.openadsdk.core.gof.yz();
            if (kuVarYz.gzf("boot")) {
                jSONObject.put("boot", String.valueOf(System.currentTimeMillis() - SystemClock.elapsedRealtime()));
                jSONObject.put("power_on_time", String.valueOf(SystemClock.elapsedRealtime()));
            }
            jSONObject.put("uuid", com.bytedance.sdk.openadsdk.core.dsz.lb(context));
            jSONObject.put("rom_version", gzf.fm());
            jSONObject.put("sys_compiling_time", com.bytedance.sdk.openadsdk.core.dsz.ro(context));
            jSONObject.put("timezone", bx.mq());
            jSONObject.put(IjkMediaMeta.IJKM_KEY_LANGUAGE, com.bytedance.sdk.openadsdk.core.dsz.ro());
            jSONObject.put("carrier_name", ol.fm());
            if (z10) {
                strVt = bx.fm(context);
                jSONObject.put("board", Build.BOARD);
                jSONObject.put("device_city", bx.hlt());
                fm(jSONObject);
            } else {
                strVt = bx.vt();
            }
            jSONObject.put("total_mem", String.valueOf(Long.parseLong(strVt) * 1024));
            jSONObject.put("locale_language", yz());
            jSONObject.put("screen_bright", Math.ceil(jnr() * 10.0f) / 10.0d);
            jSONObject.put("is_screen_off", !ro() ? 1 : 0);
            jSONObject.put("cpu_num", vt.ro());
            jSONObject.put("cpu_max_freq", vt.lb());
            jSONObject.put("cpu_min_freq", vt.yz());
            wsy.fm fmVarFm = wsy.fm();
            jSONObject.put("battery_remaining_pct", (int) fmVarFm.ro);
            jSONObject.put("is_charging", fmVarFm.fm);
            jSONObject.put("total_space", String.valueOf(bx.ro(context)));
            jSONObject.put("free_space_in", String.valueOf(bx.dsz()));
            jSONObject.put("sdcard_size", String.valueOf(bx.onz()));
            jSONObject.put("rooted", bx.irt());
            jSONObject.put("enable_assisted_clicking", ajl());
            jSONObject.put("force_language", com.bytedance.sdk.component.utils.maa.fm(context, "tt_choose_language"));
            jSONObject.put("airplane", ef(context));
            jSONObject.put("darkmode", irt(context));
            jSONObject.put("headset", qhl(context));
            jSONObject.put("ringmute", vt(context));
            jSONObject.put("screenscale", gof(context));
            jSONObject.put("volume", wu());
            jSONObject.put("low_power_mode", gqi(context));
            jSONObject.put("enable_draw_feed", bx.wbw());
            if (z10) {
                wu.fm(jSONObject, context);
                jSONObject.put("gp_v_name", jnr(context));
                jSONObject.put("gp_v_code", ajl(context));
            }
            if (kuVarYz.gzf("mnc")) {
                jSONObject.put("mnc", ol.lb());
            }
            if (kuVarYz.gzf("mcc")) {
                jSONObject.put("mcc", ol.ro());
            }
            jSONObject.put("act", com.bytedance.sdk.openadsdk.core.fm.fm.ro(context));
            jSONObject.put("act_event", com.bytedance.sdk.openadsdk.core.fm.fm.fm());
            String strLb = com.bytedance.sdk.openadsdk.core.duv.lb.lb();
            com.bytedance.sdk.openadsdk.core.duv.lb.yz();
            if (!TextUtils.isEmpty(strLb)) {
                jSONObject.put("sof_chara", strLb);
            }
            String strRo = com.bytedance.sdk.openadsdk.gqi.yz.fm.ro("ttopenadsdk", PglSSConfig.CUSTOMINFO_KEY_IPV6, "");
            if (!strRo.isEmpty()) {
                jSONObject.put("ipv6", strRo);
            }
            jSONObject.put("is_multi", !com.bytedance.sdk.component.utils.sds.fm(com.bytedance.sdk.openadsdk.core.gof.fm()));
        } catch (Exception unused) {
        }
        return jSONObject;
    }

    public static void ku(Context context) {
        AudioInfoReceiver.ro(context);
    }

    public static void fm(JSONObject jSONObject) {
        try {
            com.bytedance.sdk.openadsdk.core.settings.ku kuVarYz = com.bytedance.sdk.openadsdk.core.gof.yz();
            if (kuVarYz.gzf("boot")) {
                jSONObject.put("bt_time", gqi());
            } else {
                jSONObject.put("bt_time", "not_allowed");
                com.bytedance.sdk.openadsdk.core.lb.fm().fm("bt_time");
            }
            if (kuVarYz.gzf("bt_id")) {
                jSONObject.put("bt_id", gof());
            } else {
                jSONObject.put("bt_id", "not_allowed");
                com.bytedance.sdk.openadsdk.core.lb.fm().fm("bt_id");
            }
        } catch (Throwable unused) {
        }
    }

    private static String fm(String str, String str2, String str3) {
        if (TextUtils.isEmpty(str)) {
            return str2;
        }
        if (!TextUtils.isEmpty(str2)) {
            String[] strArrSplit = str2.split(",");
            int iNt = com.bytedance.sdk.openadsdk.core.settings.ku.ro().nt();
            if (iNt != 1) {
                if (str.equals(strArrSplit[0])) {
                    return str2;
                }
                if ("bt_time".equals(str3) && Math.abs(Long.parseLong(str) - Long.parseLong(strArrSplit[0])) < 1000) {
                    return str2;
                }
                if (strArrSplit.length < iNt) {
                    str = e.j(str, ",", str2);
                } else {
                    int iLastIndexOf = str2.lastIndexOf(",");
                    if (iLastIndexOf != -1) {
                        str = e.j(str, ",", str2.substring(0, iLastIndexOf));
                    }
                }
            }
        }
        com.bytedance.sdk.openadsdk.core.lb.fm().fm(str3, str);
        return str;
    }
}