package com.benq.platform;

import F1.AbstractC0123h;
import F1.AbstractC0125i;
import F1.H;
import F1.I;
import F1.O;
import F1.W;
import G0.h;
import G0.k;
import G0.n;
import G0.o;
import H0.q;
import Y0.d;
import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.IPackageDataObserver;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.hardware.display.DisplayManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.TetheringManager;
import android.net.Uri;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Binder;
import android.os.Build;
import android.os.UserHandle;
import android.util.Log;
import android.view.Display;
import android.view.WindowManager;
import android.view.WindowMetrics;
import androidx.annotation.Keep;
import androidx.core.hardware.display.DisplayManagerCompat;
import com.benq.platform.IBenqService;
import com.benq.platform.IFPBenQService;
import com.benq.platform.app.App;
import com.benq.platform.manager.AMSManager;
import com.benq.platform.manager.WiFiConfigManager;
import com.benq.platform.monitor.AppEventMonitor;
import com.benq.platform.monitor.SystemEventMonitor;
import com.benq.platform.utils.Constant;
import com.benq.platform.utils.FeatureUtils;
import com.benq.platform.utils.TouchPanelUtils;
import com.benq.platform.utils.UDIHelper;
import com.cvte.vman.impl.NetworkCtrlManager;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.ifpdos.udi.sdk.UdiSdk;
import com.seewo.sdk.model.SDKSourceModel;
import d0.AbstractC0443c;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import kotlin.coroutines.jvm.internal.l;
import kotlin.jvm.internal.g;
import n1.l;
import n1.m;
import n1.s;
import o1.AbstractC0676l;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import r1.AbstractC0707b;
import y1.p;

/* JADX INFO: loaded from: classes.dex */
public final class IFPBenQService extends IBenqService.Stub {
    public static final String ACTION_OPEN_TOUCH_PANEL = "com.ifpdos.touchpanel.START_TOUCH_PANEL";
    public static final String ACTION_SLIDEBAR_OFF = "action.ist.benq.sidebar_off";
    public static final String ACTION_SLIDEBAR_OFF_NEW = "action.benq.sidebar_off";
    public static final String ACTION_SLIDEBAR_ON = "action.ist.benq.sidebar_on";
    public static final String ACTION_SLIDEBAR_ON_NEW = "action.benq.sidebar_on";
    private static final int ACTIVITY_TYPE_HOME = 2;
    public static final String BENQ_PERSIST_INSTA_MODE = "persist.sys.benqbutton.config";
    public static final String BENQ_PROP_SIDE_BAR = "persist.sys.benq.sidebar";
    public static final String BROADCAST_ACTION_CROP_MODE_CHANGE = "com.ifpdos.touchpanel.crop.change";
    public static final Companion Companion = new Companion(null);
    public static final String KEY_SYSTEMBAR_TOOLBAR_STATUS = "KEY_SYSTEMBAR_TOOLBAR_STATUS";
    public static final String PERSIST_BENQ_DEVICE_MODE = "persist.sys.benq.device.mode";
    public static final String PERSIST_BENQ_DEVICE_MODE_CROP = "corporation";
    public static final String PERSIST_BENQ_DEVICE_MODE_SIGNAGE = "signage";
    public static final String PERSIST_BENQ_DEVICE_MODE_STANDARD = "standard";
    public static final String PROP_DISABLE_BUILT_IN_CAMERA = "persist.sys.benq.disable_built_in_camera";
    public static final String PROP_OSD_ADVANDCED_SETTING_ENABLED = "persist.sys.benq.osd_advanced_setting_enabled";
    private static final String THUMBNAILS_PATH = "/sdcard/.SourceThumbnails";
    public static final String TOUCH_PANEL_PACKAGE_NAME = "com.ifpdos.touchpanel";
    private final Context context;
    private String hotspotInterfaceName;
    private final n1.e mApiVersion$delegate;
    private final AppEventMonitor mAppEventMonitor;
    private final IFPBenQAudioRecordService mAudioRecordService;
    private final IFPBenQCameraService mCameraService;
    private final n1.e mClient$delegate;
    private final HashSet<ICtsStateCallback> mCtsStateCallbackSet;
    private final n1.e mGson$delegate;
    private final BroadcastReceiver mReceiver;
    private ScheduledExecutorService mScheduledSingleThreadPool;
    private final SystemEventMonitor mSystemEventMonitor;
    private long mTimeOut;
    private final IFPBenQService$mTimeOutRunnable$1 mTimeOutRunnable;
    private TouchPanelUtils mTouchPanelUtils;
    private final n1.e mWifiConfigManger$delegate;
    private TetheringManager tetheringManager;

    public static final class Companion {

        public static final class Broadcast {
            public static final String ACTION_BENQ_API = "com.benq.platform.BenQApi";
            public static final String ACTION_BENQ_API_RETURN = "com.benq.platform.BenQApi.RESULT";
            public static final String ACTION_BENQ_IDLE_TIMEOUT = "com.benq.action.IDLE_TIMEOUT";
            public static final String ACTION_BENQ_IS_EXTENT_DISPLAY = "com.benq.action.IS_ENABLE_EXTEND_DISPLAY";
            public static final String ACTION_BENQ_PROP_CHANGE = "com.benq.action.PROP_CHANGE";
            public static final String ACTION_BENQ_SETTING = "com.benq.action.click.settingmenu";
            public static final String ACTION_CHANGE_TO_DUPLICATE_DISPLAY = "com.ifpdos.displaycenter.CHANGE_TO_DUPLICATE_DISPLAY";
            public static final String ACTION_CHANGE_TO_EXTEND_DISPLAY = "com.ifpdos.displaycenter.CHANGE_TO_EXTEND_DISPLAY";
            public static final String ACTION_GOOGLE_PLAY_APP_FILTER = "com.ifpdos.touchpanel.google_play_app_filter";
            public static final String ACTION_OSSERVICE_SHOW_VOLUME_BAR = "com.ifpdos.osservice.show_volume_bar";
            public static final String ACTION_RECEIVED_INPUT_EVENT = "com.ifpdos.osservice.RECEIVED_INPUT_EVENT";
            public static final String EXTRA_METHOD = "method";
            public static final String EXTRA_PAGE = "page";
            public static final String EXTRA_PARAMS_1 = "params1";
            public static final String EXTRA_RESULT = "result";
            public static final Broadcast INSTANCE = new Broadcast();
            public static final String VALUE_CONNECTION = "Connection";
            public static final String VALUE_SETTING = "Setting";

            private Broadcast() {
            }
        }

        public static final class CO2_LEVEL {
            private static int CO2_LOW;
            public static final CO2_LEVEL INSTANCE = new CO2_LEVEL();
            private static int CO2_MODERATE = 1;
            private static int CO2_HIGH = 2;
            private static int CO2_VERY_HIGH = 3;

            private CO2_LEVEL() {
            }

            public final int getCO2_HIGH() {
                return CO2_HIGH;
            }

            public final int getCO2_LOW() {
                return CO2_LOW;
            }

            public final int getCO2_MODERATE() {
                return CO2_MODERATE;
            }

            public final int getCO2_VERY_HIGH() {
                return CO2_VERY_HIGH;
            }

            public final void setCO2_HIGH(int i2) {
                CO2_HIGH = i2;
            }

            public final void setCO2_LOW(int i2) {
                CO2_LOW = i2;
            }

            public final void setCO2_MODERATE(int i2) {
                CO2_MODERATE = i2;
            }

            public final void setCO2_VERY_HIGH(int i2) {
                CO2_VERY_HIGH = i2;
            }
        }

        public /* synthetic */ Companion(g gVar) {
            this();
        }

        private Companion() {
        }
    }

    @Keep
    public static final class EnableBody {

        @SerializedName("enable")
        private final boolean enable;

        public EnableBody(boolean z2) {
            this.enable = z2;
        }

        public static /* synthetic */ EnableBody copy$default(EnableBody enableBody, boolean z2, int i2, Object obj) {
            if ((i2 & 1) != 0) {
                z2 = enableBody.enable;
            }
            return enableBody.copy(z2);
        }

        public final boolean component1() {
            return this.enable;
        }

        public final EnableBody copy(boolean z2) {
            return new EnableBody(z2);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            return (obj instanceof EnableBody) && this.enable == ((EnableBody) obj).enable;
        }

        public final boolean getEnable() {
            return this.enable;
        }

        public int hashCode() {
            return Boolean.hashCode(this.enable);
        }

        public String toString() {
            return "EnableBody(enable=" + this.enable + ")";
        }
    }

    @Keep
    public static final class ValueBody {

        @SerializedName("value")
        private final float value;

        public ValueBody(float f2) {
            this.value = f2;
        }

        public static /* synthetic */ ValueBody copy$default(ValueBody valueBody, float f2, int i2, Object obj) {
            if ((i2 & 1) != 0) {
                f2 = valueBody.value;
            }
            return valueBody.copy(f2);
        }

        public final float component1() {
            return this.value;
        }

        public final ValueBody copy(float f2) {
            return new ValueBody(f2);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            return (obj instanceof ValueBody) && Float.compare(this.value, ((ValueBody) obj).value) == 0;
        }

        public final float getValue() {
            return this.value;
        }

        public int hashCode() {
            return Float.hashCode(this.value);
        }

        public String toString() {
            return "ValueBody(value=" + this.value + ")";
        }
    }

    /* JADX INFO: renamed from: com.benq.platform.IFPBenQService$getSystemLogZipFile$1, reason: invalid class name */
    @kotlin.coroutines.jvm.internal.f(c = "com.benq.platform.IFPBenQService$getSystemLogZipFile$1", f = "IFPBenQService.kt", l = {1277}, m = "invokeSuspend")
    static final class AnonymousClass1 extends l implements p {
        final /* synthetic */ String $fileName;
        final /* synthetic */ String $filePath;
        int label;

        /* JADX INFO: renamed from: com.benq.platform.IFPBenQService$getSystemLogZipFile$1$1, reason: invalid class name and collision with other inner class name */
        @kotlin.coroutines.jvm.internal.f(c = "com.benq.platform.IFPBenQService$getSystemLogZipFile$1$1", f = "IFPBenQService.kt", l = {}, m = "invokeSuspend")
        static final class C00621 extends l implements p {
            final /* synthetic */ String $fileName;
            final /* synthetic */ String $filePath;
            int label;

            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
            C00621(String str, String str2, q1.d dVar) {
                super(2, dVar);
                this.$filePath = str;
                this.$fileName = str2;
            }

            @Override // kotlin.coroutines.jvm.internal.a
            public final q1.d create(Object obj, q1.d dVar) {
                return new C00621(this.$filePath, this.$fileName, dVar);
            }

            @Override // y1.p
            public final Object invoke(H h2, q1.d dVar) {
                return ((C00621) create(h2, dVar)).invokeSuspend(s.f5871a);
            }

            @Override // kotlin.coroutines.jvm.internal.a
            public final Object invokeSuspend(Object obj) throws Throwable {
                AbstractC0707b.d();
                if (this.label != 0) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                m.b(obj);
                d.a aVarB = Y0.d.b("xbug -d " + this.$filePath + "/xBug_" + this.$fileName + ".zip", false);
                boolean zExportLog = UDIHelper.INSTANCE.exportLog(this.$filePath + "/LogService_" + this.$fileName + ".zip");
                Log.d("BenQIFPSys", "result:" + aVarB.f1900a + " result2:" + zExportLog);
                if (aVarB.f1900a != 0 || !zExportLog) {
                    Y0.c.h("BenQIFPSys", "getSystemLogZipFile fail");
                    return "null";
                }
                Y0.c.h("BenQIFPSys", "getSystemLogZipFile success");
                B0.a.c(this.$filePath, "/sdcard/benq/" + this.$fileName + ".zip");
                return "/sdcard/benq/" + this.$fileName + ".zip";
            }
        }

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        AnonymousClass1(String str, String str2, q1.d dVar) {
            super(2, dVar);
            this.$filePath = str;
            this.$fileName = str2;
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final q1.d create(Object obj, q1.d dVar) {
            return new AnonymousClass1(this.$filePath, this.$fileName, dVar);
        }

        @Override // y1.p
        public final Object invoke(H h2, q1.d dVar) {
            return ((AnonymousClass1) create(h2, dVar)).invokeSuspend(s.f5871a);
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final Object invokeSuspend(Object obj) {
            Object objD = AbstractC0707b.d();
            int i2 = this.label;
            if (i2 == 0) {
                m.b(obj);
                O oB = AbstractC0125i.b(I.a(W.b()), null, null, new C00621(this.$filePath, this.$fileName, null), 3, null);
                this.label = 1;
                obj = oB.q(this);
                if (obj == objD) {
                    return objD;
                }
            } else {
                if (i2 != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                m.b(obj);
            }
            return obj;
        }
    }

    /* JADX INFO: renamed from: com.benq.platform.IFPBenQService$onOOBEComplete$1, reason: invalid class name and case insensitive filesystem */
    @kotlin.coroutines.jvm.internal.f(c = "com.benq.platform.IFPBenQService$onOOBEComplete$1", f = "IFPBenQService.kt", l = {1619}, m = "invokeSuspend")
    static final class C04071 extends l implements p {
        final /* synthetic */ kotlin.jvm.internal.s $needReboot;
        int label;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        C04071(kotlin.jvm.internal.s sVar, q1.d dVar) {
            super(2, dVar);
            this.$needReboot = sVar;
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final q1.d create(Object obj, q1.d dVar) {
            return IFPBenQService.this.new C04071(this.$needReboot, dVar);
        }

        @Override // y1.p
        public final Object invoke(H h2, q1.d dVar) {
            return ((C04071) create(h2, dVar)).invokeSuspend(s.f5871a);
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final Object invokeSuspend(Object obj) {
            Object objD = AbstractC0707b.d();
            int i2 = this.label;
            if (i2 == 0) {
                m.b(obj);
                IFPBenQService iFPBenQService = IFPBenQService.this;
                this.label = 1;
                obj = iFPBenQService.setGooglePlayFeature(true, (q1.d) this);
                if (obj == objD) {
                    return objD;
                }
            } else {
                if (i2 != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                m.b(obj);
            }
            if (((Boolean) obj).booleanValue()) {
                this.$needReboot.f5100b = true;
            } else {
                Y0.c.b("BenQIFPSys", "setGooglePlayFeature failed in onOOBEComplete");
            }
            return s.f5871a;
        }
    }

    /* JADX INFO: renamed from: com.benq.platform.IFPBenQService$setGooglePlayAppFilter$1, reason: invalid class name and case insensitive filesystem */
    @kotlin.coroutines.jvm.internal.f(c = "com.benq.platform.IFPBenQService$setGooglePlayAppFilter$1", f = "IFPBenQService.kt", l = {1467}, m = "invokeSuspend")
    static final class C04081 extends l implements p {
        final /* synthetic */ boolean $onOff;
        int label;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        C04081(boolean z2, q1.d dVar) {
            super(2, dVar);
            this.$onOff = z2;
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final q1.d create(Object obj, q1.d dVar) {
            return IFPBenQService.this.new C04081(this.$onOff, dVar);
        }

        @Override // y1.p
        public final Object invoke(H h2, q1.d dVar) {
            return ((C04081) create(h2, dVar)).invokeSuspend(s.f5871a);
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final Object invokeSuspend(Object obj) {
            Object objD = AbstractC0707b.d();
            int i2 = this.label;
            if (i2 == 0) {
                m.b(obj);
                IFPBenQService iFPBenQService = IFPBenQService.this;
                boolean z2 = this.$onOff;
                this.label = 1;
                obj = iFPBenQService.setGooglePlayFeature(z2, this);
                if (obj == objD) {
                    return objD;
                }
            } else {
                if (i2 != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                m.b(obj);
            }
            if (((Boolean) obj).booleanValue()) {
                Y0.d.a("sync");
                o.f817a.a();
            } else {
                Y0.c.b("BenQIFPSys", "setGooglePlayAppFilter failed");
            }
            return s.f5871a;
        }
    }

    /* JADX INFO: renamed from: com.benq.platform.IFPBenQService$setGooglePlayFeature$1, reason: invalid class name and case insensitive filesystem */
    @kotlin.coroutines.jvm.internal.f(c = "com.benq.platform.IFPBenQService", f = "IFPBenQService.kt", l = {1738}, m = "setGooglePlayFeature")
    static final class C04091 extends kotlin.coroutines.jvm.internal.d {
        Object L$0;
        int label;
        /* synthetic */ Object result;

        C04091(q1.d dVar) {
            super(dVar);
        }

        @Override // kotlin.coroutines.jvm.internal.a
        public final Object invokeSuspend(Object obj) {
            this.result = obj;
            this.label |= Integer.MIN_VALUE;
            return IFPBenQService.this.setGooglePlayFeature(false, (q1.d) this);
        }
    }

    /* JADX WARN: Type inference failed for: r2v7, types: [com.benq.platform.IFPBenQService$mTimeOutRunnable$1] */
    public IFPBenQService(Context context, IFPBenQAudioRecordService mAudioRecordService) {
        kotlin.jvm.internal.l.e(context, "context");
        kotlin.jvm.internal.l.e(mAudioRecordService, "mAudioRecordService");
        this.context = context;
        this.mAudioRecordService = mAudioRecordService;
        this.mGson$delegate = n1.f.a(IFPBenQService$mGson$2.INSTANCE);
        this.mApiVersion$delegate = n1.f.a(new IFPBenQService$mApiVersion$2(this));
        this.mSystemEventMonitor = new SystemEventMonitor(context);
        this.mAppEventMonitor = new AppEventMonitor(context);
        this.mCameraService = new IFPBenQCameraService(context);
        this.mClient$delegate = n1.f.a(IFPBenQService$mClient$2.INSTANCE);
        this.mWifiConfigManger$delegate = n1.f.a(IFPBenQService$mWifiConfigManger$2.INSTANCE);
        this.mCtsStateCallbackSet = new HashSet<>();
        ScheduledExecutorService scheduledExecutorServiceNewSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
        kotlin.jvm.internal.l.d(scheduledExecutorServiceNewSingleThreadScheduledExecutor, "newSingleThreadScheduledExecutor(...)");
        this.mScheduledSingleThreadPool = scheduledExecutorServiceNewSingleThreadScheduledExecutor;
        this.mTimeOutRunnable = new Runnable() { // from class: com.benq.platform.IFPBenQService$mTimeOutRunnable$1
            @Override // java.lang.Runnable
            public void run() {
                Log.d("BenQIFPSys", "ACTION_BENQ_IDLE_TIMEOUT send");
                com.seewo.hiddenapi.c.c(this.this$0.context, new Intent(IFPBenQService.Companion.Broadcast.ACTION_BENQ_IDLE_TIMEOUT), com.seewo.hiddenapi.g.f3343c);
            }
        };
        Log.d("BenQIFPSys", "IFPBenQService init");
        initializeTetheringManager();
        this.mReceiver = new BroadcastReceiver() { // from class: com.benq.platform.IFPBenQService$mReceiver$1
            /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
            @Override // android.content.BroadcastReceiver
            public void onReceive(Context context2, Intent intent) {
                kotlin.jvm.internal.l.e(context2, "context");
                Log.d("BenQIFPSys", "onReceive " + (intent != null ? intent.getAction() : null));
                String action = intent != null ? intent.getAction() : null;
                if (action != null) {
                    switch (action.hashCode()) {
                        case -1825664171:
                            if (!action.equals(IFPBenQService.Companion.Broadcast.ACTION_CHANGE_TO_EXTEND_DISPLAY)) {
                                return;
                            }
                            break;
                        case -1184518282:
                            if (!action.equals(IFPBenQService.Companion.Broadcast.ACTION_CHANGE_TO_DUPLICATE_DISPLAY)) {
                                return;
                            }
                            break;
                        case -1172645946:
                            if (action.equals("android.net.conn.CONNECTIVITY_CHANGE")) {
                                Object systemService = context2.getSystemService("connectivity");
                                kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
                                NetworkInfo activeNetworkInfo = ((ConnectivityManager) systemService).getActiveNetworkInfo();
                                if (activeNetworkInfo == null || !activeNetworkInfo.isAvailable()) {
                                    return;
                                }
                                Log.d("BenQIFPSys", "onReceive: network changed");
                                IFPBenQService iFPBenQService = this.this$0;
                                iFPBenQService.setIPv6Enabled(iFPBenQService.isIPv6Enabled());
                                return;
                            }
                            return;
                        case -923089036:
                            if (action.equals(IFPBenQService.Companion.Broadcast.ACTION_BENQ_API)) {
                                String stringExtra = intent.getStringExtra(IFPBenQService.Companion.Broadcast.EXTRA_METHOD);
                                if (kotlin.jvm.internal.l.a(stringExtra, "getAllNetworkInterfaceMacAddress")) {
                                    Intent intent2 = new Intent(IFPBenQService.Companion.Broadcast.ACTION_BENQ_API_RETURN);
                                    IFPBenQService iFPBenQService2 = this.this$0;
                                    intent2.putExtra(IFPBenQService.Companion.Broadcast.EXTRA_METHOD, stringExtra);
                                    intent2.putExtra(IFPBenQService.Companion.Broadcast.EXTRA_RESULT, iFPBenQService2.getAllNetworkInterfaceMacAddress());
                                    com.seewo.hiddenapi.c.c(context2, intent2, com.seewo.hiddenapi.g.f3343c);
                                    return;
                                }
                                if (kotlin.jvm.internal.l.a(stringExtra, "getIPMacAddressMap")) {
                                    Intent intent3 = new Intent(IFPBenQService.Companion.Broadcast.ACTION_BENQ_API_RETURN);
                                    IFPBenQService iFPBenQService3 = this.this$0;
                                    intent3.putExtra(IFPBenQService.Companion.Broadcast.EXTRA_METHOD, stringExtra);
                                    intent3.putExtra(IFPBenQService.Companion.Broadcast.EXTRA_RESULT, iFPBenQService3.getIPMacAddressMap(intent.getStringExtra(IFPBenQService.Companion.Broadcast.EXTRA_PARAMS_1)));
                                    com.seewo.hiddenapi.c.c(context2, intent3, com.seewo.hiddenapi.g.f3343c);
                                    return;
                                }
                                return;
                            }
                            return;
                        case -887175540:
                            if (action.equals(IFPBenQService.Companion.Broadcast.ACTION_BENQ_SETTING)) {
                                String stringExtra2 = intent.getStringExtra(IFPBenQService.Companion.Broadcast.EXTRA_PAGE);
                                Intent intent4 = new Intent();
                                intent4.setComponent(new ComponentName(IFPBenQService.TOUCH_PANEL_PACKAGE_NAME, "com.ifpdos.touchpanel.bussiness.service.TouchPanelService"));
                                PackageManager packageManager = context2.getPackageManager();
                                boolean z2 = true;
                                if ((packageManager != null ? packageManager.resolveService(intent4, 0) : null) == null) {
                                    Log.d("BenQIFPSys", "send TouchPanel Broadcast");
                                    Context context3 = this.this$0.context;
                                    Intent intent5 = new Intent("com.cvte.settingmenu.START_TOUCHMENU");
                                    intent5.putExtra("menu", kotlin.jvm.internal.l.a(stringExtra2, IFPBenQService.Companion.Broadcast.VALUE_SETTING) || !kotlin.jvm.internal.l.a(stringExtra2, IFPBenQService.Companion.Broadcast.VALUE_CONNECTION));
                                    com.seewo.hiddenapi.c.c(context3, intent5, com.seewo.hiddenapi.g.f3343c);
                                    return;
                                }
                                Log.d("BenQIFPSys", "start TouchPanel Service");
                                intent4.putExtra(IFPBenQService.ACTION_OPEN_TOUCH_PANEL, true);
                                if (!kotlin.jvm.internal.l.a(stringExtra2, IFPBenQService.Companion.Broadcast.VALUE_SETTING) && kotlin.jvm.internal.l.a(stringExtra2, IFPBenQService.Companion.Broadcast.VALUE_CONNECTION)) {
                                    z2 = false;
                                }
                                intent4.putExtra("menu", z2);
                                intent4.putExtra("menu_index", 0);
                                intent4.putExtra("with_focus", false);
                                com.seewo.hiddenapi.c.e(context2, intent4, com.seewo.hiddenapi.g.f3343c);
                                return;
                            }
                            return;
                        case -434224464:
                            if (action.equals(IFPBenQService.Companion.Broadcast.ACTION_RECEIVED_INPUT_EVENT)) {
                                this.this$0.onInputEvent();
                                return;
                            }
                            return;
                        default:
                            return;
                    }
                    AbstractC0125i.d(I.a(W.b()), null, null, new IFPBenQService$mReceiver$1$onReceive$4(context2, this.this$0, null), 3, null);
                }
            }
        };
    }

    private final void changeOSDProp(Context context, String str, Object obj) {
        Intent intent = new Intent(Companion.Broadcast.ACTION_BENQ_PROP_CHANGE);
        intent.putExtra(str, obj.toString());
        intent.setPackage(TOUCH_PANEL_PACKAGE_NAME);
        context.sendBroadcast(intent);
    }

    private final void checkScheduledExecutorService() {
        if (!this.mScheduledSingleThreadPool.isShutdown()) {
            this.mScheduledSingleThreadPool.shutdownNow();
        }
        ScheduledExecutorService scheduledExecutorServiceNewSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
        kotlin.jvm.internal.l.d(scheduledExecutorServiceNewSingleThreadScheduledExecutor, "newSingleThreadScheduledExecutor(...)");
        this.mScheduledSingleThreadPool = scheduledExecutorServiceNewSingleThreadScheduledExecutor;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final void clearGooglePlayCache(Context context, IPackageDataObserver iPackageDataObserver) {
        try {
            com.seewo.hiddenapi.d.a(context.getPackageManager(), "com.android.vending", iPackageDataObserver);
        } catch (Exception e2) {
            Y0.c.c("BenQIFPSys", "clearGooglePlayCache unexpected error", e2);
        }
    }

    private final int convertSecurityType(int i2) {
        Integer numConvertSecurityType$fieldInt = convertSecurityType$fieldInt("SECURITY_TYPE_OPEN");
        Integer numConvertSecurityType$fieldInt2 = convertSecurityType$fieldInt("SECURITY_TYPE_WPA2_PSK");
        Integer numConvertSecurityType$fieldInt3 = convertSecurityType$fieldInt("SECURITY_TYPE_WPA3_SAE_TRANSITION");
        Integer numConvertSecurityType$fieldInt4 = convertSecurityType$fieldInt("SECURITY_TYPE_WPA3_SAE");
        Integer numConvertSecurityType$fieldInt5 = convertSecurityType$fieldInt("SECURITY_TYPE_WPA3_OWE_TRANSITION");
        Integer numConvertSecurityType$fieldInt6 = convertSecurityType$fieldInt("SECURITY_TYPE_WPA3_OWE");
        if (numConvertSecurityType$fieldInt != null && i2 == numConvertSecurityType$fieldInt.intValue()) {
            return 0;
        }
        if (numConvertSecurityType$fieldInt2 != null && i2 == numConvertSecurityType$fieldInt2.intValue()) {
            return 2;
        }
        if ((numConvertSecurityType$fieldInt3 != null && i2 == numConvertSecurityType$fieldInt3.intValue()) || (numConvertSecurityType$fieldInt4 != null && i2 == numConvertSecurityType$fieldInt4.intValue())) {
            return 4;
        }
        return ((numConvertSecurityType$fieldInt5 != null && i2 == numConvertSecurityType$fieldInt5.intValue()) || (numConvertSecurityType$fieldInt6 != null && i2 == numConvertSecurityType$fieldInt6.intValue())) ? 6 : -1;
    }

    private static final Integer convertSecurityType$fieldInt(String str) {
        try {
            return Integer.valueOf(Class.forName("android.net.wifi.SoftApConfiguration").getField(str).getInt(null));
        } catch (Exception unused) {
            return null;
        }
    }

    private final List<RunningTaskPackageInfo> getDefaultDisplayRunningTaskPackageInfos() {
        Object systemService = this.context.getSystemService("activity");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.app.ActivityManager");
        List<ActivityManager.RunningTaskInfo> runningTasks = ((ActivityManager) systemService).getRunningTasks(100);
        kotlin.jvm.internal.l.d(runningTasks, "getRunningTasks(...)");
        ArrayList<ActivityManager.RunningTaskInfo> arrayList = new ArrayList();
        for (Object obj : runningTasks) {
            if (com.seewo.hiddenapi.f.a((ActivityManager.RunningTaskInfo) obj) == 0) {
                arrayList.add(obj);
            }
        }
        ArrayList arrayList2 = new ArrayList(AbstractC0676l.o(arrayList, 10));
        for (ActivityManager.RunningTaskInfo runningTaskInfo : arrayList) {
            int i2 = runningTaskInfo.taskId;
            ComponentName componentName = runningTaskInfo.topActivity;
            String packageName = null;
            String packageName2 = componentName != null ? componentName.getPackageName() : null;
            ComponentName componentName2 = runningTaskInfo.baseActivity;
            if (componentName2 != null) {
                packageName = componentName2.getPackageName();
            }
            arrayList2.add(new RunningTaskPackageInfo(i2, packageName2, packageName));
        }
        Y0.c.a("BenQIFPSys", "getRunningTaskPackageInfos: " + arrayList2);
        return arrayList2;
    }

    private final int getDisplayId() {
        Display[] displayArrB = AbstractC0443c.b().b(this.context);
        if (displayArrB != null) {
            Y0.c.a("BenQIFPSys", "displays:" + displayArrB.length);
            if (!(displayArrB.length == 0)) {
                Y0.c.a("BenQIFPSys", "getDisplayId:" + displayArrB[0].getDisplayId());
                return displayArrB[0].getDisplayId();
            }
        }
        return 0;
    }

    private final String getInterfaceIp(String str) {
        try {
            NetworkInterface byName = NetworkInterface.getByName(str);
            if (byName == null) {
                return null;
            }
            Iterator<InterfaceAddress> it = byName.getInterfaceAddresses().iterator();
            while (it.hasNext()) {
                InetAddress address = it.next().getAddress();
                if ((address instanceof Inet4Address) && !((Inet4Address) address).isLoopbackAddress()) {
                    return ((Inet4Address) address).getHostAddress();
                }
            }
        } catch (Exception e2) {
            Y0.c.b("BenQIFPSys", "Error getting IP for interface " + str + ": " + e2.getMessage());
        }
        return null;
    }

    private final int getMApiVersion() {
        return ((Number) this.mApiVersion$delegate.getValue()).intValue();
    }

    private final OkHttpClient getMClient() {
        return (OkHttpClient) this.mClient$delegate.getValue();
    }

    private final Gson getMGson() {
        return (Gson) this.mGson$delegate.getValue();
    }

    private final WiFiConfigManager getMWifiConfigManger() {
        return (WiFiConfigManager) this.mWifiConfigManger$delegate.getValue();
    }

    private final String getPassword() {
        String preSharedKey;
        Object systemService = this.context.getSystemService("wifi");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.net.wifi.WifiManager");
        WifiManager wifiManager = (WifiManager) systemService;
        String ssid = wifiManager.getConnectionInfo().getSSID();
        Iterator it = ((List) Z0.c.l(wifiManager).b("getPrivilegedConfiguredNetworks").g()).iterator();
        while (true) {
            if (!it.hasNext()) {
                preSharedKey = HttpUrl.FRAGMENT_ENCODE_SET;
                break;
            }
            WifiConfiguration wifiConfiguration = (WifiConfiguration) it.next();
            Y0.c.a("BenQIFPSys", "targetSsid:" + ssid + " matching SSID:" + wifiConfiguration.SSID);
            if (kotlin.jvm.internal.l.a(wifiConfiguration.SSID, ssid)) {
                preSharedKey = wifiConfiguration.preSharedKey;
                kotlin.jvm.internal.l.d(preSharedKey, "preSharedKey");
                break;
            }
        }
        if (ssid == null || ssid.length() == 0 || preSharedKey.length() <= 0) {
            return preSharedKey;
        }
        String strSubstring = preSharedKey.substring(1, preSharedKey.length() - 1);
        kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
        return strSubstring;
    }

    /* JADX WARN: Multi-variable type inference failed */
    private final Display[] getPresentationDisplays(Context context) {
        Object systemService = context.getSystemService("display");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.hardware.display.DisplayManager");
        Display[] displays = ((DisplayManager) systemService).getDisplays(DisplayManagerCompat.DISPLAY_CATEGORY_PRESENTATION);
        ArrayList arrayList = new ArrayList();
        kotlin.jvm.internal.l.b(displays);
        for (Display display : displays) {
            if (display.getDisplayId() >= 0) {
                arrayList.add(display);
            }
        }
        int size = arrayList.size();
        Display[] displayArr = new Display[size];
        int size2 = arrayList.size();
        for (int i2 = 0; i2 < size2; i2++) {
            displayArr[i2] = arrayList.get(i2);
        }
        Y0.c.a("BenQIFPSys", "getPresentationDisplays:" + size);
        return displayArr;
    }

    private final int getSecurity(WifiConfiguration wifiConfiguration) {
        Log.d("BenQIFPSys", "getSecurity config.allowedKeyManagement " + wifiConfiguration.allowedKeyManagement);
        if (wifiConfiguration.allowedKeyManagement.get(4) || wifiConfiguration.allowedKeyManagement.get(1)) {
            return 2;
        }
        if (wifiConfiguration.allowedKeyManagement.get(2) || wifiConfiguration.allowedKeyManagement.get(3)) {
            return 3;
        }
        return wifiConfiguration.wepKeys[0] != null ? 1 : 0;
    }

    private final void initializeTetheringManager() {
        if (Build.VERSION.SDK_INT >= 30) {
            try {
                this.tetheringManager = (TetheringManager) this.context.getSystemService(TetheringManager.class);
                TetheringManager.TetheringEventCallback tetheringEventCallback = new TetheringManager.TetheringEventCallback() { // from class: com.benq.platform.IFPBenQService$initializeTetheringManager$callback$1
                    public void onError(String str, int i2) {
                        Y0.c.b("BenQIFPSys", "Tethering error ifName=" + str + " code=" + i2);
                    }

                    public void onTetheredInterfacesChanged(List<String> interfaces) {
                        kotlin.jvm.internal.l.e(interfaces, "interfaces");
                        Y0.c.a("BenQIFPSys", "Tethering interfaces changed: " + interfaces);
                        ArrayList arrayList = new ArrayList();
                        for (Object obj : interfaces) {
                            if (((String) obj) != null) {
                                arrayList.add(obj);
                            }
                        }
                        if (arrayList.isEmpty()) {
                            this.this$0.hotspotInterfaceName = null;
                            return;
                        }
                        this.this$0.hotspotInterfaceName = (String) AbstractC0676l.y(arrayList);
                        Y0.c.a("BenQIFPSys", "Hotspot interface detected: " + this.this$0.hotspotInterfaceName);
                    }
                };
                TetheringManager tetheringManager = this.tetheringManager;
                if (tetheringManager != null) {
                    tetheringManager.registerTetheringEventCallback(Executors.newSingleThreadExecutor(), tetheringEventCallback);
                }
                Y0.c.a("BenQIFPSys", "TetheringManager initialized successfully");
            } catch (Exception e2) {
                Y0.c.b("BenQIFPSys", "Failed to initialize TetheringManager: " + e2.getMessage());
            }
        }
    }

    private final boolean isHDCPEnableCapture() {
        q qVarF;
        if (T0.a.g(9, 10) && (qVarF = n.f815a.f()) != null) {
            return (qVarF.isHDMI() || qVarF.isTypeC()) && UDIHelper.INSTANCE.getHDMISourceEncryption();
        }
        return false;
    }

    private final boolean isSpecialApp(String str) {
        Object next;
        String className;
        List listH = AbstractC0676l.h("com.android.vending", "com.android.chrome");
        Log.d("BenQIFPSys", "isSpecialApp: " + str);
        Iterator it = listH.iterator();
        while (true) {
            if (!it.hasNext()) {
                next = null;
                break;
            }
            next = it.next();
            if (kotlin.jvm.internal.l.a((String) next, str)) {
                break;
            }
        }
        if (next != null && Build.VERSION.SDK_INT >= 33 && str != null) {
            Object systemService = this.context.getSystemService("activity");
            kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.app.ActivityManager");
            List<ActivityManager.RunningTaskInfo> runningTasks = ((ActivityManager) systemService).getRunningTasks(1);
            kotlin.jvm.internal.l.b(runningTasks);
            if (!runningTasks.isEmpty()) {
                ComponentName componentName = runningTasks.get(0).topActivity;
                if (componentName == null || (className = componentName.getClassName()) == null) {
                    className = HttpUrl.FRAGMENT_ENCODE_SET;
                }
                kotlin.jvm.internal.l.b(className);
                if (kotlin.jvm.internal.l.a(className, "org.chromium.chrome.browser.firstrun.FirstRunActivity") || kotlin.jvm.internal.l.a(className, "com.google.android.finsky.unauthenticated.activity.UnauthenticatedMainActivity")) {
                    return true;
                }
            }
        }
        return false;
    }

    private final void notifyFloatingToolStatus() {
        Intent intent = new Intent("com.benq.ezwrite.floatingtool.VISIBLE_CHANGE");
        intent.putExtra("isVisible", com.seewo.vcommons.data.d.i());
        intent.addFlags(16777216);
        com.seewo.hiddenapi.c.c(this.context, intent, com.seewo.hiddenapi.g.f3343c);
    }

    private final int toIntString(boolean z2) {
        return z2 ? 1 : 0;
    }

    public int ReadCmdIntFromTVOS(String str) {
        Y0.c.h("BenQIFPSys", "ReadCmdIntFromTVOS cmd");
        if (!kotlin.jvm.internal.l.a(str, "CMD_BENQ_GET_NEW_CO2")) {
            return -1;
        }
        int iB = h.f802a.b();
        Y0.c.h("BenQIFPSys", "getCo2:" + iB);
        return iB;
    }

    public void WriteStrToTVOS(Rect rect) {
    }

    public void addExtraSourceNoTouchArea(int i2, Rect rect) {
        if (rect == null) {
            Log.e("BenQIFPSys", "addExtraSourceNoTouchArea FAIL, noTouchArea is NULL");
            return;
        }
        G0.p.f818b.a(i2, rect);
        Y0.c.h("BenQIFPSys", "addExtraSourceNoTouchArea:" + i2 + " rect:" + rect);
    }

    public void changeToBootChannel() {
        n.f815a.j(q.ANDROID);
        Y0.c.h("BenQIFPSys", "changeToBootChannel Android");
    }

    public int configureAudioRecord(int i2, int i3, int i4) {
        return this.mAudioRecordService.configure(i2, i3, i4);
    }

    public String getAllNetworkInterfaceMacAddress() {
        ArrayList<WiFiConfigManager.NetworkMac> networkMacFromHardware = getMWifiConfigManger().getNetworkMacFromHardware();
        Y0.c.h("BenQIFPSys", "getAllNetworkInterfaceMacAddress:" + new Gson().toJson(networkMacFromHardware));
        String json = new Gson().toJson(networkMacFromHardware);
        kotlin.jvm.internal.l.d(json, "toJson(...)");
        return json;
    }

    public int getAmsStatus() {
        return AMSManager.Companion.I().getAmsStatus();
    }

    public int getApiVersion() {
        Y0.c.h("BenQIFPSys", "getApiVersion:" + getMApiVersion());
        return getMApiVersion();
    }

    public int getBacklight() {
        int iA = G0.m.f814a.a();
        Y0.c.h("BenQIFPSys", "getBacklight:" + iA);
        return iA;
    }

    public boolean getBuiltInCameraDisabled() {
        boolean zF = com.seewo.vcommons.data.d.f(PROP_DISABLE_BUILT_IN_CAMERA, false);
        Y0.c.h("BenQIFPSys", "getBuiltInCameraDisabled:" + zF);
        return zF;
    }

    public String getCameraName(String str) {
        return this.mCameraService.getCameraName(str);
    }

    public float getCh2oSensorData() throws IOException {
        Request.Builder builder = new Request.Builder();
        String fullUrl = UdiSdk.getFullUrl("/v1/device/sensor/formaldehyde");
        kotlin.jvm.internal.l.d(fullUrl, "getFullUrl(...)");
        Response responseExecute = getMClient().newCall(builder.url(fullUrl).build()).execute();
        if (responseExecute.code() != 200) {
            Y0.c.h("BenQIFPSys", "getCh2oSensorData fault");
            return 0.0f;
        }
        ResponseBody responseBodyBody = responseExecute.body();
        ValueBody valueBody = (ValueBody) new Gson().fromJson(responseBodyBody != null ? responseBodyBody.string() : null, ValueBody.class);
        Y0.c.h("BenQIFPSys", "getCh2oSensorData:" + valueBody);
        return valueBody.getValue();
    }

    public boolean getCorpMode() {
        return kotlin.jvm.internal.l.a(com.seewo.vcommons.data.d.e("persist.sys.benq.device.mode", "standard"), "corporation");
    }

    public boolean getCtsState() {
        boolean cTSStatus = UDIHelper.INSTANCE.getCTSStatus();
        Y0.c.h("BenQIFPSys", "getCtsState:" + cTSStatus + " " + this.mCtsStateCallbackSet.size());
        return cTSStatus;
    }

    public int getCurrentAudioVolume() {
        int iB = G0.f.f800a.b();
        Y0.c.h("BenQIFPSys", "getCurrentAudioVolume:" + iB);
        return iB;
    }

    public String getCurrentDeviceMode() {
        String strE = com.seewo.vcommons.data.d.e("persist.sys.benq.device.mode", "standard");
        Y0.c.h("BenQIFPSys", "getCurrentDeviceMode:" + strE);
        kotlin.jvm.internal.l.b(strE);
        return strE;
    }

    public String getCurrentSource() {
        n nVar = n.f815a;
        q qVarF = nVar.f();
        List<SDKSourceModel> listD = nVar.d();
        String strName = qVarF.name();
        kotlin.jvm.internal.l.b(listD);
        for (SDKSourceModel sDKSourceModel : listD) {
            if (qVarF == sDKSourceModel.sourceItem) {
                String originName = sDKSourceModel.originName;
                kotlin.jvm.internal.l.d(originName, "originName");
                strName = originName.toUpperCase();
                kotlin.jvm.internal.l.d(strName, "toUpperCase(...)");
            }
        }
        Y0.c.h("BenQIFPSys", "getCurrentSource:" + ((Object) strName));
        return strName;
    }

    public List<String> getCurrentWirelessConnInfo(boolean z2) {
        WifiConfiguration wifiConfiguration;
        Y0.c.a("BenQIFPSys", "getCurrentWirelessConnInfo start " + z2);
        ArrayList arrayList = new ArrayList();
        Object systemService = this.context.getSystemService("wifi");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.net.wifi.WifiManager");
        WifiManager wifiManager = (WifiManager) systemService;
        if (z2) {
            Object systemService2 = this.context.getSystemService("connectivity");
            kotlin.jvm.internal.l.c(systemService2, "null cannot be cast to non-null type android.net.ConnectivityManager");
            NetworkInfo activeNetworkInfo = ((ConnectivityManager) systemService2).getActiveNetworkInfo();
            WifiInfo connectionInfo = wifiManager.getConnectionInfo();
            Y0.c.a("BenQIFPSys", "networkInfo state " + (activeNetworkInfo != null ? Boolean.valueOf(activeNetworkInfo.isConnected()) : null) + " " + (activeNetworkInfo != null ? Integer.valueOf(activeNetworkInfo.getSubtype()) : null));
            if (activeNetworkInfo != null && activeNetworkInfo.isConnected() && activeNetworkInfo.getType() == 1) {
                String ssid = connectionInfo.getSSID();
                kotlin.jvm.internal.l.b(ssid);
                String strSubstring = ssid.substring(1, ssid.length() - 1);
                kotlin.jvm.internal.l.d(strSubstring, "substring(...)");
                arrayList.add(strSubstring);
                if (Build.VERSION.SDK_INT >= 33) {
                    int currentSecurityType = connectionInfo.getCurrentSecurityType();
                    arrayList.add(String.valueOf(currentSecurityType));
                    if (currentSecurityType == 0) {
                        arrayList.add(HttpUrl.FRAGMENT_ENCODE_SET);
                    } else {
                        arrayList.add(getPassword());
                    }
                }
                Y0.c.a("BenQIFPSys", "getCurrentWirelessConnInfo end networkInfo result " + arrayList);
                return arrayList;
            }
        } else {
            try {
                Method method = wifiManager.getClass().getMethod("getWifiApConfiguration", null);
                kotlin.jvm.internal.l.d(method, "getMethod(...)");
                Object objInvoke = method.invoke(wifiManager, null);
                kotlin.jvm.internal.l.c(objInvoke, "null cannot be cast to non-null type android.net.wifi.WifiConfiguration");
                wifiConfiguration = (WifiConfiguration) objInvoke;
            } catch (Exception e2) {
                e2.printStackTrace();
                Y0.c.a("BenQIFPSys", "getCurrentWirelessConnInfo getWifiApConfiguration fail " + e2.getMessage());
                wifiConfiguration = null;
            }
            if (wifiConfiguration != null) {
                arrayList.add(wifiConfiguration.SSID);
                arrayList.add(String.valueOf(getSecurity(wifiConfiguration)));
                arrayList.add(wifiConfiguration.preSharedKey);
                Y0.c.a("BenQIFPSys", "getCurrentWirelessConnInfo end Hotspot result " + arrayList);
                return arrayList;
            }
        }
        Y0.c.a("BenQIFPSys", "getCurrentWirelessConnInfo end result null");
        return null;
    }

    public int getExtendDisplayMode() {
        Y0.c.a("BenQIFPSys", "getExtendDisplayMode");
        int displayId = getDisplayId();
        return (displayId == 0 || AbstractC0443c.b().a(displayId)) ? 1 : 2;
    }

    public boolean getGooglePlayAppFilter() {
        return getGooglePlayFeature();
    }

    public final boolean getGooglePlayFeature() {
        return FeatureUtils.INSTANCE.isFeatureEnabled();
    }

    public List<String> getHotspotInfo() {
        ArrayList arrayList = new ArrayList();
        G0.l lVar = G0.l.f813a;
        arrayList.add(lVar.a() ? "on" : "off");
        boolean zA = lVar.a();
        String strValueOf = HttpUrl.FRAGMENT_ENCODE_SET;
        arrayList.add(zA ? getHotspotIp() : HttpUrl.FRAGMENT_ENCODE_SET);
        Object systemService = this.context.getSystemService("wifi");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.net.wifi.WifiManager");
        SoftApConfiguration softApConfiguration = ((WifiManager) systemService).getSoftApConfiguration();
        kotlin.jvm.internal.l.d(softApConfiguration, "getSoftApConfiguration(...)");
        arrayList.add(lVar.a() ? softApConfiguration.getSsid() : HttpUrl.FRAGMENT_ENCODE_SET);
        arrayList.add(lVar.a() ? softApConfiguration.getPassphrase() : HttpUrl.FRAGMENT_ENCODE_SET);
        int iConvertSecurityType = convertSecurityType(softApConfiguration.getSecurityType());
        if (lVar.a()) {
            strValueOf = String.valueOf(iConvertSecurityType);
        }
        arrayList.add(strValueOf);
        return arrayList;
    }

    public String getHotspotIp() {
        String interfaceIp;
        if (Build.VERSION.SDK_INT < 30 || !T0.a.i(18)) {
            String interfaceIp2 = getInterfaceIp("wlan1");
            if (interfaceIp2 == null || interfaceIp2.length() == 0) {
                return HttpUrl.FRAGMENT_ENCODE_SET;
            }
            Y0.c.h("BenQIFPSys", "getHotspotIp (TetheringManager): " + interfaceIp2 + " from interface wlan1");
            return interfaceIp2;
        }
        String str = this.hotspotInterfaceName;
        if (str != null && (interfaceIp = getInterfaceIp(str)) != null && interfaceIp.length() != 0) {
            Y0.c.h("BenQIFPSys", "getHotspotIp (TetheringManager): " + interfaceIp + " from interface " + str);
            return interfaceIp;
        }
        Log.i("BenQIFPSys", "getHotspotIp: by common interface");
        for (String str2 : AbstractC0676l.h("ap0", "wlan1", "wlan0")) {
            String interfaceIp3 = getInterfaceIp(str2);
            if (interfaceIp3 != null && interfaceIp3.length() != 0) {
                Y0.c.h("BenQIFPSys", "getHotspotIp (fallback): " + interfaceIp3 + " from interface " + str2);
                return interfaceIp3;
            }
        }
        return HttpUrl.FRAGMENT_ENCODE_SET;
    }

    public int getHumidity() {
        float fD = h.f802a.d();
        Y0.c.h("BenQIFPSys", "getHumidity:" + fD);
        return (int) fD;
    }

    public String getIPMacAddressMap(String str) {
        BufferedReader bufferedReader;
        List listF;
        Y0.c.a("BenQIFPSys", "getIPMacAddressMap start " + str);
        StringBuilder sb = new StringBuilder();
        try {
            bufferedReader = new BufferedReader(new FileReader("/proc/net/arp"));
        } catch (Exception e2) {
            Y0.c.a("BenQIFPSys", "getIPMacAddressMap " + e2.getMessage());
        }
        while (true) {
            try {
                String line = bufferedReader.readLine();
                if (line == null) {
                    break;
                }
                kotlin.jvm.internal.l.b(line);
                List listC = new E1.f("\\s+").c(line, 0);
                if (listC.isEmpty()) {
                    listF = AbstractC0676l.f();
                } else {
                    ListIterator listIterator = listC.listIterator(listC.size());
                    while (listIterator.hasPrevious()) {
                        if (((String) listIterator.previous()).length() != 0) {
                            listF = AbstractC0676l.M(listC, listIterator.nextIndex() + 1);
                            break;
                        }
                    }
                    listF = AbstractC0676l.f();
                }
                if (listF.size() >= 6 && !E1.g.D((CharSequence) listF.get(0), "IP", false, 2, null)) {
                    String str2 = (String) listF.get(5);
                    if (str == null || kotlin.jvm.internal.l.a(str2, str)) {
                        String str3 = (String) listF.get(0);
                        String str4 = (String) listF.get(3);
                        Y0.c.a("BenQIFPSys", "getIPMac item " + str4 + " " + str3);
                        if (sb.length() > 0) {
                            sb.append(";");
                        }
                        sb.append(str3);
                        sb.append(":");
                        sb.append(str4);
                    }
                }
                Y0.c.a("BenQIFPSys", "getIPMacAddressMap " + str + " " + ((Object) sb));
                String string = sb.toString();
                kotlin.jvm.internal.l.d(string, "toString(...)");
                return string;
            } finally {
            }
            Y0.c.a("BenQIFPSys", "getIPMacAddressMap " + e2.getMessage());
        }
        s sVar = s.f5871a;
        w1.b.a(bufferedReader, null);
        Y0.c.a("BenQIFPSys", "getIPMacAddressMap " + str + " " + ((Object) sb));
        String string2 = sb.toString();
        kotlin.jvm.internal.l.d(string2, "toString(...)");
        return string2;
    }

    public Map<String, String> getInputSrcMap() {
        Y0.c.h("BenQIFPSys", "getInputSrcMap start");
        HashMap map = new HashMap();
        List<SDKSourceModel> listD = n.f815a.d();
        kotlin.jvm.internal.l.b(listD);
        for (SDKSourceModel sDKSourceModel : listD) {
            String originName = sDKSourceModel.originName;
            kotlin.jvm.internal.l.d(originName, "originName");
            String upperCase = originName.toUpperCase();
            kotlin.jvm.internal.l.d(upperCase, "toUpperCase(...)");
            String name = sDKSourceModel.name;
            kotlin.jvm.internal.l.d(name, "name");
            map.put(upperCase, name);
        }
        ArrayList arrayList = new ArrayList(map.size());
        for (Map.Entry entry : map.entrySet()) {
            arrayList.add(entry.getKey() + ":" + entry.getValue());
        }
        Y0.c.h("BenQIFPSys", "getInputSrcMap end: " + arrayList);
        return map;
    }

    public Map<String, String> getInputSrcPlugStateMap() {
        Y0.c.h("BenQIFPSys", "getInputSrcPlugStateMap start");
        HashMap map = new HashMap();
        List<SDKSourceModel> listD = n.f815a.d();
        kotlin.jvm.internal.l.b(listD);
        for (SDKSourceModel sDKSourceModel : listD) {
            String originName = sDKSourceModel.originName;
            kotlin.jvm.internal.l.d(originName, "originName");
            String upperCase = originName.toUpperCase();
            kotlin.jvm.internal.l.d(upperCase, "toUpperCase(...)");
            map.put(upperCase, sDKSourceModel.hasSignal ? "IN" : HttpUrl.FRAGMENT_ENCODE_SET);
        }
        ArrayList arrayList = new ArrayList(map.size());
        for (Map.Entry entry : map.entrySet()) {
            arrayList.add(entry.getKey() + ":" + entry.getValue());
        }
        Y0.c.h("BenQIFPSys", "getInputSrcPlugStateMap end: " + arrayList);
        return map;
    }

    public boolean getInstaShareButtonMode() {
        return com.seewo.vcommons.data.c.g(this.context, BENQ_PERSIST_INSTA_MODE, 0, com.seewo.hiddenapi.g.f3345e) == 1;
    }

    public List<String> getMajorActiveNetwork() {
        ArrayList arrayList = new ArrayList();
        Object systemService = this.context.getSystemService("connectivity");
        kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
        NetworkInfo activeNetworkInfo = ((ConnectivityManager) systemService).getActiveNetworkInfo();
        Y0.c.a("BenQIFPSys", "networkInfo state " + (activeNetworkInfo != null ? Boolean.valueOf(activeNetworkInfo.isConnected()) : null) + " " + (activeNetworkInfo != null ? Integer.valueOf(activeNetworkInfo.getSubtype()) : null));
        boolean zA = G0.l.f813a.a();
        String str = HttpUrl.FRAGMENT_ENCODE_SET;
        if (zA) {
            arrayList.add("hotspot");
            String hotspotIp = getHotspotIp();
            if (hotspotIp.length() != 0) {
                str = hotspotIp;
            }
            arrayList.add(str);
            Log.d("BenQIFPSys", "getMajorActiveNetwork: hotspot enabled, ip=" + hotspotIp);
            return arrayList;
        }
        if (activeNetworkInfo == null || !activeNetworkInfo.isConnected()) {
            return null;
        }
        int type = activeNetworkInfo.getType();
        if (type == 1) {
            arrayList.add("wifi");
            Object systemService2 = this.context.getSystemService("wifi");
            kotlin.jvm.internal.l.c(systemService2, "null cannot be cast to non-null type android.net.wifi.WifiManager");
            int ipAddress = ((WifiManager) systemService2).getConnectionInfo().getIpAddress();
            String str2 = (ipAddress & 255) + "." + ((ipAddress >> 8) & 255) + "." + ((ipAddress >> 16) & 255) + "." + ((ipAddress >> 24) & 255);
            arrayList.add(str2);
            Log.d("BenQIFPSys", "getMajorActiveNetwork: wifi enabled, ip=" + str2);
        } else {
            if (type != 9) {
                return null;
            }
            arrayList.add("ethernet");
            String interfaceIp = getInterfaceIp("eth0");
            if (interfaceIp != null) {
                str = interfaceIp;
            }
            arrayList.add(str);
            Log.d("BenQIFPSys", "getMajorActiveNetwork: eth enabled, ip=" + interfaceIp);
        }
        return arrayList;
    }

    public String getNfcData(String str) {
        if (str == null) {
            return com.seewo.vcommons.data.c.h(this.context).toString();
        }
        List<W0.a> listH = com.seewo.vcommons.data.c.h(this.context);
        if (listH == null) {
            return HttpUrl.FRAGMENT_ENCODE_SET;
        }
        for (W0.a aVar : listH) {
            if (kotlin.jvm.internal.l.a(aVar.a(), str)) {
                return aVar.b().toString();
            }
        }
        return HttpUrl.FRAGMENT_ENCODE_SET;
    }

    public int getPM10() {
        float sensorData = UDIHelper.INSTANCE.getSensorData("pm10");
        Y0.c.h("BenQIFPSys", "getPM10:" + sensorData);
        return (int) sensorData;
    }

    public int getPMTwoPointFive() {
        float fA = h.f802a.a();
        Y0.c.h("BenQIFPSys", "getPMTwoPointFive:" + fA);
        return (int) fA;
    }

    public String getSelectedCameraId() {
        return this.mCameraService.getSelectedCameraId();
    }

    public String getSerialNumber() {
        String strA = G0.g.f801a.a();
        Y0.c.h("BenQIFPSys", "getSerialNumber:" + strA);
        kotlin.jvm.internal.l.b(strA);
        return strA;
    }

    public String getSourceChannel() {
        List listD = n.f815a.d();
        ArrayList arrayList = new ArrayList();
        kotlin.jvm.internal.l.b(listD);
        List list = listD;
        ArrayList arrayList2 = new ArrayList(AbstractC0676l.o(list, 10));
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String originName = ((SDKSourceModel) it.next()).originName;
            kotlin.jvm.internal.l.d(originName, "originName");
            String upperCase = originName.toUpperCase();
            kotlin.jvm.internal.l.d(upperCase, "toUpperCase(...)");
            arrayList2.add(upperCase);
        }
        Iterator it2 = arrayList2.iterator();
        while (it2.hasNext()) {
            arrayList.add((String) it2.next());
        }
        String json = getMGson().toJson(arrayList);
        Y0.c.h("BenQIFPSys", "getSourceChannel:" + json);
        kotlin.jvm.internal.l.b(json);
        return json;
    }

    public List<String> getSourcePicList() {
        Y0.c.h("BenQIFPSys", "getSourcePicList() start");
        ArrayList arrayList = new ArrayList();
        File file = new File(THUMBNAILS_PATH);
        if (file.exists() && file.isDirectory()) {
            File[] fileArrListFiles = file.listFiles();
            kotlin.jvm.internal.l.d(fileArrListFiles, "listFiles(...)");
            for (File file2 : fileArrListFiles) {
                String name = file2.getName();
                kotlin.jvm.internal.l.d(name, "getName(...)");
                if (E1.g.j(name, ".jpg", true)) {
                    arrayList.add(file2.getAbsolutePath());
                }
            }
        }
        Y0.c.h("BenQIFPSys", "getSourcePicList() end: " + arrayList);
        return arrayList;
    }

    public String getSystemLogZipFile() {
        Log.d("BenQIFPSys", "getSystemLogZipFile");
        String str = "sys_log_" + new SimpleDateFormat("yyyyMMdd", Locale.getDefault()).format(new Date());
        if (!new File("/sdcard/benq/log").exists()) {
            new File("/sdcard/benq/log").mkdirs();
        }
        Log.d("BenQIFPSys", "fileName:" + str + " filePath:/sdcard/benq/log");
        return (String) AbstractC0123h.b(null, new AnonymousClass1("/sdcard/benq/log", str, null), 1, null);
    }

    public int getTemperature() {
        String strE = h.f802a.e();
        Y0.c.h("BenQIFPSys", "getTemperature:" + strE);
        kotlin.jvm.internal.l.b(strE);
        return (int) Float.parseFloat(strE);
    }

    public float getTvocSensorData() throws IOException {
        Request.Builder builder = new Request.Builder();
        String fullUrl = UdiSdk.getFullUrl("/v1/device/sensor/voc");
        kotlin.jvm.internal.l.d(fullUrl, "getFullUrl(...)");
        Response responseExecute = getMClient().newCall(builder.url(fullUrl).build()).execute();
        if (responseExecute.code() != 200) {
            Y0.c.h("BenQIFPSys", "getTvocSensorData fault");
            return 0.0f;
        }
        ResponseBody responseBodyBody = responseExecute.body();
        ValueBody valueBody = (ValueBody) new Gson().fromJson(responseBodyBody != null ? responseBodyBody.string() : null, ValueBody.class);
        Y0.c.h("BenQIFPSys", "getTvocSensorData:" + valueBody);
        return valueBody.getValue();
    }

    public boolean isAndroidWindow() {
        q qVarF = n.f815a.f();
        boolean z2 = qVarF == q.ANDROID;
        Y0.c.h("BenQIFPSys", "currentSource:" + qVarF + ", isAndroid:" + z2);
        return z2;
    }

    public boolean isEnableExtendDisplay() {
        boolean zF = com.seewo.vcommons.data.d.f("persist.sys.benq.extend.display", false);
        Y0.c.a("BenQIFPSys", "isEnableExtendDisplay:" + zF);
        if (zF && h.f802a.c()) {
            return !(getPresentationDisplays(this.context).length == 0);
        }
        return false;
    }

    public boolean isEnableMultiWindow() {
        boolean z2 = com.seewo.vcommons.data.a.b() && com.seewo.vcommons.data.a.a();
        Y0.c.h("BenQIFPSys", "isEnableMultiWindow " + z2);
        return z2;
    }

    public boolean isEyecareON() {
        boolean zN = com.seewo.vcommons.data.c.n(App.Companion.getI());
        Y0.c.h("BenQIFPSys", "isEyecareON, enable:" + zN);
        return zN;
    }

    public boolean isFeatureEnabled() {
        return FeatureUtils.INSTANCE.isFeatureEnabled();
    }

    public boolean isFreezeOn() {
        boolean zJ = Y0.a.j(this.context);
        Y0.c.h("BenQIFPSys", "isFreezeOn:" + isFreezeOn());
        return zJ;
    }

    public boolean isHaveAirSensor() {
        Iterator it = AbstractC0676l.h("co2", "pm25", "formaldehyde", "temperature", "humidity", "voc").iterator();
        while (it.hasNext()) {
            if (UDIHelper.INSTANCE.getSensorEnable((String) it.next())) {
                return true;
            }
        }
        return false;
    }

    public boolean isIPv6Enabled() {
        Object objB;
        try {
            l.a aVar = n1.l.f5861g;
            objB = n1.l.b(Boolean.valueOf(NetworkCtrlManager.getInstance().GetIpv6Enable()));
        } catch (Throwable th) {
            l.a aVar2 = n1.l.f5861g;
            objB = n1.l.b(m.a(th));
        }
        Throwable thD = n1.l.d(objB);
        if (thD != null) {
            Log.e("BenQIFPSys", "getIPv6Enabled: ", thD);
        }
        Boolean bool = Boolean.TRUE;
        if (n1.l.f(objB)) {
            objB = bool;
        }
        Boolean bool2 = (Boolean) objB;
        Y0.c.f("BenQIFPSys", "getIPv6Enabled: " + bool2.booleanValue());
        return bool2.booleanValue();
    }

    public boolean isMute() {
        boolean zC = G0.f.f800a.c();
        Y0.c.h("BenQIFPSys", "isMute:" + zC);
        return zC;
    }

    public boolean isOSDAdvancedSettingEnabled() {
        return com.seewo.vcommons.data.c.f(this.context, PROP_OSD_ADVANDCED_SETTING_ENABLED, 1) == 1;
    }

    public boolean isOsdAirQualitySensorOpen() {
        return TouchPanelUtils.Companion.getInstance(this.context).isAirQualitySensor();
    }

    public boolean isRecordKernelLog() {
        return com.seewo.vcommons.data.d.f("persist.sys.logd.kernel", false);
    }

    public boolean isShowExtendDisplay() {
        return true;
    }

    /* JADX WARN: Removed duplicated region for block: B:28:0x00ab  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public boolean isShowMultiWindow(java.lang.String r9) throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
        /*
            Method dump skipped, instruction units count: 201
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.benq.platform.IFPBenQService.isShowMultiWindow(java.lang.String):boolean");
    }

    public boolean isShowSidebar() {
        boolean zF = com.seewo.vcommons.data.d.f(BENQ_PROP_SIDE_BAR, true);
        Y0.c.h("BenQIFPSys", "isShowSidebar() ? " + zF);
        return zF;
    }

    public boolean isSignageMode() {
        boolean z2 = !com.seewo.vcommons.data.d.i();
        Y0.c.h("BenQIFPSys", "signageMode:" + z2);
        return z2;
    }

    public boolean isSupportMultiWindow(String str) {
        boolean zK = com.seewo.vcommons.data.d.k();
        boolean zF = com.seewo.vcommons.data.d.f("persist.ctm.recents", false);
        Y0.c.h("BenQIFPSys", "isSupportMultiWindow:" + str + ", supportMultiWindow:" + zK + ", supportSplitWindow:" + zF);
        return zK || zF;
    }

    public boolean isUsbPortLocked(int i2) {
        return !Y0.e.a();
    }

    public void lockUsbPort(int i2, boolean z2) {
        com.seewo.vcommons.data.d.q("persist.sys.disable.keyboard", String.valueOf(z2));
        com.seewo.vcommons.data.d.q(Constant.PERSIST_MOUSE_DISABLE, String.valueOf(z2));
        Y0.e.c(this.context, !z2);
    }

    public final void notifyCtsStateChange() {
        Y0.c.h("BenQIFPSys", "cts callback:" + this.mCtsStateCallbackSet.size());
        for (ICtsStateCallback iCtsStateCallback : this.mCtsStateCallbackSet) {
            UDIHelper uDIHelper = UDIHelper.INSTANCE;
            Y0.c.h("BenQIFPSys", "notifyCtsStateChange:" + uDIHelper.getCTSStatus());
            iCtsStateCallback.onStateChange(uDIHelper.getCTSStatus());
        }
    }

    public final void onAfterBinder() {
        Intent intent = new Intent(isShowSidebar() ? ACTION_SLIDEBAR_ON : ACTION_SLIDEBAR_OFF);
        intent.addFlags(16777216);
        Context context = this.context;
        UserHandle userHandle = com.seewo.hiddenapi.g.f3343c;
        com.seewo.hiddenapi.c.c(context, intent, userHandle);
        Intent intent2 = new Intent(isShowSidebar() ? ACTION_SLIDEBAR_ON_NEW : ACTION_SLIDEBAR_OFF_NEW);
        intent2.addFlags(16777216);
        com.seewo.hiddenapi.c.c(this.context, intent2, userHandle);
        notifyFloatingToolStatus();
    }

    public final void onCreate() {
        this.mSystemEventMonitor.onCreate();
        this.mAppEventMonitor.onCreate();
        this.mAudioRecordService.onCreate();
        AMSManager.Companion.I().init();
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Companion.Broadcast.ACTION_BENQ_API);
        intentFilter.addAction(Companion.Broadcast.ACTION_BENQ_SETTING);
        intentFilter.addAction(Companion.Broadcast.ACTION_RECEIVED_INPUT_EVENT);
        intentFilter.addAction(Companion.Broadcast.ACTION_CHANGE_TO_DUPLICATE_DISPLAY);
        intentFilter.addAction(Companion.Broadcast.ACTION_CHANGE_TO_EXTEND_DISPLAY);
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        if (Build.VERSION.SDK_INT >= 33) {
            com.seewo.hiddenapi.c.b(this.context, this.mReceiver, com.seewo.hiddenapi.g.f3341a, intentFilter, null, null, 2);
        } else {
            com.seewo.hiddenapi.c.a(this.context, this.mReceiver, com.seewo.hiddenapi.g.f3341a, intentFilter, null, null);
        }
    }

    public final void onDestroy() {
        this.mSystemEventMonitor.onDestroy();
        this.mAppEventMonitor.onDestroy();
        this.mAudioRecordService.onDestroy();
        AMSManager.Companion.I().deInit();
        this.context.unregisterReceiver(this.mReceiver);
    }

    public final void onInputEvent() {
        Log.d("BenQIFPSys", "onInputEvent " + this.mTimeOut);
        if (this.mTimeOut <= 0) {
            this.mScheduledSingleThreadPool.shutdownNow();
        } else {
            checkScheduledExecutorService();
            this.mScheduledSingleThreadPool.schedule(this.mTimeOutRunnable, this.mTimeOut, TimeUnit.SECONDS);
        }
    }

    public void onOOBEComplete(boolean z2, boolean z3) {
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " onOOBEComplete: benqServiceEnabled=" + z2 + ", needReboot=" + z3);
        kotlin.jvm.internal.s sVar = new kotlin.jvm.internal.s();
        sVar.f5100b = z3;
        if (z2) {
            AbstractC0123h.b(null, new C04071(sVar, null), 1, null);
        }
        if (sVar.f5100b) {
            Y0.d.a("sync");
            o.f817a.a();
        }
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " onOOBEComplete: success=true");
    }

    public void openSplitModeDock() {
        Intent intent = new Intent();
        intent.setClassName("com.seewo.osdocked", "com.seewo.osdocked.MainService");
        intent.putExtra("show_dock_menu", true);
        com.seewo.hiddenapi.c.e(this.context, intent, com.seewo.hiddenapi.g.f3343c);
    }

    public void openVolume() {
        com.seewo.hiddenapi.c.c(this.context, new Intent(Companion.Broadcast.ACTION_OSSERVICE_SHOW_VOLUME_BAR), com.seewo.hiddenapi.g.f3341a);
        Y0.c.h("BenQIFPSys", "openVolume");
    }

    public int playDemoVideo(Uri uri, String str, int i2, int i3, int i4) {
        Y0.c.h("BenQIFPSys", "playDemoVideo:" + uri + ", type:" + str + ", playMode:" + i2 + ", xPosition:" + i3 + ", yPosition:" + i4);
        Intent intent = new Intent("android.intent.action.VIEW");
        intent.setDataAndType(uri, str);
        if (Y0.a.g(this.context, "com.ifpdos.player")) {
            intent.setPackage("com.ifpdos.player");
        }
        intent.putExtra("playMode", i2);
        intent.putExtra("xPosition", i3);
        intent.putExtra("yPosition", i4);
        boolean zO = Y0.a.o(this.context, intent);
        Y0.c.h("BenQIFPSys", "playDemoVideo success? " + zO);
        return zO ? 0 : -1;
    }

    public int readAudioRecord(byte[] bArr, int i2, int i3) {
        return this.mAudioRecordService.read(bArr, i2, i3);
    }

    public void recordKernelLog(boolean z2) {
        com.seewo.vcommons.data.d.q("persist.sys.logd.kernel", String.valueOf(z2));
    }

    public void registerCameraCallback(ICameraSelectionCallback iCameraSelectionCallback) {
        Y0.c.h("BenQIFPSys", "registerCameraCallback is deprecated, ignore");
    }

    public void registerCtsCallback(ICtsStateCallback iCtsStateCallback) {
        if (iCtsStateCallback != null) {
            this.mCtsStateCallbackSet.add(iCtsStateCallback);
        }
        Y0.c.h("BenQIFPSys", "registerCtsCallback " + this.mCtsStateCallbackSet.size());
    }

    public int releaseAudioRecord() {
        return this.mAudioRecordService.release();
    }

    public void removeExtraSourceNoTouchArea(int i2) {
        G0.p.f818b.d(i2);
        Y0.c.h("BenQIFPSys", "removeExtraSourceNoTouchArea:" + i2);
    }

    public Bitmap screenshot() {
        boolean zIsHDCPEnableCapture = isHDCPEnableCapture();
        Y0.c.h("BenQIFPSys", "screenshot start " + zIsHDCPEnableCapture);
        if (zIsHDCPEnableCapture) {
            UDIHelper.INSTANCE.setHdcpCaptureEnable(true);
        }
        Bitmap bitmapM = k.f811b.m(App.Companion.getI());
        if (zIsHDCPEnableCapture) {
            UDIHelper.INSTANCE.setHdcpCaptureEnable(false);
        }
        Y0.c.h("BenQIFPSys", "screenshot:" + bitmapM);
        return bitmapM;
    }

    public Bitmap screenshot1(Rect rect) {
        Y0.c.h("BenQIFPSys", "screenshot start");
        Bitmap bitmapScreenshot = screenshot();
        kotlin.jvm.internal.l.b(bitmapScreenshot);
        if (rect != null) {
            if (rect.left < 0) {
                rect.left = 0;
            }
            if (rect.right < 0) {
                rect.right = 0;
            }
            if (rect.top < 0) {
                rect.top = 0;
            }
            if (rect.bottom < 0) {
                rect.bottom = 0;
            }
            int iAbs = Math.abs(rect.left - rect.right);
            int iAbs2 = Math.abs(rect.top - rect.bottom);
            if (iAbs > 0 && iAbs2 > 0) {
                bitmapScreenshot = Bitmap.createBitmap(bitmapScreenshot, rect.left, rect.top, iAbs, iAbs2);
                kotlin.jvm.internal.l.d(bitmapScreenshot, "createBitmap(...)");
            }
        }
        Y0.c.h("BenQIFPSys", "screenshot:" + bitmapScreenshot);
        return bitmapScreenshot;
    }

    public void setAmsAutoLogoutTimeout(int i2) {
        AMSManager.Companion.I().setAmsAutoLogoutTimeout(i2);
    }

    public void setAmsStatus(int i2) {
        AMSManager.Companion.I().setAmsStatus(i2);
    }

    public void setBacklight(int i2) {
        G0.m.f814a.g(i2);
        Y0.c.h("BenQIFPSys", "setBacklight:" + i2);
    }

    public void setBlankMode(boolean z2) {
        h.f802a.f(!z2);
        StringBuilder sb = new StringBuilder();
        sb.append("setBlankMode:");
        sb.append(!z2);
        Y0.c.h("BenQIFPSys", sb.toString());
    }

    public void setBuiltInCameraDisabled(boolean z2) {
        boolean builtInCameraDisabled = getBuiltInCameraDisabled();
        if (builtInCameraDisabled == z2) {
            Y0.c.h("BenQIFPSys", "setBuiltInCameraDisabled no change:" + builtInCameraDisabled);
            return;
        }
        com.seewo.vcommons.data.d.q(PROP_DISABLE_BUILT_IN_CAMERA, String.valueOf(z2));
        Y0.c.h("BenQIFPSys", "setBuiltInCameraDisabled:" + builtInCameraDisabled + " -> " + z2);
    }

    public void setCorpMode(boolean z2) {
        if (kotlin.jvm.internal.l.a(com.seewo.vcommons.data.d.e("persist.sys.benq.device.mode", "standard"), "standard") || !z2) {
            com.seewo.vcommons.data.d.q("persist.sys.benq.device.mode", z2 ? "corporation" : "standard");
            com.seewo.hiddenapi.c.c(this.context, new Intent(BROADCAST_ACTION_CROP_MODE_CHANGE), com.seewo.hiddenapi.g.f3343c);
        }
    }

    public boolean setCurrentAudioVolume(int i2) {
        G0.f.f800a.g(i2);
        Y0.c.h("BenQIFPSys", "setCurrentAudioVolume:" + i2);
        return true;
    }

    public boolean setCustomFeature(String str, boolean z2) {
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " setCustomFeature: filePath=" + str + ", needReboot=" + z2);
        boolean z3 = false;
        if (str == null) {
            return false;
        }
        File file = new File(str);
        if (!file.exists()) {
            return false;
        }
        FeatureUtils featureUtils = FeatureUtils.INSTANCE;
        String path = file.getPath();
        kotlin.jvm.internal.l.d(path, "getPath(...)");
        if (featureUtils.checkFeature(path)) {
            String path2 = file.getPath();
            kotlin.jvm.internal.l.d(path2, "getPath(...)");
            if (featureUtils.customFeature(path2)) {
                if (z2) {
                    Y0.d.a("sync");
                    o.f817a.a();
                }
                z3 = true;
            }
        }
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " setCustomFeature: success=" + z3);
        return z3;
    }

    public void setExtendDisplayDirection(int i2) {
        int displayId;
        Y0.c.a("BenQIFPSys", "setExtendDisplayDirection direction:" + i2);
        if (!isEnableExtendDisplay() || (displayId = getDisplayId()) == 0) {
            return;
        }
        Context context = this.context;
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.ifpdos.displaycenter", "com.ifpdos.displaycenter.MainService"));
        int i3 = 1;
        intent.putExtra("changeDirection", true);
        intent.putExtra("displayId", displayId);
        if (i2 != 1) {
            if (i2 != 2) {
                i3 = 3;
                if (i2 != 3) {
                    i3 = i2 != 4 ? -1 : 5;
                }
            } else {
                i3 = 7;
            }
        }
        intent.putExtra("direction", i3);
        com.seewo.hiddenapi.c.e(context, intent, com.seewo.hiddenapi.g.f3343c);
    }

    public void setExtendDisplayMode(int i2) {
        int displayId;
        Y0.c.a("BenQIFPSys", "setExtendDisplayMode mode:" + i2);
        if (!isEnableExtendDisplay() || (displayId = getDisplayId()) == 0) {
            return;
        }
        Context context = this.context;
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.ifpdos.displaycenter", "com.ifpdos.displaycenter.MainService"));
        intent.putExtra("change", true);
        intent.putExtra("displayId", displayId);
        intent.putExtra("isDuplicate", i2 == 1);
        com.seewo.hiddenapi.c.e(context, intent, com.seewo.hiddenapi.g.f3343c);
    }

    public void setFreezeMode(boolean z2) {
        if (z2) {
            if (!Y0.a.j(this.context)) {
                Context context = this.context;
                Intent intent = new Intent("com.cvte.android.intent.action.ONEKEY_FREEZE_SCREEN");
                intent.setPackage("com.seewo.freezescreen");
                intent.addFlags(16777216);
                com.seewo.hiddenapi.c.c(context, intent, com.seewo.hiddenapi.g.f3343c);
            }
        } else if (Y0.a.j(this.context)) {
            Context context2 = this.context;
            Intent intent2 = new Intent("com.cvte.apps.freezescreen.action.CLOSE_ACTIVITY_ACTION");
            intent2.setPackage("com.seewo.freezescreen");
            intent2.addFlags(16777216);
            com.seewo.hiddenapi.c.c(context2, intent2, com.seewo.hiddenapi.g.f3343c);
        }
        Y0.c.h("BenQIFPSys", "setFreezeMode:" + z2);
    }

    public void setGooglePlayAppFilter(boolean z2) {
        Y0.c.a("BenQIFPSys", "setGooglePlayAppFilter:" + z2);
        AbstractC0123h.b(null, new C04081(z2, null), 1, null);
    }

    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public final java.lang.Object setGooglePlayFeature(boolean r6, q1.d r7) {
        /*
            r5 = this;
            boolean r0 = r7 instanceof com.benq.platform.IFPBenQService.C04091
            if (r0 == 0) goto L13
            r0 = r7
            com.benq.platform.IFPBenQService$setGooglePlayFeature$1 r0 = (com.benq.platform.IFPBenQService.C04091) r0
            int r1 = r0.label
            r2 = -2147483648(0xffffffff80000000, float:-0.0)
            r3 = r1 & r2
            if (r3 == 0) goto L13
            int r1 = r1 - r2
            r0.label = r1
            goto L18
        L13:
            com.benq.platform.IFPBenQService$setGooglePlayFeature$1 r0 = new com.benq.platform.IFPBenQService$setGooglePlayFeature$1
            r0.<init>(r7)
        L18:
            java.lang.Object r7 = r0.result
            java.lang.Object r1 = r1.AbstractC0707b.d()
            int r2 = r0.label
            java.lang.String r3 = "BenQIFPSys"
            r4 = 1
            if (r2 == 0) goto L39
            if (r2 != r4) goto L31
            java.lang.Object r6 = r0.L$0
            com.benq.platform.IFPBenQService r6 = (com.benq.platform.IFPBenQService) r6
            n1.m.b(r7)     // Catch: java.lang.Exception -> L2f
            goto L93
        L2f:
            r6 = move-exception
            goto L9a
        L31:
            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
            r6.<init>(r7)
            throw r6
        L39:
            n1.m.b(r7)
            int r7 = android.os.Binder.getCallingPid()
            java.lang.StringBuilder r2 = new java.lang.StringBuilder
            r2.<init>()
            r2.append(r7)
            java.lang.String r7 = " setGooglePlayFeature: enable="
            r2.append(r7)
            r2.append(r6)
            java.lang.String r7 = r2.toString()
            Y0.c.h(r3, r7)
            com.benq.platform.utils.FeatureUtils r7 = com.benq.platform.utils.FeatureUtils.INSTANCE
            boolean r2 = r7.isFeatureEnabled()
            if (r2 != r6) goto L64
            java.lang.Boolean r6 = kotlin.coroutines.jvm.internal.b.a(r4)
            return r6
        L64:
            r7.setFeatureEnabled(r6)
            r0.L$0 = r5     // Catch: java.lang.Exception -> L2f
            r0.label = r4     // Catch: java.lang.Exception -> L2f
            F1.m r6 = new F1.m     // Catch: java.lang.Exception -> L2f
            q1.d r7 = r1.AbstractC0707b.c(r0)     // Catch: java.lang.Exception -> L2f
            r6.<init>(r7, r4)     // Catch: java.lang.Exception -> L2f
            r6.v()     // Catch: java.lang.Exception -> L2f
            android.content.Context r7 = access$getContext$p(r5)     // Catch: java.lang.Exception -> L2f
            com.benq.platform.IFPBenQService$setGooglePlayFeature$2$1 r2 = new com.benq.platform.IFPBenQService$setGooglePlayFeature$2$1     // Catch: java.lang.Exception -> L2f
            r2.<init>()     // Catch: java.lang.Exception -> L2f
            access$clearGooglePlayCache(r5, r7, r2)     // Catch: java.lang.Exception -> L2f
            java.lang.Object r7 = r6.s()     // Catch: java.lang.Exception -> L2f
            java.lang.Object r6 = r1.AbstractC0707b.d()     // Catch: java.lang.Exception -> L2f
            if (r7 != r6) goto L90
            kotlin.coroutines.jvm.internal.h.c(r0)     // Catch: java.lang.Exception -> L2f
        L90:
            if (r7 != r1) goto L93
            return r1
        L93:
            java.lang.Boolean r7 = (java.lang.Boolean) r7     // Catch: java.lang.Exception -> L2f
            boolean r6 = r7.booleanValue()     // Catch: java.lang.Exception -> L2f
            goto La0
        L9a:
            java.lang.String r7 = "setGooglePlayFeature unexpected error"
            Y0.c.c(r3, r7, r6)
            r6 = 0
        La0:
            java.lang.Boolean r6 = kotlin.coroutines.jvm.internal.b.a(r6)
            return r6
        */
        throw new UnsupportedOperationException("Method not decompiled: com.benq.platform.IFPBenQService.setGooglePlayFeature(boolean, q1.d):java.lang.Object");
    }

    public void setIPv6Enabled(boolean z2) {
        try {
            Y0.c.f("BenQIFPSys", "setIPv6Enabled: " + z2);
            NetworkCtrlManager.getInstance().SetIpv6Enable(z2);
        } catch (Exception e2) {
            Log.e("BenQIFPSys", "setIPv6Enabled: " + z2, e2);
        }
    }

    public void setIdleTimeout(long j2) {
        Log.d("BenQIFPSys", "setIdleTimeout " + j2);
        this.mTimeOut = j2;
        if (j2 <= 0) {
            this.mScheduledSingleThreadPool.shutdownNow();
        } else {
            checkScheduledExecutorService();
            this.mScheduledSingleThreadPool.schedule(this.mTimeOutRunnable, j2, TimeUnit.SECONDS);
        }
    }

    public void setInstaShareButtonMode(boolean z2) {
        changeOSDProp(this.context, BENQ_PERSIST_INSTA_MODE, Integer.valueOf(toIntString(z2)));
    }

    public boolean setMute(boolean z2) {
        G0.f.f800a.e(z2);
        Y0.c.h("BenQIFPSys", "setMute:" + z2);
        return true;
    }

    public void setNfcData(String str, String str2) {
        if (str != null) {
            List<W0.a> listH = com.seewo.vcommons.data.c.h(this.context);
            if (listH != null) {
                kotlin.jvm.internal.l.b(listH);
                for (W0.a aVar : listH) {
                    if (kotlin.jvm.internal.l.a(aVar.a(), str)) {
                        com.seewo.vcommons.data.c.b(this.context, aVar);
                    }
                }
            }
            Context context = this.context;
            W0.a aVar2 = new W0.a();
            aVar2.c(str);
            aVar2.d(str2);
            com.seewo.vcommons.data.c.a(context, aVar2);
        }
    }

    public void setOSDAdvancedSettingEnabled(boolean z2) {
        changeOSDProp(this.context, PROP_OSD_ADVANDCED_SETTING_ENABLED, Integer.valueOf(toIntString(z2)));
    }

    public boolean setSignageMode(boolean z2) {
        Y0.c.h("BenQIFPSys", "setSignageMode:" + z2);
        return true;
    }

    public void setSourceChange(String str) {
        if (str == null || str.length() == 0) {
            Log.e("BenQIFPSys", "setSourceChange fail, inputSource is null");
            return;
        }
        List<SDKSourceModel> listD = n.f815a.d();
        kotlin.jvm.internal.l.b(listD);
        q qVar = null;
        for (SDKSourceModel sDKSourceModel : listD) {
            String originName = sDKSourceModel.originName;
            kotlin.jvm.internal.l.d(originName, "originName");
            String upperCase = originName.toUpperCase();
            kotlin.jvm.internal.l.d(upperCase, "toUpperCase(...)");
            if (kotlin.jvm.internal.l.a(str, upperCase)) {
                qVar = sDKSourceModel.sourceItem;
            }
        }
        if (qVar != null) {
            n.f815a.a(qVar);
            Y0.c.h("BenQIFPSys", "setSourceChange:" + qVar);
            return;
        }
        Log.e("BenQIFPSys", "setSourceChange FAIL, " + qVar + " NOT FOUND");
    }

    public void startAppMultiWindow(String str) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Y0.c.h("BenQIFPSys", "startAppMultiWindow pkgName=" + str);
        int i2 = Build.VERSION.SDK_INT;
        if (i2 >= 33) {
            Object systemService = this.context.getSystemService("activity");
            kotlin.jvm.internal.l.c(systemService, "null cannot be cast to non-null type android.app.ActivityManager");
            ActivityManager activityManager = (ActivityManager) systemService;
            Object systemService2 = this.context.getSystemService((Class<Object>) WindowManager.class);
            kotlin.jvm.internal.l.d(systemService2, "getSystemService(...)");
            WindowManager windowManager = (WindowManager) systemService2;
            ActivityOptions activityOptionsMakeBasic = ActivityOptions.makeBasic();
            if (i2 < 35 || isSpecialApp(str)) {
                Method declaredMethod = activityOptionsMakeBasic.getClass().getDeclaredMethod("setLaunchWindowingMode", Integer.TYPE);
                declaredMethod.setAccessible(true);
                declaredMethod.invoke(activityOptionsMakeBasic, 5);
            }
            WindowMetrics currentWindowMetrics = windowManager.getCurrentWindowMetrics();
            kotlin.jvm.internal.l.d(currentWindowMetrics, "getCurrentWindowMetrics(...)");
            Rect rect = new Rect(currentWindowMetrics.getBounds());
            activityOptionsMakeBasic.setLaunchBounds(new Rect(rect.width() / 4, rect.height() / 4, (rect.width() / 4) * 3, (rect.height() / 4) * 3));
            if (str != null) {
                List<ActivityManager.RunningTaskInfo> runningTasks = activityManager.getRunningTasks(1);
                Y0.c.h("BenQIFPSys", "startActivity " + str);
                Intent launchIntentForPackage = this.context.getPackageManager().getLaunchIntentForPackage(str);
                if (launchIntentForPackage != null) {
                    com.seewo.hiddenapi.c.d(this.context, launchIntentForPackage, activityOptionsMakeBasic.toBundle(), com.seewo.hiddenapi.g.f3343c);
                }
                ComponentName componentName = runningTasks.get(0).topActivity;
                String packageName = componentName != null ? componentName.getPackageName() : null;
                Y0.c.h("BenQIFPSys", "moveTaskToFront pkgName=" + packageName + " taskId=" + runningTasks.get(0).taskId);
                if (i2 < 35 || isSpecialApp(str)) {
                    activityManager.moveTaskToFront(runningTasks.get(0).taskId, 0, activityOptionsMakeBasic.toBundle());
                } else {
                    Method declaredMethod2 = activityOptionsMakeBasic.getClass().getDeclaredMethod("setLaunchWindowingMode", Integer.TYPE);
                    declaredMethod2.setAccessible(true);
                    declaredMethod2.invoke(activityOptionsMakeBasic, 5);
                }
                activityManager.moveTaskToFront(runningTasks.get(0).taskId, 0, activityOptionsMakeBasic.toBundle());
            }
        }
    }

    public int startAudioRecord() {
        return this.mAudioRecordService.startRecording();
    }

    public void startSourceMultiWindow(String str) {
        if (Build.VERSION.SDK_INT >= 33) {
            n.f815a.a(q.ANDROID);
            Y0.c.h("BenQIFPSys", "startSourceMultiWindow " + str);
            if (str != null) {
                Intent intent = new Intent();
                intent.setClassName("com.ifpdos.ospip", "com.ifpdos.ospip.service.StartPIPService");
                intent.putExtra("key_source", str);
                intent.putExtra("is_multi", true);
                Object systemService = this.context.getSystemService((Class<Object>) WindowManager.class);
                kotlin.jvm.internal.l.d(systemService, "getSystemService(...)");
                WindowMetrics currentWindowMetrics = ((WindowManager) systemService).getCurrentWindowMetrics();
                kotlin.jvm.internal.l.d(currentWindowMetrics, "getCurrentWindowMetrics(...)");
                Rect rect = new Rect(currentWindowMetrics.getBounds());
                intent.putExtra("start_rect", new Rect(rect.width() / 4, rect.height() / 4, (rect.width() / 4) * 3, (rect.height() / 4) * 3));
                com.seewo.hiddenapi.c.e(this.context, intent, com.seewo.hiddenapi.g.f3343c);
            }
        }
    }

    public void startToExtendDisplay(String str, int i2) {
        int displayId;
        Y0.c.a("BenQIFPSys", "startToExtendDisplay:" + str + " taskId:" + i2 + " displayMode" + getExtendDisplayMode());
        if (isEnableExtendDisplay() && getExtendDisplayMode() == 2 && (displayId = getDisplayId()) != 0) {
            List<Integer> listB = i2 > 0 ? AbstractC0676l.b(Integer.valueOf(i2)) : ExtendDisplayTaskResolverKt.resolveExtendDisplayTaskId(str, getDefaultDisplayRunningTaskPackageInfos());
            Y0.c.a("BenQIFPSys", "startToExtendDisplay resolvedTaskIds:" + listB + " pkgname:" + str);
            if (listB.isEmpty()) {
                AbstractC0443c.a().a(this.context, str, displayId);
                return;
            }
            Iterator<T> it = listB.iterator();
            while (it.hasNext()) {
                AbstractC0443c.a().b(this.context, ((Number) it.next()).intValue(), displayId);
            }
        }
    }

    public int stopAudioRecord() {
        return this.mAudioRecordService.stop();
    }

    public void unregisterCameraCallback(ICameraSelectionCallback iCameraSelectionCallback) {
        Y0.c.h("BenQIFPSys", "unregisterCameraCallback is deprecated, ignore");
    }

    public void unregisterCtsCallback(ICtsStateCallback iCtsStateCallback) {
        if (iCtsStateCallback != null) {
            this.mCtsStateCallbackSet.remove(iCtsStateCallback);
        }
        Y0.c.h("BenQIFPSys", "unregisterCtsCallback " + this.mCtsStateCallbackSet.size());
    }

    public boolean setGooglePlayFeature(boolean z2, boolean z3) {
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " setGooglePlayFeature: enable=" + z2 + ", needReboot=" + z3);
        if (isFeatureEnabled() == z2) {
            return true;
        }
        FeatureUtils.INSTANCE.setFeatureEnabled(z2);
        if (z3) {
            Y0.d.a("sync");
            o.f817a.a();
        }
        Y0.c.h("BenQIFPSys", Binder.getCallingPid() + " setGooglePlayFeature: success=true");
        return true;
    }
}