﻿using UnityEngine;
using System.Collections.Generic;
using System;
using UnityEngine.EventSystems;
using LitJson;
using UnityEngine.UI;
//using DHHostPlatformSDK;
using System.Runtime.InteropServices;
//using UnityEngine.InputSystem.UI;

public class UIMain : MonoBehaviour
{
    #region 变量
    public bool isAppStore = false;
    bool showNormalPanel = true;
    public GameObject normalSDKPanel;
    public GameObject gameInvitePanel;
    public TMPro.TMP_Text callbackText;
    public TMPro.TMP_Text userIdText;
    public EventSystem bothInputEventSystem;
    public GameObject StartingSelectedButton;
    public GameObject InviteDefaultSelectedButton;
    public GameObject friendListView;
    public GameObject roomPanel;
    public Button switchFriendListAndRoom;
    private static List<NoticeMsg> showMsgList = new List<NoticeMsg>();
    private static DHUnionSdkCallback mUnionSdkCallback = new DHUnionSdkCallback();
    private static string uid = "";
    private static string uname = "";
    private static int _maxHeight = Screen.height / 9;
    private static int _spaceHeight = 10;
    private static int _newHeight = _maxHeight - _spaceHeight;
    private TMPro.TMP_Text roomLabel;
    private TMPro.TMP_Text roomMeText;
    private TMPro.TMP_Text roomMeHostText;
    private TMPro.TMP_Text roomTwoText;
    private TMPro.TMP_Text roomTwoHostText;
    private TMPro.TMP_Text roomThreeText;
    private TMPro.TMP_Text roomThreeHostText;
    public event System.Action<int, string> updateUITextEvent;
    private static string friendDataJson;
    private static string currentLobbySessionId = "";
    #endregion

    /****************************************************************************************
        *                            电魂sdk api接口接入顺序图                                   *
        *   .=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-.      *
        *   |                                                                             |      *
        *   |                     ||===>share()、track()、playAd()                        |      *
        *   |                     ||                                                      |      *
        *   |  GAME ===>init() ===||===>login() ===||===>setGameUserInfo() ===>pay()      |      *
        *   |                     || 退出接口必接  ||                                     |      *
        *   |                     ||===>exit()     ||===>logout()                         |      *
        *   |                                      ||                                     |      *                             |
        *   |                                      ||===>accountChange()                  |      *
        *   |                                        目前没有切换账号接口需要先调用logout |      *
        *   |                                        在调用login接口                      |      *
        *   '-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-='      *
        *                           电魂SDK 版权所有  翻版必究                                   *
        ******************************************************************************************/

    public class NoticeMsg
    {
        public string msg { set; get; }
        public DateTime beginTime { set; get; }
    }

    // Use this for initialization, sdk should be initialized on app startup
    void Start()
    {
#if UNITY_SWITCH
        //please replace game param
        DHHostPlatformSDK.DHHostPlatformParam param = new DHHostPlatformSDK.DHHostPlatformParam();
        param.DHAppId = "1498239538";
        param.DHChannelId = "3342";
        param.DHInviteCode = "C67C08ED2E224A9B8";
        param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_HONGKONG;
        param.HostPlatformAppId = "0x010042e0157d0000";//please input 16进制字符串,china demo:0x0100b3b01019a000,global demo:0x01004b9000490000
        param.mainChannel = "100501";
        param.subChannel = "100502";
        DHSDKHelper.setHostPlatformParam(JsonUtility.ToJson(param));
#elif USE_MS_GAMECORE
        //please replace game param
        DHHostPlatformSDK.DHHostPlatformParam param = new DHHostPlatformSDK.DHHostPlatformParam();
        param.DHAppId = "1498239538";
        param.DHChannelId = "3340";
        param.DHInviteCode = "C67C08ED2E224A9B8";
        param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_HONGKONG;
        param.HostPlatformAppId = "0x72B543F7";//titleId
        param.HostPlatformAppkey = @"00000000-0000-0000-0000-000072b543f7";//scid
        param.mainChannel = "100527";
        param.subChannel = "100528";
        DHSDKHelper.setHostPlatformParam(JsonUtility.ToJson(param));
#elif STEAMWORKS
        //please replace game param
        DHHostPlatformSDK.DHHostPlatformParam param = new DHHostPlatformSDK.DHHostPlatformParam();
        param.DHAppId = "1498239538";
        param.DHChannelId = "3018";
        param.DHInviteCode = "C67C08ED2E224A9B8";
        param.HostPlatformAppId = "1946470";//appid
        param.HostPlatformAppkey = "48456A7187955E8D9A739BA9ADE3AB46";//web api key,for pay
        param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_HONGKONG;
        param.mainChannel = "100521";
        param.subChannel = "100522";
        DHSDKHelper.setHostPlatformParam(JsonUtility.ToJson(param));
#elif UNITY_PS4
        //please replace game param
        DHHostPlatformSDK.DHHostPlatformParam param = new DHHostPlatformSDK.DHHostPlatformParam();
        //bbq2
        param.DHAppId = "1498239538";
        param.DHChannelId = "3339";
        param.DHInviteCode = "C67C08ED2E224A9B8";
        param.HostPlatformAppId = "18f8a625-a657-480e-a643-30f1b3443759";//clientid
        param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_HONGKONG;
        param.mainChannel = "100535";
        param.subChannel = "100536";
        param.ageRating = 6;
        //欧区EP5090-CUSA33730_00-6551709402673673
        //美区UP4905-CUSA28958_00-8973489394369671

        ////demo
        //param.DHAppId = "1514689620";
        //param.DHChannelId = "3339";
        //param.DHInviteCode = "4DBC0F190E7442A18";
        //param.HostPlatformAppId = "af77af0c-44cd-49b8-9267-41bfe09b6f5e";//clientid
        //param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_DEBUG;
        //param.mainChannel = "0";
        //param.subChannel = "0";
        //param.ageRating = 6;
        //demo 亚洲

        DHSDKHelper.setHostPlatformParam(JsonUtility.ToJson(param));
        DHPSSDK.setAction(sessionOperate, onPsSignOut);
#elif WEGAME_SDK
        DHHostPlatformSDK.DHHostPlatformParam param = new DHHostPlatformSDK.DHHostPlatformParam();
        param.DHAppId = "1514689620";//账号支付02// "1111642418";//野2国内
        param.DHChannelId = "1451";
        param.DHInviteCode = "585D0B805AEF45B6B";
        param.HostPlatformAppId = "2001916";//wegame gameid
        param.HostUrl = DHHostPlatformSDK.DHHostPlatformConst.HOST_DEBUG_CHINA;
        param.mainChannel = "2332";// "0";
        param.subChannel = "4242";// "0";
        DHSDKHelper.setHostPlatformParam(JsonUtility.ToJson(param));
#elif MINIGAME_SDK
        /*
        string param = DHSDKHelper.DHJsonParam.Builder()
           .put("authorize", "https://sz-sdk-login-cn.sztemp.com")       // 必传，登录服务接口地址
            .put("payment", "https://sz-sdk-pay-cn.sztemp.com")    //必传，支付服务接口地址（跳转小游戏客服支付）
            .put("midas", "https://sz-sdk-notify-cn.sztemp.com")    // 必传，支付服务接口地址（米大师支付）
            .put("friendPayment", "https://sz-hsdk-order-cn.sztemp.com")    // 必传，礼物索要服务接口地址
            .put("service", "https://sz-mservice-cn.sztemp.com")        // 必传，H5客服系统服务接口地址
            .put("survey", "https://sz-mservice-cn.sztemp.com")      // 必传，问卷调查服务接口地址
            .put("gameClub", "https://sz-sdk-sec-cn.sztemp.com")      //必传，游戏圈服务接口地址
            .put("log", "https://sz-ups-sdk-log-cn.sztemp.com")      // 必传，数据上报服务接口地址
            .put("errorLog", "https://sz-ups-sdk-error-cn.sztemp.com")        // 必传，日志上报服务接口地址
            .put("gameAppId", "wx5b711f995c685fb9")     // 必传，小游戏的 AppID（于微信公众平台注册小游戏时生成的ID）
            .put("appId", "1499088730")     // 必传，小游戏的 AppID（于SDK平台注册小游戏时生成的ID）
            .put("appName", "冒险与推图")     // 必传，小游戏的应用包名
            .put("appVersion", "1.0.0")     // 必传，小游戏的版本号
            .put("channel", "1398")     // 必传，渠道ID
            .put("mainChannel", "100761")     // 必传，推广主渠道ID
            .put("secondChannel", "100762")     //  必传，推广次渠道ID
            .put("heartbeatEnable", "true")     //选传，true,false是否开启心跳数据上报，若开启，则SDK将每隔一分钟向服务器发送一条心跳数据
            .put("reyunAppKey", "")     // 选传，小游戏的热云 AppKey（于热云广告监测平台创建产品时生成的AppKey）
            .put("gravityEngineAccessToken", "")     //选传，小游戏的引力引擎 Access Token（于引力引擎控制台创建产品时生成的Access Token）
            .put("gravityEngineDebug", "true")     //选传，显式开启或关闭引力引擎数据上报的调试模式，默认根据小游戏当前的体验环境自动设置，正式版下为 false，开发版或体验版下为 true；开启调试模式后，可以在引力控制台>设置>元数据>事件流中查看实时数据上报结果
            .toJson();
        DHSDKHelper.setHostPlatformParam(param);
        */
        string param = DHSDKHelper.DHJsonParam.Builder()
                    .put("authorize", "https://sz-sdk-login-cn.sztemp.com")       // 必传，登录服务接口地址
                    .put("payment", "https://sz-sdk-pay-cn.sztemp.com")     //必传，支付服务接口地址（跳转小游戏客服支付）
                    .put("midas", "https://sz-hsdk-notify-cn.sztemp.com")    // 必传，支付服务接口地址（米大师支付）
                    .put("friendPayment", "https://sz-hsdk-order-cn.sztemp.com")    // 必传，礼物索要服务接口地址
                    .put("service", "https://sz-mservice-cn.sztemp.com")        // 必传，H5客服系统服务接口地址
                    .put("survey", "https://sz-sdk-mservice-cn.sztemp.com")      // 必传，问卷调查服务接口地址
                    .put("gameClub", "https://sz-sdk-sec-cn.sztemp.com")      //必传，游戏圈服务接口地址
                    .put("log", "https://sz-ups-sdk-log-cn.sztemp.com")      // 必传，数据上报服务接口地址
                    .put("errorLog", "https://sz-ups-sdk-error-cn.sztemp.com")        // 必传，日志上报服务接口地址
                    .put("gameAppId", "wx9daa5573513fd391")     // 必传，小游戏的 AppID（于微信公众平台注册小游戏时生成的ID）
                    .put("appId", "1499088730")     // 必传，小游戏的 AppID（于SDK平台注册小游戏时生成的ID）
                    .put("appName", "com.yzgz.official")     // 必传，小游戏的应用包名
                    .put("appVersion", "1.0.0")     // 必传，小游戏的版本号
                    .put("channel", "1398")     // 必传，渠道ID
                    .put("mainChannel", "100761")     // 必传，推广主渠道ID
                    .put("secondChannel", "100762")                 //必传，推广次渠道ID
                    .put("heartbeatEnable", "true")                 //选传，true,false是否开启心跳数据上报，若开启，则SDK将每隔一分钟向服务器发送一条心跳数据
                    .put("reyunAppKey", "")     // 选传，小游戏的热云 AppKey（于热云广告监测平台创建产品时生成的AppKey）
                    .put("gravityEngineAccessToken", "")     //选传，小游戏的引力引擎 Access Token（于引力引擎控制台创建产品时生成的Access Token）
                    .put("gravityEngineDebug", "true")     //选传，显式开启或关闭引力引擎数据上报的调试模式，默认根据小游戏当前的体验环境自动设置，正式版下为 false，开发版或体验版下为 true；开启调试模式后，可以在引力控制台>设置>元数据>事件流中查看实
                    .toJson();
        DHSDKHelper.setHostPlatformParam(param);
#endif
        DHSDKHelper.init(mUnionSdkCallback);
        Dictionary<string, string> adInfo = DHSDKHelper.DHParam.Builder()
            .put("adUnitId", "adunit-f439404af69c3a61")  //必传，广告位ID
            .put("multiton", "true")  // 选传，是否启用多例模式
            .put("event_type", "createAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
            .put("advertPlatform", "")  //选传，广告平台
            .put("advertPosition", "")  //选传，广告展示位置，预留参数，有就填写
            .toDictionary();

        DHSDKHelper.playAd(adInfo, mUnionSdkCallback);
        mUnionSdkCallback.updateUIText += (type, tip) => { updateUI(type, tip); };
        mUnionSdkCallback.updateFriendUI += (data) => { syncFriendToGameUI(data); };
        mUnionSdkCallback.updateRoomUIAction += (req, result, data) => { updateRoomUI(req, result, data); };
        updateUITextEvent += (type, tip) => { updateUI(type, tip); };
        initUI();
    }

    private void initUI()
    {
        if (roomPanel != null)
        {
            roomLabel = roomPanel.transform.Find("RoomLabel").GetComponent<TMPro.TMP_Text>();
            roomMeText = roomPanel.transform.Find("Me").GetComponent<TMPro.TMP_Text>();
            roomMeHostText = roomPanel.transform.Find("MeHost").GetComponent<TMPro.TMP_Text>();
            roomTwoText = roomPanel.transform.Find("Other").GetComponent<TMPro.TMP_Text>();
            roomTwoHostText = roomPanel.transform.Find("OtherHost").GetComponent<TMPro.TMP_Text>();
            roomThreeText = roomPanel.transform.Find("Three").GetComponent<TMPro.TMP_Text>();
            roomThreeHostText = roomPanel.transform.Find("ThreeHost").GetComponent<TMPro.TMP_Text>();
        }
    }

    private void sessionOperate(int i1, IntPtr ss)
    {
        //处理游戏逻辑
        if(i1 == 2)//收到好友邀请
        {
            //清理场景，跳转到好友房间
#if UNITY_PS4
            currentLobbySessionId = Marshal.PtrToStringAnsi(ss);
            Debug.Log("收到好友邀请，lobbySessionId:" + currentLobbySessionId);
            //DHPSSDK.setLobbySessionId(lobbySessionId);
            DHSDKHelper.joinFriendLobbyByInvited();
#endif
        }
    }

    private void onPsSignOut()
    {
        //处理游戏逻辑
    }

    private void Awake()
    {
#if UNITY_PS4 || STEAMWORKS
        InputSystemUIInputModule input = bothInputEventSystem.GetComponent<InputSystemUIInputModule>();
        if (input != null)
        {
            Debug.Log("找到新input");
            Destroy(input);
        }
#endif
        bothInputEventSystem.firstSelectedGameObject = StartingSelectedButton;
    }
    private void OnEnable()
    {
        bothInputEventSystem.SetSelectedGameObject(StartingSelectedButton, null);
    }

    // Update is called once per frame
    void Update()
    {
        //if (Input.GetKey(KeyCode.Escape))
        //{
        //when back key pressed and the app is about to exit, sdk should be released
        // DHSDKHelper.exit(mUnionSdkCallback);
        //}
    }

    public void login()
    {
        // login 默认是不需要参数传入的  但登录方式  需要在meta数据中配置  接入方不用关心此参数  请调用此接口  并根据callback返回参数 做业务逻辑
        DHSDKHelper.login(mUnionSdkCallback);
        //After login success,get the uid and use "setTrackUserId(uid)" method
        //			DHSDKHelper.setTrackUserId(uid);
        //////////////////////////////////////////////
        /*注意!!!*/
        /*SDK返回登录成功后，游戏还需要去服务端校验登录返回的账号token，具体参考服务端接口文档，如果校验失败，游戏必须调用登出接口logout，否则后续登录可能有问题*/
    }

    public void logout()
    {
        Dictionary<string, string> adInfo2 = DHSDKHelper.DHParam.Builder()
           .put("adUnitId", "adunit-f439404af69c3a61")  //必传，广告位ID
           .put("event_type", "loadAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
           .toDictionary();

        DHSDKHelper.playAd(adInfo2, mUnionSdkCallback);
        return;
        //string url = DHHostPlatformConst.getHostUrl(DHHostPlatformConst.FUNC_LOGIN, DHHostPlatformConst.HOST_DEBUG) + DHHostPlatformConst.INTERFACE_LOGIN;
        //DHHostPlatformNetUtil.getInstance().Get("http://192.168.110.30/shandianxia/hostlist.json", "{}", null);
        DHSDKHelper.logout(mUnionSdkCallback);
    }

    public void createUserInfoButton()
    {
        // 个人信息是用户的敏感数据，首次获取用户信息需要用户同意授权，具体方法为，使用
        //createUserInfoButton(options) 创建一个引导用户点击的按钮，并在点击并同意授权后获取（授权相关说明可以参考微信官方文档的权限章节）。
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("withCredentials", "true")  //选传，获取个人信息时是否携带登录态信息。当 withCredentials 为 true 时，要求此前有调用过 wx.login 且登录态尚未过期，此时返回的数据会包含 encryptedData、iv 等敏感信息；当 withCredentials 为 false 时，不要求有登录态，返回的数据不包含 encryptedData、iv 等敏感信息
            .put("lang", "zh_CN")     //选传，描述用户信息的语言 en - 英文 zh_CN - 简体中文 zh_TW - 繁体中文
            .put("type", "text")       // 必传，按钮类型 text - 文本按钮，允许自定义背景色及文本 image - 图片按钮，仅允许设置背景贴图，背景贴图会直接拉伸至按钮的宽高
            .put("text", "获取用户信息")    // 选传，文本按钮的文本，仅当 type 为 text 时有效
            .put("image", "")    // 选传，图片按钮的背景图片，仅当 type 为 image 时有效
            .put("top", "376")        // 必传，按钮左上角纵坐标
            .put("left", "100")       //必传，按钮左上角横坐标
            .put("width", "100")      // 必传，按钮宽度
            .put("height", "32")      //必传，按钮高度
            .put("backgroundColor", "#07c160")      // 必传，角色所属公会 , 无公会系统,传无
            .put("borderWidth", "0")        // 必传，按钮边框宽度
            .put("borderColor", "#07c160")     // 必传，按钮边框颜色，格式为 6 位 16 进制数
            .put("borderRadius", "0")     //必传，按钮边框圆角
            .put("color", "#ffffff")      //必传，按钮文本颜色，格式为 6 位 16 进制数
            .put("fontSize", "12")        //必传，按钮文本字号
            .put("textAlign", "center")   //必传，按钮文本水平居中方式 left - 居左 center - 居中 right - 居右
            .put("lineHeight", "32")       //必传，按钮文本行高
            .toJson();
        DHSDKHelper.createUserInfoButton(param,mUnionSdkCallback);
        
    }

    public void getSetting()
    {
        //判断微信小游戏是否获取用户信息
        DHSDKHelper.getSetting(mUnionSdkCallback);
    }

    public void getUserInfo()
    {
        //获取微信小游戏用户信息
        string param = DHSDKHelper.DHJsonParam.Builder()
           .put("withCredentials", "true")  //选传，获取个人信息时是否携带登录态信息。当 withCredentials 为 true 时，要求此前有调用过 wx.login 且登录态尚未过期，此时返回的数据会包含 encryptedData、iv 等敏感信息；当 withCredentials 为 false 时，不要求有登录态，返回的数据不包含 encryptedData、iv 等敏感信息
           .put("lang", "zh_CN")     //选传，描述用户信息的语言 en - 英文 zh_CN - 简体中文 zh_TW - 繁体中文
           .toJson();
        DHSDKHelper.getUserInfo(param,mUnionSdkCallback);
    }

    public void createFeedbackButton()
    {
        // 用于在小游戏内创建意见反馈按钮，并在点击时跳转至意见反馈页面
        //管理员可登录《微信公众平台》后台，进入“管理 > 用户反馈”栏目中查看或回复用户提交的内容。
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("type", "text")       // 必传，按钮类型 text - 文本按钮，允许自定义背景色及文本 image - 图片按钮，仅允许设置背景贴图，背景贴图会直接拉伸至按钮的宽高
            .put("text", "")    // 选传，文本按钮的文本，仅当 type 为 text 时有效
            .put("image", "")    // 选传，图片按钮的背景图片，仅当 type 为 image 时有效
            .put("top", "376")        // 必传，按钮左上角纵坐标
            .put("left", "100")       //必传，按钮左上角横坐标
            .put("width", "100")      // 必传，按钮宽度
            .put("height", "32")      //必传，按钮高度
            .put("backgroundColor", "#07c160")      // 必传，角色所属公会 , 无公会系统,传无
            .put("borderWidth", "0")        // 必传，按钮边框宽度
            .put("borderColor", "#07c160")     // 必传，按钮边框颜色，格式为 6 位 16 进制数
            .put("borderRadius", "0")     //必传，按钮边框圆角
            .put("color", "#ffffff")      //必传，按钮文本颜色，格式为 6 位 16 进制数
            .put("fontSize", "12")        //必传，按钮文本字号
            .put("textAlign", "center")   //必传，按钮文本水平居中方式 left - 居左 center - 居中 right - 居右
            .put("lineHeight", "32")       //必传，按钮文本行高
            .toJson();
        DHSDKHelper.createFeedbackButton(param, mUnionSdkCallback);

    }

    public void feedbackButtonAction()
    {
        // 在创建反馈按钮后，进行反馈按钮的操作，如显示，隐藏和删除
        string actionType = "hide"; //操作类型，show: 显示，hide:隐藏，destory:删除按钮
        DHSDKHelper.feedbackButtonAction(actionType);

    }

    public void userInfoButtonAction()
    {
        // 在创建反馈按钮后，进行反馈按钮的操作，如显示，隐藏和删除
        string actionType = "hide"; //操作类型，show: 显示，hide:隐藏，destory:删除按钮
        DHSDKHelper.userInfoButtonAction(actionType);

    }

    public void pay()
    {
        // DH 模式  android(国内或者海外支付使用此参数设置  国内wechat alipay  海外google)  ios(appstore)

        DHSDKHelper.DHSDKPayInfo payInfo = new DHSDKHelper.DHSDKPayInfo();

        // 必填
        payInfo.Uid = "123123123";// 选传，用户id 我们sdk这边电魂id  授权或电魂登录返回数据中的accountid  游客登录模式下为guestid（accountid也有值 为guestid）
        payInfo.RoleId = "0"; // 选传，角色id 没有可以不填  默认值即可
        payInfo.ProId = "53";  // 必传，商品id
        payInfo.ProNum = "1";   // 选传，商品数量
        payInfo.Price = "18";  // 必传，商品价格  android是分(99美分 100RMB) ios是元,小程序是分
        payInfo.Currency = "CNY";  // 选传，货币类型 国内CNY 海外USD
#if STEAMWORKS
        payInfo.ProId = "1000";  // 商品id  
        payInfo.Price = "99";  // 商品价格  android是分(99美分 100RMB) ios是元
        payInfo.Currency = "USD";
#elif UNITY_PS4
        payInfo.ProId = "1000000000000000";//野2美区测试
        //payInfo.ProId = "0033864281306041";//demo测试
#elif USE_MS_GAMECORE
        payInfo.ProId = "9NWQ67FG4J7M";//测试商品
#elif WEGAME_SDK
        payInfo.ProId = "com.dianhun.bbq2.1001";//野2测试
#elif MINIGAME_SDK
        payInfo.AreaId = "100"; //选传，游戏大区ID，若游戏无大区概念，可不填
        payInfo.ServerId = "100"; //选传，游戏服务器ID，若游戏无服概念，可不填
        payInfo.PaymentMessageImage = "";  //选传，进入微信客服会话时，会话窗口右下角浮动消息卡片的图片路径，仅在使用跳转小游戏客服支付时必填（设计制作一张引导玩家充值的图片并上传至CDN，引用图片CDN地址即可）
        payInfo.PaymentMessageTitle = "title";  //选传，进入微信客服会话时，会话窗口右下角浮动消息卡片的标题，仅在使用跳转小游戏客服支付时必填（建议填写当前所购物品的中文名称，如：我要充值68元首充礼包）
        payInfo.CPOrderId = "123456";  //选传，游戏开发者自定义的唯一订单号，预留参数，有就填写
        payInfo.Rate = "10";  //必传，游戏币兑换汇率，用于计算游戏币购买数量；例如：后台配置为 1:10，则 rate 为 10；可登录《微信公众平台》后台，进入“功能 > 虚拟支付 > 基本配置 > 游戏币配置”栏目中查看
        payInfo.Timestamp = "12332123123"; //必传，时间戳
        payInfo.Ios = " customer-service";  //选传，iOS设备下使用的支付方式，可选值为 customer-service
        payInfo.Android = "midas";  //选传，Android设备下使用的支付方式，可选值为 midas、customer-service
        payInfo.Windows = "midas";  //选传，Windows设备下的支付方式，可选值为 midas、customer-service
        payInfo.Devtools = "midas"; //选传，微信小游戏开发者工具的支付方式，可选值为 midas、customer-service
#endif

        // 重要参数说明 角色大区id  如果游戏存在大区概念 正式发布游戏时请填入角色大区id 测试环境填100  没有则 测试支付环境下填100  正式发布填1
        payInfo.AreaId = "100";

        // 可选
        payInfo.Uname = "user name";  // 选传，角色名称
        payInfo.ProName = "Gold";  // 必传，商品名称
        payInfo.Memo = "This is gold";  // 选传，附加信息

        DHSDKHelper.pay(payInfo, mUnionSdkCallback);
    }
    public void invitePsFriend()
    {
        //临时测试
        DHSDKHelper.invitePsFriend(2508262431545540131);
        //60jiqi 2508262431545540131
        //27 7378018184174634059
    }
    public void querySkus()
    {

        //string[] productidArray = { "com.dhmobile.aos.a001", "com.dhmobile.aos.a002", "com.dianhun.testMax" };
        List<string> list = new List<string>();
        list.Add("com.dhmobile.aos.a001");
        list.Add("com.dhmobile.aos.a002");
        list.Add("com.dianhun.testMax");

        DHSDKHelper.querySkus(list, mUnionSdkCallback);
    }

    public void setGameUserInfo()
    {
        //  设置游戏角色接口  在登陆后 支付接口调用前 必须设置 
        //string type = "CREATE_ROLE";   // 创建角色
        string type = "LOGIN_GAME"; //登录游戏
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("areaId", "100")       // 大区ID , 纯数字  
            .put("areaName", "火烧赤壁")    // 大区名称
            .put("roleId", "1000010000")    // 角色ID , 纯数字
            .put("roleName", "MESS")        // 角色名称
            .put("roleLevel", "1")      // 角色等级 , 纯数字
            .put("roleVipLevel", "0")      // vip等级 , 纯数字 , 没有vip系统传"0" ;
            .put("userGuild", "无")      // 角色所属公会 , 无公会系统,传无
            .put("roleBalance", "0")        // 角色虚拟币余额 . 纯数字
            .put("roleCTime", "1514881870")     // 游戏角色创建时间 . 时间戳  有秒级数据就秒级（10位） 有毫秒级就毫秒级（13位）
            .toJson();
        DHSDKHelper.setGameUserInfo(type, param);
    }

    public void gameRecord()
    {
        //  游戏视频录制
        // 检查是否支持录制游戏画面，返回一个字符串值"true"为是，"false"为否
        string isFrameSupported = DHSDKHelper.query("isFrameSupported");
        // 检查是否支持录制游戏画面时，同步录制游戏音频信息，返回一个字符串值"true"为是，"false"为否
        string isSoundSupported = DHSDKHelper.query("isSoundSupported");
        // 检查是否支持调节录制视频的音量，返回一个字符串值"true"为是，"false"为否
        string isVolumeSupported = DHSDKHelper.query("isVolumeSupported");
        // 检查是否支持调节录制视频的播放速率，返回一个字符串值"true"为是，"false"为否
        string isAtempoSupported = DHSDKHelper.query("isAtempoSupported");

        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "create")       // 必传，操作字段，create:创建视频回放录制器，addListener:添加监听器，removeListener：取消监听器，start：开始录制，pause：暂停录制，resume：继续录制，stop：结束录制，abort：取消录制
            .put("fps", "24")    // 选传，视频帧率（fps）
            .put("bitrate", "10000")    // 选传，视频比特率（kbps），最小值 600，最大值 3000
            .put("gop", "12")        // 选传，视频关键帧间隔
            .put("duration", "7200")      // 选传，视频时长限制，单位为秒；最小值 5，最大值 7200，到达指定时长后不会再录制，但仍然需要手动调用 GameRecorder.stop() 来结束录制
            .put("hookBgm", "true")      // 选传，是否录制游戏音效（仅iOS支持）
            .toJson();
        DHSDKHelper.gameRecord(param, mUnionSdkCallback);
    }

    public void gameRecordShare()
    {
        // 创建录制回放分享按钮
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("icon", "")       // 选传，按钮图标的 url，支持 http/https 开头的网络资源和 wxfile:// 开头的本地资源，如果不设置则使用默认图标
            .put("image", "24")    // 选传，按钮背景图片的 url，支持 http/https 开头的网络资源和 wxfile:// 开头的本地资源，如果不设置则使用默认图片
            .put("text", "")    // 选传，按钮文本
            .put("top", "0")        // 选传，按钮左上角纵坐标，单位逻辑像素
            .put("left", "0")      // 选传，按钮左上角横坐标，单位逻辑像素
            .put("height", "40")      // 选传，按钮高度，最小 40 逻辑像素
            .put("paddingLeft", "16")      // 选传，按钮的左内边距，最小 16 逻辑像素
            .put("paddingRight", "16")      // 选传，按钮的右内边距，最小 16 逻辑像素
            .put("color", "#ffffff")      // 选传，按钮文本颜色，格式为 6 位 16 进制数
            .put("fontSize", "17")      // 选传，按钮文本字号，最小值 17，最大值 22
            .put("iconMarginRight", "8")      // 选传，图标和文本之间的距离，最小 8 逻辑像素
            .put("path", "")      // 选传，分享的对局回放打开后跳转小游戏的独立分包路径
            .put("query", "")      // 选传，分享的对局回放打开后跳转小游戏的自定义查询字符串
            .put("bgm", "")      // 选传，对局回放背景音乐的地址
            .put("timeRange", "")      // 选传，对局回放的剪辑区间，是一个二维数组json字符串，单位毫秒，内部都是字符串，如 "["["1000", "3000"]", "["4000", "5000"]"] "表示剪辑已录制对局回放的 1-3 秒和 4-5 秒最终合成为一个 3 秒的对局回放；对局回放剪辑后的总时长最多 60 秒，即 1 分钟
            .put("volume", "1")      // 选传，对局回放的音量大小，最小值 0，最大值 1
            .put("atempo", "1")      // 选传，对局回放的播放速率，只能设置以下几个值：0.3、0.5、1、1.5、2、2.5、3；其中1表示原速播放，小于 1 表示减速播放，大于 1 表示加速播放
            .put("audioMix", "false")      // 选传，如果原始视频文件中有音频，是否与新传入的 bgm 混音，默认为 false，表示不混音，只保留一个音轨，值为 true 时表示原始音频与传入的 bgm 混音
            .toJson();
        DHSDKHelper.createGameRecordShareButton(param, mUnionSdkCallback);
        //操作录制回放分享按钮
        string action = "hide";//操作类型，hide:隐藏，show:显示,destory:移除
        DHSDKHelper.gameRecordShareButtonAction(action);
        //分享录制的回放
        string shareParam = DHSDKHelper.DHJsonParam.Builder()
            .put("title", "标题")       // 选传，分享的对局回放打开后的标题内容
            .put("desc", "内容")       // 选传，分享的对局回放打开后的描述内容
            .put("path", "")      // 选传，分享的对局回放打开后跳转小游戏的独立分包路径
            .put("query", "")      // 选传，分享的对局回放打开后跳转小游戏的自定义查询字符串
            .put("bgm", "")      // 选传，对局回放背景音乐的地址
            .put("timeRange", "")      // 选传，对局回放的剪辑区间，是一个二维数组json字符串，单位毫秒，内部都是字符串，如 "["["1000", "3000"]", "["4000", "5000"]"] "表示剪辑已录制对局回放的 1-3 秒和 4-5 秒最终合成为一个 3 秒的对局回放；对局回放剪辑后的总时长最多 60 秒，即 1 分钟
            .put("volume", "1")      // 选传，对局回放的音量大小，最小值 0，最大值 1
            .put("atempo", "1")      // 选传，对局回放的播放速率，只能设置以下几个值：0.3、0.5、1、1.5、2、2.5、3；其中1表示原速播放，小于 1 表示减速播放，大于 1 表示加速播放
            .put("audioMix", "false")      // 选传，如果原始视频文件中有音频，是否与新传入的 bgm 混音，默认为 false，表示不混音，只保留一个音轨，值为 true 时表示原始音频与传入的 bgm 混音
            .toJson();
        DHSDKHelper.gameRecordShare(shareParam, mUnionSdkCallback);
    }

    public void share()
    {
        Debug.Log(Application.persistentDataPath);

        DHSDKHelper.DHSDKShareContent content = new DHSDKHelper.DHSDKShareContent();
        //share link
        //content.Title = "来《光影对决》跟我一起打爆对面！";
        //content.Desc = "我在玩超带感的动漫MOBA，姿势已摆好，来一个会喊666的队友！";
        //content.ThumbImage = "/var/mobile/Containers/Data/Application/8A3C7EB1-E592-43ED-A6D2-09C7C989CB35/Documents/imag1.png";//缩略图本地图片文件路径
        //content.ThumbImageUrl = "";//缩略图网络图片地址
        //         //content.LinkUrl = "http://m.goodmoba.develop.icodemo.com/app/gy-startgame/?name=20059&type=1&id=20059";
        //content.Type = DHSDKHelper.DHSDKShareType.shareType_image;
        //content.Platform = DHSDKHelper.DHSDKSharePlatform.Platform_None;
        //DHSDKHelper.share (content, mUnionSdkCallback);
        //share image
        content.Desc = "Description 1";
        //content.ThumbImage = "";//缩略图本地图片文件路径
        //content.ThumbImageUrl = "";//缩略图网络图片地址
        content.Image = "/storage/emulated/0/Download/image.jpg";   //本地图片文件路径
                                                                    //content.ImageUrl = ""; //网络图片地址
        content.Type = DHSDKHelper.DHSDKShareType.shareType_image;
        content.Platform = DHSDKHelper.DHSDKSharePlatform.Platform_None;
        DHSDKHelper.share(content, mUnionSdkCallback);
#if MINIGAME_SDK
        DHSDKHelper.DHSDKShareContent miniContent = new DHSDKHelper.DHSDKShareContent();
        //设置被动分享参数
        miniContent.Type = DHSDKHelper.DHSDKShareType.shareType_minigame_set;
        miniContent.Platform = DHSDKHelper.DHSDKSharePlatform.Platform_MiniGame;
        miniContent.Title = "分享标题"; //选填，分享时显示的标题，不填时默认使用当前小游戏的名称
        miniContent.ImageUrl = "";  //选填，分享时显示的图片链接，可以是网络图片路径，或本地图片文件路径，亦或相对代码包根目录的图片文件路径，建议长宽比为 5:4，不填时默认使用当前小游戏的ICON
        miniContent.ImageUrlId = ""; //选填，自定义 imageUrl 时，审核通过后其对应的图片编号
        miniContent.Path = "";  //选填，独立分包路径
        miniContent.Query = "parm1=a&parm2=b"; //选填，自定义查询字符串，必须是 key1=val1&key2=val2 的格式，可通过 DHSDKHelper.query("wxLaunchOptions") 获取 query 查询字符串
        //转发朋友圈
        miniContent.Type = DHSDKHelper.DHSDKShareType.shareType_minigame_shareImageMenu;
        miniContent.Platform = DHSDKHelper.DHSDKSharePlatform.Platform_MiniGame;
        miniContent.Path = ""; //必填，要分享的图片地址，必须为本地路径或临时路径
        //主动分享
        miniContent.Type = DHSDKHelper.DHSDKShareType.shareType_minigame_share;
        miniContent.Platform = DHSDKHelper.DHSDKSharePlatform.Platform_MiniGame;
        miniContent.Title = "分享标题"; //选填，分享时显示的标题，不填时默认使用当前小游戏的名称
        miniContent.ImageUrl = "";  //选填，分享时显示的图片链接，可以是网络图片路径，或本地图片文件路径，亦或相对代码包根目录的图片文件路径，建议长宽比为 5:4，不填时默认使用当前小游戏的ICON
        miniContent.ImageUrlId = ""; //选填，自定义 imageUrl 时，审核通过后其对应的图片编号
        miniContent.Path = "";  //选填，独立分包路径
        miniContent.Query = "parm1=a&parm2=b"; //选填，自定义查询字符串，必须是 key1=val1&key2=val2 的格式，可通过 DHSDKHelper.query("wxLaunchOptions") 获取 query 查询字符串
        
        DHSDKHelper.share(miniContent, mUnionSdkCallback);
#endif

    }

    public void track()
    {
        /*
        // adjust 支付数据统计相关参数
        Dictionary<string, string> paramsDic = new Dictionary<string, string>();
        paramsDic.Add("orderId", "112233445566"); // 订单号  必填  防止重复统计
        paramsDic.Add("revenue", "6");  // 收入, string型, 单位分, 可传商品价格, 必填
        paramsDic.Add("currency", "USD"); //非必填 货币码, String型, 默认USD,
        string token = "";  // 此参数在测试此接口时必须提供给我们  由贵方向adjust 申请得到  
        DHSDKHelper.track("pay", paramsDic);
        */
#if MINIGAME_SDK
        //上报热云注册事件
        Dictionary<string, string> regiseterParamsDic = new Dictionary<string, string>();
        regiseterParamsDic.Add("accountId", "1321123"); // 必传，账号ID（账号唯一标识）
        regiseterParamsDic.Add("extendParams", "{\"key\":\"value\"}");  // 选传，自定义扩展参数，属性 key 只能为 string 类型，需要以英文字符开头，仅支持输入英文字符、数字、下划线（以 _ 开头为内置属性，不可以使用）；value 支持字符串
        DHSDKHelper.reyunUpload("register", regiseterParamsDic);
        //上报角色信息
        Dictionary<string, string> roleInfoParamsDic = new Dictionary<string, string>();
        roleInfoParamsDic.Add("type", "LOGIN_GAME"); // 必传，上报类型 LOGIN_GAME - 登录游戏服 CREATE_ROLE - 创角 LEVEL_UP - 升级
        roleInfoParamsDic.Add("accountId", "123123123");  // 必传，账号ID（账号唯一标识）
        roleInfoParamsDic.Add("areaId", "100"); //选传，游戏大区ID，若游戏无大区概念，可不填，默认值为 1，表示初始大区编号
        roleInfoParamsDic.Add("areaName", ""); //选传，游戏大区名称
        roleInfoParamsDic.Add("serverId", "100"); //选传，游戏服务器ID，若游戏无服概念，可不填，默认值为 1，表示初始服务器编号
        roleInfoParamsDic.Add("serverName", ""); //选传，游戏服务器名称
        roleInfoParamsDic.Add("roleId", "123123"); //选传，角色ID，若游戏无角色概念，可不填，默认值同 accountId 账号ID
        roleInfoParamsDic.Add("roleName", "abc"); //选传，角色名称
        roleInfoParamsDic.Add("roleLevel", "1"); //选传，角色等级，若游戏无角色及等级概念，可填关卡等级或不填，默认值为 1
        DHSDKHelper.gameRoleInfoUpload(roleInfoParamsDic);
        //上报支付信息
        Dictionary<string, string> payParamsDic = new Dictionary<string, string>();
        payParamsDic.Add("accountId", "123456"); // 必传，账号ID（账号唯一标识）
        payParamsDic.Add("areaId", "1");  // 选传，游戏大区ID，若游戏无大区概念，可不填，默认值为 1，表示初始大区编号
        payParamsDic.Add("serverId", "100"); //选传，游戏服务器ID，若游戏无服概念，可不填，默认值为 1，表示初始服务器编号
        payParamsDic.Add("roleId", "123"); //选传，角色ID，若游戏无角色概念，可不填，默认值同 accountId 账号ID
        payParamsDic.Add("roleLevel", "1"); //选传，角色等级，若游戏无角色及等级概念，可填关卡等级或不填，默认值为 1
        payParamsDic.Add("vipLevel", "1"); //选传，VIP等级
        payParamsDic.Add("orderId", "11341123"); //必传，订单唯一编号，注意不要出现重复订单编号，只需上报成功订单
        payParamsDic.Add("productId", "100"); //必传，所购商品ID
        payParamsDic.Add("payAmount", "100"); //必传，支付的真实货币金额，单位为元！！！
        payParamsDic.Add("payType", "weixinpay"); //选传，支付方式  weixinpay - 微信支付 alipay - 支付宝 yeepay - 易宝支付 unionpay - 银联
        payParamsDic.Add("payChannel", ""); //选传，支付渠道ID，默认值同 sdk.channel 渠道ID
        payParamsDic.Add("currencyType", "CNY"); //选传，货币类型 CNY - 人民币 USD - 美元
        DHSDKHelper.payInfoUpload(payParamsDic);
        //上报自定义热云事件
        Dictionary<string, string> reyunParamsDic = new Dictionary<string, string>();
        reyunParamsDic.Add("extendParams", "{\"key\":\"value\"}"); // 选传，自定义扩展参数，属性 key 只能为 string 类型，需要以英文字符开头，仅支持输入英文字符、数字、下划线（以 _ 开头为内置属性，不可以使用）；value 支持字符串

        string reyunEventName = "event_1"; //必传，自定义事件名称，必须为 event_1 到 event_30
        DHSDKHelper.reyunUpload(reyunEventName, reyunParamsDic);
        //上报oss事件
        Dictionary<string, string> ossParamsDic = new Dictionary<string, string>();
        ossParamsDic.Add("accountId", "123456"); // 必传，账号ID（账号唯一标识）
        ossParamsDic.Add("areaId", "1");  // 选传，游戏大区ID，若游戏无大区概念，可不填，默认值为 1，表示初始大区编号（v1.1.17版本新增，向下兼容历史版本中的 zid 参数）
        ossParamsDic.Add("serverId", "100"); //选传，游戏服务器ID，若游戏无服概念，可不填，默认值为 1，表示初始服务器编号（v1.1.17版本新增）
        ossParamsDic.Add("roleId", "123"); //选传，角色ID，若游戏无角色概念，可不填，默认值同 accountId 账号ID
        ossParamsDic.Add("userId", "123123123"); //选传，游戏内用于唯一标识一个玩家的ID，一个 userId 可能对应多个 roleId，若游戏无此概念，此处可填写与 accountId 相同的值
        ossParamsDic.Add("eventObj", ""); //选传，事件操作对象，如果是按钮点击事件，则对应按钮ID
        ossParamsDic.Add("eventResult", ""); //选传，事件操作结果，如果是按钮点击事件，则返回按钮点击的结果，例如跳转至另一个页面，则填写结果页ID
        ossParamsDic.Add("eventCode", ""); //选传，事件操作原因 code 码
        ossParamsDic.Add("dataMode", "1"); //选传，数据统计方式 1 - 按 eventName eventObj eventCode 聚合后统计人数次数 2 - 按 eventName eventObj eventCode 取每个用户最新记录，然后统计人数次数
        ossParamsDic.Add("extendParams", "{\"key\":\"value\"}"); //选传，扩展参数，格式为 JSON 字符串，如：JSON.stringify({ kills: 0, deaths: 0, assistant: 0 })；参数最多 20 个

        string ossEventName = "levelUp";//必传，自定义事件名称，请使用英文单词命名，如 levelUp、joinCorp
        DHSDKHelper.track(ossEventName, ossParamsDic);
        //上报漏斗图日志事件
        Dictionary<string, string> logParamsDic = new Dictionary<string, string>();
        logParamsDic.Add("subEventId", ""); // 选传，子事件ID
        logParamsDic.Add("logLevel", "d");  // 选传，日志级别 d - 正常或成功日志 e - 失败日志
        logParamsDic.Add("logContent", "log content"); //必传，日志内容，可填写相应网络请求响应信息或程序执行错误信息等
        logParamsDic.Add("accountId", "123123123");  // 选传，账号ID（账号唯一标识）

        string logEventName = "530000::SDK_CLIENT_PAY"; //必传，事件ID
        DHSDKHelper.log(logEventName, logParamsDic);
#endif
    }

    public void playAd()
    {
#if MINIGAME_SDK
        //创建广告实例，可以创建多个广告实例，使用adUnitId 来判断区分
        /*
        Dictionary<string, string> adInfo = DHSDKHelper.DHParam.Builder()
            .put("adUnitId", "adunit-f439404af69c3a61")  //必传，广告位ID
            .put("multiton", "true")  // 选传，是否启用多例模式
            .put("event_type", "createAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
            .put("advertPlatform", "weixin")  //选传，广告平台
            .put("advertPosition", "")  //选传，广告展示位置，预留参数，有就填写
            .toDictionary();

        DHSDKHelper.playAd(adInfo, mUnionSdkCallback);
        */
        //加载广告，根据广告id找到对应广告实例
        /*
        Dictionary<string, string> adInfo2 = DHSDKHelper.DHParam.Builder()
            .put("adUnitId", "asdcv123123")  //必传，广告位ID
            .put("event_type", "loadAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
            .toDictionary();

        DHSDKHelper.playAd(adInfo2, mUnionSdkCallback);
        */
        //判断是否能播放广告，根据广告id找到对应广告实例
        /*
        Dictionary<string, string> adInfo3 = DHSDKHelper.DHParam.Builder()
            .put("adUnitId", "asdcv123123")  //必传，广告位ID
            .put("event_type", "couldPlayAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
            .toDictionary();

        DHSDKHelper.playAd(adInfo3, mUnionSdkCallback);
        */
        //播放广告，根据广告id找到对应广告实例
        Dictionary<string, string> adInfo4 = DHSDKHelper.DHParam.Builder()
            .put("adUnitId", "adunit-f439404af69c3a61")  //必传，广告位ID
            .put("event_type", "playAd")  // 必传，createAd 创建广告实例，loadAd 加载广告,couldPlayAd 是否可以播放  playAd 播放广告
            .put("advertPosition", "")  //选传，广告展示位置，预留参数，有就填写
            .toDictionary();

        DHSDKHelper.playAd(adInfo4, mUnionSdkCallback);
#else
        Dictionary<string, string> adInfo = DHSDKHelper.DHParam.Builder()
            .put("uid", "123456")
            .put("adType", "1")  // 广告类型
            .put("event_type", "couldPlayAd")  // couldPlayAd 是否可以播放  playAd 播放广告
            .toDictionary();

        DHSDKHelper.playAd(adInfo, mUnionSdkCallback);
#endif
    }

    public void query()
    {

        String android_id = DHSDKHelper.query("android_id");
        Debug.Log("android_id: " + android_id);
        string unityid = SystemInfo.deviceUniqueIdentifier;
        Debug.Log("Unity android_id: " + unityid);
        //String imei = DHSDKHelper.query("imei");
        //Debug.Log("imei: " + imei);
#if STEAMWORKS
        String currency = DHSDKHelper.query(DHHostPlatformSDK.DHHostPlatformConst.KEY_STEAM_CURRENCY);
        Debug.Log("currency: " + currency);
        updateUITextEvent?.Invoke(1, "currency:" + currency);
#elif MINIGAME_SDK
        string version = DHSDKHelper.query("version"); //SDK的版本号，如 1.0.0
        Debug.Log("version:" + version);
        string system = DHSDKHelper.query("system");   //系统信息，详情请参考 wx.getSystemInfoSync() 接口文档
        string platform = DHSDKHelper.query("system.platform"); //客户端设备类型 android - Android微信 ios - iOS微信 windows - Windows微信 mac - macOS微信 devtools - 微信开发者工具
        Debug.Log("platform:"+platform);
        string networkType = DHSDKHelper.query("networkType");  //网络类型，详情请参考 wx.getNetworkType() 接口文档
        string deviceId = DHSDKHelper.query("deviceId");  //设备唯一标识（注意，因小游戏客户端SDK无法获取真实的设备唯一标识，故使用一个32位随机字符串作为设备唯一标识，并存储于客户端缓存中；后续进入小游戏，若有缓存则从缓存中获取，无缓存则重新生成并存入缓存；因此无法确保设备唯一标识的准确性）
        string launchOptions = DHSDKHelper.query("launchOptions");  //小游戏的启动参数，详情请参考 wx.getLaunchOptionsSync() 接口文档
        string gameAppId = DHSDKHelper.query("gameAppId");   //小游戏的 AppID（于微信公众平台注册小游戏时生成的ID）
        string appId = DHSDKHelper.query("appId");   //小游戏的 AppID（于SDK平台注册小游戏时生成的ID）
        string appName = DHSDKHelper.query("appName");    //小游戏的应用包名，如 com.dianhun.abc
        string appVersion = DHSDKHelper.query("appVersion");   //小游戏的版本号，如 2.0.4.10
        string channel = DHSDKHelper.query("channel");    //渠道ID，如 1389
        string mainChannel = DHSDKHelper.query("mainChannel");   //推广主渠道ID，如 100708
        string secondChannel = DHSDKHelper.query("secondChannel");  //推广次渠道ID，如 100709
        string userInfo = DHSDKHelper.query("userInfo");  //用户信息，仅在授权登录成功后可读
        string loginType = DHSDKHelper.query("userInfo.loginType");  //用户授权登录类型
        string token = DHSDKHelper.query("userInfo.token");   //用户授权登录Token
        Debug.Log("token:" + token);
        string account = DHSDKHelper.query("userInfo.account");   //用户账号
        string accountId = DHSDKHelper.query("userInfo.accountId");  //用户账号ID
        string openId = DHSDKHelper.query("userInfo.openId");   //用户微信唯一标识（openId）
#endif
    }

    void insertPhoto()
    {
        //  插入相册图片
        Dictionary<string, string> param = DHSDKHelper.DHParam.Builder()
            .put("fileName", "aaa.png")
            .put("filePaht", "/data/com.dh/m3/photo/aaa.png")
            .toDictionary();

        DHSDKHelper.toolExtend("insert_photo", param, mUnionSdkCallback);
    }

    //void track(int index)
    //{
    //    //  跳转到电魂数据统计界面  如果游戏要接入电魂数据统计  请查看DHLog.cs类示例
    //    if (GUI.Button(new Rect(50, _maxHeight * index + _spaceHeight, Screen.width - 100, _newHeight), "track"))
    //    {
    //        AsyncOperation op = SceneManager.LoadSceneAsync("DHTrackDemo");
    //        op.allowSceneActivation = true;
    //    }
    //}
    public void exec()
    {
        /*
        JsonData json = new JsonData();
        json["areaId"] = "100";
        json["roleId"] = "100010000";
        json["serverId"] = "1";
        JsonData jsonParam = new JsonData();
        jsonParam["plugin_type"] = "tools";
        jsonParam["unionsdk_type"] = "platform";
        jsonParam["event_type"] = "showWebviewByKey";
        jsonParam["event_key"] = "personalInformation";
        jsonParam["jsonstring"] = json.ToJson();
        DHSDKHelper.exec(jsonParam.ToJson(), mUnionSdkCallback);
        */
    }

    public void exit()
    {
        DHSDKHelper.exit(mUnionSdkCallback);
    }

    public void log()
    {
        //流程统计
        Dictionary<string, string> paramsDic = new Dictionary<string, string>();
        //   DHSDKHelper.log("000000:GAME_CLIENT_TEST", paramsDic);  //  000000:GAME_CLIENT_TEST事件ID请参考文档具体说明
    }

    public void tool()
    {
        DHSDKHelper.tool("country", mUnionSdkCallback);
#if UNITY_SWITCH
        DHSDKHelper.showApplicationError(1, "", "");
#endif
    }

    public void GameClub()
    {
#if MINIGAME_SDK
        // 创建游戏圈按钮
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("type", "text ")       // 必传，按钮类型 text - 文本按钮，允许自定义背景色及文本 image - 图片按钮，仅允许设置背景贴图，背景贴图会直接拉伸至按钮的宽高
            .put("icon", "")       // 选传，图片按钮的图标，仅当 type 为 image 时有效 green - 绿色图标 white - 白色图标 dark - 有黑色圆角背景的白色图标 light - 有白色圆角背景的绿色图标
            .put("image", "")    // 选传，图片按钮的背景图片，仅当 type 为 image 时有效
            .put("text", "")    // 选传，文本按钮的文本，仅当 type 为 text 时有效
            .put("top", "0")        // 必传，按钮左上角纵坐标
            .put("left", "0")      // 必传，按钮左上角横坐标
            .put("width", "100")      // 必传，按钮宽度
            .put("height", "32")      //必传，按钮高度
            .put("backgroundColor", "#07c160")      // 必传，角色所属公会 , 无公会系统,传无
            .put("borderWidth", "0")        // 必传，按钮边框宽度
            .put("borderColor", "#07c160")     // 必传，按钮边框颜色，格式为 6 位 16 进制数
            .put("borderRadius", "0")     //必传，按钮边框圆角
            .put("color", "#ffffff")      //必传，按钮文本颜色，格式为 6 位 16 进制数
            .put("fontSize", "12")        //必传，按钮文本字号
            .put("textAlign", "center")   //必传，按钮文本水平居中方式 left - 居左 center - 居中 right - 居右
            .put("lineHeight", "32")       //必传，按钮文本行高
            .put("openlink", "")       //选传，设置后可以跳转到对应的活动页面，可登录《微信公众平台》后台，进入“功能 > 游戏运营工具箱 > 游戏圈 > 管理”，由帖子或话题的"游戏内跳转ID"生成；不设置时默认跳转至游戏圈主页（注意，该参数必须设置为真实有效的值，没有的情况下请直接去除该参数，不允许留空，否则将导致点击按钮时报错）
            .put("hasRedDot", "true")       //选传，当传递了openlink 值时，此字段生效，决定创建的按钮是否显示红点
            .toJson();
        DHSDKHelper.createGameClubButton(param, mUnionSdkCallback);

        //操作游戏圈按钮
        string gameClubAction = "hide";//游戏圈操作类型，show:显示，hide:隐藏，destory:移除
        DHSDKHelper.gameClubButtonAction(gameClubAction);
#endif
    }

    public void gameClubShare()
    {
#if MINIGAME_SDK
        //分享网络图片到游戏圈
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("type", "image")       // 必传，分享类型，image:网络图片分享，canvas:canvas分享
            .put("title", "")       // 选传，分享标题
            .put("content", "")    // 必传，分享文案
            .put("url", "")    // 选传，分享图片的网络路径，其对应的域名需要添加至“服务器域名（downloadFile 合法域名）”中
            .toJson();
        DHSDKHelper.gameClubShare(param, mUnionSdkCallback);

        //分享Canvas截图到游戏圈
        string param2 = DHSDKHelper.DHJsonParam.Builder()
            .put("type", "canvas")       // 必传，分享类型，image:网络图片分享，canvas:canvas分享
            .put("title", "")       // 选传，分享标题
            .put("content", "")    // 必传，分享文案
            .put("x", "0")    // 选传，截取 canvas 的左上角横坐标
            .put("y", "0")    // 选传，截取 canvas 的左上角纵坐标
            .put("width", "")    // 选传，截取 canvas 的宽度
            .put("height", "")    // 选传，截取 canvas 的高度
            .put("destWidth", "")    // 选传，目标文件的宽度，会将截取的部分拉伸或压缩至该数值
            .put("destHeight", "")    // 选传，目标文件的高度，会将截取的部分拉伸或压缩至该数值
            .put("fileType", "png")    // 选传，目标文件的类型 png - PNG图片 jpg - JPG图片
            .put("quality", "1.0")    // 选传，JPG图片的质量，仅当 fileType 为 jpg 时有效；取值范围为 0.0 ~ 1.0，不含 0，不在范围内时视作 1.0
            .toJson();
        DHSDKHelper.gameClubShare(param2, mUnionSdkCallback);
#endif
    }

    public void gameClubPushSeed()
    {
#if MINIGAME_SDK
        //推送小游戏动态
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("eventId", "image")       // 必传，事件（素材）ID
            .put("query", "")       // 选传，自定义查询字符串，必须是 key1=val1&key2=val2 的格式
            .toJson();
        DHSDKHelper.gameClubPushSeed(param, mUnionSdkCallback);
#endif
    }

    public void gameClubShowActivity()
    {
#if MINIGAME_SDK
        //展示R活动
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("offerId", "123123")       // 必传，在米大师侧申请的应用ID；可登录《微信公众平台》后台，进入“功能 > 虚拟支付 > 基本配置 > 基本配置”栏目中查看
            .put("exchangeRate", "1")       // 必传，游戏币兑换比例，表示1人民币可以兑换多少游戏币，可选值为 1、10、100（要跟开通虚拟支付时选择的比例保持一致）；请登录《微信公众平台》后台，进入“功能 > 虚拟支付 > 基本配置 > 游戏币配置”栏目中查看
            .put("levelList", "[\"1\",\"2\"]")       // 选传，标记该用户当前已购买了哪些 level 的礼包
            .put("zoneId", "1")       // 选传，分区ID
            .toJson();
        DHSDKHelper.gameClubShowActivity(param, mUnionSdkCallback);
#endif
    }

    public void gameClubGetData()
    {
#if MINIGAME_SDK
        //获取游戏圈参数
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("dataTypeList", "[{\"type\":\"1\",\"subKey\":\"\"},{\"type\":\"3\",\"subKey\":\"\"}]")       // 必传，需要获取的数据指标对象数组
            .toJson();
        DHSDKHelper.gameClubGetData(param, mUnionSdkCallback);
        /*参数解析
         * dataTypelist为一个json字符串，结构为包含若干Dictionary的数组
         * Dictionary中字段说明
           type	         说明	                        subKey
             1	加入该游戏圈时间，秒级Unix时间戳	   无需传入
             3	用户禁言状态；0：正常，1：禁言	       无需传入
             4	当天(自然日)点赞贴子数	               无需传入
             5	当天(自然日)评论贴子数	               无需传入
             6	当天(自然日)发表贴子数	               无需传入
             7	当天(自然日)发表视频贴子数	           无需传入
             8	当天(自然日)点赞官方贴子数	           无需传入
             9	当天(自然日)评论官方贴子数	           无需传入
             10	当天(自然日)发表到本圈子话题的贴子数   传入话题ID，从微信公众平台后台-游戏圈话题管理处获取
         */
#endif
    }

    public void ChannelAction()
    {
#if MINIGAME_SDK
        //打开视频号主页
        string profileParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "openUserProfile")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必选，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .toJson();
        DHSDKHelper.videoChannelAction(profileParam, mUnionSdkCallback);

        //打开视频号活动页
        string eventParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "openEvent")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必选，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .put("eventId", "111")       // 必选，活动ID
            .toJson();
        DHSDKHelper.videoChannelAction(eventParam, mUnionSdkCallback);

        //打开视频号视频
        string activityParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "openActivity")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必选，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .put("feedId", "111")       // 必选，视频feedId
            .toJson();
        DHSDKHelper.videoChannelAction(activityParam, mUnionSdkCallback);

        //打开视频号直播
        string liveParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "openLive")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必选，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .put("feedId", "")       // 选填，直播feedId，通过 action 为getLiveInfo 方法获取
            .put("noticeId", "")       // 选填，直播nonceId，通过 action 为getLiveInfo 方法获取
            .toJson();
        DHSDKHelper.videoChannelAction(liveParam, mUnionSdkCallback);

        //预约视频号直播
        string reserveParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "reserveLive")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("noticeId", "")       // 必填，预告ID，通过 action 为getLiveInfo 方法获取
            .toJson();
        DHSDKHelper.videoChannelAction(reserveParam, mUnionSdkCallback);

        //视频号直播预告信息
        string getLiveNoticeParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "getLiveNoticeInfo")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必填，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .toJson();
        DHSDKHelper.videoChannelAction(getLiveNoticeParam, mUnionSdkCallback);

        //视频号直播信息
        string getLiveParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "getLiveInfo")       // 必传，视频号方法类型，openUserProfile：打开视频号主页，openEvent：打开视频号活动页，openActivity：打开视频号视频，openLive：打开视频号直播，reserveLive：预约视频号直播，getLiveNoticeInfo：获取视频号直播预告信息，getLiveInfo：获取视频号直播信息
            .put("finderUserName", "sph111")       // 必填，视频号ID，以“sph”开头的ID，可在视频号助手获取
            .put("startTime", "0")       // 选填，起始时间，筛选指定时间段的直播；若设置了 endTime，未设置 startTime，则 startTime 默认为 0
            .put("endTime", "")       // 选填，结束时间，筛选指定时间段的直播；若设置了 startTime，未设置 endTime，则 endTime 默认取当前时间
            .toJson();
        DHSDKHelper.videoChannelAction(getLiveParam, mUnionSdkCallback);
#endif
    }

    public void SubscribeAction()
    {
#if MINIGAME_SDK
        //一次性订阅消息
        string messageParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "message")       // 必传,订阅方法类型，message：一次性订阅消息，systemMessage：系统订阅消息
            .put("tmplIds", "sph111")       // 必选，需要订阅的消息模板 id 集合，一次调用最多可订阅 3 条消息；可登录《微信公众平台》后台，进入“功能 > 订阅消息”栏目中配置及查看消息模板 id，每个 tmplId 对应的模板标题需要不同，否则会被过滤
            .toJson();
        DHSDKHelper.subscribeAction(messageParam, mUnionSdkCallback);

        //系统订阅消息
        string systemParam = DHSDKHelper.DHJsonParam.Builder()
            .put("action", "systemMessage")       // 必传,订阅方法类型，message：一次性订阅消息，systemMessage：系统订阅消息
            .put("msgTypeList", "[\"SYS_MSG_TYPE_INTERACTIVE\"]")       // 必选，系统订阅消息类型列表，一次调用最多可订阅 3 条消息 SYS_MSG_TYPE_INTERACTIVE - 好友互动提醒 SYS_MSG_TYPE_RANK - 排行榜好友超越提醒 SYS_MSG_TYPE_WHATS_NEW - 游戏更新提醒，基础库 2.32.1 版本开始支持
            .toJson();
        DHSDKHelper.subscribeAction(systemParam, mUnionSdkCallback);
#endif
    }

    public void bindPhone()
    {
        // 查询是否绑定  数据返回请看底部callback
        //DHSDKHelper.queryBindPhone("", mUnionSdkCallback);


        // 发送短信  数据返回请看底部callback
        //            string sms = DHSDKHelper.DHJsonParam.Builder()
        //                .put("mobile", "15258834990")
        //                .toJson();
        //
        //
        //            DHSDKHelper.sendSMS(sms, mUnionSdkCallback);

        // 进行绑定  数据返回请看底部callback
        /*
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("mobile", "15258834990")
            .put("code", "884989")
            .toJson();


        DHSDKHelper.bindPhone(param, mUnionSdkCallback);
        */
        string param = DHSDKHelper.DHJsonParam.Builder()
            .put("connect", "connect")
            .toJson();


        DHSDKHelper.delegateBindPhone(param, mUnionSdkCallback);
    }


    public void showFAQView()
    {
#if MINIGAME_SDK
        //faq相关参数
        Dictionary<string, string> paramsDic = new Dictionary<string, string>();
        paramsDic.Add("areaId", "1"); //必传，游戏大区ID，若游戏无大区概念，可传空字符串
        paramsDic.Add("serverId", "1");  // 必传，游戏服务器ID，若游戏无服概念，可传空字符串
        paramsDic.Add("roleId", "111231423"); //必传，角色ID，若游戏无角色概念，可传空字符串
        paramsDic.Add("nickname", "昵称"); //必传，角色昵称
        paramsDic.Add("level", "1"); //必传，角色等级
        paramsDic.Add("targetAppId", "21658"); //必传，客服系统应用ID，可填 21658
        DHSDKHelper.showFAQ(paramsDic,mUnionSdkCallback);
#else
        //faq相关参数
        Dictionary<string, string> paramsDic = new Dictionary<string, string>();
        paramsDic.Add("nick", "昵称1"); //角色昵称，string类型，必填
        paramsDic.Add("level", "6");  // 角色等级,string类型 数字，必填
        paramsDic.Add("role_id", "111231423"); //游戏角色id，string类型，必填
        DHSDKHelper.showFAQ(paramsDic);
#endif
    }

    void showSurveyView()
    {
#if MINIGAME_SDK
        //问卷调查相关参数
        Dictionary<string, string> paramsDic = new Dictionary<string, string>();
        paramsDic.Add("areaId", "1"); //必传，游戏大区ID，若游戏无大区概念，可传空字符串
        paramsDic.Add("serverId", "1");  // 必传，游戏服务器ID，若游戏无服概念，可传空字符串
        paramsDic.Add("roleId", "111231423"); //必传，角色ID，若游戏无角色概念，可传空字符串
        paramsDic.Add("nickname", "昵称"); //必传，角色昵称
        paramsDic.Add("level", "1"); //必传，角色等级
        paramsDic.Add("targetAppId", "21658"); //必传，客服系统应用ID，可填 21658
        paramsDic.Add("surveyId", ""); //必传，问卷ID，由相关运营人员负责提供
        DHSDKHelper.showSurvey(paramsDic, mUnionSdkCallback);
#endif
    }

    public void ShowToast(string msg)
    {
        GUI.skin.box.fontSize = 20;
        GUI.Box(new Rect(0, Screen.height - 150, Screen.width, 100), msg);
    }

    public static void message(string msg)
    {
        NoticeMsg notice = new NoticeMsg();
        notice.msg = msg;
        notice.beginTime = System.DateTime.Now;
        showMsgList.Add(notice);
    }

    private void updateUI(int type, string tip)
    {
        Debug.Log("type is :" + type + ",tip:" + tip);
        if (type == 1)
        {
            callbackText.text = tip;
        }
        else if (type == 2)
        {
            userIdText.text = tip;
        }
    }

    private class DHUnionSdkCallback : DHSDKHelper.IDHSDKUnityCallback
    {
        public event System.Action<int, string> updateUIText;
        public event System.Action<string> updateFriendUI;
        public event System.Action<int, int,string> updateRoomUIAction;
        public void onDHSDKResult(String requestCode, int resultCode, String resultData)
        {
            Debug.Log("request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
            message("request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
            updateUIText?.Invoke(1, "request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
        }

        public void onDHSDKResult(int requestCode, int resultCode, String resultData)
        {
            Debug.Log("request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
            message("request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
            updateUIText?.Invoke(1, "request:" + requestCode + ", result:" + resultCode + ", Data:" + resultData);
            updateRoomUIAction?.Invoke(requestCode, resultCode, resultData);

            if (resultCode == DHSDKHelper.DHSDKConst.RET_OK)
            {
                // 所有接口成功返回调用逻辑
                if (requestCode == DHSDKHelper.DHSDKConst.REQ_INIT)
                {
                    // 初始化成功 返回调用  
                    Debug.Log("初始化成功");
                    //String imei = DHSDKHelper.query("imei");
                    //Debug.Log("imei: " + imei);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_LOGIN)
                {

                    /**  
                      登录成功后  返回调用  请查看各返回字段说明 
                      json 数据格式
                    */

                    Debug.Log("login:" + resultData);

                    //  sdk登录成功后 需要游戏服务端做校验 详细校验过程 请查看服务端文档登录校验说明
                    // 当前返回的是sdk测试环境的账号数据  如果游戏服务端去sdk服务端验证账号和token数据请到测试环境验证

                    var loginJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + loginJson.ToString());

                    string logintype = loginJson["loginType"].ToString();
                    string Token = loginJson["token"].ToString();
                    uid = loginJson["accountId"].ToString();
                    uname = loginJson["account"].ToString();
                    string openId = loginJson["openId"].ToString();
                    updateUIText?.Invoke(2, uid);

                    /* 请在登陆成功后  创建游戏角色成功的时候  调用setGameUserInfo接口  此接口必须接入  接入参数请查看上面  demo提供的示例  */

                    // 设置数据埋点 电魂id
                    DHSDKHelper.setTrackUserId(uid);

                    //////////////////////////////////////////////
                    /*注意!!!*/
                    /*SDK返回登录成功后，游戏还需要去服务端校验登录返回的账号token，具体参考服务端接口文档，如果校验失败，游戏必须调用登出接口logout，否则后续登录可能有问题*/


                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CREATE_USER_INFO_BUTTON)
                {

                    /**  
                      创建按钮成功，用户点击授权成功返回调用  请查看各返回字段说明 
                      json 数据格式
                      用户信息示例
                    {"code":"0", "data":"{"encryptedData":"k3yMy/IHZ2rru7IeOLD1hGfx12342ozs0E8ErWTheIb/AX2J606Crvlb+1ZZfkWGeOgSuSGYZbMDnvUs9XH/261I4WCVkgWf3JYdKL6NuAiOgqXgYdM87e2qgxCxHuyPI0UCundXNK98tyS5hbXuvtN7NlmPcF/69uoo3gAm+dwUuIuOeTMVJRC0a830eebdvV6SMG//KymseI4OYdNscTkhnZblRtV/09ppzaqIHiLLHj9lA/EUyS87X5Cg6nsEQZbwbUuYLZDQmw8w8f3LZSPjnBM0uRMJIvqXWKCmMLa+NNTC6TJ2vfoT31rpf47N02suWsGOEPrDdHyrCcNoKvb8XFON6vsR8w/qgNYIGDQyanagnKg8nKq865RL9nyJjkRPw2R7++9Rs3R7z4jAVg8WFuhgL3L8mt69EO5/x9zf65dWICFrpKbMh/xkofBueMdDxLccbzrXmf6jr3Z0MHfCn1dpd/S+9SjalZpgcEkHqERNVat0OuEg8Zn7bttCLiMT59LvU/rPdyjcHSMb29b8n/sszX36cz0de9dUQpk=", "iv":"vZUenkxHRoyYJYDjuxqT3g==", "signature":"ab0984ce5124ca295ade65392fe6a067f4c8661e", "userInfo":"{"nickName":"辰", "gender":"0", "language":"zh_CN", "avatarUrl":"https://thirdwx.qlogo.cn/mmopen/vi_32/u9p3ibvl90RpEct1xiauAdX3a12321aVn4JSKJLGgpC763mUVyEeHfqZIHibWA2hibTCqUd6uMruh6mCLZ6qicmhoiaBexAibibPiaic4Td3eib8zcWNh8/132"}", "rawData":"{\"nickName\":\"辰\",\"gender\":0,\"language\":\"zh_CN\",\"city\":\"\",\"province\":\"\",\"country\":\"\",\"avatarUrl\":\"https://thirdwx.qlogo.cn/mmopen/vi_32/u9p3ibvl90RpEct1xiauAdX3a6YibGV12321JSKJLGgpC763mUVyEeHfqZIHibWA2hibTCqUd6uMruh6mCLZ6qicmhoiaBexAibibPiaic4Td3eib8zcWNh8/132\"}", "errMsg":"getUserInfo:ok"}", "message":"获取用户信息成功"}
                    */

                    Debug.Log("user agree:" + resultData);

                    var userInfoJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("userInfoJson:" + userInfoJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GET_SETTING)
                {

                    /**  
                      判断是否获取用户信息  返回调用  请查看各返回字段说明 
                      
                    */

                    Debug.Log("user setting:" + resultData);

                    //已获取用户信息

                    //需要调用getUserInfo接口获取用户信息

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GET_USERINFO)
                {

                    /**  
                      获取用户信息成功后  返回调用  请查看各返回字段说明 
                      json 数据格式
                      用户信息示例
                    {"code":"0", "data":"{"encryptedData":"k3yMy/IHZ2rru7IeOLD1hGfx12342ozs0E8ErWTheIb/AX2J606Crvlb+1ZZfkWGeOgSuSGYZbMDnvUs9XH/261I4WCVkgWf3JYdKL6NuAiOgqXgYdM87e2qgxCxHuyPI0UCundXNK98tyS5hbXuvtN7NlmPcF/69uoo3gAm+dwUuIuOeTMVJRC0a830eebdvV6SMG//KymseI4OYdNscTkhnZblRtV/09ppzaqIHiLLHj9lA/EUyS87X5Cg6nsEQZbwbUuYLZDQmw8w8f3LZSPjnBM0uRMJIvqXWKCmMLa+NNTC6TJ2vfoT31rpf47N02suWsGOEPrDdHyrCcNoKvb8XFON6vsR8w/qgNYIGDQyanagnKg8nKq865RL9nyJjkRPw2R7++9Rs3R7z4jAVg8WFuhgL3L8mt69EO5/x9zf65dWICFrpKbMh/xkofBueMdDxLccbzrXmf6jr3Z0MHfCn1dpd/S+9SjalZpgcEkHqERNVat0OuEg8Zn7bttCLiMT59LvU/rPdyjcHSMb29b8n/sszX36cz0de9dUQpk=", "iv":"vZUenkxHRoyYJYDjuxqT3g==", "signature":"ab0984ce5124ca295ade65392fe6a067f4c8661e", "userInfo":"{"nickName":"辰", "gender":"0", "language":"zh_CN", "avatarUrl":"https://thirdwx.qlogo.cn/mmopen/vi_32/u9p3ibvl90RpEct1xiauAdX3a12321aVn4JSKJLGgpC763mUVyEeHfqZIHibWA2hibTCqUd6uMruh6mCLZ6qicmhoiaBexAibibPiaic4Td3eib8zcWNh8/132"}", "rawData":"{\"nickName\":\"辰\",\"gender\":0,\"language\":\"zh_CN\",\"city\":\"\",\"province\":\"\",\"country\":\"\",\"avatarUrl\":\"https://thirdwx.qlogo.cn/mmopen/vi_32/u9p3ibvl90RpEct1xiauAdX3a6YibGV12321JSKJLGgpC763mUVyEeHfqZIHibWA2hibTCqUd6uMruh6mCLZ6qicmhoiaBexAibibPiaic4Td3eib8zcWNh8/132\"}", "errMsg":"getUserInfo:ok"}", "message":"获取用户信息成功"}
                    */

                    Debug.Log("user info:" + resultData);

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_INDULGE)
                {

                    // {"gamePart": "1","account_id": "174873602","heartbeat_count": "100","action": "logout"}
                    // 防沉迷系统 被动回调监听接口  sdk会主动通知游戏   游戏需要解析action字段  做相应业务逻辑
                    Debug.Log("realNameAuth:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_LOGOUT)
                {
                    Debug.Log("logout success");
                    // logout成功 返回调用
                    updateUIText?.Invoke(2, "");
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_PAY)
                {

                    // pay成功 返回调用

                    // android 返回数据不是json 只作为结果或者错误信息提示  用来排除问题

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_EXIT)
                {

                    // exit成功 返回调用
                    Application.Quit();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SHARE)
                {

                    // share成功 返回调用
                    var shareJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("shareJson:" + shareJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CID)
                {

                    Debug.Log("GetChanneIdJson,ChannelID:" + resultData);

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD)
                {
                    Debug.Log("AD:" + resultData);
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD_LOAD)
                {
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                    Debug.Log("AD load:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD_READY)
                {
                    Debug.Log("AD ready:" + resultData);
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_REALNAMEAUTH)
                {

                    /***
                     * 实名认证成功 返回调用  实名认证目前只有国内电魂官方版本使用  如果没有实名认证的账号  会弹出窗体进行实名认证  游客账号会先进行绑定手机号操作
                     * 
                     * {"accountid":164639521,"account":"17681827653","token":"eaa5df647e382467fc09e9fbc87","accountview":"176***53","logintype":901,"isRealNameAuth":1,"isAdult":1,"timestamp":"1546149044","sign":"a79aa6ec0a66f1f1bd9b5d6bf6c391dc","region":1}
                     * 
                     * isRealNameAuth  0未实名认证  1已实名认证
                     * 
                     * isAdult  0未成年  1已成年
                     */
                    Debug.Log("realNameAuth:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CHEKREAL)
                {
                    /***
                     * 检查实名认证成功 返回调用  检查实名认证接口只返回实名认证数据 
                     * 
                     * {"accountid":164639521,"account":"17681827653","token":"eaa5df647e382467fc09e9fbc87","accountview":"176***53","logintype":901,"isRealNameAuth":1,"isAdult":1,"timestamp":"1546149044","sign":"a79aa6ec0a66f1f1bd9b5d6bf6c391dc","region":1}
                     * 
                     * isRealNameAuth  0未实名认证  1已实名认证
                     * 
                     * isAdult  0未成年  1已成年
                     */

                    Debug.Log("checkReal:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_FACEBOOK_FRIENDS)
                {
                    // facebook 好友列表获取成功 返回调用  
                    Debug.Log("FACEBOOK:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_QUERY_BIND_PHONE)
                {
                    /**
                      * 查询账号是否有绑定手机号接口
                      * 
                      * 返回数据格式json {"success":"2","bindTime":""}  success 状态码 info 提示信息
                      */
                    Debug.Log("EQ_QUERY_BIND_PHONE:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SEND_SMS)
                {

                    /**
                     * 发送短信接口
                     * 
                     * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
                     */
                    Debug.Log("REQ_SEND_SMS:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_BIND_PHONE)
                {

                    /**
                     * 账号绑定手机号接口
                     * 
                     * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
                     */
                    Debug.Log("REQ_BIND_PHONE:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_INDULGE)
                {
                    /**
                     * 防沉迷信息通知
                     * 
                     * 返回数据格式json {"action":"logout","accountid":"123123"} 
                     */
                    Debug.Log("REQ_INDULGE:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_TOOL)
                {
                    /**
                     * 防沉迷信息通知
                     * 
                     * 返回数据格式json {"insert_photo":"true"} 
                     */
                    Debug.Log("REQ_TOOL:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_FRIENDS_INFO_CHANGE)
                {
                    //收到好友状态变化回调，刷新游戏界面显示(如果是拉黑用户，需要游戏内屏蔽)
                    Debug.Log("game receive sdk friend callback");
                    friendDataJson = resultData;
                    updateFriendUI?.Invoke(resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_INVITE)
                {
                    //收到好友状态变化回调，刷新游戏界面显示(如果是拉黑用户，需要游戏内屏蔽)
                    Debug.Log("game invite 打开成功");
                }
                else if(requestCode == DHSDKHelper.DHSDKConst.REQ_SCREEN_CHANGED)
                {
                    Debug.Log("屏幕变化");
                    /**
                     * 屏幕变化通知
                     * 返回数据格式json：{"width":1920,"height":1080}
                     */
                    Debug.Log("屏幕变化:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CREATE_FEEDBACK_BUTTON)
                {
                    Debug.Log("创建意见反馈成功，用户点击触发");
                    Debug.Log( resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SERVICE)
                {
                    Debug.Log("打开客服成功");
                    Debug.Log(resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SURVEY)
                {
                    Debug.Log("打开问卷调查成功");
                    Debug.Log(resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_RECORD)
                {
                    Debug.Log("录制视频操作成功");
                    var recordJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("recordJson:" + recordJson.ToString());

                    string action = recordJson["action"].ToString();
                    /*
                    action事件名称

                    start - 录制开始事件
                    pause - 录制暂停事件
                    resume - 录制恢复事件
                    stop - 录制结束事件
                    abort - 录制取消事件
                    timeUpdate - 录制时间更新事件，在录制过程中触发该事件
                    error - 错误事件，当录制和分享过程中发生错误时触发该事件
                    */
                    if(action == "stop")
                    {
                        string duration = recordJson["duration"].ToString();
                    }
                    else if(action == "timeUpdate")
                    {
                        string currentTime = recordJson["currentTime"].ToString();
                    }
                    else if(action == "error")
                    {
                        string code = recordJson["code"].ToString();
                        string message = recordJson["message"].ToString();
                    }

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_RECORD_SHARE)
                {
                    Debug.Log("录制视频分享成功");
                    var recordJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("recordJson:" + recordJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CREATE_GAME_CLUB_BUTTON)
                {
                    Debug.Log("游戏圈按钮点击打开游戏圈");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_SHARE)
                {
                    Debug.Log("游戏圈分享成功");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());
                    string type = gameClubJson["type"];
                    if(type == "image")
                    {
                        //分享网络图片
                    }
                    else if(type == "canvas")
                    {
                        //分享canvas
                    }

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_PUSH_SEED)
                {
                    Debug.Log("推送小游戏动态成功");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_SHOW_ACTIVITY)
                {
                    Debug.Log("展示R活动成功");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_GET_DATA)
                {
                    Debug.Log("获取游戏圈数据成功");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());
                    var data = gameClubJson["data"];
                    var signature = data["signature"];//使用 sha1(rawData sessionkey) 得到的字符串，用于校验用户信息
                    var encryptedData = data["encryptedData"];//包括 GameClubData 在内的加密数据，详见加密数据解密算法
                    var iv = data["iv"];//加密算法的初始向量
                    var cloudID = data["cloudID"];//敏感数据对应的云ID，开通云开发的小游戏才会返回，可通过云调用直接获取开放数据
                    var dataList = data["dataList"];//经过解密处理的 GameClubData 数据

                    //响应数据 encryptedData 解密后得到的 GameClubData 的结构示例
                    //{"dataList":[{"dataType":{"type":"1","subKey":""},"value":"1"},{"dataType":{"type":"2","subKey":""},"value":"2"}]}
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CHANNEL_ACTION)
                {
                    Debug.Log("视频号操作成功");
                    var channelJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("channelJson:" + channelJson.ToString());
                    string action = channelJson["action"].ToString();
                    /*
                    action事件名称

                    openUserProfile - 打开视频号主页
                    openEvent - 打开视频号活动页
                    openActivity - 打开视频号视频
                    openLive - 打开视频号直播
                    getLiveNoticeInfo - 获取视频号直播预告信息
                    getLiveInfo - 获取视频号直播信息
                    */
                    if(action == "openUserProfile")
                    {
                        Debug.Log("打开视频号主页成功");
                    }
                    else if(action == "openEvent")
                    {
                        Debug.Log("打开视频号活动页成功");
                    }
                    else if (action == "openActivity")
                    {
                        Debug.Log("打开视频号视频成功");
                    }
                    else if (action == "openLive")
                    {
                        Debug.Log("打开视频号直播成功");
                    }
                    else if (action == "getLiveNoticeInfo")
                    {
                        Debug.Log("获取视频号直播预告信息成功");
                        var data = channelJson["data"];
                        var noticeId = data["noticeId"];//预告ID
                        var status = data["status"];//预告状态：0 可用、1 取消、2 已用
                        var startTime = data["startTime"];//开始时间
                        var headUrl = data["headUrl"];//直播封面
                        var nickname = data["nickname"];//视频号昵称
                        var reservable = data["reservable"];//是否可预约
                        var otherInfos = data["otherInfos"];//除最近的一条预告信息外，其他的预告信息列
                    }
                    else if (action == "getLiveInfo")
                    {
                        Debug.Log("获取视频号直播信息成功");
                        var data = channelJson["data"];
                        var feedId = data["feedId"];//直播feedId
                        var noticeId = data["noticeId"];//直播nonceId
                        var description = data["description"];//直播主题
                        var status = data["status"];//直播状态：2 直播中、3 直播结束
                        var replayStatus = data["replayStatus"];//直播回放状态：0 未生成、1 已生成、3 生成中、6 已过期
                        var nickname = data["nickname"];//视频号昵称
                        var headUrl = data["headUrl"];//视频号头像
                        var otherInfos = data["otherInfos"];//除最近的一条预告信息外，其他的预告信息列
                    }
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SUBSCRIBE_ACTION)
                {
                    Debug.Log("订阅操作成功");
                    var subscribeJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("subscribeJson:" + subscribeJson.ToString());
                    string action = subscribeJson["action"].ToString();
                    /*
                    action事件名称

                    message - 一次性订阅消息
                    systemMessage - 系统订阅消息
                    */
                    if (action == "message")
                    {
                        Debug.Log("一次性订阅消息成功");
                        var data = subscribeJson["data"];
                        var TEMPLATE_ID = data["TEMPLATE_ID"];//[TEMPLATE_ID]是动态的键，即模板 id，值包括 accept、reject、ban、filter，其中 accept 表示用户同意订阅该条 id 对应的模板消息，reject 表示用户拒绝订阅该条 id 对应的模板消息，ban 表示已被后台封禁，filter 表示该条 id 对应的模板因为标题同名被后台过滤

                    }
                    else if (action == "systemMessage")
                    {
                        Debug.Log("系统订阅消息成功");
                        var data = subscribeJson["data"];
                        var TEMPLATE_ID = data["TEMPLATE_ID"];//[TEMPLATE_ID]是动态的键，即模板 id，值包括 accept、reject、ban、filter，其中 accept 表示用户同意订阅该条 id 对应的模板消息，reject 表示用户拒绝订阅该条 id 对应的模板消息，ban 表示已被后台封禁，filter 表示该条 id
                    }
                }
            }

            else if (resultCode == DHSDKHelper.DHSDKConst.RET_FAIL)
            {

                // 所有接口失败返回调用逻辑  所有失败信息请游戏接入方测试时log打印记录并反馈给sdk方  方便排查问题

                if (requestCode == DHSDKHelper.DHSDKConst.REQ_INIT)
                {

                    // 初始化失败调用  返回信息数据可能游戏接入方看不懂  打印log 反馈给sdk处理者即可  

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_LOGIN)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_LOGOUT)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_PAY)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_EXIT)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SHARE)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD)
                {
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD_LOAD)
                {
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD_READY)
                {
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_AD_CLOSE)
                {
                    var adJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("loginJson:" + adJson.ToString());

                    string adUnityId = adJson["adUnitId"].ToString();

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_FACEBOOK_FRIENDS)
                {

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_REALNAMEAUTH)
                {
                    Debug.Log("realNameAuth:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_QUERY_BIND_PHONE)
                {
                    Debug.Log("EQ_QUERY_BIND_PHONE:" + resultData);
                }

                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SEND_SMS)
                {
                    Debug.Log("REQ_SEND_SMS:" + resultData);
                }

                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_BIND_PHONE)
                {
                    Debug.Log("REQ_BIND_PHONE:" + resultData);
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_INVITE)
                {
                    Debug.Log("game invite 打开失败");
                }
                else if(requestCode == DHSDKHelper.DHSDKConst.REQ_CREATE_FEEDBACK_BUTTON)
                {
                    Debug.Log("创建意见反馈按钮失败");
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SERVICE)
                {
                    Debug.Log("打开客服失败");
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SURVEY)
                {
                    Debug.Log("打开问卷调查失败");
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_RECORD)
                {
                    Debug.Log("录制视频失败");
                    var recordJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("recordJson:" + recordJson.ToString());

                    string action = recordJson["action"].ToString();
                    /*
                    action事件名称

                    start - 录制开始事件
                    pause - 录制暂停事件
                    resume - 录制恢复事件
                    stop - 录制结束事件
                    abort - 录制取消事件
                    timeUpdate - 录制时间更新事件，在录制过程中触发该事件
                    error - 错误事件，当录制和分享过程中发生错误时触发该事件
                    */
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_RECORD_SHARE)
                {
                    Debug.Log("录制视频分享失败");
                    var recordJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("recordJson:" + recordJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CREATE_GAME_CLUB_BUTTON)
                {
                    Debug.Log("创建游戏圈按钮失败，或者游戏圈按钮点击打开游戏圈失败");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_SHARE)
                {
                    Debug.Log("游戏圈分享失败");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());
                    string type = gameClubJson["type"];
                    if (type == "image")
                    {
                        //分享网络图片
                    }
                    else if (type == "canvas")
                    {
                        //分享canvas
                    }

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_PUSH_SEED)
                {
                    Debug.Log("推送小游戏动态失败");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_SHOW_ACTIVITY)
                {
                    Debug.Log("展示R活动失败");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_GAME_CLUB_GET_DATA)
                {
                    Debug.Log("获取游戏圈数据失败失败");
                    var gameClubJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("gameclubJson:" + gameClubJson.ToString());

                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_CHANNEL_ACTION)
                {
                    Debug.Log("视频号操作失败");
                    var channelJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("channelJson:" + channelJson.ToString());
                    string action = channelJson["action"].ToString();
                    /*
                    action事件名称

                    openUserProfile - 打开视频号主页
                    openEvent - 打开视频号活动页
                    openActivity - 打开视频号视频
                    openLive - 打开视频号直播
                    getLiveNoticeInfo - 获取视频号直播预告信息
                    getLiveInfo - 获取视频号直播信息
                    */
                }
                else if (requestCode == DHSDKHelper.DHSDKConst.REQ_SUBSCRIBE_ACTION)
                {
                    Debug.Log("订阅操作失败");
                    var subscribeJson = LitJson.JSON.Parse(resultData);
                    Debug.Log("subscribeJson:" + subscribeJson.ToString());
                    string action = subscribeJson["action"].ToString();
                    /*
                    action事件名称

                    message - 一次性订阅消息
                    systemMessage - 系统订阅消息
                    */
                }


            }
        }
    }

    public void syncFriendToGameUI(string data)
    {
        Debug.Log("handle syncFriendToGameUI");
        if (friendListView != null)
        {
            friendListView.SendMessage("updateFriendState", data);
        }
        else
        {
            Debug.Log("handle syncFriendToGameUI,but friendListView is null");
        }
    }

    public void updateRoomUI(int req, int result, string data)
    {
        if (req == DHSDKHelper.DHSDKConst.REQ_CREATE_LOBBY)
        {
            if (result == 0)
            {
#if USE_MS_GAMECORE || UNITY_PS4
                currentLobbySessionId = JsonUtility.FromJson<DHHostPlatformTeamSessionInfo>(data).sessionId;
#endif
                roomLabel.text = "Room " + currentLobbySessionId;
                roomMeText.gameObject.SetActive(true);
                roomMeHostText.gameObject.SetActive(true);
                roomTwoText.gameObject.SetActive(false);
                roomTwoHostText.gameObject.SetActive(false);
                roomThreeText.gameObject.SetActive(false);
                roomThreeHostText.gameObject.SetActive(false);
            }
            else
            {
                clearRoom();
            }
        }
        else if (req == DHSDKHelper.DHSDKConst.REQ_LOBBY_JOINED || req == DHSDKHelper.DHSDKConst.REQ_MEMBER_JOINED_LOBBY ||
            req == DHSDKHelper.DHSDKConst.REQ_MEMBER_LEAVE_LOBBY || req == DHSDKHelper.DHSDKConst.REQ_LOBBY_HOST_CHANGE)
        {
            if (result == 0)
            {
#if USE_MS_GAMECORE
                DHXboxTeamInfo info = JsonUtility.FromJson<DHXboxTeamInfo>(data);
                currentLobbySessionId = info.sessionId;
                roomLabel.text = "Room " + currentLobbySessionId;
                List<DHXboxTeamUserInfo> userList = info.userInfo;
                roomTwoText.gameObject.SetActive(false);
                roomTwoHostText.gameObject.SetActive(false);
                roomThreeText.gameObject.SetActive(false);
                roomThreeHostText.gameObject.SetActive(false);

                foreach (var user in userList)
                {
                    bool me = uid == user.accountid;
                    if (me)
                    {
                        roomMeText.gameObject.SetActive(true);
                        roomMeHostText.gameObject.SetActive(user.isHost);
                        userList.Remove(user);
                        break;
                    }
                }

                for (int i = 0; i < userList.Count; i++)
                {
                    DHXboxTeamUserInfo user = userList[i];
                    if (i == 0)
                    {
                        roomTwoText.gameObject.SetActive(true);
                        roomTwoText.text = user.accountid;
                        roomTwoHostText.gameObject.SetActive(user.isHost);
                    }
                    else
                    {
                        roomThreeText.gameObject.SetActive(true);
                        roomThreeText.text = user.accountid;
                        roomThreeHostText.gameObject.SetActive(user.isHost);
                    }
                }
#elif UNITY_PS4
                roomLabel.text = "Room " + currentLobbySessionId;
                roomMeText.gameObject.SetActive(true);
                roomMeHostText.gameObject.SetActive(false);
                roomTwoText.gameObject.SetActive(false);
                roomTwoHostText.gameObject.SetActive(false);
                roomThreeText.gameObject.SetActive(false);
                roomThreeHostText.gameObject.SetActive(false);
#endif
            }
            else
            {
                clearRoom();
            }
        }
        else if (req == DHSDKHelper.DHSDKConst.REQ_LOBBY_LEAVE)
        {
            clearRoom();
        }else if(req == DHSDKHelper.DHSDKConst.REQ_RECEIVE_FRIEND_INVITE)
        {
            if(result == 0)
            {
                currentLobbySessionId = data;
                //收到好友邀请并在外部点击参加
            }
        }
    }

    public void clearRoom()
    {
        roomLabel.text = "No Room";
        roomMeText.gameObject.SetActive(false);
        roomMeHostText.gameObject.SetActive(false);
        roomTwoText.gameObject.SetActive(false);
        roomTwoHostText.gameObject.SetActive(false);
        roomThreeText.gameObject.SetActive(false);
        roomThreeHostText.gameObject.SetActive(false);
    }

    public void inviteFriend()
    {
#if USE_MS_GAMECORE
        DHSDKHelper.inviteFriend();
#elif UNITY_PS4
        //根据游戏房间设置最大邀请人数
        DHSDKHelper.inviteFriendByMaxCount(7);
#endif
    }

    public void createLobby()
    {
#if USE_MS_GAMECORE
        DHSDKHelper.createLobby();
#elif UNITY_PS4
        //根据游戏房间设置最大邀请人数
        DHSDKPSCreateLobbyBean bean = new DHSDKPSCreateLobbyBean();
        bean.sessionMaxUser = 3;
        bean.sessionType = DHHostPlatformConst.VALUE_SESSION_TYPE_OWNER_MIGRATION;
        bean.sessionPrivacy = DHHostPlatformConst.VALUE_SESSION_PRIVACY_PRIVATE;
        string jsonStr = JsonUtility.ToJson(bean);
        DHSDKHelper.createLobby(jsonStr);
#endif
    }

    public void leaveLobby()
    {
        DHSDKHelper.leaveLobby();
        //没有回调，立即离开
        clearRoom();
    }

    public void showOrHideFriendList()
    {
        string nextFunc = switchFriendListAndRoom.GetComponentInChildren<TMPro.TMP_Text>(true).text;
        if(nextFunc == "ShowFriendsList")
        {
            roomPanel.active = false;
            friendListView.active = true;
            switchFriendListAndRoom.GetComponentInChildren<TMPro.TMP_Text>(true).text = "ShowRoom";
            if (friendListView != null)
            {
                friendListView.SendMessage("handleReresh", friendDataJson);
            }
        }
        else
        {
            roomPanel.active = true;
            friendListView.active = false;
            switchFriendListAndRoom.GetComponentInChildren<TMPro.TMP_Text>(true).text = "ShowFriendsList";
        }
    }

    public void joinFriendLobbyByInvited()
    {
        DHSDKHelper.joinFriendLobbyByInvited();

    }

    //public void deleteLobby()
    //{
    //    DHSDKHelper.deleteLobby();
    //}


    public void showOrHideNormalSDKPanel()
    {
        showNormalPanel = !showNormalPanel;
        normalSDKPanel.SetActive(showNormalPanel);
        gameInvitePanel.SetActive(!showNormalPanel);
        GameObject selectButton = showNormalPanel ? StartingSelectedButton : InviteDefaultSelectedButton;
        bothInputEventSystem.SetSelectedGameObject(selectButton, null);
    }
}
