package com.benq.platform;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.net.Uri;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;
import com.benq.platform.IBenQApiBinder;
import com.benq.platform.IBenQCameraBinder;
import com.benq.platform.IBenQNetworkBinder;
import com.benq.platform.IBenQRecordingBinder;
import com.benq.platform.IBenQScreenshotBinder;
import com.benq.platform.IBenQServicesBinder;
import com.benq.platform.IBenqRecorderService;
import com.benq.platform.IRecordEventCallback;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import kotlin.jvm.internal.g;
import kotlin.jvm.internal.l;
import kotlin.jvm.internal.z;
import okhttp3.HttpUrl;

/* JADX INFO: loaded from: classes.dex */
public final class BenQServices extends Service {
    public static final String BENQ_API_SERVICE_NAME = "BenQIFPSys";
    public static final String BENQ_AUDIO_RECORD_SERVICE_NAME = "BenQIFPAudioRecord";
    public static final String BENQ_CAMERA_SERVICE_NAME = "BenQIFPCamera";
    public static final String BENQ_NETWORK_SERVICE_NAME = "BenQIFPNetwork";
    public static final String BENQ_RECORDING_SERVICE_NAME = "BenQIFPRecorder";
    public static final String BENQ_SCREENSHOT_SERVICE_NAME = "BenQIFPScreenshot";
    public static final Companion Companion = new Companion(null);
    public static final String IFP_RECORD_SERVICE = "BenQIFPRecorder";
    public static final String TAG = "@BenQServices";
    private IFPBenQAudioRecordService mBenQAudioRecordService;
    private final CopyOnWriteArrayList<IOnStateChangeListener> mBenQCallbackList = new CopyOnWriteArrayList<>();
    private IBenQCameraService mBenQCameraService;
    private IBenQNetworkService mBenQNetworkService;
    private IBenQRecordingService mBenQRecordingService;
    private IBenQScreenshotService mBenQScreenshotService;
    private IBenQApiService mBenqApiService;
    private IRecordEventCallback mRecordEventCallback;

    private final class BenQServicesImpl extends IBenQServicesBinder.Stub {
        public BenQServicesImpl() {
        }

        public int getApiVersion() {
            return BenQApi.getInstance().getApiVersion();
        }

        /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
        public IBinder getService(String str) {
            IBenQRecordingBinder.Stub stub;
            Log.d("BenQIFPSys", "get service: " + str);
            if (str == null) {
                return null;
            }
            switch (str.hashCode()) {
                case -1652968533:
                    if (!str.equals("BenQIFPRecorder")) {
                        return null;
                    }
                    stub = BenQServices.this.mBenQRecordingService;
                    if (stub == null) {
                        l.s("mBenQRecordingService");
                        return null;
                    }
                    break;
                case -516716269:
                    if (!str.equals(BenQServices.BENQ_SCREENSHOT_SERVICE_NAME)) {
                        return null;
                    }
                    stub = BenQServices.this.mBenQScreenshotService;
                    if (stub == null) {
                        l.s("mBenQScreenshotService");
                        return null;
                    }
                    break;
                case 984661409:
                    if (!str.equals(BenQServices.BENQ_NETWORK_SERVICE_NAME)) {
                        return null;
                    }
                    stub = BenQServices.this.mBenQNetworkService;
                    if (stub == null) {
                        l.s("mBenQNetworkService");
                        return null;
                    }
                    break;
                case 1511707584:
                    if (!str.equals("BenQIFPSys")) {
                        return null;
                    }
                    stub = BenQServices.this.mBenqApiService;
                    if (stub == null) {
                        l.s("mBenqApiService");
                        return null;
                    }
                    break;
                case 1586015674:
                    if (!str.equals(BenQServices.BENQ_AUDIO_RECORD_SERVICE_NAME)) {
                        return null;
                    }
                    stub = BenQServices.this.mBenQAudioRecordService;
                    if (stub == null) {
                        l.s("mBenQAudioRecordService");
                        return null;
                    }
                    break;
                case 2068227410:
                    if (!str.equals(BenQServices.BENQ_CAMERA_SERVICE_NAME)) {
                        return null;
                    }
                    stub = BenQServices.this.mBenQCameraService;
                    if (stub == null) {
                        l.s("mBenQCameraService");
                        return null;
                    }
                    break;
                default:
                    return null;
            }
            return stub;
        }
    }

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

        private Companion() {
        }
    }

    private final class IBenQApiService extends IBenQApiBinder.Stub {
        public IBenQApiService() {
        }

        public void addExtraSourceNoTouchArea(int i2, Rect rect) {
            BenQApi.getInstance().addExtraSourceNoTouchArea(i2, rect);
        }

        public boolean getBuiltInCameraDisabled() {
            return BenQApi.getInstance().getBuiltInCameraDisabled();
        }

        public String[] getCurrentDeviceMode() {
            String[] currentDeviceMode = BenQApi.getInstance().getCurrentDeviceMode();
            return currentDeviceMode == null ? new String[0] : currentDeviceMode;
        }

        public Map<Object, Object> getInputSrcMap() {
            Map<Object, Object> inputSrcMap = BenQApi.getInstance().getInputSrcMap();
            if (!z.f(inputSrcMap)) {
                inputSrcMap = null;
            }
            return inputSrcMap == null ? new LinkedHashMap() : inputSrcMap;
        }

        public boolean isEnableMultiWindow() {
            return BenQApi.getInstance().isEnableMultiWindow();
        }

        public boolean isShowMultiWindow(String str) {
            return BenQApi.getInstance().isShowMultiWindow(str);
        }

        public boolean isSignageMode() {
            return BenQApi.getInstance().isSignageMode();
        }

        public void openVolume() {
            BenQApi.getInstance().openVolume();
        }

        public void removeExtraSourceNoTouchArea(int i2) {
            BenQApi.getInstance().removeExtraSourceNoTouchArea(i2);
        }

        public void setBuiltInCameraDisabled(boolean z2) {
            BenQApi.getInstance().setBuiltInCameraDisabled(z2);
        }

        public boolean setSourceChange(String str) {
            BenQApi benQApi = BenQApi.getInstance();
            BenQServices benQServices = BenQServices.this;
            if (str == null) {
                str = HttpUrl.FRAGMENT_ENCODE_SET;
            }
            benQApi.setSourceChange(benQServices, str);
            return true;
        }

        public void startAppMultiWindow(String str) {
            BenQApi.getInstance().startAppMultiWindow(str);
        }

        public void startSourceMultiWindow(String str) {
            BenQApi.getInstance().startSourceMultiWindow(str);
        }
    }

    private final class IBenQCameraService extends IBenQCameraBinder.Stub {
        public IBenQCameraService() {
        }

        public String getCameraName(String str) {
            return BenQApi.getInstance().getCameraName(str);
        }
    }

    private final class IBenQNetworkService extends IBenQNetworkBinder.Stub {
        public IBenQNetworkService() {
        }

        public String getAllNetworkInterfaceMacAddress() {
            String allNetworkInterfaceMacAddress = NetworkController.getInstance().getAllNetworkInterfaceMacAddress();
            l.d(allNetworkInterfaceMacAddress, "getAllNetworkInterfaceMacAddress(...)");
            return allNetworkInterfaceMacAddress;
        }

        public List<String> getCurrentWirelessConnInfo(boolean z2) {
            return NetworkController.getInstance().getCurrentWirelessConnInfo(z2);
        }

        public List<String> getHotspotInfo() {
            ArrayList hotspotInfo = NetworkController.getInstance().getHotspotInfo();
            return hotspotInfo == null ? new ArrayList() : hotspotInfo;
        }

        public String getHotspotIp() {
            String hotspotIp = NetworkController.getInstance().getHotspotIp();
            l.d(hotspotIp, "getHotspotIp(...)");
            return hotspotIp;
        }

        public List<String> getMajorActiveNetwork() {
            ArrayList majorActiveNetwork = NetworkController.getInstance().getMajorActiveNetwork();
            return majorActiveNetwork == null ? new ArrayList() : majorActiveNetwork;
        }
    }

    private final class IBenQRecordingService extends IBenQRecordingBinder.Stub {
        public IBenQRecordingService() {
        }

        public void addRecordingListener(IOnStateChangeListener iOnStateChangeListener) {
            BenQServices.this.addRecordingListener(iOnStateChangeListener);
        }

        public void clearRecordingListeners() {
            BenQServices.this.clearRecordingListeners();
        }

        public void forceStopRecording() {
            RecorderController.getInstance().forceStopRecording();
        }

        public boolean isPause() {
            return RecorderController.getInstance().isPause();
        }

        public boolean isPauseSupported() {
            return RecorderController.getInstance().isPauseSupported();
        }

        public boolean isRecording() {
            return RecorderController.getInstance().isRecording();
        }

        public void pauseRecord() {
            RecorderController.getInstance().pauseRecord();
        }

        public void resumeRecord() {
            RecorderController.getInstance().resumeRecord();
        }

        public void startRecord(Uri uri) {
            if (uri == null) {
                return;
            }
            RecorderController.getInstance().startRecord(BenQServices.this, uri);
        }

        public void stopRecording() {
            RecorderController.getInstance().stopRecording();
        }
    }

    private final class IBenQScreenshotService extends IBenQScreenshotBinder.Stub {
        public IBenQScreenshotService() {
        }

        public Bitmap screenshot() {
            try {
                return ScreenControl.screenshot();
            } catch (Exception e2) {
                Log.e(BenQServices.TAG, "screenshot", e2);
                return null;
            }
        }
    }

    private final IBenqRecorderService getRecordService() {
        IBinder service = ServiceManager.getService("BenQIFPRecorder");
        if (service == null) {
            return null;
        }
        return IBenqRecorderService.Stub.asInterface(service);
    }

    public final void addRecordingListener(IOnStateChangeListener iOnStateChangeListener) {
        Y0.c.h("BenQIFPSys", "addRecordingListener(), callback:" + iOnStateChangeListener);
        if (iOnStateChangeListener != null) {
            this.mBenQCallbackList.add(iOnStateChangeListener);
        }
    }

    public final void clearRecordingListeners() {
        Y0.c.h("BenQIFPSys", "clearRecordingListeners()");
        this.mBenQCallbackList.clear();
    }

    @Override // android.app.Service
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "BenQServices onBind");
        return new BenQServicesImpl();
    }

    @Override // android.app.Service
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "BenQServices onCreate");
        BenqServiceManager.init(this);
        this.mBenqApiService = new IBenQApiService();
        this.mBenQNetworkService = new IBenQNetworkService();
        this.mBenQRecordingService = new IBenQRecordingService();
        this.mBenQScreenshotService = new IBenQScreenshotService();
        this.mBenQCameraService = new IBenQCameraService();
        Context applicationContext = getApplicationContext();
        l.d(applicationContext, "getApplicationContext(...)");
        IFPBenQAudioRecordService iFPBenQAudioRecordService = new IFPBenQAudioRecordService(applicationContext);
        this.mBenQAudioRecordService = iFPBenQAudioRecordService;
        iFPBenQAudioRecordService.onCreate();
        this.mRecordEventCallback = new IRecordEventCallback.Stub() { // from class: com.benq.platform.BenQServices.onCreate.1
            public void onStateChange(int i2) {
                Iterator it = new CopyOnWriteArrayList(BenQServices.this.mBenQCallbackList).iterator();
                while (it.hasNext()) {
                    try {
                        ((IOnStateChangeListener) it.next()).onStateChange(i2);
                    } catch (RemoteException e2) {
                        e2.printStackTrace();
                    }
                }
            }
        };
        IBenqRecorderService recordService = getRecordService();
        if (recordService != null) {
            recordService.registerCallback(this.mRecordEventCallback);
        }
    }

    @Override // android.app.Service
    public void onDestroy() {
        IBenqRecorderService recordService;
        super.onDestroy();
        IRecordEventCallback iRecordEventCallback = this.mRecordEventCallback;
        if (iRecordEventCallback != null && (recordService = getRecordService()) != null) {
            recordService.unregisterCallback(iRecordEventCallback);
        }
        IFPBenQAudioRecordService iFPBenQAudioRecordService = null;
        this.mRecordEventCallback = null;
        IFPBenQAudioRecordService iFPBenQAudioRecordService2 = this.mBenQAudioRecordService;
        if (iFPBenQAudioRecordService2 == null) {
            l.s("mBenQAudioRecordService");
        } else {
            iFPBenQAudioRecordService = iFPBenQAudioRecordService2;
        }
        iFPBenQAudioRecordService.onDestroy();
    }
}