/*******************************************************************************
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;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using LitJson;
using Unity.XR.PXR;
using UnityEngine;
using UnityEngine.XR;
using KeyValuePair = Unity.XR.PICO.TOBSupport.KeyValuePair;

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_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(bool isCamera=false)
        {
#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 !isCamera || 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,int ext)
        {
            string result = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return result;
            }
            result = IToBService.Call<string>("pbsStateGetDeviceInfo", GetEnumType(type), ext);
#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,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlAPPManger", GetEnumType(packageControl), path, ext,  new IntCallback(callback));
#endif
        }

        public static void UPxr_ControlSetAutoConnectWIFI(string ssid, string pwd, Action<bool> callback,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsControlSetAutoConnectWIFI", ssid, pwd, ext, 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,int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsSwitchSystemFunction", GetEnumType(systemFunction), GetEnumType(switchEnum), ext);
#endif
        }

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

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

        public static void UPxr_GetControllerPairTime(Action<int> callback,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsGetControllerPairTime",new IntCallback(callback), ext);
#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,int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsKillAppsByPidOrPackageName", pids, packageNames, ext);
#endif
        }

        public static void UPxr_KillBackgroundAppsWithWhiteList(string[] packageNames,int ext)
        {
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return;
            }
            IToBService.Call("pbsKillBackgroundAppsWithWhiteList",packageNames, ext);
#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,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSwitchLargeSpaceScene", new BoolCallback(callback), open, ext);
#endif
        }

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

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

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

        public static void UPxr_ImportMaps(Action<bool> callback,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsImportMaps", new BoolCallback(callback), ext);
#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 ext)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            
            value = IToBService.Call<int>("pbsInstallOTAPackage",otaPackagePath, ext);
#endif
            return value;
        }

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

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

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

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

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

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

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

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

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

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

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

        public static ScreenOffDelayTimeEnum UPxr_PropertyGetScreenOffDelay(int ext)
        {
            ScreenOffDelayTimeEnum screenOffDelayTimeEnum = ScreenOffDelayTimeEnum.NEVER;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsPropertyGetScreenOffDelay", ext);
                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(int ext)
        {
            SleepDelayTimeEnum sleepDelayTime = SleepDelayTimeEnum.NEVER;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsPropertyGetSleepDelay", ext);
                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(int ext)
        {
            string value = "";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        public static PICOCastOptionValueEnum UPxr_PICOCastGetOptionOrStatus(PICOCastOptionOrStatusEnum castOptionOrStatus,int ext)
        {
            PICOCastOptionValueEnum value = PICOCastOptionValueEnum.STATUS_VALUE_ERROR;
#if PICO_PLATFORM
                int num = 0;
                if (tobHelper == null)
                {
                    return value;
                }
                num = tobHelper.Call<int>("pbsPicoCastGetOptionOrStatus", GetEnumType(castOptionOrStatus), ext);
                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 ext)
        {
            int num = 0;
#if PICO_PLATFORM
                num = IToBService.Call<int>("pbsSetSystemLanguage", language, ext);
#endif
            return num;
        }

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

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

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

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

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

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

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

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

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

            return num;
        }

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

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

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

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

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

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

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

        public static ScreencastAudioOutputEnum UPxr_GetScreenCastAudioOutput(int ext)
        {
            ScreencastAudioOutputEnum value = ScreencastAudioOutputEnum.AUDIO_ERROR;
#if PICO_PLATFORM
                int num = 0;               
                num = tobHelper.Call<int>("pbsGetScreenCastAudioOutput",ext);
                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 ext)
        {
            int value = 0;
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }

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

        public static SwitchEnum UPxr_GetCustomizeSettingsTabStatus(CustomizeSettingsTabEnum customizeSettingsTabEnum,int ext)
        {
            SwitchEnum switchEnum = SwitchEnum.S_OFF;
#if PICO_PLATFORM
                int num = 0;
                num = tobHelper.Call<int>("pbsGetCustomizeSettingsTabStatus",GetEnumType(customizeSettingsTabEnum),ext);
                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,int ext)
        {
           
#if PICO_PLATFORM
             if (IToBService==null)
            {
                return;
            }
            IToBService.Call("pbsControlSetPowerOffwithUSBCable", GetEnumType(switchEnum),ext);
#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,int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsPropertySetPowerOnOffLogo",GetEnumType(powerOnOffLogoEnum),path,ext, 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(int ext)
        {
            string value = " ";
#if PICO_PLATFORM
            if (IToBService == null)
            {
                return value;
            }
            value = IToBService.Call<string>("pbsGetAutoMiracastConfig",ext);
#endif
            return value;
        }
        public static int UPxr_SetPicoCastMediaFormat(PicoCastMediaFormat mediaFormat, int ext)
        {
            int value = -1;
#if PICO_PLATFORM
            value = tobHelper.Call<int>("setPicoCastMediaFormat",mediaFormat.bitrate,ext);
#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
            if (BAuthLib==null)
            {
                UPxr_InitEnterpriseService();
            }
            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.pose.x;
                frame.pose.position.y = (float)antiDistortionFrameItemExt.six_dof_pose.pose.y;
                frame.pose.position.z = (float)antiDistortionFrameItemExt.six_dof_pose.pose.z;
                frame.pose.rotation.w = (float)antiDistortionFrameItemExt.six_dof_pose.pose.rw;
                frame.pose.rotation.x = (float)antiDistortionFrameItemExt.six_dof_pose.pose.rx;
                frame.pose.rotation.y = (float)antiDistortionFrameItemExt.six_dof_pose.pose.ry;
                frame.pose.rotation.z = (float)antiDistortionFrameItemExt.six_dof_pose.pose.rz;
            }
            frame.status = antiDistortionFrameItemExt.six_dof_pose.pose.confidence;
            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()
        {
            double predictedDisplayTime = PXR_Plugin.System.UPxr_GetPredictedDisplayTime();
            
            PLog.d(TAG, "UPxr_GetPredictedDisplayTime() predictedDisplayTime：" + predictedDisplayTime);
            return predictedDisplayTime;
        }

        public static SensorState UPxr_GetPredictedMainSensorState(double predictTime,bool isGlobal)
        {
            SensorState sensorState = new SensorState();
            PxrSensorState2 sensorState2 = new PxrSensorState2();
            int sensorFrameIndex = 0;
#if PICO_PLATFORM
            PXR_Plugin.Pxr_GetPredictedMainSensorState2(predictTime, ref sensorState2, ref sensorFrameIndex);
#endif
           
            sensorState.status = sensorState2.status == 3 ? 1 : 0;
            if (isGlobal)
            {
                sensorState.pose.position.x = sensorState2.globalPose.position.x;
                sensorState.pose.position.y = sensorState2.globalPose.position.y;
                sensorState.pose.position.z = sensorState2.globalPose.position.z;
                sensorState.pose.rotation.x = sensorState2.globalPose.orientation.x;
                sensorState.pose.rotation.y = sensorState2.globalPose.orientation.y;
                sensorState.pose.rotation.z = sensorState2.globalPose.orientation.z;
                sensorState.pose.rotation.w = sensorState2.globalPose.orientation.w;
            }
            else
            {
                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 ext)
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("gotoSeeThroughFloorSetting",ext);
#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, int ext)
        {
           
#if PICO_PLATFORM
            tobHelper.Call("isMapInEffect",path,new IntCallback(callback),ext);
#endif
        }
        public static void UPxr_ImportMapByPath(String path, Action<int> callback, int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("importMapByPath",path,new IntCallback(callback),ext);
#endif
        }
        public static void UPxr_SetWifiP2PDeviceName(String deviceName, Action<int> callback, int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("setWifiP2PDeviceName",deviceName,new IntCallback(callback),ext);
#endif
        }
        public static String UPxr_GetWifiP2PDeviceName(int ext)
        {
            String value = "";

#if PICO_PLATFORM
            value = IToBService.Call<String>("getWifiP2PDeviceName",ext);
#endif
            return value;
        }

        public static int UPxr_SetScreenBrightness(int brightness, int ext)
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("setScreenBrightness", brightness, ext);
#endif
            return value;
        }
        public static void UPxr_SwitchSystemFunction(int systemFunction, int switchEnum, Action<int> callback, int ext)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSwitchSystemFunction",systemFunction,switchEnum,new IntCallback(callback),ext);
#endif
        }
        public static int UPxr_SetSystemKeyUsability(int key, int usability)
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("setSystemKeyUsability", key, usability);
#endif
            return value;
        }
        public static int UPxr_SetLauncher(String packageName)
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("setLauncher", packageName);
#endif
            return value;
        }
        public static int UPxr_SetSystemAutoSleepTime(SleepDelayTimeEnum delayTimeEnum)
        {
            int value = -1;

#if PICO_PLATFORM
             value = IToBService.Call<int>("setSystemAutoSleepTime", GetEnumType(delayTimeEnum));
#endif
            return value;
        }

        public static int UPxr_OpenTimingStartup(int year, int month, int day, int hour, int minute)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("openTimingStartup", year, month, day, hour, minute);
#endif
            return value;
        }
        public static int UPxr_OpenTimingStartup(int hour, int minute, int repeat)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("openTimingStartup", hour, minute,repeat);
#endif
            return value;
        }
        public static int UPxr_CloseTimingStartup()
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("closeTimingStartup");
#endif
            return value;
        }
        public static int UPxr_OpenTimingShutdown(int year, int month, int day, int hour, int minute)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("openTimingShutdown", year, month, day, hour, minute);
#endif
            return value;
        }
        public static int UPxr_OpenTimingShutdown(int hour, int minute, int repeat)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("openTimingShutdown",  hour, minute,repeat);
#endif
            return value;
        }
        public static int UPxr_CloseTimingShutdown()
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("closeTimingShutdown");
#endif
            return value;
        }
        public static int UPxr_SetTimeZone(String timeZone)
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("setTimeZone", timeZone);
#endif
            return value;
        }
        public static void UPxr_AppCopyrightVerify(string packageName, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("appCopyrightVerify",packageName,new IntCallback(callback));
#endif
        }
        public static int UPxr_GotoEnvironmentTextureCheck()
        {
            int value = -1;

#if PICO_PLATFORM
            value = IToBService.Call<int>("gotoEnvironmentTextureCheck");
#endif
            return value;
        }
        private const string LibraryName = "PICO_TOBAPI";

        [DllImport(LibraryName,  CallingConvention = CallingConvention.Cdecl)]
        public static extern float oxr_get_trackingorigin_height();
        public static int UPxr_SetSystemDate(int year, int month, int day)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("setSystemDate", year, month, day);
#endif
            return value;
        }
        public static int UPxr_SetSystemTime(int hourOfDay, int minute, int second)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("setSystemTime", hourOfDay, minute, second);
#endif
            return value;
        }
        public static int UPxr_KeepAliveBackground(int keepAlivePid, int flags, int level)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("keepAliveBackground", keepAlivePid, flags, level);
#endif
            return value;
        }
        public static int UPxr_OpenIPDDetectionPage()
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("openIPDDetectionPage");
#endif
            return value;
        }
        public static int UPxr_SetFloorHeight(float height)
        {
            int value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<int>("setFloorHeight",height);
#endif
            return value;
        }
        public static float UPxr_GetFloorHeight()
        {
            float value = -1;
#if PICO_PLATFORM
            value =IToBService.Call<float>("getFloorHeight");
#endif
            return value;
        }
        public static String UPxr_GetTimingStartupStatusTwo(int ext)
        {
            String value = "";
#if PICO_PLATFORM
            value =IToBService.Call<String>("pbsGetTimingStartupStatusTwo",ext);
#endif
            return value;
        }
        public static String UPxr_GetTimingShutDownStatusTwo(int ext)
        {
            String value = "";
#if PICO_PLATFORM
            value =IToBService.Call<String>("pbsGetTimingShutDownStatusTwo",ext);
#endif
            return value;
        }
        public static String[] UPxr_GetRunningAppProcesses()
        {
            String[] value = null;
#if PICO_PLATFORM
            value=tobHelper.Call<String[]>("pbsGetRunningAppProcesses");
#endif
            return value;
        }
        
        public static String UPxr_GetFocusedApp()
        {
            String value = "";
#if PICO_PLATFORM
            value = tobHelper.Call<String>("pbsGetFocusedApp");
#endif
            return value;
        }

        

        public static String UPxr_StartService(AndroidJavaObject intent)
        {
            String value = "";
#if PICO_PLATFORM
            value = tobHelper.Call<String>("pbsStartService", intent);
#endif
            return value;
        }
        

        public static String UPxr_StartForegroundService(AndroidJavaObject intent)
        {
            String value = "";
#if PICO_PLATFORM
            value = tobHelper.Call<String>("pbsStartForegroundService", intent);
#endif
            return value;
        }
        
        public static int UPxr_SendBroadcast(AndroidJavaObject intent)
        {
            int value = -1;
#if PICO_PLATFORM
            value = IToBService.Call<int>("sendBroadcast", intent);
#endif
            return value;
        }
        

        public static int UPxr_SendOrderedBroadcast(AndroidJavaObject intent, String receiverPermission)
        {
            int value = -1;
#if PICO_PLATFORM
            value = IToBService.Call<int>("sendOrderedBroadcast", intent,string.IsNullOrEmpty(receiverPermission)?null:receiverPermission);
#endif
            return value;
        }
        public static int UPxr_SetVirtualEnvironment(String envPath)
        {
            int value = -1;
#if PICO_PLATFORM
            value = IToBService.Call<int>("setVirtualEnvironment",string.IsNullOrEmpty(envPath)?null:envPath);
#endif
            return value;
        }
        public static string UPxr_GetVirtualEnvironment()
        {
            string value = "";
#if PICO_PLATFORM
            value = IToBService.Call<string>("getVirtualEnvironment");
#endif
            return value;
        }



        private static IntPtr? _VirtualDisplayPlugin;
        private static IntPtr createVirtualDisplayMethodId;
        private static IntPtr startAppMethodId;
        private static jvalue[] setUnityActivityParams;
        private static IntPtr? _Activity;

        private static IntPtr Activity
        {
            get
            {
                if (!_Activity.HasValue)
                {
                    try
                    {
                        IntPtr unityPlayerClass = AndroidJNI.FindClass("com/unity3d/player/UnityPlayer");
                        IntPtr currentActivityField = AndroidJNI.GetStaticFieldID(unityPlayerClass, "currentActivity",
                            "Landroid/app/Activity;");
                        IntPtr activity = AndroidJNI.GetStaticObjectField(unityPlayerClass, currentActivityField);

                        _Activity = AndroidJNI.NewGlobalRef(activity);

                        AndroidJNI.DeleteLocalRef(activity);
                        AndroidJNI.DeleteLocalRef(unityPlayerClass);
                    }
                    catch (Exception ex)
                    {
                        Debug.LogException(ex);
                        _Activity = IntPtr.Zero;
                    }
                }

                return _Activity.GetValueOrDefault();
            }
        }

        private static IntPtr VirtualDisplayPlugin
        {
            get
            {
                if (!_VirtualDisplayPlugin.HasValue)
                {
                    try
                    {
                        IntPtr myClass =
                            AndroidJNI.FindClass("com/picoxr/tobservice/VirtualDisplay/VirtualDisplayPlugin");

                        if (myClass != IntPtr.Zero)
                        {
                            _VirtualDisplayPlugin = AndroidJNI.NewGlobalRef(myClass);

                            AndroidJNI.DeleteLocalRef(myClass);
                        }
                        else
                        {
                            Debug.LogError("Failed to find VirtualDisplayPlugin class");
                            _VirtualDisplayPlugin = IntPtr.Zero;
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.LogError("Failed to find VirtualDisplayPlugin class");
                        Debug.LogException(ex);
                        _VirtualDisplayPlugin = IntPtr.Zero;
                    }
                }

                return _VirtualDisplayPlugin.GetValueOrDefault();
            }
        }

        private static IntPtr setUnityActivityMethodId;

        public static void SetUnityActivity()
        {
            if (setUnityActivityMethodId == System.IntPtr.Zero)
            {
                setUnityActivityMethodId = AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "setUnityActivity",
                    "(Landroid/content/Context;)V");
                setUnityActivityParams = new jvalue[1];
            }

            setUnityActivityParams[0].l = Activity;
            AndroidJNI.CallStaticVoidMethod(VirtualDisplayPlugin, setUnityActivityMethodId, setUnityActivityParams);
        }
        private static jvalue[] CVDParams;
        public static int UPxr_CreateVirtualDisplay(string displayName, IntPtr surfaceObj, int width, int height,
            int densityDpi, int flags)
        {
            int value = -1;
#if PICO_PLATFORM
            // SetUnityActivity();
            if (createVirtualDisplayMethodId == System.IntPtr.Zero)
            {
                createVirtualDisplayMethodId = AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin,
                    "CreateVirtualDisplay", "(Ljava/lang/String;Landroid/view/Surface;IIII)I");
                CVDParams = new jvalue[6];
            }

            IntPtr displayNameString = AndroidJNI.NewStringUTF(displayName);

            CVDParams[0].l = displayNameString;
            CVDParams[1].l = surfaceObj;
            CVDParams[2].i = width;
            CVDParams[3].i = height;
            CVDParams[4].i = densityDpi;
            CVDParams[5].i = flags;
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, createVirtualDisplayMethodId, CVDParams);

            AndroidJNI.DeleteLocalRef(displayNameString);
#endif
            return value;
        }
        private static jvalue[] SAParams;
        public static int UPxr_StartApp(int displayId, AndroidJavaObject intent)
        {
            int value = -1;
#if PICO_PLATFORM
            if (startAppMethodId == IntPtr.Zero)
            {
                startAppMethodId =
                    AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "StartApp", "(ILandroid/content/Intent;)I");
                SAParams = new jvalue[2];
            }

            SAParams[0].i = displayId;
            SAParams[1].l = intent.GetRawObject();
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, startAppMethodId, SAParams);

#endif
            return value;
        }
        private static IntPtr releaseVirtualDisplayMethodId;
        private static jvalue[] RVDParams;
        public static int UPxr_ReleaseVirtualDisplay(int displayId)
        {
            int value = -1;
#if PICO_PLATFORM
            if (releaseVirtualDisplayMethodId == IntPtr.Zero)
            {
                releaseVirtualDisplayMethodId =
                    AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "ReleaseVirtualDisplay", "(I)I");
                RVDParams = new jvalue[1];
            }

            RVDParams[0].i = displayId;
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, releaseVirtualDisplayMethodId, RVDParams);

#endif
            return value;
        }
        private static IntPtr setVirtualDisplaySurfaceMethodId;
        private static jvalue[] SFParams;
        public static int UPxr_SetVirtualDisplaySurface(int displayId, IntPtr surfaceObj)
        {
            int value = -1;
#if PICO_PLATFORM
            if (setVirtualDisplaySurfaceMethodId == IntPtr.Zero)
            {
                setVirtualDisplaySurfaceMethodId = AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin,
                    "SetVirtualDisplaySurface", "(ILandroid/view/Surface;)I");
                SFParams = new jvalue[2];
            }
            
            SFParams[0].i = displayId;
            SFParams[1].l = surfaceObj;
           
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, setVirtualDisplaySurfaceMethodId, SFParams);
#endif
            return value;
        }
        private static IntPtr injectEventMMethodId;
        private static jvalue[] JEMParams;
        public static int UPxr_InjectEvent(int displayId, int action, int source, float x, float y)
        {
            int value = -1;
#if PICO_PLATFORM
            if (injectEventMMethodId == IntPtr.Zero)
            {
                injectEventMMethodId =
                    AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "InjectEvent", "(IIIFF)I");
                JEMParams = new jvalue[5];
            }
           
            JEMParams[0].i = displayId;
            JEMParams[1].i = action;
            JEMParams[2].i = source;
            JEMParams[3].f = x;
            JEMParams[4].f = y;
           
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, injectEventMMethodId, JEMParams);

#endif
            return value;
        }
        private static IntPtr injectEventKMethodId;
        private static jvalue[] JEParams;
        public static int UPxr_InjectEvent(int displayId, int action, int source, int keycode)
        {
            int value = -1;
#if PICO_PLATFORM
            if (injectEventKMethodId == IntPtr.Zero)
            {
                injectEventKMethodId =
                    AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "InjectEvent", "(IIII)I");
                JEParams = new jvalue[4];
            }

            JEParams[0].i = displayId;
            JEParams[1].i = action;
            JEParams[2].i = source;
            JEParams[3].i = keycode;
           
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, injectEventKMethodId, JEParams);

#endif
            return value;
        }
        private static IntPtr resizeVirtualDisplayMethodId;
        private static jvalue[] RVParams;
        public static int UPxr_ResizeVirtualDisplay(int displayId, int width, int height, int densityDpi)
        {
            int value = -1;
#if PICO_PLATFORM
            if (resizeVirtualDisplayMethodId == IntPtr.Zero)
            {
                resizeVirtualDisplayMethodId =
                    AndroidJNI.GetStaticMethodID(VirtualDisplayPlugin, "ResizeVirtualDisplay", "(IIII)I");
                RVParams = new jvalue[4];
            }

            RVParams[0].i = displayId;
            RVParams[1].i = width;
            RVParams[2].i = height;
            RVParams[3].i = densityDpi;
           
            value = AndroidJNI.CallStaticIntMethod(VirtualDisplayPlugin, resizeVirtualDisplayMethodId, RVParams);

#endif
            return value;
        }

        public static int UPxr_ShowGlobalMessageDialog(Texture2D icon, String title, String body, long time, int gap,
            int position)
        {
            int value = 1;
#if PICO_PLATFORM
            if (icon == null)
            {
                value = tobHelper.Call<int>("pbsShowGlobalMessageDialog", null, 0, 0, title, body, time, gap, position);
            }
            else
            {
                Color[] colors = icon.GetPixels();
                // Color[] colors=  new Color[icon.width * icon.height];
                int[] colorint = new int[icon.width * icon.height * 4];
                // for (int i = 0; i < colors.Length; i++)
                // {
                //     colors[i]=Color.red;
                // }
                for (int i = 0; i < colors.Length; i++)
                {
                    colorint[4 * i] = (int)(colors[i].a * 255);
                    colorint[4 * i + 1] = (int)(colors[i].r * 255);
                    colorint[4 * i + 2] = (int)(colors[i].g * 255);
                    colorint[4 * i + 3] = (int)(colors[i].b * 255);
                }

                value = tobHelper.Call<int>("pbsShowGlobalMessageDialog", colorint, icon.width, icon.height, title,
                    body, time, gap, position);
            }
#endif
            return value;
        }

        public static Point3D[] UPxr_GetLargeSpaceBoundsInfo()
        {
            String[] value = null;
            List<Point3D> ModelList = new List<Point3D>();
#if PICO_PLATFORM
            value = tobHelper.Call<String[]>("pbsGetLargeSpaceBoundsInfo");
            // Point3D[] value1 = IToBService.Call<Point3D[]>("getLargeSpaceBoundsInfo");
            foreach (var json in value)
            {
                JsonData jsonData = JsonMapper.ToObject(json);
                Point3D model = new Point3D();
                model.x = double.Parse(jsonData["x"].ToString());
                model.y = double.Parse(jsonData["y"].ToString());
                model.z = double.Parse(jsonData["z"].ToString());
                ModelList.Add(model);
           
            }
#endif
            return ModelList.ToArray();
        }
        public static void UPxr_OpenLargeSpaceQuickMode(int length, int width, int originType, bool openVst, float distance, int timeout, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsOpenLargeSpaceQuickMode",length,width,originType,openVst,distance,timeout,new IntCallback(callback));
#endif
        }
        public static void UPxr_CloseLargeSpaceQuickMode()
        {
#if PICO_PLATFORM
            IToBService.Call("closeLargeSpaceQuickMode");
#endif
        }
        public static void UPxr_SetOriginOfLargeSpaceQuickMode(int originType, bool openVst, float distance, int timeout, Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetOriginOfLargeSpaceQuickMode",originType,openVst,distance,timeout,new IntCallback(callback));
#endif
        }
        public static void UPxr_SetBoundaryOfLargeSpaceQuickMode(int length, int width,Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetBoundaryOfLargeSpaceQuickMode",length,width,new IntCallback(callback));
#endif
        }
        public static LargeSpaceQuickModeInfo UPxr_GetLargeSpaceQuickModeInfo()
        {
            String value = "";
            LargeSpaceQuickModeInfo model = new LargeSpaceQuickModeInfo();
#if PICO_PLATFORM
            value = tobHelper.Call<String>("pbsGetLargeSpaceQuickModeInfo");
            JsonData jsonData = JsonMapper.ToObject(value);
            model.length= int.Parse(jsonData["length"].ToString());
            model.width = int.Parse(jsonData["width"].ToString());
            model.originType = int.Parse(jsonData["originType"].ToString());
            model.status = bool.Parse(jsonData["status"].ToString());
#endif
            return model;
        }
        
        public static int UPxr_StartLeftControllerPair()
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("startLeftControllerPair");
#endif
            return value;
        }
        public static int UPxr_MakeLeftControllerUnPair()
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("makeLeftControllerUnPair");
#endif
            return value;
        }
        public static int UPxr_StartRightControllerPair()
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("startRightControllerPair");
#endif
            return value;
        }
        public static int UPxr_MakeRightControllerUnPair()
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("makeRightControllerUnPair");
#endif
            return value;
        }
        
        public static int UPxr_StopControllerPair()
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("stopControllerPair");
#endif
            return value;
        }
        public static int UPxr_SetControllerPreferHand(bool isLeft)
        {
            int value = 1;
#if PICO_PLATFORM
            value=IToBService.Call<int>("setControllerPreferHand",isLeft);
#endif
            return value;
        }
        public static int UPxr_SetControllerVibrateAmplitude(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setControllerVibrateAmplitude",value);
#endif
            return value1;
        }
        public static int UPxr_SetPowerManageMode(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setPowerManageMode",value);
#endif
            return value1;
        }
        public static int UPxr_StartRoomMark()
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("startRoomMark");
#endif
            return value1;
        }
        public static int UPxr_ClearRoomMark()
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("clearRoomMark");
#endif
            return value1;
        }
        public static int UPxr_ClearEyeTrackData()
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("clearEyeTrackData");
#endif
            return value1;
        }
        public static int UPxr_SetEyeTrackRate(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setEyeTrackRate",value);
#endif
            return value1;
        }
        public static int UPxr_SetTrackFrequency(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setTrackFrequency",value);
#endif
            return value1;
        }
        public static int UPxr_StartSetSecureBorder()
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("startSetSecureBorder");
#endif
            return value1;
        }
        public static int UPxr_SetDistanceSensitivity(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setDistanceSensitivity",value);
#endif
            return value1;
        }
        public static int UPxr_SetSpeedSensitivity(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setSpeedSensitivity",value);
#endif
            return value1;
        }
        public static int UPxr_SetMotionTrackerPredictionCoefficient(float value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setMotionTrackerPredictionCoefficient",value);
#endif
            return value1;
        }
        public static float UPxr_GetMotionTrackerPredictionCoefficient()
        {
            float value1 = -1;
#if PICO_PLATFORM
            value1=IToBService.Call<float>("getMotionTrackerPredictionCoefficient");
#endif
            return value1;
        }
        public static int UPxr_StartMotionTrackerApp(int failMode, int avatarMode)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("startMotionTrackerApp",failMode,avatarMode);
#endif
            return value1;
        }
        public static int UPxr_SetSingleEyeSource(bool isLeft)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setSingleEyeSource",isLeft);
#endif
            return value1;
        }
        public static int UPxr_SetViewVisual(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setViewVisual",value);
#endif
            return value1;
        }
        public static int UPxr_SetAcceptCastMode(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setAcceptCastMode",value);
#endif
            return value1;
        }
        public static int UPxr_SetScreenCastMode(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setScreenCastMode",value);
#endif
            return value1;
        }
        public static int UPxr_SetScreenRecordShotRatio(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setScreenRecordShotRatio",value);
#endif
            return value1;
        }
        public static int UPxr_SetScreenResolution(int width, int height)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setScreenResolution",width,height);
#endif
            return value1;
        }
        public static int UPxr_SetScreenRecordFrameRate(int value)
        {
            int value1 = 1;
#if PICO_PLATFORM
            value1=IToBService.Call<int>("setScreenRecordFrameRate",value);
#endif
            return value1;
        }
        public static void UPxr_HideGlobalMessageDialog()
        {
#if PICO_PLATFORM
            IToBService.Call("hideGlobalMessageDialog");
#endif
        }
        public static int UPxr_ShowGlobalTipsDialog(Texture2D icon, String title, long time, int position, int bgColor)
        {
            int value = 1;
#if PICO_PLATFORM
            if (icon == null)
            {
                value = tobHelper.Call<int>("pbsShowGlobalTipsDialog", null, 0, 0, title, time, position, bgColor);
            }
            else
            {
                Color[] colors = icon.GetPixels();
                // Color[] colors=  new Color[icon.width * icon.height];
                int[] colorint = new int[icon.width * icon.height * 4];
                // for (int i = 0; i < colors.Length; i++)
                // {
                //     colors[i]=Color.red;
                // }
                for (int i = 0; i < colors.Length; i++)
                {
                    colorint[4 * i] = (int)(colors[i].a * 255);
                    colorint[4 * i + 1] = (int)(colors[i].r * 255);
                    colorint[4 * i + 2] = (int)(colors[i].g * 255);
                    colorint[4 * i + 3] = (int)(colors[i].b * 255);
                }

                value = tobHelper.Call<int>("pbsShowGlobalTipsDialog", colorint, icon.width, icon.height,  title, time, position, bgColor);
            }
#endif
            return value;
        }
        public static void UPxr_HideGlobalTipsDialog()
        {
#if PICO_PLATFORM
            IToBService.Call("hideGlobalTipsDialog");
#endif
        }
        public static int UPxr_ShowGlobalBigStatusDialog(Texture2D icon,String title, String body, long time, int gap, int position)
        {
            int value = 1;
#if PICO_PLATFORM
            if (icon == null)
            {
                value = tobHelper.Call<int>("pbsShowGlobalBigStatusDialog", null, 0, 0, title,body, time,gap, position);
            }
            else
            {
                Color[] colors = icon.GetPixels();
                // Color[] colors=  new Color[icon.width * icon.height];
                int[] colorint = new int[icon.width * icon.height * 4];
                // for (int i = 0; i < colors.Length; i++)
                // {
                //     colors[i]=Color.red;
                // }
                for (int i = 0; i < colors.Length; i++)
                {
                    colorint[4 * i] = (int)(colors[i].a * 255);
                    colorint[4 * i + 1] = (int)(colors[i].r * 255);
                    colorint[4 * i + 2] = (int)(colors[i].g * 255);
                    colorint[4 * i + 3] = (int)(colors[i].b * 255);
                }

                value = tobHelper.Call<int>("pbsShowGlobalBigStatusDialog", colorint, icon.width, icon.height,  title,body, time,gap, position);
            }
#endif
            return value;
        }
        public static void UPxr_HideGlobalBigStatusDialog()
        {
#if PICO_PLATFORM
            IToBService.Call("hideGlobalBigStatusDialog");
#endif
        }
        public static int UPxr_ShowGlobalSmallStatusDialog(Texture2D icon,String title,  long time, int gap, int position)
        {
            int value = 1;
#if PICO_PLATFORM
            if (icon == null)
            {
                value = tobHelper.Call<int>("pbsShowGlobalSmallStatusDialog", null, 0, 0, title, time,gap, position);
            }
            else
            {
                Color[] colors = icon.GetPixels();
                // Color[] colors=  new Color[icon.width * icon.height];
                int[] colorint = new int[icon.width * icon.height * 4];
                // for (int i = 0; i < colors.Length; i++)
                // {
                //     colors[i]=Color.red;
                // }
                for (int i = 0; i < colors.Length; i++)
                {
                    colorint[4 * i] = (int)(colors[i].a * 255);
                    colorint[4 * i + 1] = (int)(colors[i].r * 255);
                    colorint[4 * i + 2] = (int)(colors[i].g * 255);
                    colorint[4 * i + 3] = (int)(colors[i].b * 255);
                }

                value = tobHelper.Call<int>("pbsShowGlobalSmallStatusDialog", colorint, icon.width, icon.height,  title,time,gap, position);
            }
#endif
            return value;
        }
        public static void UPxr_HideGlobalSmallStatusDialog()
        {
#if PICO_PLATFORM
            IToBService.Call("hideGlobalSmallStatusDialog");
#endif
        }
        
        public static int UPxr_ShowGlobalDialogByType(String type,Texture2D icon,String title, String body, long time, int gap, int position, int bgColor)
        {
            int value = 1;
#if PICO_PLATFORM
            if (icon == null)
            {
                value = tobHelper.Call<int>("pbsShowGlobalDialogByType", type,null, 0, 0, title,body, time,gap, position,bgColor);
            }
            else
            {
                Color[] colors = icon.GetPixels();
                // Color[] colors=  new Color[icon.width * icon.height];
                int[] colorint = new int[icon.width * icon.height * 4];
                // for (int i = 0; i < colors.Length; i++)
                // {
                //     colors[i]=Color.red;
                // }
                for (int i = 0; i < colors.Length; i++)
                {
                    colorint[4 * i] = (int)(colors[i].a * 255);
                    colorint[4 * i + 1] = (int)(colors[i].r * 255);
                    colorint[4 * i + 2] = (int)(colors[i].g * 255);
                    colorint[4 * i + 3] = (int)(colors[i].b * 255);
                }

                value = tobHelper.Call<int>("pbsShowGlobalDialogByType", type,colorint, icon.width, icon.height,  title,body, time,gap, position,bgColor);
            }
#endif
            return value;
        }
        public static void UPxr_HideGlobalDialogByType(String type)
        {
#if PICO_PLATFORM
            IToBService.Call("hideGlobalDialogByType",type);
#endif
        }

        public static int UPxr_Recenter()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("recenter");
#endif
            return value;
        }

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

        public static int UPxr_OnlineSystemUpdate(SystemUpdateCallback callback)
        {
            int value = -1;
#if PICO_PLATFORM
            value = tobHelper.Call<int>("pbsSonlineSystemUpdate", callback);
#endif
            return value;
        }
        public static int UPxr_OfflineSystemUpdate(OffLineSystemUpdateConfig systemUpdateConfig,SystemUpdateCallback callback)
        {
            int value = -1;
#if PICO_PLATFORM
            if (systemUpdateConfig != null)
            {
                if (string.IsNullOrEmpty(systemUpdateConfig.otaFilePath))
                {
                   Debug.LogError("systemUpdateConfig.otaFilePath is null");
                }
                else
                {
                    value = tobHelper.Call<int>("pbsOfflineSystemUpdate", systemUpdateConfig.otaFilePath, systemUpdateConfig.autoReboot, systemUpdateConfig.showProgress, callback);
                }
               
            }
            else
            {
                Debug.LogError("systemUpdateConfig is null");
            }
#endif
            return value;
        }
        public static int UPxr_GetControllerVibrateAmplitude()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getControllerVibrateAmplitude");
#endif
            return value;
        }
        public static int UPxr_SetHMDVolumeKeyFunc(int func)
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("setHMDVolumeKeyFunc",func);
#endif
            return value;
        }
        public static int UPxr_GetHMDVolumeKeyFunc()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getHMDVolumeKeyFunc");
#endif
            return value;
        }
        public static int UPxr_GetPowerManageMode()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getPowerManageMode");
#endif
            return value;
        }
        public static int UPxr_GetEyeTrackRate()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getEyeTrackRate");
#endif
            return value;
        }
        public static int UPxr_GetTrackFrequency()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getTrackFrequency");
#endif
            return value;
        }
        public static int UPxr_GetDistanceSensitivity()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getDistanceSensitivity");
#endif
            return value;
        }
        public static int UPxr_GetSpeedSensitivity()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getSpeedSensitivity");
#endif
            return value;
        }
        public static int UPxr_SetMRCollisionAlertSensitivity(float v)
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("setMRCollisionAlertSensitivity",v);
#endif
            return value;
        }
        public static float UPxr_GetMRCollisionAlertSensitivity()
        {
            float value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<float>("getMRCollisionAlertSensitivity");
#endif
            return value;
        }
        public static void UPxr_ConnectWifi(WifiConfiguration configuration,Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsConnectWifi", configuration.ssid,configuration.password,configuration.isClient,new IntCallback(callback));
#endif
        }
        public static void UPxr_SetStaticIpConfigurationtoConnectWifi(WifiConfiguration configuration,string staticIP,string subnet_mask,string gateway,string[] DNS,Action<int> callback)
        {
#if PICO_PLATFORM
            tobHelper.Call("pbsSetStaticIpConfigurationtoConnectWifi", configuration.ssid,configuration.password,staticIP,subnet_mask,gateway,DNS,new IntCallback(callback));
#endif
        }
        public static int UPxr_GetSingleEyeSource()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getSingleEyeSource");
#endif
            return value;
        }
        public static int UPxr_GetViewVisual()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getViewVisual");
#endif
            return value;
        }
        public static int UPxr_GetAcceptCastMode()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getAcceptCastMode");
#endif
            return value;
        }
        public static int UPxr_GetScreenCastMode()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getScreenCastMode");
#endif
            return value;
        }
      
        public static int UPxr_GetScreenRecordShotRatio()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getScreenRecordShotRatio");
#endif
            return value;
        }
        public static int[] UPxr_GetScreenResolution()
        {
            int[] value = new[] {-2, -2}; 
#if PICO_PLATFORM
            value= IToBService.Call<int[]>("getScreenResolution");
#endif
            return value;
        }
        public static int UPxr_GetScreenRecordFrameRate()
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getScreenRecordFrameRate");
#endif
            return value;
        }
        public delegate void CapturelibCallBack(int type);
        [DllImport("CameraRenderingPlugin")]
        public static extern void setCameraFrameBuffer(ref Frame t);
        [DllImport("CameraRenderingPlugin")]
        public static extern void setCapturelibCallBack(CapturelibCallBack callback);
        [DllImport("CameraRenderingPlugin")]
        public static extern bool getCameraIntrinsics(int width, int height, double h_fov, double v_fov,ref int configCount, ref IntPtr configArray);
        [DllImport("CameraRenderingPlugin")]
        public static extern bool getCameraExtrinsics(ref int leftCount, ref IntPtr leftExtrinsics,ref int rightCount, ref IntPtr rightExtrinsics);
        [DllImport("CameraRenderingPlugin")]
        public static extern bool getCameraParametersNew(int width, int height, ref RGBCameraParamsNew paramsNew);
        [DllImport("CameraRenderingPlugin")]
        public static extern void setConfigure(bool enableMvHevc,int videoFps);
        [DllImport("CameraRenderingPlugin")]
        public static extern void setConfigureDefault();
        [DllImport("CameraRenderingPlugin")]
        public static extern bool openCameraAsync([In] KeyValuePair[] pairs, int count);
        [DllImport("CameraRenderingPlugin")]
        public static extern bool closeCamera();
        [DllImport("CameraRenderingPlugin")]
        public static extern bool startPerformance(int mode,int width, int height);

        [DllImport("CameraRenderingPlugin")]
        public static extern bool startPreview(IntPtr androidSurface,int mode,int width, int height);
        [DllImport("CameraRenderingPlugin")]
        public static extern void setConfigureMap([In] KeyValuePair[] pairs, int count);
        // 0: success, -1: error
        public static bool OpenCameraAsync(Dictionary<string, string>setting=null)
        {
            bool value = false;
            if (Application.platform == RuntimePlatform.Android)
            {
                if (setting != null)
                {
                    // 转换为结构体数组
                    var pairs = new KeyValuePair[setting.Count];
                    int index = 0;
                    foreach (var pair in setting)
                    {
                        pairs[index++] = new KeyValuePair 
                        { 
                            Key = pair.Key, 
                            Value = pair.Value 
                        };
                    }
                    value = openCameraAsync(pairs, setting.Count);
                }
                else
                {
                    value = openCameraAsync(null, 0);
                }
            }
            return value;
        }
        

        public static bool StartPreview(IntPtr surfaceObj,PXRCaptureRenderMode mode)
        {
            bool value = false;
            if (Application.platform == RuntimePlatform.Android)
            {
                value=startPreview(surfaceObj,(int)mode,1024,1024);
            }
            return value;
        }
        
        public static void Configure(Dictionary<string, string> config=null)
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                if (config==null)
                {
                    setConfigureDefault();
                }
                else
                {
                    var pairs = new KeyValuePair[config.Count];
                    int index = 0;
                    foreach (var pair in config)
                    {
                        pairs[index++] = new KeyValuePair 
                        { 
                            Key = pair.Key, 
                            Value = pair.Value 
                        };
                    }
                    setConfigureMap(pairs, config.Count);
                }
            }
        }
        public static void Configure(bool enableMvHevc,int videoFps)
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                setConfigure(enableMvHevc, videoFps);
            }
        }
        public static bool StartPerformance(PXRCaptureRenderMode mode,int width, int height)
        {
            bool value = false;
            if (Application.platform == RuntimePlatform.Android)
            {
                value=startPerformance((int)mode,width,height);
            }
            return value;
        }

        public static bool CloseCamera()
        {
            bool value = false;
            if (Application.platform == RuntimePlatform.Android)
            {
                value=closeCamera();
            }
            return value;
        }
        public static bool GetCameraExtrinsics(out double[] leftExtrinsics, out double[] rightExtrinsics)
        {
            leftExtrinsics = Array.Empty<double>();
            rightExtrinsics = Array.Empty<double>();
            int leftCount = 0;
            int rightCount = 0;
            IntPtr leftHandle = IntPtr.Zero;
            IntPtr rightHandle = IntPtr.Zero;
            // if (UPxr_GetToken())
            {
                bool ret = getCameraExtrinsics(ref leftCount, ref leftHandle, ref rightCount, ref rightHandle);
                leftExtrinsics = new Double[leftCount];
                rightExtrinsics = new Double[rightCount];
                Marshal.Copy(leftHandle, leftExtrinsics, 0, leftCount);
                Marshal.Copy(rightHandle, rightExtrinsics, 0, rightCount);
                return ret;
            }
            return false;
        }
        public static double[] GetCameraIntrinsics(int width, int height, double h_fov, double v_fov)
        {
            double[] configArray = null;
            int configCount = 0;
            IntPtr configHandle = IntPtr.Zero;
            // if (UPxr_GetToken())
            {
                getCameraIntrinsics(width ,height,h_fov,v_fov,ref configCount, ref configHandle);
                configArray = new Double[configCount];
                Marshal.Copy(configHandle, configArray, 0, configCount);
            }
            return configArray;
        }
        public static Matrix4x4 DoubleArrayToMatrix4x4(double[] array)
        {
            if (array==null)
            {
                return Matrix4x4.identity;
            }
            if (array.Length != 16)
            {
                Debug.LogError("The double array must have exactly 16 elements for a 4x4 matrix.");
                return Matrix4x4.identity;
            }
            return new Matrix4x4(
                new Vector4((float)array[0], (float)array[4], (float)array[8], (float)array[12]),
                new Vector4((float)array[1], (float)array[5], (float)array[9], (float)array[13]),
                new Vector4((float)array[2], (float)array[6], (float)array[10], (float)array[14]),
                new Vector4((float)array[3], (float)array[7], (float)array[11], (float)array[15])
            );
        }
        public static bool GetCameraParametersNew(int width, int height, ref RGBCameraParamsNew paramsNew)
        {
            // if (UPxr_GetToken())
            {
                return getCameraParametersNew(width,height,ref paramsNew);
            }
        }
        
        public static int UPxr_SetDeviceOwner(string pkg, string cls)
        {
            int value = 1;
#if PICO_PLATFORM
            value= tobHelper.Call<int>("pbsSetDeviceOwner",pkg,cls);
#endif
            return value;
        }

        public static ComponentName UPxr_GetDeviceOwner()
        {
          
#if PICO_PLATFORM
            string[] value = tobHelper.Call<String[]>("pbsGetDeviceOwner");
            if (value!=null&&value.Length==6)
            {
                return new ComponentName(value[0], value[1], value[2], value[3], value[4], value[5]);
            }
#endif
            return new ComponentName("", "");
        }
        public static int UPxr_SetBrowserHomePage(string url)
        {
            int value = 1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("setBrowserHomePage",url);
#endif
            return value;
        }
        public static string UPxr_GetBrowserHomePage()
        {
            string value = "";
#if PICO_PLATFORM
            value= IToBService.Call<string>("getBrowserHomePage");
#endif
            return value;
        }
        public static string UPxr_SetMotionTrackerAutoStart(int enable)
        {
            string value = "";
#if PICO_PLATFORM
            value= IToBService.Call<string>("setMotionTrackerAutoStart",enable);
#endif
            return value;
        }

        public static int UPxr_AllowWifiAutoJoin(WifiConfiguration configuration, int networkID, bool allowAutoJoin)
        {
            int value = 1;
           
#if PICO_PLATFORM
             if (configuration == null)
            {
                value = IToBService.Call<int>("allowWifiAutoJoin", null, networkID, allowAutoJoin);
            }
            else
            {
                value = tobHelper.Call<int>("pbsAllowWifiAutoJoin", configuration.ssid, configuration.password, configuration.isClient, networkID,
                    allowAutoJoin);
            }
#endif
            return value;
        }
        
        public static LargeSpaceBoundsInfo[] UPxr_GetLargeSpaceBoundsInfoWithType()
        {
            string[] value = null;
            List<LargeSpaceBoundsInfo> LargeSpaceBoundsInfos = new List<LargeSpaceBoundsInfo>();
          
#if PICO_PLATFORM
              value=tobHelper.Call<String[]>("pbsGetLargeSpaceBoundsInfoWithType");
            if (value!=null)
            {
                foreach (var json in value)
                {
                    LargeSpaceBoundsInfo temp = new LargeSpaceBoundsInfo();
                    JsonData jsonData = JsonMapper.ToObject(json);
                    temp.setType(int.Parse(jsonData["type"].ToString()));
                    IDictionary dictionary = jsonData["bounds"] as IDictionary;
                    for (int i = 0; i < dictionary.Count; i++)
                    {
                        Point3D model = new Point3D();
                        model.x = double.Parse(jsonData["bounds"][i]["x"].ToString());
                        model.y = double.Parse(jsonData["bounds"][i]["y"].ToString());
                        model.z = double.Parse(jsonData["bounds"][i]["z"].ToString());
                        temp.addPoint3D(model);;
                    }
                    LargeSpaceBoundsInfos.Add(temp);
                }
            }
#endif
            return LargeSpaceBoundsInfos.ToArray();
        }
        
        public static int UPxr_GetHeadTrackingStatus()
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("getHeadTrackingStatus");
#endif
            return value;
        }
        
        public static Pose UPxr_GetHeadPose(long predictTime)
        {
            Pose value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetHeadPose",predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetHeadPose: headPose = "+temp);
              value=JsonParser.ParsePoseFromJson(temp);
          }
#endif
            return value;
        }

        public static List<Pose> UPxr_GetControllerPose(long predictTime)
        {
            List<Pose> value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetControllerPose",predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetControllerPose: ControllerPose = "+temp);
              value=JsonParser.ParsePoseArrayFromJson(temp);
              if (value==null)
              {
                  Debug.Log("pbsGetControllerPose: value=null ");
              }
          }
#endif
            return value;
        }
        public static List<SwiftDevice> UPxr_GetSwiftTrackerDevices()
        {
            List<SwiftDevice> value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetSwiftTrackerDevices");
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetSwiftTrackerDevices: devices = "+temp);
              value=JsonParser.ParseSwiftDeviceArrayFromJson(temp);
              if (value==null)
              {
                  Debug.Log("pbsGetSwiftTrackerDevices: value=null ");
              }
          }
#endif
            return value;
        }
        
        public static Pose UPxr_GetSwiftPose(String swiftSN, long predictTime)
        {
            Pose value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetSwiftPose",swiftSN,predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetSwiftPose: Pose = "+temp);
              value=JsonParser.ParsePoseFromJson(temp);
          }
#endif
            return value;
        }
        
        public static IMUData UPxr_GetSwiftIMUData(String swiftSN, long predictTime)
        {
            IMUData value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetSwiftIMUData",swiftSN,predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetSwiftIMUData: data = "+temp);
              value=JsonParser.ParseIMUDataFromJson(temp);
          }
#endif
            return value;
        }
        public static IMUData UPxr_GetHeadIMUData(long predictTime)
        {
            IMUData value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetHeadIMUData",predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetHeadIMUData: IMUData = "+temp);
              value=JsonParser.ParseIMUDataFromJson(temp);
          }
#endif
            return value;
        }
        
        public static List<IMUData> UPxr_GetControllerIMUData(long predictTime)
        {
            List<IMUData> value = null;
#if PICO_PLATFORM
          string  temp= tobHelper.Call<string>("pbsGetControllerIMUData",predictTime);
          if (!string.IsNullOrEmpty(temp))
          {
              // Debug.Log("pbsGetControllerIMUData: IMUDatas = "+temp);
              value=JsonParser.ParseIMUDatasFromJson(temp);
              if (value==null)
              {
                  Debug.Log("pbsGetControllerIMUData: value=null ");
              }
          }
#endif
            return value;
        }
        
        public static int UPxr_StartSwiftTrackerPairing(int trackerId)
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("startSwiftTrackerPairing",trackerId);
#endif
            return value;
        }
        public static int UPxr_UnBondSwiftTracker(int trackerId)
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("unBondSwiftTracker",trackerId);
#endif
            return value;
        }
        public static int UPxr_ResetTracking()
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("resetTracking");
#endif
            return value;
        }
        
        
        public static int UPxr_FileSync()
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("fileSync");
#endif
            return value;
        }
        public static int UPxr_SetFenceColor(int fenceType, int red, int green, int blue, int alpha)
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("setFenceColor",fenceType,red,green,blue,alpha);
#endif
            return value;
        }
        public static int[] UPxr_GetFenceColor(int fenceType)
        {
            int[] value = null;
#if PICO_PLATFORM
            value= IToBService.Call<int[]>("getFenceColor",fenceType);
#endif
            return value;
        }
        
        public static int UPxr_BeginHandTrackingHook()
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("beginHandTrackingHook");
#endif
            return value;
        }
        public static int UPxr_EndHandTrackingHook()
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("endHandTrackingHook");
#endif
            return value;
        }
        
        public static int UPxr_SetHandTrackingHookData(HandStateAlg left, HandStateAlg right)
        {
            int value = 1;
            string leftJson = HandStateAlg.ToJson(left);
            string rightJson = HandStateAlg.ToJson(right);
#if PICO_PLATFORM
            value= tobHelper.Call<int>("pbsSetHandTrackingHookData",leftJson,rightJson);
          
#endif
            return value;
        }
        public static int UPxr_SetUsbTetheringStaticIP(String localAddr, String clientAddr)
        {
            int value = -1;
#if PICO_PLATFORM
            value= IToBService.Call<int>("setUsbTetheringStaticIP",localAddr,clientAddr);
#endif
            return value;
        }
        public static string UPxr_GetUsbTetheringStaticIPLocal()
        {
            string value = "";
#if PICO_PLATFORM
            value= IToBService.Call<string>("getUsbTetheringStaticIPLocal");
#endif
            return value;
        }
        public static string UPxr_GetUsbTetheringStaticIPClient()
        {
            string value = "";
#if PICO_PLATFORM
            value= IToBService.Call<string>("getUsbTetheringStaticIPClient");
#endif
            return value;
        }
        public static int UPxr_SetLargeSpaceMapScale(float scale, Action<int> callback)
        {
            int value = -1;
#if PICO_PLATFORM
            value=tobHelper.Call<int>("pbsSetLargeSpaceMapScale",scale,new IntCallback(callback));
#endif
            return value;
        }
        
        public static PxrSensorState2 UPxr_GetPredictedMainSensorState2(double predictTime)
        {
            PxrSensorState2 sensorState2 = new PxrSensorState2();
            int sensorFrameIndex = 0;
#if PICO_PLATFORM
            PXR_Plugin.Pxr_GetPredictedMainSensorState2(predictTime, ref sensorState2, ref sensorFrameIndex);
#endif
            return sensorState2;
        }
        
        private const string SLAM_DLL_NAME="libtrackingclient.pxr";

        [DllImport(SLAM_DLL_NAME, CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr CreateClient();
        [DllImport(SLAM_DLL_NAME, CallingConvention = CallingConvention.Cdecl)]
        private static extern int ConvertCoordinate(IntPtr client, ref AlgoResult src,ConvertCoordinateType type,ref AlgoResult dest);

        private static IntPtr SlamDllclient;
        public static void Create_Client()
        {
            SlamDllclient= CreateClient();
        }
        public static int ConvertCoordinate(ConvertCoordinateType type,UnityEngine.Pose srcPose,ref UnityEngine.Pose destPose)
        {
            AlgoResult src = new AlgoResult();
            AlgoResult dest = new AlgoResult();
            src.pose.x = srcPose.position.x;
            src.pose.y = srcPose.position.y;
            src.pose.z = srcPose.position.z;
            src.pose.rw = srcPose.rotation.w;
            src.pose.rx = srcPose.rotation.x;
            src.pose.rz = srcPose.rotation.z;
            src.pose.ry = srcPose.rotation.y;
            int ret= ConvertCoordinate(SlamDllclient, ref src, type, ref dest);
            destPose.position = new Vector3((float)dest.pose.x, (float)dest.pose.y, (float)dest.pose.z);
            destPose.rotation = new Quaternion( (float)dest.pose.rx,(float)dest.pose.ry, (float)dest.pose.rz,(float) dest.pose.rw);
            float y = PXR_Plugin.System.UPxr_GetConfigFloat(ConfigType.ToDelaSensorY);
            if (type==ConvertCoordinateType.kLocal2Global)
            {
                destPose.position -= y * Vector3.up;
            }
            else
            {
                destPose.position += y * Vector3.up;
            }
           
            return ret;
        }
        public enum ConvertCoordinateType{
            kLocal2Global = 0,
            kGlobal2Local = 1,
        }
            
       
    }
   
}