#if PICO_SDK || PXR_SDK
using Unity.XR.PICO.TOBSupport;
using Unity.XR.PXR;
using UnityEngine;
using UnityEngine.XR;

public class PicoAPI : MonoBehaviour
{
    public static PicoAPI _Instance;

    private void Awake()
    {
        if (_Instance == null)
            _Instance = this;

        // PXR_Enterprise.InitEnterpriseService();
        // PXR_Enterprise.BindEnterpriseService();
    }
    private void OnDestroy()
    {
        PXR_Enterprise.UnBindEnterpriseService();
    }

    /// <summary>
    /// ���WakeLock��
    /// </summary>
    public void AcquireWakeLock()
    {
        PXR_Enterprise.AcquireWakeLock();
    }

    /// <summary>
    /// У���ӽ�
    /// </summary>
    public void TryRecenter()
    {
        InputDevices.GetDeviceAtXRNode(XRNode.Head).subsystem.TryRecenter();//У���ӽ�
    }


    /// <summary>
    /// ����Ͷ��
    /// </summary>
    public void OpenTouPing()
    {
        //AndroidProcessData.OpenPackage(packageNmae, activity);
        PXR_Enterprise.StartActivity("com.pvr.picocast", "com.pvr.picocast.view.CastMainActivity", "", "", new string[] { }, new int[] { });
    }

    public void OpenApp(string pkgName)
    {
        PXR_Enterprise.StartActivity(pkgName, "", "", "", new string[] { }, new int[] { });
    }
    /// <summary>
    /// ����wifi
    /// </summary>
    public void OpenWIFI()
    {
        PXR_Enterprise.StartVrSettingsItem(StartVRSettingsEnum.START_VR_SETTINGS_ITEM_WIFI, true, 0);
    }


    /// <summary>
    /// ����pico������
    /// </summary>
    public void PlayPicoVideo(string fileName)
    {
        AndroidJavaObject context = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaObject videoPlayer = new AndroidJavaObject("com.picovr.picoplaymanager.PicovrLaunchPlayer");
        videoPlayer.Call<AndroidJavaObject>("uri", fileName, false).Call<AndroidJavaObject>("playTime", 0).Call<AndroidJavaObject>("scenes", 2).Call("launchVideoPlayer", context);
    }


    /// <summary>
    /// ����Ӧ�ó����Ծ
    /// </summary>
    public void AppKeepAlive(string appPackageName)
    {
        PXR_Enterprise.AppKeepAlive(appPackageName, true, 0);
    }

    /// <summary>
    /// ����Ӧ����Ϊ��������
    /// </summary>
    public void SetAppAsHome(string pkgName)
    {
        PXR_Enterprise.SetAPPAsHome(SwitchEnum.S_ON, pkgName);
    }

    /// <summary>
    /// ����USB����ģʽΪMTP
    /// </summary>
    public void SetUSBConfigMode()
    {
        PXR_Enterprise.SwitchSetUsbConfigurationOption(USBConfigModeEnum.MTP);
    }

    /// <summary>
    /// ǿ���˳�Ӧ��
    /// </summary>
    public void KillAppsByPidOrPackageName(string pkgName)
    {
        PXR_Enterprise.KillAppsByPidOrPackageName(new int[] { }, new string[] { pkgName });
    }
    /// <summary>
    /// �����̨Ӧ�ð�����
    /// </summary>
    public void KillBackgroundAppsWithWhiteList(string pkgName)
    {
        PXR_Enterprise.KillBackgroundAppsWithWhiteList(new string[] { pkgName });
    }

    /// <summary>
    /// ����ͫ��
    /// </summary>
    public void SetIpd(float ipd)
    {
        PXR_Enterprise.SetIPD(ipd, CallBack);
        void CallBack(int code)
        {
            string installCode = code switch
            {
                1 => "ʧ��",
                2 => "������Ч��Χ",
                _ => "�ɹ�",
            };
        }
    }

    #region �򿪹ر���������
    /// <summary>
    /// ͨ������������������
    /// </summary>
    /// <param name="pkgName">Ӧ�ð���</param>
    /// <param name="activity">AndroidJavaObject</param>
    public void OpenPackage(string pkgName, AndroidJavaObject activity = null)
    {

        if (activity == null)
        {
            AndroidJavaClass UnityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            activity = UnityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        }

        using (AndroidJavaObject joPackageManager = activity.Call<AndroidJavaObject>("getPackageManager"))
        {
            using (AndroidJavaObject joIntent = joPackageManager.Call<AndroidJavaObject>("getLaunchIntentForPackage", pkgName))
            {
                if (null != joIntent)
                {
                    activity.Call("startActivity", joIntent);
                }
                else
                {
                    Debug.Log("δ��װ��������" + pkgName);
                }
            }
        }

    }

    /// <summary>
    /// �Ƿ�װ�˴�app
    /// </summary>
    public bool IsAppInstalled(string packageName)
    {
        AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
        AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaObject packageManager = currentActivity.Call<AndroidJavaObject>("getPackageManager");
        AndroidJavaObject packageInfo = null;

        try
        {
            packageInfo = packageManager.Call<AndroidJavaObject>("getPackageInfo", packageName, 0);
        }
        catch (AndroidJavaException e)
        {
            // Application is not installed
        }

        if (packageInfo == null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    /// <summary>
    /// ��ȡapk����
    /// </summary>
    public string GetPackageNameFromApk(string apkFilePath)
    {
        AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
        AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaObject packageManager = currentActivity.Call<AndroidJavaObject>("getPackageManager");
        AndroidJavaObject packageInfo = packageManager.Call<AndroidJavaObject>("getPackageArchiveInfo", apkFilePath, 0);

        if (packageInfo != null)
        {
            AndroidJavaObject applicationInfo = packageInfo.Get<AndroidJavaObject>("applicationInfo");
            string packageName = applicationInfo.Get<string>("packageName");
            return packageName;
        }

        return null;
    }
    #endregion


    #region �رհ�ȫ�߽�
    /// <summary>
    /// �رձ߽�
    /// </summary>
    public void OffBoundary()
    {
        PXR_Boundary.SetGuardianSystemDisable(false);
    }

    #endregion


    #region �����ֱ���
    /// <summary>
    /// �����ֱ���
    /// </summary>
    /// <param name="vibrateType">�ֱ�</param>
    /// <param name="amplitude">���</param>
    /// <param name="duration">����ʱ��</param>
    /// <param name="frequency">��Ƶ��</param>
    // public void SetControllerVibration(PXR_Input.VibrateType vibrateType, float amplitude, int duration, int frequency = 150)
    // {
    //     PXR_Input.SendHapticImpulse(vibrateType, amplitude, duration, frequency);
    // }

    /// <summary>
    /// ����ֱ�����  0�����ֱ���1�����ֱ�
    /// </summary>
    /// <returns></returns>
    public int[] GetControllerBattery()
    {
        return PXR_Enterprise.GetControllerBattery();
    }
    #endregion


    #region ��Ĭ��װ/ж��apk
    /// <summary>
    /// ��Ĭ��װapk
    /// </summary>
    public void InstallApk(string path)
    {
        if (!string.IsNullOrEmpty(path))
        {
            PXR_Enterprise.ControlAPPManager(PackageControlEnum.PACKAGE_SILENCE_INSTALL, path, CallBack);
        }

        void CallBack(int code)
        {
            string installCode = code switch
            {
                1 => "ʧ��",
                2 => "�޴˲���Ȩ��",
                _ => "�ɹ�",
            };
            Debug.Log($"��Ĭ��װapk��·��: {path}, code: {installCode}");
        }
    }
    /// <summary>
    /// ��Ĭж��app
    /// </summary>
    public void UnInstallApp(string appPackageName)
    {
        PXR_Enterprise.ControlAPPManager(PackageControlEnum.PACKAGE_SILENCE_UNINSTALL, appPackageName, CallBack);
        void CallBack(int code)
        {
            string unInstallCode = code switch
            {
                1 => "ʧ��",
                2 => "�޴˲���Ȩ��",
                _ => "�ɹ�",
            };
            Debug.Log($"��Ĭж��app����: {appPackageName}, code: {unInstallCode}");
        }
    }
    #endregion


    #region ��ȡ�豸��Ϣ
    /// <summary>
    /// pico�豸SN
    /// </summary>
    public string PicoSN()
    {
        return StateGetDeviceInfo(SystemInfoEnum.EQUIPMENT_SN);
    }
    /// <summary>
    /// pico�豸����
    /// </summary>
    public string PicoPower()
    {
        return StateGetDeviceInfo(SystemInfoEnum.ELECTRIC_QUANTITY);
    }
    /// <summary>
    /// ���״̬
    /// </summary>
    /// <returns>��2���dz���У���3����û���</returns>
    public string ChargingStatus()
    {
        return StateGetDeviceInfo(SystemInfoEnum.CHARGING_STATUS);
    }
    /// <summary>
    /// pico�豸WIFI״̬
    /// </summary>
    public string PicoWIFIState()
    {
        return StateGetDeviceInfo(SystemInfoEnum.DEVICE_WIFI_STATUS);
    }
    /// <summary>
    /// ��ȡ�豸��Ϣ
    /// </summary>
    string StateGetDeviceInfo(SystemInfoEnum infoEnum)
    {
        return PXR_Enterprise.StateGetDeviceInfo(infoEnum);
    }
    /// <summary>
    /// ��������
    /// </summary>
    void SetCommonBrightness(float Ilight)
    {
        PXR_System.SetCommonBrightness(int.Parse(Ilight.ToString()));
    }
    /// <summary>
    /// �������
    /// </summary>
    int GetCommonBrightness()
    {
        return PXR_System.GetCommonBrightness();
    }
    #endregion


    #region �����豸�ػ�������
    /// <summary>
    /// �����豸�ػ�������
    /// </summary>
    void ControlDeviceShutDownOrReboot(DeviceControlEnum deviceControlEnum)
    {
        PXR_Enterprise.ControlSetDeviceAction(deviceControlEnum, callback);
        void callback(int obj)
        {
            string Code = obj switch
            {
                1 => "ʧ��",
                2 => "�޴˲���Ȩ��",
                _ => "�ɹ�",
            };
        }
    }
    /// <summary>
    /// �ػ�
    /// </summary>
    public void ShutDown()
    {
        ControlDeviceShutDownOrReboot(DeviceControlEnum.DEVICE_CONTROL_SHUTDOWN);
    }
    /// <summary>
    /// ����
    /// </summary>
    public void Reboot()
    {
        ControlDeviceShutDownOrReboot(DeviceControlEnum.DEVICE_CONTROL_REBOOT);
    }
    #endregion


    #region ����Home��ť�¼�

    /// <summary>
    /// ����home��ť��Ч
    /// </summary>
    public void SetHomeNoAvail()
    {
        PropertySetHomeKey(HomeEventEnum.SINGLE_CLICK, HomeFunctionEnum.VALUE_HOME_DISABLE);
    }
    /// <summary>
    /// ����home��ťĬ��
    /// </summary>
    public void RemoveControllerHomeKey()
    {
        PXR_Enterprise.RemoveControllerHomeKey(HomeEventEnum.SINGLE_CLICK);
    }

    /// <summary>
    /// ����Home��ť�¼�
    /// </summary>
    public void PropertySetHomeKey(HomeEventEnum eventEnum, HomeFunctionEnum function)
    {
        PXR_Enterprise.PropertySetHomeKey(eventEnum, function, callback);
        void callback(bool obj)
        {
            string Code = obj switch
            {
                false => "ʧ��",
                _ => "�ɹ�",
            };
        }
    }
    #endregion


    #region �����豸������������Ϣ��
    /// <summary>
    /// �����豸��ʹ��ʱ��Ļ�رյ�ʱ��
    /// </summary>
    void PropertySetScreenOffDelay(ScreenOffDelayTimeEnum timeEnum)
    {
        PXR_Enterprise.PropertySetScreenOffDelay(timeEnum, callback);
        void callback(int obj)
        {
            string Code = obj switch
            {
                0 => "�ɹ�",
                2 => "ʧ��",
                10 => "ӦС��ϵͳ����ʱ��",
                _ => "�쳣"
            };
        }
    }
    /// <summary>
    /// �����豸��ʹ��ʱϵͳ����ʱ��
    /// </summary>
    void PropertySetSleepDelay(SleepDelayTimeEnum timeEnum)
    {
        PXR_Enterprise.PropertySetSleepDelay(timeEnum);
    }
    /// <summary>
    /// �����豸������������Ϣ��
    /// </summary>
    public void NeverSleepScreenOff()
    {
        PropertySetSleepDelay(SleepDelayTimeEnum.NEVER);//��������
        PropertySetScreenOffDelay(ScreenOffDelayTimeEnum.NEVER);//����Ϣ��
    }
    #endregion


    #region ��/�ر�ָ����ϵͳ����
    /// <summary>
    /// ��/�ر�ָ����ϵͳ����
    /// </summary>
    void SwitchSystemFunction(SystemFunctionSwitchEnum systemFunctionSwitchEnum, SwitchEnum switchEnum)
    {
        PXR_Enterprise.SwitchSystemFunction(systemFunctionSwitchEnum, switchEnum);
    }
    /// <summary>
    /// �����ض�λ����
    /// </summary>
    public void HandRecenter()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_GESTURE_RECOGNITION_RESET_ENABLE, SwitchEnum.S_OFF);
    }
    public void OpenHandRecenter()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_GESTURE_RECOGNITION_RESET_ENABLE, SwitchEnum.S_ON);
    }
    /// <summary>
    /// ����Home
    /// </summary>
    public void HandHome()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_GESTURE_RECOGNITION_HOME_ENABLE, SwitchEnum.S_OFF);
    }

    public void OpenHandHome()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_GESTURE_RECOGNITION_HOME_ENABLE, SwitchEnum.S_ON);
    }
    /// <summary>
    /// ����USB����
    /// </summary>
    public void OnUSBDebugging()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_USB, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �ر��Զ�����
    /// </summary>
    public void OffAutoSleep()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_AUTOSLEEP, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// �ر�ϵͳ����
    /// </summary>
    public void OffSystemUpdate()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SYSTEM_UPDATE, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// ��ϵͳ����
    /// </summary>
    public void OpenSystemUpdate()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SYSTEM_UPDATE, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �ر��Զ�ɱ��̨VRӦ��
    /// </summary>
    public void OffKillVRapp()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_BASIC_SETTING_KILL_BACKGROUND_VR_APP, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// �����Զ�ɱ��̨VRӦ��
    /// </summary>
    public void OpenKillVRapp()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_BASIC_SETTING_KILL_BACKGROUND_VR_APP, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �رյ�����
    /// </summary>
    public void OffNavgation()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_NAVGATION_SWITCH, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// �򿪵�����
    /// </summary>
    public void OpenNavgation()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_NAVGATION_SWITCH, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �豸���߻�ر�ʱ������������
    /// </summary>
    public void OnPowerCtrlWIFIEnable()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_POWER_CTRL_WIFI_ENABLE, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �ر�ϵͳ��������
    /// </summary>
    public void OffSystemUpdateApp()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SYSTEM_UPDATE_APP, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// ��ϵͳ��������
    /// </summary>
    public void OpenSystemUpdateApp()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SYSTEM_UPDATE_APP, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �ر�Ӧ�ó����˳��Ի���
    /// </summary>
    public void OffAppQuitConfirmDialog()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_BASIC_SETTING_SHOW_APP_QUIT_CONFIRM_DIALOG, SwitchEnum.S_OFF);
    }
    /// <summary>
    /// ��Ӧ�ó����˳��Ի���
    /// </summary>
    public void OpenAppQuitConfirmDialog()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_BASIC_SETTING_SHOW_APP_QUIT_CONFIRM_DIALOG, SwitchEnum.S_ON);
    }
    /// <summary>
    /// �ر�6DoFλ�ø���
    /// </summary>
    public void OffSixDof()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SIX_DOF_SWITCH, SwitchEnum.S_OFF);
    }
    public void OnSixDof()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SIX_DOF_SWITCH, SwitchEnum.S_ON);
    }

    /// <summary>
    /// ����Ͷ����ť
    /// </summary>
    public void OffCastUI()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_SHORTCUT_SHOW_CAST_UI, SwitchEnum.S_OFF);
    }

    /// <summary>
    /// VRӦ����ʵʱ��Ӧͷ�����ؼ�
    /// </summary>
    public void HMDBackKey()
    {
        //ͷ�����ؼ����·���DOWN�¼���̧�𷢳�UP�¼�
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_REAL_TIME_RESPONSE_HMD_BACK_KEY_IN_VR_APP, SwitchEnum.S_ON);
    }
    #endregion


    #region ��������
    /// <summary>
    /// ��ȡ�������
    /// </summary>
    public int GetMaxVolumeNumber()
    {
        return PXR_System.GetMaxVolumeNumber();
    }
    /// <summary>
    /// ��ȡ��ǰ����
    /// </summary>
    public int GetCurrentVolumeNumber()
    {
        return PXR_System.GetCurrentVolumeNumber();
    }
    /// <summary>
    /// ��������
    /// </summary>
    public void VolumeUp()
    {
        PXR_System.VolumeUp();
    }
    /// <summary>
    /// ������
    /// </summary>
    public void VolumeDown()
    {
        PXR_System.VolumeDown();
    }
    /// <summary>
    /// ��������
    /// </summary>
    public void SetVolumeNum(int volume)
    {
        PXR_System.SetVolumeNum(volume);
    }
    /// <summary>
    /// �������õ����ֵ
    /// </summary>
    public void SetVolumeMaxNum()
    {
        SetVolumeNum(GetMaxVolumeNumber());
    }
    #endregion

    #region Ͷ������
    /// <summary>
    /// Ͷ����ַ
    /// </summary>
    public string GetCastUrl()
    {
        PXR_Enterprise.PICOCastInit(null);
        return PXR_Enterprise.PICOCastGetUrl(PICOCastUrlTypeEnum.NO_CONFIRM_URL);
    }

    /// <summary>
    /// ��Ļ¼����Ȩ��������
    /// </summary>
    public void PICOCastSetShowAuthorization()
    {
        PXR_Enterprise.PICOCastSetShowAuthorization(1);
    }

    /// <summary>
    /// ����Ͷ��ʱ��ɫͼ��
    /// </summary>
    public void OffCastNotification()
    {
        SwitchSystemFunction(SystemFunctionSwitchEnum.SFS_BASIC_SETTING_SHOW_CAST_NOTIFICATION, SwitchEnum.S_OFF);
    }

    /// <summary>
    /// Ͷ������-��������¼��
    /// </summary>
    public void CastOption()
    {
        PICOCastSetOption(PICOCastOptionOrStatusEnum.OPTION_AUDIO_ENABLE, PICOCastOptionValueEnum.OPTION_VALUE_AUDIO_ON);
    }

    /// <summary>
    /// Ͷ������
    /// </summary>
    void PICOCastSetOption(PICOCastOptionOrStatusEnum castOptionOrStatus, PICOCastOptionValueEnum castOptionValue)
    {
        PXR_Enterprise.PICOCastSetOption(castOptionOrStatus, castOptionValue);
    }
    #endregion

}
#else
using UnityEngine;

public class PicoAPI : MonoBehaviour
{
    public static PicoAPI _Instance;

    private void Awake()
    {
        if (_Instance == null)
        {
            _Instance = this;
        }
    }

    public void AcquireWakeLock() { }
    public void TryRecenter() { }
    public void OpenTouPing() { }
    public void OpenApp(string pkgName) { }
    public void OpenWIFI() { }
    public void PlayPicoVideo(string fileName) { }
    public void AppKeepAlive(string appPackageName) { }
    public void SetAppAsHome(string pkgName) { }
    public void SetUSBConfigMode() { }
    public void KillAppsByPidOrPackageName(string pkgName) { }
    public void KillBackgroundAppsWithWhiteList(string pkgName) { }
    public void SetIpd(float ipd) { }
    public void OffBoundary() { }
    public int[] GetControllerBattery() { return new int[0]; }
    public void InstallApk(string path) { }
    public void UnInstallApp(string appPackageName) { }
    public string PicoSN() { return ""; }
    public string PicoPower() { return "0"; }
    public string ChargingStatus() { return ""; }
    public string PicoWIFIState() { return ""; }
    public void ShutDown() { }
    public void Reboot() { }
    public void SetHomeNoAvail() { }
    public void RemoveControllerHomeKey() { }
    public void OffSystemUpdateApp() { }
    public void OffSystemUpdate() { }
    public void OffNavgation() { }
    public void OffKillVRapp() { }
    public void OnPowerCtrlWIFIEnable() { }
    public void OffAppQuitConfirmDialog() { }
    public void OnSixDof() { }
    public void HandRecenter() { }
    public void HandHome() { }
    public void OnUSBDebugging() { }
    public void OffCastNotification() { }
    public void PICOCastSetShowAuthorization() { }
    public void CastOption() { }
    public string GetCastUrl() { return ""; }
    public void OpenSystemUpdateApp() { }
    public void OpenSystemUpdate() { }
    public void OpenNavgation() { }
    public void OpenKillVRapp() { }
    public void OpenAppQuitConfirmDialog() { }
    public void OpenHandRecenter() { }
    public void OpenHandHome() { }
    public void SetVolumeNum(int volume) { }
}
#endif