package com.bytedance.sdk.openadsdk.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
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.brentvatne.react.ReactVideoViewManager;
import com.bytedance.JProtect;
import com.bytedance.sdk.openadsdk.core.settings.EH;
import com.bytedance.sdk.openadsdk.utils.wN;
import com.google.android.gms.ads.identifier.AdvertisingIdClient;
import com.ironsource.md;
import com.unity3d.services.core.properties.MadeWithUnityDetector;
import java.io.IOException;
import java.util.Iterator;
import java.util.Locale;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
import okhttp3.internal.ws.RealWebSocket;
import org.json.JSONException;
import org.json.JSONObject;
/* loaded from: classes2.dex */
public class DeviceUtils {
    private static int GA = 0;
    private static int NjR = 0;
    public static String YFl = "";
    private static int YoT;
    private static int eT;
    private static int nc;
    private static int qsH;
    private static volatile long Sg = System.currentTimeMillis();
    private static volatile boolean tN = false;
    private static volatile boolean AlY = false;
    private static volatile boolean wN = false;
    private static volatile boolean vc = true;
    private static long DSW = 0;
    private static AtomicBoolean pDU = new AtomicBoolean(false);

    public static int DSW() {
        return nc;
    }

    private static int EH(Context context) {
        return YoT;
    }

    public static int NjR() {
        return NjR;
    }

    public static long YFl() {
        return Sg;
    }

    private static int lG(Context context) {
        return GA;
    }

    public static int qsH() {
        return eT;
    }

    public static int qsH(Context context) {
        return qsH;
    }

    public static void YFl(Context context) {
        if (tN) {
            return;
        }
        try {
            Sg sg = new Sg();
            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(sg, intentFilter);
            tN = true;
        } catch (Throwable unused) {
        }
    }

    @JProtect
    public static boolean Sg() {
        if (SystemClock.elapsedRealtime() - DSW >= 20000) {
            DSW = SystemClock.elapsedRealtime();
            try {
                PowerManager powerManager = (PowerManager) com.bytedance.sdk.openadsdk.core.lG.YFl().getSystemService("power");
                if (powerManager != null) {
                    vc = powerManager.isInteractive();
                }
            } catch (Throwable th) {
                com.bytedance.sdk.component.utils.YoT.YFl("TTAD.DeviceUtils", th.getMessage());
            }
        }
        return vc;
    }

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

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

    public static int AlY(Context context) {
        if (tN(context)) {
            return 3;
        }
        return Sg(context) ? 2 : 1;
    }

    private static void YFl(JSONObject jSONObject) throws JSONException {
        Sg(jSONObject);
    }

    private static void Sg(JSONObject jSONObject) throws JSONException {
        jSONObject.put(md.v, Build.MODEL);
        if (com.bytedance.sdk.openadsdk.core.lG.AlY().dXO(md.D0)) {
            jSONObject.put(md.D0, com.bytedance.sdk.openadsdk.Wwa.YFl.Sg.YFl.YFl().Sg());
        }
    }

    @JProtect
    public static JSONObject YFl(Context context, boolean z) {
        String Sg2;
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("sys_adb_status", vc(context));
            YFl(jSONObject);
            jSONObject.put("type", AlY(context));
            jSONObject.put(md.y, 1);
            jSONObject.put("os_version", Build.VERSION.RELEASE);
            jSONObject.put("vendor", Build.MANUFACTURER);
            jSONObject.put("conn_type", Sco.YoT(context));
            jSONObject.put("app_set_id", com.bytedance.sdk.openadsdk.core.settings.AlY.tN());
            jSONObject.put("app_set_id_scope", com.bytedance.sdk.openadsdk.core.settings.AlY.Sg());
            jSONObject.put("installed_source", com.bytedance.sdk.openadsdk.core.settings.AlY.AlY());
            jSONObject.put("screen_width", GS.tN(context));
            jSONObject.put("screen_height", GS.AlY(context));
            jSONObject.put("sec_did", com.bytedance.sdk.openadsdk.core.NjR.tN.DSW());
            com.bytedance.sdk.openadsdk.core.settings.vc AlY2 = com.bytedance.sdk.openadsdk.core.lG.AlY();
            if (AlY2.dXO("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.YoT.tN(context));
            jSONObject.put("rom_version", bZ.YFl());
            jSONObject.put("sys_compiling_time", com.bytedance.sdk.openadsdk.core.YoT.Sg(context));
            jSONObject.put("timezone", Sco.Wwa());
            jSONObject.put("language", com.bytedance.sdk.openadsdk.core.YoT.YFl());
            jSONObject.put("carrier_name", YI.YFl());
            if (z) {
                Sg2 = Sco.YFl(context);
            } else {
                Sg2 = Sco.Sg(context);
            }
            jSONObject.put("total_mem", String.valueOf(Long.parseLong(Sg2) * RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE));
            jSONObject.put("locale_language", AlY());
            jSONObject.put("screen_bright", Math.ceil(wN() * 10.0f) / 10.0d);
            jSONObject.put("is_screen_off", !Sg() ? 1 : 0);
            jSONObject.put("cpu_num", DSW.YFl(context));
            jSONObject.put("cpu_max_freq", DSW.Sg(context));
            jSONObject.put("cpu_min_freq", DSW.tN(context));
            wN.YFl YFl2 = wN.YFl();
            jSONObject.put("battery_remaining_pct", (int) YFl2.Sg);
            jSONObject.put("is_charging", YFl2.YFl);
            jSONObject.put("total_space", String.valueOf(Sco.tN(context)));
            jSONObject.put("free_space_in", String.valueOf(Sco.AlY(context)));
            jSONObject.put("sdcard_size", String.valueOf(Sco.wN(context)));
            jSONObject.put("rooted", Sco.vc(context));
            jSONObject.put("enable_assisted_clicking", vc());
            jSONObject.put("force_language", com.bytedance.sdk.component.utils.qO.YFl(context, "tt_choose_language"));
            jSONObject.put("airplane", DSW(context));
            jSONObject.put("darkmode", pDU(context));
            jSONObject.put("headset", EH(context));
            jSONObject.put("ringmute", qsH(context));
            jSONObject.put("screenscale", rkt(context));
            jSONObject.put(ReactVideoViewManager.PROP_VOLUME, qsH());
            jSONObject.put("low_power_mode", lG(context));
            if (AlY2.dXO("mnc")) {
                jSONObject.put("mnc", YI.tN());
            }
            if (AlY2.dXO("mcc")) {
                jSONObject.put("mcc", YI.Sg());
            }
            jSONObject.put("act", com.bytedance.sdk.openadsdk.core.act.YFl.Sg(context));
            jSONObject.put("act_event", com.bytedance.sdk.openadsdk.core.act.YFl.YFl());
            String AlY3 = com.bytedance.sdk.openadsdk.core.NjR.tN.AlY();
            Object[] objArr = new Object[2];
            Long.valueOf(com.bytedance.sdk.openadsdk.core.NjR.tN.wN());
            if (!TextUtils.isEmpty(AlY3)) {
                jSONObject.put("sof_chara", AlY3);
            }
        } catch (Exception unused) {
        }
        return jSONObject;
    }

    public static JSONObject wN(Context context) {
        return YFl(context, false);
    }

    public static int tN() {
        return com.bytedance.sdk.openadsdk.core.tN.YFl(com.bytedance.sdk.openadsdk.core.lG.YFl()).Sg("limit_ad_track", -1);
    }

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

    public static float wN() {
        int i = -1;
        try {
            Context YFl2 = com.bytedance.sdk.openadsdk.core.lG.YFl();
            if (YFl2 != null) {
                i = Settings.System.getInt(YFl2.getContentResolver(), "screen_brightness", -1);
            }
        } catch (Throwable th) {
            com.bytedance.sdk.component.utils.YoT.YFl("TTAD.DeviceUtils", th.getMessage());
        }
        if (i < 0) {
            return -1.0f;
        }
        return Math.round((i / 255.0f) * 10.0f) / 10.0f;
    }

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

    public static int vc(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.YoT.YFl("TTAD.DeviceUtils", th.getMessage());
            return -1;
        }
    }

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

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

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

    public static String NjR(Context context) {
        if (TextUtils.isEmpty(YFl)) {
            YFl = com.bytedance.sdk.openadsdk.core.tN.YFl(context).Sg("framework_name", "");
        }
        return YFl;
    }

    @JProtect
    public static void nc() {
        new tN().run();
        Context YFl2 = com.bytedance.sdk.openadsdk.core.lG.YFl();
        if (YFl2 != null) {
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("cpu_count", DSW.YFl());
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("cpu_max_frequency", DSW.YFl(DSW.YFl()));
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("cpu_min_frequency", DSW.Sg(DSW.YFl()));
            String NjR2 = Sco.NjR();
            if (NjR2 != null) {
                com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("total_memory", NjR2);
            }
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("total_internal_storage", Sco.nc());
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("free_internal_storage", com.bytedance.sdk.component.utils.GA.YFl());
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("total_sdcard_storage", Sco.eT());
            com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("is_root", Sco.YoT() ? 1 : 0);
            if (TextUtils.isEmpty(NjR(YFl2))) {
                try {
                    Class.forName(MadeWithUnityDetector.UNITY_PLAYER_CLASS_NAME);
                    YFl = "unity";
                } catch (ClassNotFoundException unused) {
                    YFl = "native";
                }
                com.bytedance.sdk.openadsdk.core.tN.YFl(YFl2).YFl("framework_name", YFl);
            }
            eT();
            Wwa(YFl2);
            GA = aIu(YFl2);
        }
    }

    public static void eT() {
        try {
            int ringerMode = ((AudioManager) com.bytedance.sdk.openadsdk.core.lG.YFl().getSystemService("audio")).getRingerMode();
            if (ringerMode == 2) {
                qsH = 1;
            } else if (ringerMode == 1) {
                qsH = 2;
            } else {
                qsH = 0;
            }
        } catch (Throwable unused) {
        }
    }

    private static void Wwa(Context context) {
        try {
            AudioManager audioManager = (AudioManager) context.getSystemService("audio");
            NjR = audioManager.getStreamMaxVolume(3);
            int streamVolume = audioManager.getStreamVolume(3);
            nc = streamVolume;
            eT = (int) ((streamVolume / NjR) * 100.0d);
        } catch (Throwable unused) {
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void qO(Context context) {
        if (context == null) {
            return;
        }
        final Context applicationContext = context.getApplicationContext();
        mn.Sg(new com.bytedance.sdk.component.qsH.qsH("DeviceUtils_get_low_power_mode") { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.1
            @Override // java.lang.Runnable
            public void run() {
                int unused = DeviceUtils.GA = DeviceUtils.aIu(applicationContext);
            }
        });
    }

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

    /* JADX WARN: Code restructure failed: missing block: B:13:0x0031, code lost:
        if (android.provider.Settings.System.getInt(r4.getContentResolver(), "SmartModeStatus") == 4) goto L7;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static int wXo(android.content.Context r4) {
        /*
            java.lang.String r0 = android.os.Build.MANUFACTURER     // Catch: java.lang.Throwable -> L35
            java.lang.String r1 = "XIAOMI"
            boolean r0 = r0.equalsIgnoreCase(r1)     // Catch: java.lang.Throwable -> L35
            r1 = 1
            r2 = 0
            if (r0 == 0) goto L1c
            android.content.ContentResolver r4 = r4.getContentResolver()     // Catch: java.lang.Throwable -> L35
            java.lang.String r0 = "POWER_SAVE_MODE_OPEN"
            int r4 = android.provider.Settings.System.getInt(r4, r0)     // Catch: java.lang.Throwable -> L35
            if (r4 != r1) goto L19
            goto L1a
        L19:
            r1 = r2
        L1a:
            r2 = r1
            goto L34
        L1c:
            java.lang.String r0 = android.os.Build.MANUFACTURER     // Catch: java.lang.Throwable -> L35
            java.lang.String r3 = "HUAWEI"
            boolean r0 = r0.equalsIgnoreCase(r3)     // Catch: java.lang.Throwable -> L35
            if (r0 == 0) goto L34
            android.content.ContentResolver r4 = r4.getContentResolver()     // Catch: java.lang.Throwable -> L35
            java.lang.String r0 = "SmartModeStatus"
            int r4 = android.provider.Settings.System.getInt(r4, r0)     // Catch: java.lang.Throwable -> L35
            r0 = 4
            if (r4 != r0) goto L19
            goto L1a
        L34:
            return r2
        L35:
            r4 = -1
            return r4
        */
        throw new UnsupportedOperationException("Method not decompiled: com.bytedance.sdk.openadsdk.utils.DeviceUtils.wXo(android.content.Context):int");
    }

    public static void nc(Context context) {
        AudioInfoReceiver.Sg(context);
    }

    public static void eT(Context context) {
        Context applicationContext;
        if (wN || context == null || (applicationContext = context.getApplicationContext()) == null) {
            return;
        }
        try {
            if (Build.MANUFACTURER.equalsIgnoreCase("XIAOMI")) {
                Ne(applicationContext);
            } else {
                YFl.Sg(applicationContext);
            }
            wN = true;
        } catch (Throwable unused) {
        }
    }

    private static void Ne(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.2
            @Override // android.database.ContentObserver
            public void onChange(boolean z) {
                super.onChange(z);
                DeviceUtils.qO(applicationContext);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes2.dex */
    public static class Sg extends BroadcastReceiver {
        Sg() {
        }

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

    /* loaded from: classes2.dex */
    public static class tN implements Runnable {
        /* JADX WARN: Multi-variable type inference failed */
        /* JADX WARN: Type inference failed for: r1v6, types: [com.bytedance.sdk.openadsdk.core.tN] */
        /* JADX WARN: Type inference failed for: r3v0 */
        /* JADX WARN: Type inference failed for: r3v1, types: [int] */
        /* JADX WARN: Type inference failed for: r3v3 */
        @Override // java.lang.Runnable
        public void run() {
            ?? r3;
            try {
                final AdvertisingIdClient.Info advertisingIdInfo = AdvertisingIdClient.getAdvertisingIdInfo(com.bytedance.sdk.openadsdk.core.lG.YFl());
                if (advertisingIdInfo != null) {
                    boolean isLimitAdTrackingEnabled = advertisingIdInfo.isLimitAdTrackingEnabled();
                    DeviceUtils.Sg(advertisingIdInfo);
                    com.bytedance.sdk.openadsdk.core.settings.rkt.YFl(new EH.YFl() { // from class: com.bytedance.sdk.openadsdk.utils.DeviceUtils.tN.1
                        @Override // com.bytedance.sdk.openadsdk.core.settings.EH.YFl
                        public void YFl() {
                            DeviceUtils.Sg(advertisingIdInfo);
                        }

                        @Override // com.bytedance.sdk.openadsdk.core.settings.EH.YFl
                        public void Sg() {
                            DeviceUtils.Sg(advertisingIdInfo);
                        }
                    });
                    r3 = isLimitAdTrackingEnabled;
                } else {
                    r3 = -1;
                }
                if (r3 != -1) {
                    com.bytedance.sdk.openadsdk.core.tN.YFl(com.bytedance.sdk.openadsdk.core.lG.YFl()).YFl("limit_ad_track", r3);
                }
            } catch (IOException e) {
                com.bytedance.sdk.component.utils.YoT.YFl("TTAD.DeviceUtils", "getLmtTask error : signaling connection to Google Play Services failed.", e);
            } catch (Throwable th) {
                com.bytedance.sdk.component.utils.YoT.YFl("TTAD.DeviceUtils", th.getMessage());
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void Sg(AdvertisingIdClient.Info info) {
        if (!com.bytedance.sdk.openadsdk.core.lG.AlY().dXO(md.D0) || pDU.getAndSet(true)) {
            return;
        }
        String id = info.getId();
        if (TextUtils.isEmpty(id)) {
            return;
        }
        com.bytedance.sdk.openadsdk.Wwa.YFl.Sg.YFl.YFl().Sg(id);
        com.bytedance.sdk.openadsdk.Wwa.YFl.Sg.YFl.YFl(id);
        com.bytedance.sdk.openadsdk.core.NjR.tN.YFl(id);
    }

    /* loaded from: classes2.dex */
    public static class AudioInfoReceiver extends BroadcastReceiver {
        static final CopyOnWriteArrayList<com.bytedance.sdk.openadsdk.YoT.DSW> YFl = new CopyOnWriteArrayList<>();

        /* JADX INFO: Access modifiers changed from: private */
        public static void Sg(Context context) {
            if (!DeviceUtils.AlY && context != null) {
                try {
                    IntentFilter intentFilter = new IntentFilter();
                    intentFilter.addAction("android.media.VOLUME_CHANGED_ACTION");
                    intentFilter.addAction("android.intent.action.HEADSET_PLUG");
                    context.registerReceiver(new AudioInfoReceiver(), intentFilter);
                    boolean unused = DeviceUtils.AlY = true;
                } catch (Throwable unused2) {
                }
            }
        }

        public static void YFl(com.bytedance.sdk.openadsdk.YoT.DSW dsw) {
            if (dsw != null) {
                CopyOnWriteArrayList<com.bytedance.sdk.openadsdk.YoT.DSW> copyOnWriteArrayList = YFl;
                if (copyOnWriteArrayList.contains(dsw)) {
                    return;
                }
                copyOnWriteArrayList.add(dsw);
            }
        }

        public static void Sg(com.bytedance.sdk.openadsdk.YoT.DSW dsw) {
            if (dsw == null) {
                return;
            }
            YFl.remove(dsw);
        }

        @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 (intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1) == 3) {
                        int unused = DeviceUtils.nc = intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_VALUE", 0);
                        Iterator<com.bytedance.sdk.openadsdk.YoT.DSW> it = YFl.iterator();
                        while (it.hasNext()) {
                            it.next().YFl(DeviceUtils.nc);
                        }
                        if (DeviceUtils.NjR != 0) {
                            int unused2 = DeviceUtils.eT = (int) ((DeviceUtils.nc / DeviceUtils.NjR) * 100.0d);
                        }
                    }
                } else if ("android.intent.action.HEADSET_PLUG".equals(intent.getAction())) {
                    int unused3 = DeviceUtils.YoT = intent.getIntExtra("state", 0);
                }
            } catch (Exception unused4) {
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* loaded from: classes2.dex */
    public static class YFl extends BroadcastReceiver {
        private YFl() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static void Sg(Context context) {
            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 (Build.VERSION.SDK_INT >= 33) {
                    context.registerReceiver(new YFl(), intentFilter, 2);
                } else {
                    context.registerReceiver(new YFl(), 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.qO(context);
            } else if ("huawei.intent.action.POWER_MODE_CHANGED_ACTION".equals(intent.getAction())) {
                int unused = DeviceUtils.GA = intent.getIntExtra("state", 0) == 1 ? 1 : 0;
            }
        }
    }
}