/*******************************************************************************
Copyright © 2015-2022 PICO Technology Co., Ltd.All rights reserved.  

NOTICE：All information contained herein is, and remains the property of 
PICO Technology Co., Ltd. The intellectual and technical concepts 
contained herein are proprietary to PICO Technology Co., Ltd. and may be 
covered by patents, patents in process, and are protected by trade secret or 
copyright law. Dissemination of this information or reproduction of this 
material is strictly forbidden unless prior written permission is obtained from
PICO Technology Co., Ltd. 
*******************************************************************************/
#if (UNITY_ANDROID && !UNITY_EDITOR)
#define PICO_PLATFORM
#endif
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
#if PICO_XR
using Unity.XR.PXR;
#else
using Unity.XR.OpenXR.Features.PICOSupport;
#endif
using UnityEngine;
using UnityEngine.XR;

namespace Unity.XR.PICO.TOBSupport
{
    public partial class PXR_EnterprisePlugin
    {
        private const string TAG = "[PXR_EnterprisePlugin]";
        public const int MAX_SIZE = 12208032;

        public static string token;
        private static int curSize = 0;
        private static bool camOpenned = false;

        private static FrameItemExt antiDistortionFrameItemExt;
        private static FrameItemExt distortionFrameItemExt;
        private static bool initDistortionFrame;

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int getHeadTrackingConfidence();

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int openVSTCamera();

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int closeVSTCamera();

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int getHeadTrackingData(Int64 predictTime, ref SixDof data, int type);

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int acquireVSTCameraFrame(ref FrameItemExt frame);

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int acquireVSTCameraFrameAntiDistortion(string token, Int32 width, Int32 height, ref FrameItemExt frame);

        [DllImport("libpxr_xrsdk_native", CallingConvention = CallingConvention.Cdecl)]
        public static extern int getCameraParameters(string token, out RGBCameraParams rgb_Camera_Params);

#if PICO_XR
        [DllImport("pxr_api", CallingConvention = CallingConvention.Cdecl)]
#else
        [DllImport("openxr_pico", EntryPoint = "PICO_GetPredictedDisplayTime",
            CallingConvention = CallingConvention.Cdecl)]
#endif
        public static extern int Pxr_GetPredictedDisplayTime(ref double predictedDisplayTime);
        
#if PICO_XR
         [DllImport("pxr_api", CallingConvention = CallingConvention.Cdecl)]
#else
        [DllImport("openxr_pico", EntryPoint = "PICO_GetPredictedMainSensorState2",
            CallingConvention = CallingConvention.Cdecl)]
#endif
        public static extern int Pxr_GetPredictedMainSensorState2(double predictTimeMs, ref PxrSensorState2 sensorState, ref int sensorFrameIndex);

#if PICO_PLATFORM
            private static AndroidJavaClass unityPlayer;
            private static AndroidJavaObject currentActivity;
            private static AndroidJavaObject tobHelper;
            private static AndroidJavaClass tobHelperClass;
            private static AndroidJavaObject IToBService;
            private static AndroidJavaClass BAuthLib;
#endif

        public static Action<bool> BoolCallback;
        public static Action<int> IntCallback;
        public static Action<long> LongCallback;
        public static Action<string> StringCallback;
        
        private static AndroidJavaObject GetEnumType(Enum enumType)
        {
            AndroidJavaClass enumjs =
                new AndroidJavaClass("com.pvr.tobservice.enums" + enumType.GetType().ToString().Replace("Unity.XR.PICO.TOBSupport.", ".PBS_"));
            AndroidJavaObject enumjo = enumjs.GetStatic<AndroidJavaObject>(enumType.ToString());
            return enumjo;
        }
        
        public static bool UPxr_InitEnterpriseService()
        {
#if PICO_PLATFORM
                tobHelperClass = new AndroidJavaClass("com.picoxr.tobservice.ToBServiceUtils");
                tobHelper = tobHelperClass.CallStatic<AndroidJavaObject>("getInstance");
                unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
                currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
                BAuthLib = new AndroidJavaClass("com.pvr.tobauthlib.AuthCheckServer");
#endif
            return UPxr_GetToken();
        }

        public static void UPxr_SetBindCallBack(BindCallback mBoolCallback)
        {
#if PICO_PLATFORM
            tobHelper.Call("setBindCallBack", mBoolCallback);
#endif
        }

        public static void UPxr_BindEnterpriseService(Action<bool> callback = null)
        {
#if PICO_PLATFORM

            UPxr_SetBindCallBack(new BindCallback(callback));
            tobHelper.Call("bindTobService", currentActivity);
#endif
        }

        public static void UPxr_UnBindEnterpriseService()
        {
#if PICO_PLATFORM
                tobHelper.Call("unBindTobService");
#endif
        }

        public static void GetServiceBinder()
        {
#if PICO_PLATFORM
            IToBService = tobHelper.Call<AndroidJavaObject>("getServiceBinder");
#endif
        }

        public static string UPxr_StateGetDeviceInfo(SystemInfoEnum type)
        {
            string result = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return result;
            }
            result = IToBService.Call<string>("pbsStateGetDeviceInfo", GetEnumType(type), 0);
#endif
            return result;
        }

        public static void UPxr_ControlSetDeviceAction(DeviceControlEnum deviceControl, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlSetDeviceAction", GetEnumType(deviceControl), new IntCallback(callback));
#endif
        }

        public static void UPxr_ControlAPPManager(PackageControlEnum packageControl, string path, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlAPPManger", GetEnumType(packageControl), path, 0,  new IntCallback(callback));
#endif
        }

        public static void UPxr_ControlSetAutoConnectWIFI(string ssid, string pwd, Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlSetAutoConnectWIFI", ssid, pwd, 0, new BoolCallback(callback));
#endif
        }

        public static void UPxr_ControlClearAutoConnectWIFI(Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlClearAutoConnectWIFI", new BoolCallback(callback));
#endif
        }

        public static void UPxr_PropertySetHomeKey(HomeEventEnum eventEnum, HomeFunctionEnum function, Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertySetHomeKey", GetEnumType(eventEnum), GetEnumType(function),  new BoolCallback(callback));
#endif
        }

        public static void UPxr_PropertySetHomeKeyAll(HomeEventEnum eventEnum, HomeFunctionEnum function, int timesetup, string pkg, string className, Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertySetHomeKeyAll", GetEnumType(eventEnum), GetEnumType(function), timesetup, pkg,
                className, new BoolCallback(callback));
#endif
        }

        public static void UPxr_PropertyDisablePowerKey(bool isSingleTap, bool enable, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertyDisablePowerKey", isSingleTap, enable,  new IntCallback(callback));
#endif
        }

        public static void UPxr_PropertySetScreenOffDelay(ScreenOffDelayTimeEnum timeEnum, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertySetScreenOffDelay", GetEnumType(timeEnum), new IntCallback(callback));
#endif
        }

        public static void UPxr_PropertySetSleepDelay(SleepDelayTimeEnum timeEnum)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }

            IToBService.Call("pbsPropertySetSleepDelay", GetEnumType(timeEnum));
#endif
        }

        public static void UPxr_SwitchSystemFunction(SystemFunctionSwitchEnum systemFunction, SwitchEnum switchEnum)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsSwitchSystemFunction", GetEnumType(systemFunction), GetEnumType(switchEnum), 0);
#endif
        }

        public static void UPxr_SwitchSetUsbConfigurationOption(USBConfigModeEnum uSBConfigModeEnum)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsSwitchSetUsbConfigurationOption", GetEnumType(uSBConfigModeEnum), 0);
#endif
        }

        public static void UPxr_SetControllerPairTime(ControllerPairTimeEnum timeEnum, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetControllerPairTime", GetEnumType(timeEnum),new IntCallback(callback), 0);
#endif
        }

        public static void UPxr_GetControllerPairTime(Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsGetControllerPairTime",new IntCallback(callback), 0);
#endif
        }

        public static void UPxr_ScreenOn()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsScreenOn");
#endif
        }

        public static void UPxr_ScreenOff()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsScreenOff");
#endif
        }

        public static void UPxr_AcquireWakeLock()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsAcquireWakeLock");
#endif
        }

        public static void UPxr_ReleaseWakeLock()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsReleaseWakeLock");
#endif
        }

        public static void UPxr_EnableEnterKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsEnableEnterKey");
#endif
        }

        public static void UPxr_DisableEnterKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsDisableEnterKey");
#endif
        }

        public static void UPxr_EnableVolumeKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsEnableVolumeKey");
#endif
        }

        public static void UPxr_DisableVolumeKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsDisableVolumeKey");
#endif
        }

        public static void UPxr_EnableBackKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsEnableBackKey");
#endif
        }

        public static void UPxr_DisableBackKey()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsDisableBackKey");
#endif
        }


        public static void UPxr_ResetAllKeyToDefault(Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsResetAllKeyToDefault", new BoolCallback(callback));
#endif
        }

        public static void UPxr_SetAPPAsHome(SwitchEnum switchEnum, string packageName)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsAppSetAPPAsHomeTwo", GetEnumType(switchEnum), packageName);
#endif
        }

        public static void UPxr_KillAppsByPidOrPackageName(int[] pids, string[] packageNames)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsKillAppsByPidOrPackageName", pids, packageNames, 0);
#endif
        }

        public static void UPxr_KillBackgroundAppsWithWhiteList(string[] packageNames)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsKillBackgroundAppsWithWhiteList",packageNames, 0);
#endif
        }

        public static void UPxr_FreezeScreen(bool freeze)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsFreezeScreen", freeze);
#endif
        }

        public static void UPxr_OpenMiracast()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsOpenMiracast");
#endif
        }

        public static bool UPxr_IsMiracastOn()
        {
            bool value = false;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<bool>("pbsIsMiracastOn");
#endif
            return value;
        }

        public static void UPxr_CloseMiracast()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsCloseMiracast");
#endif
        }

        public static void UPxr_StartScan()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsStartScan");
#endif
        }

        public static void UPxr_StopScan()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsStopScan");
#endif
        }

        public static void UPxr_ConnectWifiDisplay(string modelJson)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsConnectWifiDisplay", modelJson);
#endif
        }

        public static void UPxr_DisConnectWifiDisplay()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsDisConnectWifiDisplay");
#endif
        }

        public static void UPxr_ForgetWifiDisplay(string address)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsForgetWifiDisplay", address);
#endif
        }

        public static void UPxr_RenameWifiDisplay(string address, string newName)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsRenameWifiDisplay", address, newName);
#endif
        }

        public static void UPxr_SetWDModelsCallback(Action<List<WifiDisplayModel>> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetWDModelsCallback", new WifiDisplayModelCallback(callback));
#endif
        }

        public static void UPxr_SetWDJsonCallback(Action<string> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetWDJsonCallback", new StringCallback(callback));
#endif
        }

        public static void UPxr_UpdateWifiDisplays()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsUpdateWifiDisplays");
#endif
        }

        public static string UPxr_GetConnectedWD()
        {
            string result = "";
#if PICO_PLATFORM
            result = tobHelper.Call<string>("pbsGetConnectedWD");
#endif
            return result;
        }

        public static void UPxr_SwitchLargeSpaceScene(bool open, Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSwitchLargeSpaceScene", new BoolCallback(callback), open, 0);
#endif
        }

        public static void UPxr_GetSwitchLargeSpaceStatus(Action<string> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsGetSwitchLargeSpaceStatus",new StringCallback(callback), 0);
#endif
        }

        public static bool UPxr_SaveLargeSpaceMaps()
        {
            bool value = false;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<bool>("pbsSaveLargeSpaceMaps", 0);
#endif
            return value;
        }

        public static void UPxr_ExportMaps(Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsExportMaps", new BoolCallback(callback), 0);
#endif
        }

        public static void UPxr_ImportMaps(Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsImportMaps", new BoolCallback(callback), 0);
#endif
        }

        public static float[] UPxr_GetCpuUsages()
        {
            float[] data = null;
#if PICO_PLATFORM
            data = tobHelper.Call<float[]>("pbsGetCpuUsages");
#endif
            return data;
        }

        public static float[] UPxr_GetDeviceTemperatures(int type, int source)
        {
            float[] data = null;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return null;
            }

            data = IToBService.Call<float[]>("pbsGetDeviceTemperatures", type, source);
#endif

            return data;
        }

        public static void UPxr_Capture()
        {
#if PICO_PLATFORM
            IToBService.Call("pbsCapture");
#endif
        }

        public static void UPxr_Record()
        {
#if PICO_PLATFORM
            IToBService.Call("pbsRecord");
#endif
        }

        public static void UPxr_ControlSetAutoConnectWIFIWithErrorCodeCallback(String ssid, String pwd, int ext, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlSetAutoConnectWIFIWithErrorCodeCallback",ssid,pwd,ext,new IntCallback(callback));
#endif
        }

        public static void UPxr_AppKeepAlive(String appPackageName, bool keepAlive, int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return ;
            }
            IToBService.Call("pbsAppKeepAlive",appPackageName,keepAlive,ext);
#endif
        }

        public static void UPxr_TimingStartup(int year, int month, int day, int hour, int minute, bool open)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return ;
            }
            IToBService.Call("pbsTimingStartup", year, month, day, hour, minute, open);
#endif
        }

        public static void UPxr_TimingShutdown(int year, int month, int day, int hour, int minute, bool open)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return ;
            }
            IToBService.Call("pbsTimingShutdown", year, month, day, hour, minute, open);
#endif
        }

        public static void UPxr_StartVrSettingsItem(StartVRSettingsEnum settingsEnum, bool hideOtherItem, int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return ;
            }
            IToBService.Call("pbsStartVrSettingsItem", GetEnumType(settingsEnum), hideOtherItem, ext);
#endif
        }

        public static void UPxr_SwitchVolumeToHomeAndEnter(SwitchEnum switchEnum, int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return ;
            }
            IToBService.Call("pbsSwitchVolumeToHomeAndEnter", GetEnumType(switchEnum), ext);
#endif
        }

        public static SwitchEnum UPxr_IsVolumeChangeToHomeAndEnter()
        {
            SwitchEnum switchEnum = SwitchEnum.S_OFF;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsIsVolumeChangeToHomeAndEnter");
                if (num == 0)
                {
                    switchEnum = SwitchEnum.S_ON;
                }
                else if (num == 1) {
                    switchEnum = SwitchEnum.S_OFF;
                }
#endif
            return switchEnum;
        }

        public static int UPxr_InstallOTAPackage(String otaPackagePath)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            
            value = IToBService.Call<int>("pbsInstallOTAPackage",otaPackagePath, 0);
#endif
            return value;
        }

        public static string UPxr_GetAutoConnectWiFiConfig()
        {
            string value= "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsGetAutoConnectWiFiConfig", 0);
#endif
            return value;
        }

        public static string UPxr_GetTimingStartupStatus()
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsGetTimingStartupStatus", 0);
#endif
            return value;
        }

        public static string UPxr_GetTimingShutdownStatus()
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsGetTimingShutdownStatus", 0);
#endif
            return value;
        }

        public static int UPxr_GetControllerKeyState(ControllerKeyEnum pxrControllerKey)
        {
            int value = 1;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsGetControllerKeyState", GetEnumType(pxrControllerKey),0);
#endif
            return value;
        }

        public static int UPxr_SetControllerKeyState(ControllerKeyEnum controllerKeyEnum, SwitchEnum status)
        {
            int value = 1;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsSetControllerKeyState", GetEnumType(controllerKeyEnum),GetEnumType(status),0);
#endif
            return value;
        }

        public static SwitchEnum UPxr_ControlGetPowerOffWithUSBCable()
        {
            SwitchEnum switchEnum = SwitchEnum.S_OFF;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsControlGetPowerOffWithUSBCable",0);
                if (num == 0)
                {
                    switchEnum = SwitchEnum.S_ON;
                }
                else if (num == 1) {
                    switchEnum = SwitchEnum.S_OFF;
                }
#endif
            return switchEnum;
        }

        public static ScreenOffDelayTimeEnum UPxr_PropertyGetScreenOffDelay()
        {
            ScreenOffDelayTimeEnum screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.NEVER;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsPropertyGetScreenOffDelay", 0);
                switch (num) {
                    case 0:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.THREE;
                        break;
                    case 1:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.TEN;
                        break;
                    case 2:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.THIRTY;
                        break;
                    case 3:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.SIXTY;
                        break;
                    case 4:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.THREE_HUNDRED;
                        break;
                    case 5:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.SIX_HUNDRED;
                        break;
                    case 6:
                        screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.NEVER;
                        break;
                }
#endif
            return screenOffDelayTimeEnum;
        }

        public static SleepDelayTimeEnum UPxr_PropertyGetSleepDelay()
        {
            SleepDelayTimeEnum sleepDelayTime = SleepDelayTimeEnum.NEVER;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsPropertyGetSleepDelay", 0);
                switch (num)
                {
                    case 0:
                        sleepDelayTime = SleepDelayTimeEnum.FIFTEEN;
                        break;
                    case 1:
                        sleepDelayTime = SleepDelayTimeEnum.THIRTY;
                        break;
                    case 2:
                        sleepDelayTime = SleepDelayTimeEnum.SIXTY;
                        break;
                    case 3:
                        sleepDelayTime = SleepDelayTimeEnum.THREE_HUNDRED;
                        break;
                    case 4:
                        sleepDelayTime = SleepDelayTimeEnum.SIX_HUNDRED;
                        break;
                    case 5:
                        sleepDelayTime = SleepDelayTimeEnum.ONE_THOUSAND_AND_EIGHT_HUNDRED;
                        break;
                    case 6:
                        sleepDelayTime = SleepDelayTimeEnum.NEVER;
                        break;
                }
#endif
            return sleepDelayTime;
        }

        public static string UPxr_PropertyGetPowerKeyStatus()
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsPropertyGetPowerKeyStatus", 0);
#endif
            return value;
        }

        public static int UPxr_GetEnterKeyStatus()
        {
            int value = 1;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsGetEnterKeyStatus",0);
#endif
            return value;
        }

        public static int UPxr_GetVolumeKeyStatus()
        {
            int value = 1;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsGetVolumeKeyStatus",0);
#endif
            return value;
        }

        public static int UPxr_GetBackKeyStatus()
        {
            int value = 1;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsGetBackKeyStatus",0);
#endif
            return value;
        }

        public static string UPxr_PropertyGetHomeKeyStatus(HomeEventEnum homeEvent)
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsPropertyGetHomKeyStatus", GetEnumType(homeEvent),0);
#endif
            return value;
        }

        public static void UPxr_GetSwitchSystemFunctionStatus(SystemFunctionSwitchEnum systemFunction, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsGetSwitchSystemFunctionStatus", GetEnumType(systemFunction), new IntCallback(callback),
                0);
#endif
        }

        public static string UPxr_SwitchGetUsbConfigurationOption()
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsSwitchGetUsbConfigurationOption", 0);
#endif
            return value;
        }

        public static string UPxr_GetCurrentLauncher()
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsGetCurrentLauncher", 0);
#endif
            return value;
        }

        public static int UPxr_PICOCastInit(Action<int> callback)
        {
            int value = 0;
#if PICO_PLATFORM
            value = tobHelper.Call<int>("pbsPicoCastInit", new IntCallback(callback), 0);
#endif
            return value;
        }

        public static int UPxr_PICOCastSetShowAuthorization(int authZ)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsPicoCastSetShowAuthorization",authZ,0);
#endif
            return value;
        }

        public static int UPxr_PICOCastGetShowAuthorization()
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<int>("pbsPicoCastGetShowAuthorization",0);
#endif
            return value;
        }

        public static string UPxr_PICOCastGetUrl(PICOCastUrlTypeEnum urlType)
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<string>("pbsPicoCastGetUrl",GetEnumType(urlType), 0);
#endif
            return value;
        }

        public static int UPxr_PICOCastStopCast()
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<int>("pbsPicoCastStopCast",0);
#endif
            return value;
        }

        public static int UPxr_PICOCastSetOption(PICOCastOptionOrStatusEnum castOptionOrStatus, PICOCastOptionValueEnum castOptionValue)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<int>("pbsPicoCastSetOption",GetEnumType(castOptionOrStatus),GetEnumType(castOptionValue),0);
#endif
            return value;
        }

        public static PICOCastOptionValueEnum UPxr_PICOCastGetOptionOrStatus(PICOCastOptionOrStatusEnum castOptionOrStatus)
        {
            PICOCastOptionValueEnum value = PICOCastOptionValueEnum.STATUS_VALUE_ERROR;
#if PICO_PLATFORM
                int num = 0;
                if (tobHelper == null)
                {
                    return value;
                 }
                num = tobHelper.Call<int>("pbsPicoCastGetOptionOrStatus", GetEnumType(castOptionOrStatus), 0);
                switch (num)
                {
                    case 0:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_RESOLUTION_HIGH;
                        break;
                    case 1:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_RESOLUTION_MIDDLE;
                        break;
                    case 2:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_RESOLUTION_AUTO;
                        break;
                    case 3:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_RESOLUTION_HIGH_2K;
                        break;
                    case 4:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_RESOLUTION_HIGH_4K;
                        break;
                    case 5:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_BITRATE_HIGH;
                        break;
                    case 6:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_BITRATE_MIDDLE;
                        break;
                    case 7:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_BITRATE_LOW;
                        break;
                    case 8:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_AUDIO_ON;
                        break;
                    case 9:
                        value = PICOCastOptionValueEnum.OPTION_VALUE_AUDIO_OFF;
                        break;
                    case 10:
                        value = PICOCastOptionValueEnum.STATUS_VALUE_STATE_STARTED;
                        break;
                    case 11:
                        value = PICOCastOptionValueEnum.STATUS_VALUE_STATE_STOPPED;
                        break;
                    case 12:
                        value = PICOCastOptionValueEnum.STATUS_VALUE_ERROR;
                        break;
                }
#endif
            return value;
        }

        public static int UPxr_SetSystemLanguage(String language)
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsSetSystemLanguage", language, 0);
#endif
            return num;
        }

        public static String UPxr_GetSystemLanguage()
        {
            string value = "";
#if PICO_PLATFORM
            value = IToBService.Call<string>("pbsGetSystemLanguage", 0);
#endif
            return value;
        }

        public static int UPxr_ConfigWifi(String ssid, String pwd)
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsConfigWifi",ssid,pwd, 0);
#endif
            return num;
        }

        public static String[] UPxr_GetConfiguredWifi()
        {
#if PICO_PLATFORM
                return IToBService.Call<string[]>("pbsGetConfiguredWifi",0);
#endif
            return null;
        }

        public static int UPxr_SetSystemCountryCode(String countryCode, Action<int> callback)
        {
            int num = 0;
#if PICO_PLATFORM
            num = tobHelper.Call<int>("pbsSetSystemCountryCode",countryCode,new IntCallback(callback),0);
#endif
            return num;
        }

        public static string UPxr_GetSystemCountryCode()
        {
            string value = "";
#if PICO_PLATFORM
            value = IToBService.Call<string>("pbsGetSystemCountryCode",0);
#endif
            return value;
        }

        public static int UPxr_SetSkipInitSettingPage(int flag)
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsSetSkipInitSettingPage",flag,0);
#endif
            return num;
        }

        public static int UPxr_GetSkipInitSettingPage()
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsGetSkipInitSettingPage",0);
#endif
            return num;
        }

        public static int UPxr_IsInitSettingComplete()
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsIsInitSettingComplete",0);
#endif
            return num;
        }

        public static int UPxr_StartActivity(String packageName, String className, String action, String extra, String[] categories, int[] flags)
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsStartActivity", packageName, className, action, extra, categories, flags, 0);
#endif

            return num;
        }

        public static int UPxr_CustomizeAppLibrary(String[] packageNames, SwitchEnum switchEnum)
        {
            int num = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return num;
            }
            num = IToBService.Call<int>("pbsCustomizeAppLibrary", packageNames,GetEnumType(switchEnum), 0);
#endif
            return num;
        }

        public static int[] UPxr_GetControllerBattery()
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return null;
            }
            return IToBService.Call<int[]>("pbsGetControllerBattery", 0);
#endif
            return null;
        }

        public static int UPxr_GetControllerConnectState()
        {
            int num = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return num;
            }
            num = IToBService.Call<int>("pbsGetControllerConnectState",0);
#endif
            return num;
        }

        public static string UPxr_GetAppLibraryHideList()
        {
            string value = " ";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<string>("pbsGetAppLibraryHideList",0);
#endif
            return value;
        }

        public static int UPxr_SetScreenCastAudioOutput(ScreencastAudioOutputEnum screencastAudioOutput)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsSetScreenCastAudioOutput",GetEnumType(screencastAudioOutput),0);
#endif
            return value;
        }

        public static ScreencastAudioOutputEnum UPxr_GetScreenCastAudioOutput()
        {
            ScreencastAudioOutputEnum value = ScreencastAudioOutputEnum.AUDIO_ERROR;
#if PICO_PLATFORM
                int num = 0;               
                num = tobHelper.Call<int>("pbsGetScreenCastAudioOutput",0);
                switch (num)
                {
                    case 0:
                        value = ScreencastAudioOutputEnum.AUDIO_SINK;
                        break;
                    case 1:
                        value = ScreencastAudioOutputEnum.AUDIO_TARGET;
                        break;
                    case 2:
                        value = ScreencastAudioOutputEnum.AUDIO_SINK_TARGET;
                        break;
                }
#endif
            return value;
        }

        public static int UPxr_CustomizeSettingsTabStatus(CustomizeSettingsTabEnum customizeSettingsTabEnum, SwitchEnum switchEnum)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

            value = IToBService.Call<int>("pbsCustomizeSettingsTabStatus", GetEnumType(customizeSettingsTabEnum), GetEnumType(switchEnum), 0);
#endif
            return value;
        }

        public static SwitchEnum UPxr_GetCustomizeSettingsTabStatus(CustomizeSettingsTabEnum customizeSettingsTabEnum)
        {
            SwitchEnum switchEnum = SwitchEnum.S_OFF;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsGetCustomizeSettingsTabStatus",GetEnumType(customizeSettingsTabEnum),0);
                if (num == 0)
                {
                    switchEnum = SwitchEnum.S_ON;
                }
                else if (num == 1) {
                    switchEnum = SwitchEnum.S_OFF;
                }
#endif
            return switchEnum;
        }
        
        public static void UPxr_SetPowerOffWithUSBCable(SwitchEnum switchEnum)
        {
           
#if PICO_PLATFORM
             if (IToBService==null)
            {
                return;
            }
            IToBService.Call("pbsControlSetPowerOffwithUSBCable", GetEnumType(switchEnum),0);
#endif
        }
        public static void UPxr_RemoveControllerHomeKey(HomeEventEnum EventEnum)
        {
#if PICO_PLATFORM
            if (IToBService==null)
            {
                return;
            }
            IToBService.Call("pbsRemoveControllerHomeKey", GetEnumType(EventEnum));
#endif
        }
        public static void UPxr_SetPowerOnOffLogo(PowerOnOffLogoEnum powerOnOffLogoEnum, String path, Action<bool> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertySetPowerOnOffLogo",GetEnumType(powerOnOffLogoEnum),path,0, new BoolCallback(callback));
#endif
        }
        public static void UPxr_SetIPD(float ipd, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetIPD",ipd, new IntCallback(callback));
#endif
        }
        
        public static string UPxr_GetAutoMiracastConfig()
        {
            string value = " ";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<string>("pbsGetAutoMiracastConfig",0);
#endif
            return value;
        }
        public static int UPxr_SetPicoCastMediaFormat(PicoCastMediaFormat mediaFormat)
        {
            int value = -1;
#if PICO_PLATFORM
            value = tobHelper.Call<int>("setPicoCastMediaFormat",mediaFormat.bitrate,0);
#endif
            return value;
        }
        
        public static int UPxr_setMarkerInfoCallback(TrackingOriginModeFlags trackingMode,float cameraYOffset,Action<List<MarkerInfo>>  mediaFormat)
        {
            int value = -1;

#if PICO_PLATFORM
            value = tobHelper.Call<int>("setMarkerInfoCallback",new MarkerInfoCallback(trackingMode,cameraYOffset,mediaFormat));
#endif
            return value;
        }


        private static bool UPxr_GetToken()
        {
            PLog.i(TAG, "GetToken Start");
#if PICO_PLATFORM
            token = BAuthLib.CallStatic<string>("featureAuthByToken", currentActivity, "getCameraInfo");
#endif
            if (string.IsNullOrEmpty(token))
            {
                PLog.e(TAG, "Failed to obtain token, camera data cannot be obtained!");
                return false;
            }
            PLog.i(TAG, "GetToken End token :" + token);
            return true;
        }

        public static int UPxr_GetHeadTrackingConfidence()
        {
            PLog.d(TAG, "GetHeadTrackingConfidence Start");
            int result = -1;
#if PICO_PLATFORM
            result = getHeadTrackingConfidence();
#endif
            PLog.d(TAG, "GetToken End result :" + result);

            return result;
        }

        public static bool UPxr_OpenVSTCamera()
        {
            PLog.d(TAG, "OpenVSTCamera Start");
            if (camOpenned)
            {
                PLog.d(TAG, "Camera has Openned!");
                return true;
            }

            int result = -1;
#if PICO_PLATFORM
            result = openVSTCamera();
#endif
            camOpenned = result == 0;
            PLog.d(TAG, "OpenVSTCamera End result :" + result + ", camOpenned : " + camOpenned);
            return result == 0;
        }

        public static bool UPxr_CloseVSTCamera()
        {
            PLog.d(TAG, "CloseVSTCamera Start");
            if (!camOpenned)
            {
                PLog.d(TAG, "Camera has Closed!");
                return true;
            }

            int result = -1;
#if PICO_PLATFORM
            result = closeVSTCamera();
#endif
            camOpenned = !(result == 0);
            PLog.d(TAG, "CloseVSTCamera End result :" + result + ", camOpenned : " + camOpenned);
            return result == 0;
        }

        public static int UPxr_GetHeadTrackingData(Int64 predictTime, ref SixDof data, int type)
        {
            PLog.d(TAG, "GetHeadTrackingData Start");
            int result = -1;
#if PICO_PLATFORM
            result = getHeadTrackingData(predictTime, ref data, type);
#endif
            PLog.d(TAG, "GetHeadTrackingData End result :" + result);

            return result;
        }

        public static int UPxr_AcquireVSTCameraFrame(out Frame frame)
        {
            PLog.d(TAG, "AcquireVSTCameraFrame Start");
            frame = new Frame();
            if (string.IsNullOrEmpty(token))
            {
                PLog.e(TAG, "Failed to obtain token, camera data cannot be obtained!");
                return -1;
            }

            if (!camOpenned)
            {
                PLog.e(TAG, "Failed to obtain data due to camera not being turned on!");
                return -1;
            }

            InitDistortionFrame();
            int result = -1;
#if PICO_PLATFORM
            result = acquireVSTCameraFrame(ref distortionFrameItemExt);
#endif
            frame.width = distortionFrameItemExt.frame.width;
            frame.height = distortionFrameItemExt.frame.height;
            frame.timestamp = distortionFrameItemExt.frame.timestamp;
            frame.datasize = distortionFrameItemExt.frame.datasize;
            frame.data = distortionFrameItemExt.frame.data;

            if (frame.pose != null)
            {
                frame.pose.position.x = (float)distortionFrameItemExt.six_dof_pose.pose.x;
                frame.pose.position.y = (float)distortionFrameItemExt.six_dof_pose.pose.y;
                frame.pose.position.z = (float)distortionFrameItemExt.six_dof_pose.pose.z;
                frame.pose.rotation.w = (float)distortionFrameItemExt.six_dof_pose.pose.rw;
                frame.pose.rotation.x = (float)distortionFrameItemExt.six_dof_pose.pose.rx;
                frame.pose.rotation.y = (float)distortionFrameItemExt.six_dof_pose.pose.ry;
                frame.pose.rotation.z = (float)distortionFrameItemExt.six_dof_pose.pose.rz;
            }
            frame.status = distortionFrameItemExt.six_dof_pose.pose.confidence;

            PLog.d(TAG, "AcquireVSTCameraFrame End result :" + result);
            return result;
        }

        public static int UPxr_AcquireVSTCameraFrameAntiDistortion(int width, int height, out Frame frame)
        {
            PLog.d(TAG, "AcquireVSTCameraFrameAntiDistortion Start width:" + width + ", height:" + height);
            frame = new Frame();
            if (string.IsNullOrEmpty(token))
            {
                PLog.e(TAG, "Failed to obtain token, camera data cannot be obtained!");
                return -1;
            }

            if (!camOpenned)
            {
                PLog.e(TAG, "Failed to obtain data due to camera not being turned on!");
                return -1;
            }

            int size = width * height * 3;
            InitAntiDistortionFrame(size);
            int result = -1;
#if PICO_PLATFORM
            result = acquireVSTCameraFrameAntiDistortion(token, width, height, ref antiDistortionFrameItemExt);
#endif
            PLog.d(TAG, "AcquireVSTCameraFrameAntiDistortion End result :" + result +
                ", width : " + antiDistortionFrameItemExt.frame.width +
                ", height : " + antiDistortionFrameItemExt.frame.height +
                ", datasize : " + antiDistortionFrameItemExt.frame.datasize +
                ", data : " + antiDistortionFrameItemExt.frame.data +
                ", confidence : " + antiDistortionFrameItemExt.six_dof_pose.pose.confidence);

            frame.width = antiDistortionFrameItemExt.frame.width;
            frame.height = antiDistortionFrameItemExt.frame.height;
            frame.timestamp = antiDistortionFrameItemExt.frame.timestamp;
            frame.datasize = antiDistortionFrameItemExt.frame.datasize;
            frame.data = antiDistortionFrameItemExt.frame.data;

            if (frame.pose != null)
            {
                frame.pose.position.x = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.x;
                frame.pose.position.y = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.y;
                frame.pose.position.z = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.z;
                frame.pose.rotation.w = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rw;
                frame.pose.rotation.x = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rx;
                frame.pose.rotation.y = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.ry;
                frame.pose.rotation.z = (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rz;
            }
            frame.status = antiDistortionFrameItemExt.six_dof_pose.relocation_pose.confidence;
            
            PLog.d(TAG, "zzzzzz relocation_pose.x=" + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.x +
                        ", relocation_pose.y=" + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.y +
                        ", relocation_pose.z=: " + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.z +
                        ", relocation_pose.rw=: " + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rw +
                        ", relocation_pose.rx = " + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rx +
                        ", relocation_pose.ry = " + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.ry +
                        ", relocation_pose.rz = " + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.rz);
            PLog.d(TAG, "zzzzzz pose.x=" + (float)antiDistortionFrameItemExt.six_dof_pose.relocation_pose.x +
                        ", pose.y=" + (float)antiDistortionFrameItemExt.six_dof_pose.pose.y +
                        ", relocation_pose.z=: " + (float)antiDistortionFrameItemExt.six_dof_pose.pose.z +
                        ", pose.rw=: " + (float)antiDistortionFrameItemExt.six_dof_pose.pose.rw +
                        ", pose.rx = " + (float)antiDistortionFrameItemExt.six_dof_pose.pose.rx +
                        ", pose.ry = " + (float)antiDistortionFrameItemExt.six_dof_pose.pose.ry +
                        ", pose.rz = " + (float)antiDistortionFrameItemExt.six_dof_pose.pose.rz);
            return result;
        }

        public static UnityEngine.Pose ToUnityPose(UnityEngine.Pose poseR)
        {
            UnityEngine.Pose poseL;
            poseL.position.x = poseR.position.x;
            poseL.position.y = poseR.position.y;
            poseL.position.z = -poseR.position.z;
            poseL.rotation.x = poseR.rotation.x;
            poseL.rotation.y = poseR.rotation.y;
            poseL.rotation.z = -poseR.rotation.z;
            poseL.rotation.w = -poseR.rotation.w;
            return poseL;
        }

        // RGB Camera pose （Left-handed coordinate system: X right, Y up, Z out）
        public static UnityEngine.Pose ToRGBCameraPose(RGBCameraParams cameraParams, UnityEngine.Pose headPose)
        {
            Vector3 headToCameraPos = new Vector3((float)cameraParams.x, (float)cameraParams.y, (float)cameraParams.z);
            Quaternion headToCameraRot = new Quaternion((float)cameraParams.rx, (float)cameraParams.ry, (float)cameraParams.rz, (float)cameraParams.rw);

            Matrix4x4 headMx = Matrix4x4.TRS(headPose.position, headPose.rotation, Vector3.one);
            Matrix4x4 cameraMx = Matrix4x4.TRS(headToCameraPos, headToCameraRot, Vector3.one);
            Matrix4x4 rgbMx = headMx * cameraMx;
            Matrix4x4 rotX180 = Matrix4x4.Rotate(Quaternion.Euler(180f, 0f, 0f));
            rgbMx *= rotX180;
#if UNITY_2021_2_OR_NEWER
            UnityEngine.Pose rgbCameraPose = ToUnityPose(new UnityEngine.Pose(rgbMx.GetPosition(), rgbMx.rotation));
#else
            UnityEngine.Pose rgbCameraPose = ToUnityPose(new UnityEngine.Pose(new Vector3(rgbMx.m03, rgbMx.m13, rgbMx.m23), rgbMx.rotation));
#endif
            return rgbCameraPose;
        }

        private static void InitDistortionFrame()
        {
            if (initDistortionFrame)
            {
                return;
            }
            distortionFrameItemExt = new FrameItemExt();
            initDistortionFrame = true;
        }

        private static void InitAntiDistortionFrame(int size)
        {
            if (curSize == size)
            {
                return;
            }
            Debug.LogFormat("InitAntiDistortionFrame curSize={0}, size={1}", curSize, size);
            antiDistortionFrameItemExt = new FrameItemExt();
            if (antiDistortionFrameItemExt.frame.data != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(antiDistortionFrameItemExt.frame.data);
                antiDistortionFrameItemExt.frame.data = IntPtr.Zero;
            }
            antiDistortionFrameItemExt.frame.data = Marshal.AllocHGlobal(size);
            curSize = size;
        }

        public static RGBCameraParams UPxr_GetCameraParameters()
        {
            PLog.d(TAG, "GetCameraParameters Start");
            RGBCameraParams rgbCameraParams = new RGBCameraParams();
            if (string.IsNullOrEmpty(token))
            {
                PLog.e(TAG, "Failed to obtain token, camera data cannot be obtained!");
                return rgbCameraParams;
            }
            int result = getCameraParameters(token, out rgbCameraParams);
            PLog.d(TAG, "GetCameraParameters End result :" + result);

            return rgbCameraParams;
        }

        public static double UPxr_GetPredictedDisplayTime()
        {
            PLog.d(TAG, "UPxr_GetPredictedDisplayTime()");
            double predictedDisplayTime = 0;
#if PICO_PLATFORM
            Pxr_GetPredictedDisplayTime(ref predictedDisplayTime);
#endif
            PLog.d(TAG, "UPxr_GetPredictedDisplayTime() predictedDisplayTime：" + predictedDisplayTime);
            return predictedDisplayTime;
        }

        public static SensorState UPxr_GetPredictedMainSensorState(double predictTime)
        {
            SensorState sensorState = new SensorState();
            PxrSensorState2 sensorState2 = new PxrSensorState2();
            int sensorFrameIndex = 0;
#if PICO_PLATFORM
            Pxr_GetPredictedMainSensorState2(predictTime, ref sensorState2, ref sensorFrameIndex);
#endif
            sensorState.status = sensorState2.status == 3 ? 1 : 0;
            sensorState.pose.position.x = sensorState2.pose.position.x;
            sensorState.pose.position.y = sensorState2.pose.position.y;
            sensorState.pose.position.z = sensorState2.pose.position.z;
            sensorState.pose.rotation.x = sensorState2.pose.orientation.x;
            sensorState.pose.rotation.y = sensorState2.pose.orientation.y;
            sensorState.pose.rotation.z = sensorState2.pose.orientation.z;
            sensorState.pose.rotation.w = sensorState2.pose.orientation.w;
            return sensorState;
        }
        
        public static int UPxr_gotoSeeThroughFloorSetting()
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("gotoSeeThroughFloorSetting",0);
#endif
            return value;
        }
        public static int UPxr_fileCopy(String srcPath, String dstPath, FileCopyCallback callback)
        {
            int value = -1;
#if PICO_PLATFORM
            value = tobHelper.Call<int>("FileCopy",srcPath,dstPath,callback);
#endif
            return value;
        }
        public static void UPxr_IsMapInEffect(String path, Action<int> callback)
        {
           
#if PICO_PLATFORM
            tobHelper.Call("isMapInEffect",path,new IntCallback(callback),0);
#endif
        }
        public static void UPxr_ImportMapByPath(String path, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("importMapByPath",path,new IntCallback(callback),0);
#endif
        }
        
        
        private const string LibraryName = "PICO_TOBAPI";

        [DllImport(LibraryName,  CallingConvention = CallingConvention.Cdecl)]
        public static extern float oxr_get_trackingorigin_height();
    }
}