// ------------------------------------------------------------------------------
//  <autogenerated>
//      This code was generated by a tool.
//      Mono Runtime Version: 4.0.30319.1
// 
//      Changes to this file may cause incorrect behavior and will be lost if 
//      the code is regenerated.
//  </autogenerated>
// ------------------------------------------------------------------------------
using UnityEngine;
using LitJson;
using System;
using System.Reflection;
using System.Collections;
using System.Runtime.InteropServices;
using System.Collections.Generic;

/**
 * DHSDKHelper for Unity
 */
public class DHSDKHelper
{
    /** DH Unity3d SDK version */
    public static float VERSION = 1.31f;

    /************************** DHUnionSDKHelper For Android Begin ***************************/
#if UNITY_ANDROID
	static AndroidJavaClass DHUnityHelperProxy = new AndroidJavaClass ("com.dhplugin.unity.DHUnityHelper");
    static AndroidJavaObject ActivityProxy = new AndroidJavaClass ("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject> ("currentActivity");
#endif
    delegate void Action();
#if UNITY_ANDROID
	static void Run (Action action) {
		ActivityProxy.Call ("runOnUiThread", new AndroidJavaRunnable (action));
	}
#endif

    private static IDHSDKUnityCallback mUnityCallback = null;
#if UNITY_ANDROID
	private static IDHUnityCallbackProxy mCallbackProxy = new IDHUnityCallbackProxy();
#endif

    #region sdk unity辅助类
    /**
	 * DHUnionSDK Callback For Unity Project
	 */
    public interface IDHSDKUnityCallback
    {
        void onDHSDKResult(int requestCode, int resultCode, String resultData);
        void onDHSDKResult(string requestCode, int resultCode, String resultData);
    }
#if UNITY_ANDROID
	private class IDHUnityCallbackProxy : AndroidJavaProxy {
		
		public IDHUnityCallbackProxy ()
			: base ("com.dhplugin.unity.DHUnityHelper$IDHUnityCallback") {
		}

		public void onDHSDKResult(int requestCode, int resultCode, String resultData) {
			if (mUnityCallback != null) {
				mUnityCallback.onDHSDKResult(requestCode, resultCode, resultData);
			}
		}

        public void onDHSDKResult(String requestCode, int resultCode, String resultData) {
            if (mUnityCallback != null) {
                mUnityCallback.onDHSDKResult(requestCode, resultCode, resultData);
            }
        }

	}
#endif
    /************************** DHUnionSDKHelper For Android End ***************************/

    /**
	 * necessity infomation for pay sdk
	 */
    public class DHSDKPayInfo
    {
        private string uid = "";
        private string uname = "";
        private string roleId = "";
        private string roleLevel = "";
        private string areaId = "";
        private string proId = "";
        private string proName = "";
        private string proNum = "";
        private string price = "";


        private string currency = "";
        /** pay memo */
        private string memo = "memo";
        private string sdk_memo = "";
        private string rate = "";
        private string cpOrderId = "";
        private string gameInfo = "";

        //v2
        private string accountId = "";
        private string accountName = "";
        private string itemId = "";
        private string itemNum = "";
        private string itemPrice = "";
        private string itemName = "";


#if MINIGAME_SDK
        private string serverId = "";
        private string paymentMessageTitle = "";
        private string paymentMessageImage = "";
        private string android = "";
        private string ios = "";
        private string devtools = "";
        private string timestamp = "";
        private string windows = "";
        private string mac = "";
        private string cardMessageTitle = "";
        private string cardMessageImage = "";
        private string areaName = "";
        private string roleName = "";
        private string remark = ""; 
#elif H5_SDK
        private string areaName = "";
        private string roleName = "";
        private string orderId = ""; 
        private string remark = ""; 
#endif

        /** game user id */
        public string Uid { get { return uid; } set { uid = value; } }
        /** game uesr name */
        public string Uname { get { return uname; } set { uname = value; } }
        /** game role id */
        public string RoleId { get { return roleId; } set { roleId = value; } }
        /** game role level */
        public string RoleLevel { get { return roleLevel; } set { roleLevel = value; } }
        /** game area id */
        public string AreaId { get { return areaId; } set { areaId = value; } }
        /** pay product id */
        public string ProId { get { return proId; } set { proId = value; } }
        /** pay product name */
        public string ProName { get { return proName; } set { proName = value; } }
        /** pay product number */
        public string ProNum { get { return proNum; } set { proNum = value; } }
        /** pay product price */
        public string Price { get { return price; } set { price = value; } }
        /** pay product rate */
        public string Rate { get { return rate; } set { rate = value; } }
        /** pay memo */
        public string Memo { get { return memo; } set { memo = value; } }
        /** memo for specific pay channel */
        public string SdkMemo { get { return sdk_memo; } set { sdk_memo = value; } }
        /** the order id from cp */
        public string CPOrderId { get { return cpOrderId; } set { cpOrderId = value; } }

        public string Currency { get { return currency; } set { currency = value; } }
        public string GameInfo { get { return gameInfo; } set { gameInfo = value; } }

        //v2
        public string AccountId { get { return accountId; } set { accountId = value;uid = value; } }
        public string AccountName { get { return accountName; } set { accountName = value;uname = value; } }
        public string ItemId { get { return itemId; } set { itemId = value;proId = value; } }
        public string ItemNum { get { return itemNum; } set { itemNum = value;proNum = value; } }
        public string ItemPrice { get { return itemPrice; } set { itemPrice = value;price = value; } }
        public string ItemName { get { return itemName; } set { itemName = value;proName = value; } }
#if MINIGAME_SDK
        public string ServerId { get { return serverId; } set { serverId = value; } }
        public string PaymentMessageTitle { get { return paymentMessageTitle; } set { paymentMessageTitle = value; } }
        public string PaymentMessageImage { get { return paymentMessageImage; } set { paymentMessageImage = value; } }
        public string Android { get { return android; } set { android = value; } }
        public string Ios { get { return ios; } set { ios = value; } }
        public string Devtools { get { return devtools; } set { devtools = value; } }
        public string Timestamp { get { return timestamp; } set { timestamp = value; } }
        public string Windows { get { return windows; } set { windows = value; } }
        public string Mac { get { return mac; } set { mac = value; } }
        public string CardMessageTitle { get { return cardMessageTitle; } set { cardMessageTitle = value; } }
        public string CardMessageImage { get { return cardMessageImage; } set { cardMessageImage = value; } }
        public string AreaName { get { return areaName; } set { areaName = value; } }
        public string RoleName { get { return roleName; } set { roleName = value; } }
        public string Remark { get { return remark; } set { remark = value; } }
#elif H5_SDK
        public string AreaName { get { return areaName; } set { areaName = value; } }
        public string RoleName { get { return roleName; } set { roleName = value; } }
        public string OrderId { get { return orderId; } set { orderId = value; } }
        public string Remark { get { return remark; } set { remark = value; } }
#endif

        public string toJson()
        {
            Type t = typeof(DHSDKPayInfo);
            FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);

            LitJson.JSONClass json = new LitJson.JSONClass();
            foreach (FieldInfo field in fields)
            {
                object obj = field.GetValue(this);
                if (obj != null && obj.ToString().Length > 0)
                    json.Add(field.Name, field.GetValue(this).ToString());
            }
            return json.ToString();
        }
    }

    public class DHParam
    {
        private static DHParam param = new DHParam();

        Dictionary<string, string> paramsDic;

        public static DHParam Builder()
        {
            if (param != null)
            {
                param.paramsDic = new Dictionary<string, string>();
            }
            return param;
        }

        public DHParam put(string key, string value)
        {
            paramsDic.Add(key, value);
            return this;
        }

        public Dictionary<string, string> toDictionary()
        {
            return paramsDic;
        }

    }

    public class DHJsonParam
    {
        private static DHJsonParam param = new DHJsonParam();

        LitJson.JSONClass json;

        public static DHJsonParam Builder()
        {
            if (param != null)
            {
                param.json = new LitJson.JSONClass();
            }
            return param;
        }

        public DHJsonParam put(string key, string value)
        {
            json.Add(key, value);
            return this;
        }

        public DHJsonParam put(string key, int value)
        {
            json.Add(key, value.ToString());
            return this;
        }

        public string toJson()
        {
            return json.ToString();
        }
    }

    public class DHArrayParam
    {
        private static DHArrayParam param = new DHArrayParam();

        ArrayList list;

        public static DHArrayParam Builder()
        {
            if (param != null)
            {
                param.list = new ArrayList();
            }
            return param;
        }

        public DHArrayParam put(string value)
        {
            list.Add(value);
            return this;
        }

        public string toJson()
        {

            if (list.Count == 0)
            {
                return "";
            }

            string json = "[";

            for (int i = 0; i < list.Count; i++)
            {

                if (i == list.Count - 1)
                {
                    json = json + "\"" + list.IndexOf(i) + "\"";
                }
                else
                {
                    json = json + "\"" + list.IndexOf(i) + "\"" + ",";
                }
            }

            json = json + "]";

            return json;
        }

    }
    public class DHSDKAdInfo
    {
        private string uid = "";
        private int adType = 0;
        /** game user id */
        public string Uid { get { return uid; } set { uid = value; } }
        /** game uesr name */
        public int AdType { get { return adType; } set { adType = value; } }

        public string toJson()
        {
            Type t = typeof(DHSDKAdInfo);
            FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);

            LitJson.JSONClass json = new LitJson.JSONClass();
            foreach (FieldInfo field in fields)
            {
                object obj = field.GetValue(this);
                if (obj != null && obj.ToString().Length > 0)
                    json.Add(field.Name, field.GetValue(this).ToString());
            }
            return json.ToString();
        }

    }
    #if UNITY_ANDROID
    public static AndroidJavaObject dicToMap(Dictionary<string, string> dictionary)
    {
        if (dictionary == null)
        {
            return null;
        }
        AndroidJavaObject map = new AndroidJavaObject("java.util.HashMap");
        foreach (KeyValuePair<string, string> pair in dictionary)
        {
            map.Call<string>("put", pair.Key, pair.Value);
        }
        return map;
    }
    #endif
    /**
     * Constants for DHUnionSDK
     */
    public static class DHSDKConst
    {
        public static int REQ_INIT = 0;
        public static int REQ_LOGIN = 1;
        public static int REQ_PAY = 2;
        public static int REQ_EXIT = 3;
        public static int REQ_LOGOUT = 4;
        public static int REQ_SHARE = 5;
        public static int REQ_CID = 6;
        public static int REQ_AD = 7;
        public static int REQ_SKUS = 20;
        public static int REQ_QUERY = 21;
        public static int REQ_REALNAMEAUTH = 22;
        public static int REQ_LINK = 23;
        public static int REQ_LINK_INFO = 24;
        public static int REQ_AD_READY = 25;
        public static int REQ_CHEKREAL = 31;
        public static int REQ_INDULGE = 32;
        public static int REQ_FACEBOOK_FRIENDS = 61;
        public static int REQ_EXEC = 99;
        public static int REQ_QUERY_BIND_PHONE = 101;
        public static int REQ_SEND_SMS = 102;
        public static int REQ_BIND_PHONE = 103;
        public static int REQ_TOOL = 104;
        public static int REQ_SCREEN_CHANGED = 105;
        public static int REQ_BIND_SECURITY_PHONE = 106;
        public static int REQ_QUERY_BIND_SECURITY_PHONE = 107;
        public static int REQ_CREATE_USER_INFO_BUTTON = 108;
        public static int REQ_GET_SETTING = 109;
        public static int REQ_GET_USERINFO = 110;
        public static int REQ_AD_LOAD = 111;
        public static int REQ_CREATE_FEEDBACK_BUTTON = 112;
        public static int REQ_SERVICE = 113;
        public static int REQ_SURVEY = 114;
        public static int REQ_GAME_RECORD = 115;
        public static int REQ_GAME_RECORD_SHARE = 116;
        public static int REQ_CREATE_GAME_CLUB_BUTTON = 117;
        public static int REQ_GAME_CLUB_SHARE = 118;
        public static int REQ_GAME_CLUB_PUSH_SEED = 119;
        public static int REQ_GAME_CLUB_SHOW_ACTIVITY = 120;
        public static int REQ_GAME_CLUB_GET_DATA = 121;
        public static int REQ_CHANNEL_ACTION = 122;
        public static int REQ_SUBSCRIBE_ACTION = 123;
        public static int REQ_AD_CLOSE = 124;
        public static int REQ_CREATE_USER_INFO_BUTTON_SUCCESS = 125;
        public static int REQ_CREATE_FEEDBACK_BUTTON_SUCCESS = 126;
        public static int REQ_CREATE_GAME_CLUB_BUTTON_SUCCESS = 127;
        public static int REQ_PRIVACY_AUTHORIZE = 128;
        public static int REQ_SCENE = 129;


        public static int REQ_FRIENDS_INFO_CHANGE = 10000;
        public static int REQ_CREATE_LOBBY = 10001;//host
        public static int REQ_LOBBY_JOINED = 10002;//guest
        public static int REQ_LOBBY_LEAVE = 10003;//host、guest
        public static int REQ_RECEIVE_FRIEND_INVITE = 10004;//guest
        public static int REQ_MEMBER_JOINED_LOBBY = 10005;//host
        public static int REQ_MEMBER_LEAVE_LOBBY = 10006;//host
        public static int REQ_LOBBY_HOST_CHANGE = 10007;//host
        public static int REQ_DELETE_LOBBY = 10008;//host
        public static int REQ_INVITE = 10009;
        public static int REQ_NETWORK_STATE = 10010;

        public static int RET_OK = 0;
        public static int RET_FAIL = 1;
    }

    /**
	 * Share Platform
	 */
    public static class DHSDKSharePlatform
    {
        public static int Platform_None = 0;             //弹出平台列表选择
        public static int Platform_QQ = 1;               //QQ
        public static int Platform_Wechat_session = 2;   //微信
        public static int Platform_Wechat_timeline = 3;  //微信朋友圈
        public static int Platform_Sina = 4;             //新浪微博
        public static int Platform_QZone = 5;            //QQ空间
        public static int Platform_MiniGame = 6;            //微信小游戏
    }

    /**
	 * Share type
	 */
    public static class DHSDKShareType
    {
        public static int shareType_link = 0;     //链接分享
        public static int shareType_image = 1;   //图片分享
        public static int shareType_minigame_set = 2;   //小程序设置分享参数被动分享
        public static int shareType_minigame_share = 3;   //小程序主动分享
        public static int shareType_minigame_shareImageMenu = 4;   //小程序转发自定义图片
    }

    /**
	 * Share content
	 */
    public class DHSDKShareContent
    {
        private string title = "";              //分享标题
        private string desc = "";               //分享内容
        private string image = "";              //分享图片本地地址(image和imageUrl二选一，优先imageUrl，如果type是shareTYpe_image，必填)
        private string imageUrl = "";           //分享图片网络地址
        private string thumbImage = "";         //缩略图本地文件地址（thumbImage和thumbImageUrl二选一，thumbImageUrl优先）
        private string thumbImageUrl = "";      //缩略图网络地址
        private string linkUrl = "";            //分享链接url(如果是type是shareType_link，必填)
        private string imageUrlId = "";            //(小程序)自定义 imageUrl 时，审核通过后其对应的图片编号
        private string imagePreviewUrl = "";            //(小程序)自定义 朋友圈的预览图链接，不填时默认使用当前游戏的画面截图
        private string imagePreviewUrlId = "";            //(小程序)自定义 自定义 imagePreviewUrl 时，审核通过后其对应的图片编号，详情请查看使用审核通过的转发图片
        private string path = "";            //(小程序)独立分包路径
        private string query = "";            //(小程序)自定义查询字符串，必须是 key1=val1&key2=val2 的格式
        private string channel = "";            //(小程序)自定义查询字符串，转发内容类型，为空字符串或者不传时，使用默认分享方式；详情请参考 ShareParam 说明
        private string extra = "";            //(小程序)自定义查询字符串，附加信息，仅当 channel 为 video 或 picture 时有效；详情请参考 ShareParam 说明
        private string templateId = "";            //(小程序)自定义查询字符串，分享素材模板ID，指定通过抖音开放平台审核通过的 templateId 来选择分享内容
        private int platform = DHSDKSharePlatform.Platform_None;   //分享平台，默认弹出列表框选择
        private int type = DHSDKShareType.shareType_link;          //分享类型，默认链接分享

        /** share title */
        public string Title { get { return title; } set { title = value; } }
        /** share description */
        public string Desc { get { return desc; } set { desc = value; } }
        /** share image */
        public string Image { get { return image; } set { image = value; } }
        /** share imageUrl */
        public string ImageUrl { get { return imageUrl; } set { imageUrl = value; } }
        /** share thumbimage local path */
        public string ThumbImage { get { return thumbImage; } set { thumbImage = value; } }
        /** share thumbimage url path */
        public string ThumbImageUrl { get { return thumbImageUrl; } set { thumbImageUrl = value; } }
        /** share link url string */
        public string LinkUrl { get { return linkUrl; } set { linkUrl = value; } }
        public string ImageUrlId { get { return imageUrlId; } set { imageUrlId = value; } }
        public string ImagePreviewUrl { get { return imagePreviewUrl; } set { imagePreviewUrl = value; } }
        public string ImagePreviewUrlId { get { return imagePreviewUrlId; } set { imagePreviewUrlId = value; } }
        public string Path { get { return path; } set { path = value; } }
        public string Query { get { return query; } set { query = value; } }
        public string Channel { get { return channel; } set { channel = value; } }
        public string Extra { get { return extra; } set { extra = value; } }
        public string TemplateId { get { return templateId; } set { templateId = value; } }
        /** share platform type */
        public int Platform { get { return platform; } set { platform = value; } }
        /** share type */
        public int Type { get { return type; } set { type = value; } }

        public string toJson()
        {
            Type t = typeof(DHSDKShareContent);
            FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);

            LitJson.JSONClass json = new LitJson.JSONClass();
            foreach (FieldInfo field in fields)
            {
                object obj = field.GetValue(this);
                if (obj != null && obj.ToString().Length > 0)
                    json.Add(field.Name, field.GetValue(this).ToString());
            }
            return json.ToString();
        }
    }
    #endregion

    #region sdk 初始化相关接口
    /**
	 * init DHUnionSDK 全平台
	 */
    public static void init(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		Run (delegate {
		mUnityCallback = callback;
		DHUnityHelperProxy.CallStatic ("init", mCallbackProxy);
		});

#elif UNITY_IPHONE
		Debug.Log ("ios SDK init+++");
		mUnityCallback = callback;
		initIosSDK(initCallback);
        initIosLogin();
		//mUnityCallback.onDHSDKResult (0, 0, "Init success");

#elif UNITY_SWITCH
        DHSwitchSDK.init(callback);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.init(callback);
#elif STEAMWORKS
        DHSteamSDK.init(callback);
#elif UNITY_PS4
        DHPSSDK.init(callback);
#elif WEGAME_SDK
        DHWeGameSDK.init(callback);
#elif MINIGAME_SDK
        mUnityCallback = callback;
        initMiniGameSDK(initCallback);
#elif UNITY_OPENHARMONY
        mUnityCallback = callback;
        DHHarmonySDK.init(callback);
#elif UWP_SDK
        DHUWPSDK.init(callback);
#elif H5_SDK
        mUnityCallback = callback;
        initH5SDK(initCallback);
#endif
    }
    /**
     * 设置主机平台相关参数
     */
    public static void setHostPlatformParam(string param)
    {
#if UNITY_SWITCH
        DHSwitchSDK.setHostPlatformParam(param);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.setHostPlatformParam(param);
#elif STEAMWORKS
        DHSteamSDK.setHostPlatformParam(param);
#elif UNITY_PS4
        DHPSSDK.setHostPlatformParam(param);
#elif WEGAME_SDK
        DHWeGameSDK.setHostPlatformParam(param);
#elif MINIGAME_SDK
        setMiniGameSDKParams(param);
#elif UWP_SDK
        DHUWPSDK.setHostPlatformParam(param);
#elif H5_SDK
        setH5SDKParams(param);
#endif
    }
    #endregion

    #region sdk 登录相关接口
    /**
	 * 登录
	 */
    public static void login(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		Run (delegate {
		mUnityCallback = callback;
		DHUnityHelperProxy.CallStatic ("login", mCallbackProxy);
		});

#elif UNITY_IPHONE
		initIosLogin();
		mUnityCallback = callback;
		login (loginCallback);

#elif UNITY_SWITCH
        DHSwitchSDK.login(callback);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.login(callback);
#elif STEAMWORKS
        DHSteamSDK.login(callback);
#elif UNITY_PS4
        DHPSSDK.login(callback);
#elif WEGAME_SDK
        DHWeGameSDK.login(callback);
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameLogin(loginCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.login();
#elif UWP_SDK
        DHUWPSDK.login(callback);
#elif H5_SDK
        mUnityCallback = callback;
        h5Login(loginCallback);
#endif
    }

    /**
	 * 创建获取用户信息按钮
	 */
    public static void createUserInfoButton(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameCreateUserInfoButton(param,createUserInfoButtonCallback);
#endif
    }

    /**
	 * 判断是否获取用户设置信息，包括头像，昵称等
	 */
    public static void getSetting(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGetSetting(getSettingCallback);
#endif
    }

    /**
	 * 获取用户设置信息，包括头像，昵称等
	 */
    public static void getUserInfo(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGetUserInfo(param,getUserInfoCallback);
#endif
    }

    /**
	 * 创建信息反馈按钮
	 */
    public static void createFeedbackButton(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameCreateFeedbackButton(param, createFeedbackCallback);
#endif
    }

    /**
	 * 信息反馈按钮操作
	 */
    public static void feedbackButtonAction(string param)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        miniGameFeedbackButtonAction(param);
#endif
    }

    /**
	 * 用户信息按钮操作
	 */
    public static void userInfoButtonAction(string param)
    {
#if UNITY_ANDROID
		
#elif UNITY_IPHONE
		
#elif MINIGAME_SDK
        miniGameUserInfoButtonAction(param);
#endif
    }

    /**
	 * 注销登录
	 */
    public static void logout(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("logout", mCallbackProxy);
        });

#elif UNITY_IPHONE
		initIosLogin();
		mUnityCallback = callback;
		logout (loginCallback);

#elif UNITY_SWITCH
        DHSwitchSDK.logout(callback);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.logout(callback);
#elif UNITY_PS4
        DHPSSDK.logout(callback);
#elif WEGAME_SDK
        DHWeGameSDK.logout(callback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.logout();
#elif UWP_SDK
        DHUWPSDK.logout(callback);
#elif H5_SDK
        mUnityCallback = callback;
        h5Logout(loginCallback);
#endif
    }

    /// <summary>
    /// 检测社交是否受限，目前只拿聊天限制判断，ugc限制未判断
    /// </summary>
    /// <returns></returns>
    public static int IsSocialLimit()
    {
#if UNITY_PS4
        return DHPSSDK.SCEIsSocialLimit();
#else
        return 0;
#endif
    }
    /// <summary>
    /// 更新黑名单
    /// </summary>
    public static void UpdateBlockedUserList()
    {
#if UNITY_PS4
        DHPSSDK.UpdateBlockedUserList();
#endif
    }

    public static bool IsUserBlocked(ulong accountId)
    {
#if UNITY_PS4
        return DHPSSDK.IsUserBlocked(accountId);
#else
        return false;
#endif
    }

#if UNITY_PS4
    // 这个函数只能ps平台使用
    public static int MsgDialogOpen(DHPSSDK.MsgDialogType eMsgDialogType, string kMsg, DHPSSDK.SysMsgType iSysMsgType)
    {
        return DHPSSDK.SCEMsgDialogOpen(eMsgDialogType, kMsg, (int)iSysMsgType);
    }
#endif

    //账号绑定(选接,如果开启电魂游客功能必接)
    public static void link(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("link", mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
		bindAccountWithList(bindAccountCallback);
#endif
    }

    /**
     * 游客绑定接口  只有国内或者海外游客登陆情况下才能调用
     * 
     * 有参数版本  指定绑定第账号渠道 例如facebook
     */
    public static void link(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("link", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
		bindSingleAccountWithParam(param, bindAccountCallback);
#endif
    }

    #endregion

    #region sdk 支付类接口
    /**
	 * query sku details.
	 * for ios, this function can query skus
	 * for android, this function will only return results for google, onestore channels
	 */
    public static void querySkus(List<string> skusList, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            LitJson.JSONArray json = new LitJson.JSONArray();

            foreach (string sku in skusList)
            {
                json.Add(sku);
            }
            DHUnityHelperProxy.CallStatic("querySkus", json.ToString(), mCallbackProxy);
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;

		string strs="[";
		if (skusList.Count>0){
			for (int i=0;i<skusList.Count;i++){
				string str = skusList[i];
				strs = strs +"\"" + str + "\"";
				if(i == skusList.Count-1){
					
				}
				else{
					strs = strs + ",";
				}
			}
		}
		strs = strs+"]";
		requireProducts (strs , productCallback);
#elif UNITY_SWITCH
        DHSwitchSDK.querySkus(skusList, callback);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.querySkus(callback);
#elif STEAMWORKS
        DHSteamSDK.querySkus(callback);
#elif UNITY_PS4
        DHPSSDK.querySkus(callback);
#endif
    }

    /**
	 * invoke pay function
	 */
    public static void pay(DHSDKPayInfo payInfo, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("pay", payInfo.toJson(), mCallbackProxy);
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;
		pay (payInfo.toJson (), payCallback);
#elif UNITY_SWITCH
        DHSwitchSDK.pay(payInfo.toJson(), callback);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.pay(payInfo.toJson(), callback);
#elif STEAMWORKS
        DHSteamSDK.pay(payInfo.toJson(), callback);
#elif UNITY_PS4
        DHPSSDK.pay(payInfo.toJson(), callback);
#elif WEGAME_SDK
        DHWeGameSDK.pay(payInfo.toJson(), callback);
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGamePay(payInfo.toJson(), payCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.pay(payInfo.toJson());
#elif UWP_SDK
        DHUWPSDK.pay(payInfo.toJson(), callback);
#elif H5_SDK
        mUnityCallback = callback;
        h5Pay(payInfo.toJson(), payCallback);
#endif
    }
    #endregion

    #region sdk 分享相关接口
    /**
	 * invoke share function
	 */
    public static void share(DHSDKShareContent content, IDHSDKUnityCallback callback)
    {
        /*
		 SDSDKShareContet
		 Share Link 参数
		 title (可选)
		 desc (可选)
		 thumbImage,thumbImageUrl(可选,二选一)
		 linkUrl(必选)
		 type = DHSDKShareType.shareType_link


         Share Image 参数
         desc(可选)
         image,imageUrl(必选,二选一)
         thumbImage,thumbImageUrl(可选,二选一)
         type = DHSDKShareType.shareType_image
		 */
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("share", content.toJson(), mCallbackProxy);
        });
#elif UNITY_IPHONE
        mUnityCallback = callback;

		share (content.toJson (),shareCallback);
#elif MINIGAME_SDK
        mUnityCallback = callback;
        miniGameShare(content.toJson(), shareCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.share(content.toJson());
#endif
    }
#endregion

#region sdk 其他接口

    public static void CheckNetworkAvailable(object callback)
    {
#if UNITY_PS4
        DHPSSDK.CheckNetworkAvailable(callback);
#endif
    }

    public static void exit(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("exit", mCallbackProxy);
        });
#elif UNITY_IPHONE

#elif MINIGAME_SDK
        miniGameExit();

#endif
    }

    public static void showFAQ(Dictionary<string, string> faqParams)
    {
        /*faqParams:
		 必传：
		 nick: 角色昵称
         level: 角色等级
         role_id:角色id

         非必传:
         token: 电魂sdk login接口 返回json数据中token字段值
         userid: 电魂sdk login接口 返回json数据中accountid字段值
		*/
#if UNITY_ANDROID
        Run(delegate {
            AndroidJavaObject map = dicToMap(faqParams);
            DHUnityHelperProxy.CallStatic("showFaqs", map);
        });
#elif UNITY_IPHONE
		LitJson.JSONClass json = new LitJson.JSONClass ();
		List<string> keysList = new List<string>(faqParams.Keys);
		if(keysList.Count>0){
			for(int i=0;i<keysList.Count;i++){
				string keyName = keysList[i];
				string keyValue = faqParams[keyName];
				json.Add(keyName,keyValue);
			}
		}
		string jsonString = json.ToString();
		openFAQ(jsonString);
#elif UNITY_OPENHARMONY
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(faqParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = faqParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        DHHarmonySDK.showFaqs(jsonString);
#endif
    }
    /*
     * 微信小游戏客服专用
     */
    public static void showFAQ(Dictionary<string, string> faqParams, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(faqParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = faqParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        mUnityCallback = callback;
        miniGameService(jsonString, serviceCallback);
#elif H5_SDK
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(faqParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = faqParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        h5showFAQ(jsonString);
#endif
    }

    public static void showSurvey(Dictionary<string, string> faqParams, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(faqParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = faqParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        mUnityCallback = callback;
        miniGameSurvey(jsonString, surveyCallback);
#endif
    }

    public static void gameRecord(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGameRecorderAction(param, gameRecordCallback);
#endif
    }

    public static void createGameRecordShareButton(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameCreateGameRecordShareButton(param, gameRecordShareCallback);
#endif
    }

    public static void gameRecordShareButtonAction(string param)
    {
#if MINIGAME_SDK
        miniGameGameRecordShareButtonAction(param);
#endif
    }

    public static void gameRecordShare(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGameRecordShare(param, gameRecordShareCallback);
#endif
    }

    public static void createGameClubButton(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameCreateGameClubButton(param, createGameClubButtonCallback);
#endif
    }

    public static void gameClubButtonAction(string param)
    {
#if MINIGAME_SDK
        miniGameGameClubButtonAction(param);
#endif
    }

    public static void gameClubShare(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGameClubShare(param, gameClubShareCallback);
#endif
    }

    public static void gameClubPushSeed(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGamePushSeed(param, gameClubPushSeedCallback);
#endif
    }

    public static void gameClubShowActivity(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameShowActivity(param, gameClubShowActivityCallback);
#endif
    }

    public static void gameClubGetData(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameGetGameClubData(param, gameClubGetDataCallback);
#endif
    }

    public static void videoChannelAction(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameChannelAction(param, channelActionCallback);
#endif
    }

    public static void subscribeAction(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameSubscribeAction(param, subscribeActionCallback);
#endif
    }

    public static void scene(string param, IDHSDKUnityCallback callback)
    {
#if MINIGAME_SDK
        mUnityCallback = callback;
        miniGameScene(param, sceneCallback);
#endif
    }
    /*
     * 订阅推送主题
     */
    public static void setAlias(string themeId)
    {
#if UNITY_ANDROID
        DHUnityHelperProxy.CallStatic("setAlias", themeId);
#elif UNITY_IPHONE
        setPushAlias(themeId);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.setAlias(themeId);
#endif
    }
    /*
     * 取消订阅推送主题
     */
    public static void delAlias(string themeId)
    {
#if UNITY_ANDROID
        DHUnityHelperProxy.CallStatic("delAlias", themeId);
#elif UNITY_IPHONE
        delPushAlias(themeId);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.delAlias(themeId);
#endif
    }
    
    /**
     * invoke openUserCenter function
     */
    public static void openUserCenter(string param)
    {
#if UNITY_ANDROID
        Run(delegate {
            DHUnityHelperProxy.CallStatic("openUserCenter", param);
        });
#elif UNITY_IPHONE
        openUserCenterView (param);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.openUserCenter(param);
#endif
    }
    /**
     * 查询sdk信息接口  所有需要向sdk查询的配置数据或者缓存数据都可以通过此接口查询 
     * 
     * 目前可查询值说明
     * key   说明  示例  使用平台
     * imei  android设备标志码  ios的key为idfa
     * orderId  支付订单号 (android ios key相同)
     * login_channelId  登录渠道id 示例 1085 (android ios key相同)
     * dh_channelId   渠道id  示例 1058  (android ios key相同)
     * dh_channelName 渠道名称  示例 dianhun 、baidu  (android key)
     * @return string 固定返回类型  接入方和开发人员确定返回内容  
     */
    public static string query(string key)
    {

        string value = "";
#if UNITY_ANDROID
        value = DHUnityHelperProxy.CallStatic<string>("query", key);
#elif UNITY_IPHONE
		value = queryInfo(key);
#elif STEAMWORKS
        value = DHSteamSDK.query(key);
#elif MINIGAME_SDK
        value = minigameQuery(key);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.query(key);
#elif H5_SDK
        value = h5Query(key);
#endif
        return value;
    }
    /**
 * 扩展接口
 */
    public static void exec(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("exec", param, mCallbackProxy);
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;
        execFunction(param,execCallback);
#elif UNITY_SWITCH
        DHSwitchSDK.exec(param, callback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.exec(param);
#elif UWP_SDK
        DHUWPSDK.exec(param, callback);
#elif H5_SDK
        h5Exec(param,execCallback);
#elif MINIGAME_SDK
        mUnityCallback = callback;
        var paramDic = LitJson.JSON.Parse (param);
        var eventType = paramDic["event_type"];
        if(eventType == "privacyAuthorize"){
            miniGamePrivacyAuthorize(privacyAuthorizeCallback);
        }
#endif
    }
    /**
     * 查询账号是否有绑定手机号接口
     * 返回数据格式json {"success":"2","bindTime":""}  success 状态码 info 提示信息
     */
    public static void queryBindPhone(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("queryBindPhone", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        checkBindPhone (param, checkBindPhoneCallback);
#elif WEGAME_SDK
        mUnityCallback = callback;
        DHWeGameSDK.queryBindPhone(param, mUnityCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.queryBindPhone(param);
#endif
    }

    /**
 * 查询账号是否有绑定密保手机号接口
 * 返回数据格式json {"success":"2","bindTime":""}  success 状态码 info 提示信息
 */
    public static void querySecurityBindPhone(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("querySecurityBindPhone", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        checkSecurityBindPhone (param, checkBindPhoneCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.querySecurityBindPhone(param);
#endif
    }
    /**
     * 发送短信接口
     * 
     * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
     */
    public static void sendSMS(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("sendSMS", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        sendSMSCode (param, sendSMSCodeCallback);
#elif WEGAME_SDK
        mUnityCallback = callback;
        DHWeGameSDK.sendSMS(param, mUnityCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.sendSMS(param);
#endif
    }

    /**
     * 账号绑定手机号接口
     * 
     * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
     */
    public static void bindPhone(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("bindPhone", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        bindPhoneNum (param, bindPhoneNumCallback);
#elif WEGAME_SDK
        mUnityCallback = callback;
        DHWeGameSDK.bindPhone(param,mUnityCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.bindPhone(param);
#endif
    }

    /**
 * 账号绑定密保手机号接口
 * 
 * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
 */
    public static void bindSecurityPhone(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("bindSecurityPhone", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        bindSecurityPhoneNum (param, bindPhoneNumCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.bindSecurityPhone(param);
#endif
    }
    /**
     * 打开账号绑定手机号界面
     * 
     * 返回数据格式json {"success":"2","info":""}  success 状态码 info 提示信息
     */
    public static void delegateBindPhone(string param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("delegateBindPhone", param, mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
        showBindPhoneNumView (param, bindPhoneNumCallback);
#elif WEGAME_SDK
        mUnityCallback = callback;
        DHWeGameSDK.showBindPhoneView(param, mUnityCallback);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.delegateBindPhone(param);
#endif
    }

    #endregion

    #region sdk 废弃接口
    //好友赠予(限海外游戏)
    [Obsolete("接口已废弃", false)]
    public static void gameInviteBestowal(Dictionary<string, string> data, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            AndroidJavaObject map = dicToMap(data);
            DHUnityHelperProxy.CallStatic("gameInviteBestowal", map, mCallbackProxy);
        });

#elif UNITY_IPHONE
#endif
    }
    /**
 * invoke trackUserID function
 */
    [Obsolete("接口已废弃", false)]
    public static void setTrackUserId(string userId)
    {
#if UNITY_ANDROID
        Run(delegate {
            DHUnityHelperProxy.CallStatic("setUid", userId);
        });
#elif UNITY_IPHONE
		configTrackUserId (userId);
#endif
    }
    /**
     * 可以使用SDK提供的基础工具类
     * 
     * 目前提供的工具方法type
     * type   说明  
     * battery  android电池电量百分比
     * language  当前系统语言
     * country  当前地区码
     * brand   设备品牌
     * model 设备型号
     * release 系统版本
     * netType 网络类型
     */
    [Obsolete("接口已废弃", false)]
    public static void tool(string type, IDHSDKUnityCallback callback)
    {

#if UNITY_ANDROID
        mUnityCallback = callback;
        DHUnityHelperProxy.CallStatic("tool", type, mCallbackProxy);
#elif UNITY_IPHONE
        mUnityCallback = callback;
        toolFunction(type,toolCallback);
#endif
    }
    [Obsolete("接口已废弃", false)]
    public static string toolExtend(string type, Dictionary<string, string> param, IDHSDKUnityCallback callback)
    {
        string value = "";
#if UNITY_ANDROID
        mUnityCallback = callback;
        AndroidJavaObject map = dicToMap(param);
        value = DHUnityHelperProxy.CallStatic<string>("toolExtend", type, map, mCallbackProxy);
#elif UNITY_IPHONE
        mUnityCallback = callback;
        LitJson.JSONClass json = new LitJson.JSONClass ();
        List<string> keysList = new List<string>(param.Keys);
        if(keysList.Count>0){
            for(int i=0;i<keysList.Count;i++){
                string keyName = keysList[i];
                string keyValue = param[keyName];
                json.Add(keyName,keyValue);
            }
        }
        string jsonString = json.ToString();
        value = toolExtendFunction (type,jsonString, toolCallback);
#endif
        return value;
    }

    /**
	 * hide personal center float ball
	 */
    [Obsolete("接口已废弃", false)]
    public static void hideFloat(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            DHUnityHelperProxy.CallStatic("hideFloat");
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;
		initIosLogin();
		hideFloat (loginCallback);
#endif
    }
    [Obsolete("接口已废弃", false)]
    public static void facebookFriends(String param, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("facebookFriends",param, mCallbackProxy);
        });

#elif UNITY_IPHONE
#endif
    }
    [Obsolete("接口已废弃，研发无需调用", false)]
    public static void openHeartBeat(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("openHeartBeat", mCallbackProxy);
        });

#elif UNITY_IPHONE
		startHeartBeat();
#endif
    }
    [Obsolete("接口已废弃，研发无需调用", false)]
    public static void closeHeartBeat()
    {
#if UNITY_ANDROID
        Run(delegate {
            DHUnityHelperProxy.CallStatic("closeHeartBeat");
        });
#elif UNITY_IPHONE
		stopHeartBeat();
#endif
    }
    [Obsolete("接口已废弃,请使用query接口查询", false)]
    public static void getChannelId(IDHSDKUnityCallback callback)
    {

#if UNITY_ANDROID
        //android requestCode no match code  here define  9
        //mUnityCallback.onDHSDKResult(9, DHSDKConst.RET_OK, String.valueOf(channelID));
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("requireChannelId", mCallbackProxy);
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;
		requireChannelId (channelIdCallback);
#endif
    }
    /***
     * 
     * 检查是否实名认证
     * 
     * 国内官方登陆、游客登录、包括qq、wechat授权登陆都可以检查是否实名认证   本接口不会对账号类型做检查
     * 
     *@return {"accountid":164639521,"account":"17681827653","token":"eaa5df647e382467fc09e9fbc87","accountview":"176***53","logintype":901,"isRealNameAuth":1,"isAdult":1,"timestamp":"1546149044","sign":"a79aa6ec0a66f1f1bd9b5d6bf6c391dc","region":1}
     */
    public static void checkRealName(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("checkRealName", mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
		checkRealName (checkRealNameCallback);
#endif
    }

    /***
     * 
     * 进行实名认证
     * 
     * 调用此接口前  可以调用检查实名认证接口做检查  此进行实名认证接口  如果没有实名认证的账号  会弹出实名认证窗体  检查是否实名认证接口没有弹出窗口逻辑
     * 
     * 国内官方登陆、包括qq、wechat授权登陆可以进行实名认证  本接口会做账号类型进行检查  游客模式不可以做实名认证   
     * 
     * @return {"accountid":164639521,"account":"","token":"eaa5df647e382467fc09e9fbc87","accountview":"","logintype":901,"isRealNameAuth":1,"isAdult":1,"timestamp":"1546149044","sign":"a79aa6ec0a66f1f1bd9b5d6bf6c391dc","region":1}
     */
    public static void realNameAuth(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            DHUnityHelperProxy.CallStatic("realNameAuth", mCallbackProxy);
        });

#elif UNITY_IPHONE
		mUnityCallback = callback;
		realNameAuth (realNameAuthCallback);
#endif
    }

    /**
     * 游客绑定接口  只有国内或者海外游客登陆情况下才能调用
     * 
     * 无参数版本  调用出来的是选择界面  一般接入方没有特别定制要求  默认国内 qq、wechat  海外facebook、google等
     * 
     *                
     * @return json {
                    "account": "1850866967",
                    "accountid": "1850866967",
                    "accountview": "",
                    "bindChannel": "",
                    "guestid": "",
                    "logintype": "LoginType_QQ",
                    "memo": "",
                    "mobileinfo": "",
                    "region": "1",
                    "sign": "",
                    "timestamp": "",
                    "token": "711ba034c1ca5fc8258cf6be15d"
                    }
     */
    /**
* show personal center float ball
*/
    public static void showFloat(IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            DHUnityHelperProxy.CallStatic("showFloat");
        });
#elif UNITY_IPHONE
		mUnityCallback = callback;
		initIosLogin();
		showFloat (loginCallback);
#endif
    }
#endregion

#region sdk 广告相关接口
    public static void playAd(Dictionary<string, string> adInfo, IDHSDKUnityCallback callback)
    {
#if UNITY_ANDROID
        Run(delegate {
            mUnityCallback = callback;
            AndroidJavaObject map = dicToMap(adInfo);
            DHUnityHelperProxy.CallStatic("playAd", map, mCallbackProxy);
        });

#elif UNITY_IPHONE
        mUnityCallback = callback;
        LitJson.JSONClass json = new LitJson.JSONClass ();
        List<string> keysList = new List<string>(adInfo.Keys);
        if(keysList.Count>0){
            for(int i=0;i<keysList.Count;i++){
                string keyName = keysList[i];
                string keyValue = adInfo[keyName];
                json.Add(keyName,keyValue);
            }
        }
        string jsonString = json.ToString();
        playAdvertisement (jsonString, playAdsCallback);
#elif UNITY_OPENHARMONY
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(adInfo.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = adInfo[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        string eventType = adInfo["event_type"];
        if (eventType == "couldPlayAd")
        {
            DHHarmonySDK.couldPlayAd(jsonString);
        }
        else if (eventType == "playAd")
        {
            DHHarmonySDK.playAd(jsonString);
        }
        
#elif MINIGAME_SDK
        mUnityCallback = callback;
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(adInfo.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = adInfo[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        string eventType = adInfo["event_type"];
        if(eventType == "createAd")
        {
            miniGameCreateAds(jsonString, playAdsCallback);
        }
        else if(eventType == "loadAd")
        {
            miniGameLoadAds(jsonString, playAdsCallback);
        }
        else if(eventType == "couldPlayAd")
        {
            miniGameCouldPlayAds(jsonString, playAdsCallback);
        }
        else if(eventType == "playAd")
        {
            miniGamePlayAds(jsonString, playAdsCallback);
        }

#endif
    }
#endregion

#region sdk 上报类接口
    //上报游戏角色信息接口，必接
    public static void setGameUserInfo(string type, string gameUserInfo)
    {
#if UNITY_ANDROID
		Run (delegate {
			DHUnityHelperProxy.CallStatic ("setGameUserInfo", type, gameUserInfo);
		});
#elif UNITY_IPHONE
        configGameUserInfo (type, gameUserInfo);
#elif UNITY_SWITCH
        DHSwitchSDK.setGameUserInfo(type, gameUserInfo);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.setGameUserInfo(type, gameUserInfo);
#elif UNITY_PS4
        DHPSSDK.setGameUserInfo(type, gameUserInfo);
#elif UNITY_OPENHARMONY
        DHHarmonySDK.setGameUserInfo(type, gameUserInfo);
#elif H5_SDK
        h5SetGameUserInfo(type, gameUserInfo);
#endif
    }
    /**
	 * oss数据打点
	 */
    public static void track(string eventName, Dictionary<string, string> eventParams)
    {
        /*eventName:
		login:登录
		signup：注册
		turtorial:新手教程
		levelup:等级提升
		pay:支付
		createRole:创建角色
		custom1:自定义事件1
		custom2:自定义事件2
		custom3:自定义事件3
		custom4:自定义事件4
		custom5:自定义事件5
		custom6:自定义事件6
		custom7:自定义事件7
		custom8:自定义事件8
		custom9:自定义事件9
		custom10:自定义事件10
        */

        /*eventParams:
		ios: 
		level:等级
		revenue:价格
		orderId:订单id
		productId:苹果商品id
		currency:货币单位
		virtualCurrency:游戏内虚拟货币单位
		paymentType:支付类型(如苹果官方支付)

		android:
		revenue:价格
		currency:货币单位
		contentId:商品id
		contentType:商品名
		memo:自定义备注
		*/
#if UNITY_ANDROID
        AndroidJavaObject map = dicToMap(eventParams);
        Run(delegate {
            DHUnityHelperProxy.CallStatic("track", eventName, map);
        });
#elif UNITY_OPENHARMONY
        string jsonString = "{}";
        if (eventParams != null)
        {
            LitJson.JSONClass json = new LitJson.JSONClass();
            List<string> keysList = new List<string>(eventParams.Keys);
            if (keysList.Count > 0)
            {
                for (int i = 0; i < keysList.Count; i++)
                {
                    string keyName = keysList[i];
                    string keyValue = eventParams[keyName];
                    json.Add(keyName, keyValue);
                }
            }
            jsonString = json.ToString();
        }
        DHHarmonySDK.track(eventName, jsonString);
#elif UNITY_IPHONE
        if (eventParams == null){
            string jsonString = "{}";
            trackData (eventName,jsonString);
        }
        else{
		LitJson.JSONClass json = new LitJson.JSONClass ();
		List<string> keysList = new List<string>(eventParams.Keys);
		if(keysList.Count>0){
			for(int i=0;i<keysList.Count;i++){
				string keyName = keysList[i];
				string keyValue = eventParams[keyName];
				json.Add(keyName,keyValue);
			}
		}
		string jsonString = json.ToString();
		trackData (eventName,jsonString);
    }
#elif UNITY_SWITCH
        DHSwitchSDK.track(eventName, eventParams);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.track(eventName, eventParams);
#elif STEAMWORKS
        DHSteamSDK.track(eventName, eventParams);
#elif UNITY_PS4
        DHPSSDK.track(eventName, eventParams);
#elif WEGAME_SDK
        DHWeGameSDK.track(eventName, eventParams);
#elif MINIGAME_SDK
        if (eventParams == null)
        {
            string jsonString = "{}";
            ossDataUpload(eventName, jsonString);
        }
        else
        {
            LitJson.JSONClass json = new LitJson.JSONClass();
            List<string> keysList = new List<string>(eventParams.Keys);
            if (keysList.Count > 0)
            {
                for (int i = 0; i < keysList.Count; i++)
                {
                    string keyName = keysList[i];
                    string keyValue = eventParams[keyName];
                    json.Add(keyName, keyValue);
                }
            }
            string jsonString = json.ToString();
            ossDataUpload(eventName, jsonString);
        }
#elif H5_SDK
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(eventParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = eventParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        h5Track(eventName, jsonString);
#endif
        }

    /**
	 * invoke track function
	 */
    public static void log(string eventId, Dictionary<string, string> logParams)
    {
        /*eventId:
          110000::GAME_CLIENT_LAUNCH
          120000::SDK_CLIENT_LAUNCH
          210000::GAME_CLIENT_INIT
          220000::SDK_CLIENT_INIT
          310000::GAME_CLIENT_UPDATE
          410000::GAME_CLIENT_LOGIN
          420000::GAME_SERVER_LOGIN
          430000::SDK_CLIENT_LOGINs
          440000::SDK_SERVER_LOGIN
          510000::GAME_CLIENT_PAY
          520000::GAME_SERVER_PAY
          530000::SDK_CLIENT_PAY
          540000::SDK_SERFVER_PAY  

          自定义事件id说明：
          数字编号 + 接入方标识（大写） + 事件名称（大写）

        */

        /*logParams:
         * 格式 hashmap  所有字段值都是string类型 
		基础数据字段：
		"log": "",  // 具体日志内容 需要base64
		"log_level": "e",  // 日志级别  普通信息记录使用d字符  异常信息记录请使用e字符
		"event_id": "000000:SDK_CLIENT_CRASH",   // 事件id  一些流程提供了固定字段  游戏和服务端可以自定义  自定义格式请参考事件id说明 
		"sub_event_type": "10000",  // 子事件id  默认0

		附加数据字段：
		此字段有数据则上传 之后每次上传必须附加
		"account_id": "174719903",  //电魂账号id  
		"role_id": "171830",      // 角色id  

		*/
#if UNITY_ANDROID
        Run(delegate {
            AndroidJavaObject map = dicToMap(logParams);
            DHUnityHelperProxy.CallStatic("log", eventId, map);
        });
#elif UNITY_IPHONE
		LitJson.JSONClass json = new LitJson.JSONClass ();
		List<string> keysList = new List<string>(logParams.Keys);
		if(keysList.Count>0){
			for(int i=0;i<keysList.Count;i++){
				string keyName = keysList[i];
				string keyValue = logParams[keyName];
				json.Add(keyName,keyValue);
			}
		}
		string jsonString = json.ToString();
		uploadLog (eventId,jsonString);
#elif UNITY_OPENHARMONY
        string jsonString = "{}";
        if (logParams != null)
        {
            LitJson.JSONClass json = new LitJson.JSONClass();
            List<string> keysList = new List<string>(logParams.Keys);
            if (keysList.Count > 0)
            {
                for (int i = 0; i < keysList.Count; i++)
                {
                    string keyName = keysList[i];
                    string keyValue = logParams[keyName];
                    json.Add(keyName, keyValue);
                }
            }
            jsonString = json.ToString();
        }
        DHHarmonySDK.track(eventId, jsonString);
#elif UNITY_SWITCH
        DHSwitchSDK.log(eventId, logParams);
#elif USE_MS_GAMECORE
        DHXboxOneSDK.log(eventId, logParams);
#elif STEAMWORKS
        DHSteamSDK.log(eventId, logParams);
#elif UNITY_PS4
        DHPSSDK.log(eventId, logParams);
#elif WEGAME_SDK
        DHWeGameSDK.log(eventId, logParams);
#elif MINIGAME_SDK
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(logParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = logParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        logUpload(eventId, jsonString);
#endif
    }

#if MINIGAME_SDK
    /**
    * invoke reyun track function
    */
    public static void reyunUpload(string eventId, Dictionary<string, string> logParams)
    {
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(logParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = logParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        reyunUpload(eventId, jsonString);
    }

    /**
    * invoke reyun track function
    */
    public static void gameRoleInfoUpload(Dictionary<string, string> logParams)
    {
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(logParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = logParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        roleInfoUpload(jsonString);
    }

    /**
    * invoke reyun track function
    */
    public static void payInfoUpload(Dictionary<string, string> logParams)
    {
        LitJson.JSONClass json = new LitJson.JSONClass();
        List<string> keysList = new List<string>(logParams.Keys);
        if (keysList.Count > 0)
        {
            for (int i = 0; i < keysList.Count; i++)
            {
                string keyName = keysList[i];
                string keyValue = logParams[keyName];
                json.Add(keyName, keyValue);
            }
        }
        string jsonString = json.ToString();
        payInfoUpload(jsonString);
    }
#endif
#endregion

#region sdk 主机额外接口

    public static bool isNetworkAvailable()
    {
#if UNITY_SWITCH
        return DHSwitchSDK.isSwitchNetworkAvailable();
#else
        return true;
#endif
    }

    public static int unlockTrophy(int iTrophyId)
    {
#if UNITY_PS4
        /**
         * 返回值说明
         * 2153059852 已解锁
         * 0 解锁成功
         * 小于0 解锁失败
        */
        return DHPSSDK.unlockTrophy(iTrophyId);
#else
        return 0;
#endif
    }
    public static bool getParentalControl()
    {
#if UNITY_SWITCH
        return DHSwitchSDK.getSwitchParentalControl();
#else
        return true;
#endif
    }

    public static bool getParentalControlForTry()
    {
#if UNITY_SWITCH
        return DHSwitchSDK.TryBeginSwitchFreeCommunication();
#else
        return true;
#endif
    }

    public static string checkShieldingString(string checkText, bool isOnCharacter)
    {
#if UNITY_SWITCH
        return DHSwitchSDK.CheckShieldingString(checkText, isOnCharacter);
#else
        return checkText;
#endif
    }

    public static void showApplicationError(uint number, string dialogViewMessage, string fullScreenViewMessage)
    {
#if UNITY_SWITCH
        DHSwitchSDK.ShowSwitchApplicationError(number, dialogViewMessage, fullScreenViewMessage);
#endif
    }
    public static void inviteFriend()
    {
#if USE_MS_GAMECORE
        DHXboxOneSDK.inviteFriend();
#endif
    }

    public static void invitePsFriend(ulong psAccountId)
    {
#if UNITY_PS4
        DHPSSDK.invitePsFriend(psAccountId);
#endif
    }

    public static void inviteFriendByMaxCount(int maxCount)
    {
#if UNITY_PS4
        DHPSSDK.inviteFriend(maxCount);
#endif
    }

    public static void createLobby(string createLobbyJson = "")
    {
#if USE_MS_GAMECORE
        DHXboxOneSDK.createLobby();
#elif UNITY_PS4
        DHPSSDK.createLobby(createLobbyJson);
#endif
    }

    public static void leaveLobby()
    {
#if USE_MS_GAMECORE
        DHXboxOneSDK.leaveLobby();
#elif UNITY_PS4
        DHPSSDK.leaveLobby();
#endif
    }

    public static void joinFrinedLobby(string userId)
    {
#if USE_MS_GAMECORE
        DHXboxOneSDK.joinFriendTeam(userId);
#endif
    }

    public static void joinFriendLobbyByInvited()
    {
#if USE_MS_GAMECORE
        DHXboxOneSDK.joinFriendTeamByInvited();
#elif UNITY_PS4
        DHPSSDK.joinFriendTeam();
#endif
    }

    public static void setNintendoEnvironment(string environment)
    {
#if UNITY_SWITCH
        DHSwitchSDK.setNintendoEnvironment(environment);
#endif
    }
#endregion

#region  v2 版本参数处理

/*
public static string transV2param(string param, List<string> paramList, List<string> orignParamList)
    {
        string result = param;
        if(param == null){
            return result;
        }
        var paramDic = LitJson.JSON.Parse (param);
        if(paramDic == null){
            return result;
        }
        
        if(paramList!=null&&paramList.Count>0){
            LitJson.JSONClass resultJson = new LitJson.JSONClass ();
            List<string> keysList = new List<string>(paramDic.Keys);
            if(keysList.Count>0){
                for(int i=0;i<keysList.Count;i++){
                    string keyName = keysList[i];
                    string keyValue = paramDic[keyName];
                    resultJson.Add(keyName,keyValue);
                }
            }

            for(int i=0;i<paramList.Count;i++){
                string keyName = paramList[i];
                string keyValue = paramDic[keyName];
                if(keyValue!=null&&keyValue.ToString().Length>0){
                    string oriKeyListStr = orignParamList[i];
                    var oriKeyList = LitJson.JSON.Parse(oriKeyListStr);
                    for(int j=0;j<oriKeyList.Count;j++){
                        string oriKey = oriKeyList[j];
                        string oriValue = paramDic[oriKey];
                        if(oriValue!=null&&oriValue.ToString().Length>0){

                        }
                        else{
                            resultJson.Add(oriKey,keyValue);
                        }
                    }
                }
                
            }
            result = resultJson.ToString();
        }
        return result;
    }
*/
#endregion

#if UNITY_ANDROID
#elif UNITY_IPHONE
	public delegate void PayDelegate (int stCode,string payCallBackJson);

	public delegate void ProductDelegate (int stCode,string productCallBackJson);

    // ios init delegate
    public delegate void InitDelegate (int stCode,string initCallBackJson);

	// ios login delegate
	public delegate void LoginDelegate (int stCode,string loginCallBackJson);


	// ios get device info delegate
	public delegate void GetDeviceInfoDelegate (int stCode,string getDeviceInfoCallBackJson);

	//ios share delegate
	public delegate void ShareDelegate (int stCode,string shareCallBackJson);

	//ios channelId delegate
	public delegate void ChannelIdDelegate (int stCode,string channelIdCallBackJson);

	//ios realNameAuth delegate
	public delegate void RealNameAuthDelegate (int stCode,string realNameAuthCallBackJson);

	//ios checkRealName delegate
	public delegate void CheckRealNameDelegate (int stCode,string checkRealNameCallBackJson);
    
    //ios checkBindPhone delegate
    public delegate void CheckBindPhoneDelegate (int stCode,string checkBindPhoneCallBackJson);

    //ios sendSMSCode delegate
    public delegate void SendSMSCodeDelegate (int stCode,string sendSMSCodeCallBackJson);

    //ios bindPhoneNum delegate
    public delegate void BindPhoneNumDelegate (int stCode,string bindPhoneNumCallBackJson);

	//ios bindAccount delegate
	public delegate void BindAccountDelegate (int stCode,string bindAccountCallBackJson);

    //ios bindAccount delegate
    public delegate void PlayAdsDelegate (int stCode,string  playAdsCallBackJson);

    //ios toolFunction delegate
    public delegate void ToolDelegate (int stCode,string  toolCallBackJson);

    //ios execFunction delegate
    public delegate void ExecDelegate (int stCode,string  execCallBackJson);


    [AOT.MonoPInvokeCallback (typeof(InitDelegate))]
    static void initCallback (int stCode, string initCallBackJson)
    {
        Debug.Log ("initCallBack+++ initCallBackJson"+initCallBackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // init failed
                mUnityCallback.onDHSDKResult (0, 1, initCallBackJson);
            } else if (stCode == 1) { // init success
                mUnityCallback.onDHSDKResult (0, 0, initCallBackJson);
            }
        } else {
            mUnityCallback.onDHSDKResult (0, 1, initCallBackJson);
        }
    }

	[AOT.MonoPInvokeCallback (typeof(LoginDelegate))]
	static void loginCallback (int stCode, string loginCallBackJson)
	{
		Debug.Log ("loginCallBack+++ loginCallBackJson"+loginCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // login failed
				mUnityCallback.onDHSDKResult (1, 1, loginCallBackJson);
			} else if (stCode == 1) { // login success
				mUnityCallback.onDHSDKResult (1, 0, loginCallBackJson);
			} else if (stCode == 2) { //  logout 
				mUnityCallback.onDHSDKResult (4, 0, loginCallBackJson);
			} else if (stCode == 3) { //  防沉迷通知    
				mUnityCallback.onDHSDKResult (32, 0, loginCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (1, 1, loginCallBackJson);
		}
	}

	[AOT.MonoPInvokeCallback (typeof(PayDelegate))]
	static void payCallback (int stCode, string payCallBackJson)
	{
		Debug.Log ("payCallBack+++ payCallBackJson"+payCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { //pay failed
				mUnityCallback.onDHSDKResult (2, 1, payCallBackJson);
			} else if (stCode == 1) {// appstore sdk callback
				mUnityCallback.onDHSDKResult (2, 0, payCallBackJson);
			}
			else if (stCode == 2) {//alipay sdk callback
				mUnityCallback.onDHSDKResult (2, 0, payCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (2, 1, payCallBackJson);
		}
		//		if (mPayListener != null) {
		//			if (stCode == 0) {
		//				var root = LitJson.JSON.Parse (payCallBackJson);
		//				if (root != null) {
		//					IosError err = new IosError ();
		//					err.errCode = root ["errCode"].AsInt;
		//					err.errMsg = root ["errMsg"].ToString ();
		//					mPayListener.OnFailure (err.errCode, err.errMsg);
		//				} else {
		//					mPayListener.OnFailure (-99, "json pass exp,fail");
		//				}
		//			} else if (stCode == 1) { // appstore sdk callback
		//				var root = LitJson.JSON.Parse (payCallBackJson);
		//				if (root != null) {
		//					IosPayCallBackInfo payBackInfo = new IosPayCallBackInfo ();
		//					payBackInfo.code = root ["code"].AsInt;
		//					payBackInfo.payCallBackInfo = root ["pbInfo"].ToString ();
		//					//									Debug.Log("pbInfo -->> "+ payBackInfo.payCallBackInfo);
		//					TransactionInfo iosTransactionInfo = new TransactionInfo ();
		//					if (payBackInfo.payCallBackInfo != null && payBackInfo.payCallBackInfo.Length > 0) {
		//						var transactionJson = LitJson.JSON.Parse (payBackInfo.payCallBackInfo);
		//						iosTransactionInfo.errCode = transactionJson ["errCode"].AsInt;
		//						iosTransactionInfo.errMsg = transactionJson ["errMsg"].ToString ();
		//						iosTransactionInfo.purchaseTransactionId = transactionJson ["purchaseTransactionId"].ToString ();
		//						iosTransactionInfo.purchaseTransactionReceipt = transactionJson ["purchaseTransactionReceipt"].ToString ();
		//						iosTransactionInfo.purchaseProductPrice = transactionJson ["purchaseProductPrice"].ToString ();
		//						iosTransactionInfo.purchaseTransactionDate = transactionJson ["purchaseProductPrice"].AsLong;
		//					}
		//					mPayListener.OnSuccess ((PayCallBackType)(payBackInfo.code), iosTransactionInfo);
		//
		//				} else {
		//					mPayListener.OnFailure (-99, "json pass exp,fail");
		//				}
		//			} else if (stCode == 2) {//alipay sdk callback
		//				var root = LitJson.JSON.Parse (payCallBackJson);
		//				if (root != null) {
		//					mPayListener.OnSuccess ((PayCallBackType)root ["code"].AsInt, null);
		//				} else {
		//					mPayListener.OnFailure (-99, "json pass exp,fail");
		//				}
		//			}
		//		}
	}

	[AOT.MonoPInvokeCallback (typeof(ProductDelegate))]
	static void productCallback (int stCode, string productCallBackJson)
	{
		Debug.Log ("productCallBack+++ productCallBackJson"+productCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // product failed
				mUnityCallback.onDHSDKResult (20, 1, productCallBackJson);
			} else if (stCode == 1) { // product success
				mUnityCallback.onDHSDKResult (20, 0, productCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (20, 1, productCallBackJson);
		}
	}

	[AOT.MonoPInvokeCallback (typeof(ShareDelegate))]
	static void shareCallback (int stCode, string shareCallBackJson)
	{
		Debug.Log ("shareCallBack+++ shareCallBackJson"+shareCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // share failed
				mUnityCallback.onDHSDKResult (5, 1, shareCallBackJson);
			} else if (stCode == 1) { // share success
				mUnityCallback.onDHSDKResult (5, 0, shareCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (5, 1, shareCallBackJson);
		}
	}

	[AOT.MonoPInvokeCallback (typeof(ChannelIdDelegate))]
	static void channelIdCallback (int stCode, string channelIdCallBackJson)
	{
		Debug.Log ("channelIdCallBack+++ channelIdCallBackJson"+channelIdCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // share failed
				mUnityCallback.onDHSDKResult (6, 1, channelIdCallBackJson);
			} else if (stCode == 1) { // share success
				mUnityCallback.onDHSDKResult (6, 0, channelIdCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (6, 1, channelIdCallBackJson);
		}
	}


	[AOT.MonoPInvokeCallback (typeof(RealNameAuthDelegate))]
	static void realNameAuthCallback (int stCode, string realNameAuthCallBackJson)
	{
		Debug.Log ("realNameAuthCallBack+++ realNameAuthCallBackJson"+realNameAuthCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // realName failed
				mUnityCallback.onDHSDKResult (22, 1, realNameAuthCallBackJson);
			} else if (stCode == 1) { // realName success
				mUnityCallback.onDHSDKResult (22, 0, realNameAuthCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (22, 1, realNameAuthCallBackJson);
		}
	}

	[AOT.MonoPInvokeCallback (typeof(CheckRealNameDelegate))]
	static void checkRealNameCallback (int stCode, string checkRealNameCallBackJson)
	{
		Debug.Log ("checkRealNameCallBack+++ checkRealNameCallBackJson"+checkRealNameCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // checkRealName failed
				mUnityCallback.onDHSDKResult (31, 1, checkRealNameCallBackJson);
			} else if (stCode == 1) { // checkRealName success
				mUnityCallback.onDHSDKResult (31, 0, checkRealNameCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (31, 1, checkRealNameCallBackJson);
		}
	}

    [AOT.MonoPInvokeCallback (typeof(CheckBindPhoneDelegate))]
    static void checkBindPhoneCallback (int stCode, string checkBindPhoneCallBackJson)
    {
        Debug.Log ("checkBindPhoneCallBack+++ checkBindPhoneCallBackJson"+checkBindPhoneCallBackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // checkBindPhone failed
                mUnityCallback.onDHSDKResult (101, 1, checkBindPhoneCallBackJson);
            } else if (stCode == 1) { // checkBindPhone success
                mUnityCallback.onDHSDKResult (101, 0, checkBindPhoneCallBackJson);
            } else if (stCode == 3) { // checkBindPhone success
                mUnityCallback.onDHSDKResult (107, 0, checkBindPhoneCallBackJson);
            }

        } else {
                mUnityCallback.onDHSDKResult (101, 1, checkBindPhoneCallBackJson);
        }
    }

    [AOT.MonoPInvokeCallback (typeof(SendSMSCodeDelegate))]
    static void sendSMSCodeCallback (int stCode, string sendSMSCodeCallBackJson)
    {
        Debug.Log ("sendSMSCodeCallBack+++ sendSMSCodeCallBackJson"+sendSMSCodeCallBackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // sendSMS failed
                mUnityCallback.onDHSDKResult (102, 1, sendSMSCodeCallBackJson);
            } else if (stCode == 1) { // sendSMS success
                mUnityCallback.onDHSDKResult (102, 0, sendSMSCodeCallBackJson);
            }
        } else {
            mUnityCallback.onDHSDKResult (102, 1, sendSMSCodeCallBackJson);
        }
    }
   
    [AOT.MonoPInvokeCallback (typeof(BindPhoneNumDelegate))]
    static void bindPhoneNumCallback (int stCode, string bindPhoneNumCallBackJson)
    {
        Debug.Log ("bindPhoneNumCallBack+++ bindPhoneNumCallBackJson"+bindPhoneNumCallBackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // bindPhoneNum failed
                mUnityCallback.onDHSDKResult (103, 1, bindPhoneNumCallBackJson);
            } else if (stCode == 1) { // bindPhoneNum success
                mUnityCallback.onDHSDKResult (103, 0, bindPhoneNumCallBackJson);
            }
            else if (stCode == 2){
                mUnityCallback.onDHSDKResult (106, 1, bindPhoneNumCallBackJson);
            }
            else if (stCode == 3){
                mUnityCallback.onDHSDKResult (106, 0, bindPhoneNumCallBackJson);
            }

        } else {
            mUnityCallback.onDHSDKResult (103, 1, bindPhoneNumCallBackJson);
        }
    }

	[AOT.MonoPInvokeCallback (typeof(BindAccountDelegate))]
	static void bindAccountCallback (int stCode, string bindAccountCallBackJson)
	{
		Debug.Log ("bindAccountCallBack+++ bindAccountCallBackJson"+bindAccountCallBackJson+"code"+stCode);
		if (mUnityCallback != null) {
			if (stCode == 0) { // bindAccount failed
				mUnityCallback.onDHSDKResult (23, 1, bindAccountCallBackJson);
			} else if (stCode == 1) { // bindAccount success
				mUnityCallback.onDHSDKResult (23, 0, bindAccountCallBackJson);
			}
		} else {
			mUnityCallback.onDHSDKResult (23, 1, bindAccountCallBackJson);
		}
	}

    [AOT.MonoPInvokeCallback (typeof(PlayAdsDelegate))]
    static void playAdsCallback (int stCode, string playAdsCallbackJson)
    {
        Debug.Log ("playAdsCallBack+++ playAdsCallBackJson"+playAdsCallbackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // playAds failed
                mUnityCallback.onDHSDKResult (7, 1, playAdsCallbackJson);
            } else if (stCode == 1) { // playAds success
                mUnityCallback.onDHSDKResult (7, 0, playAdsCallbackJson);
            }
            else if (stCode == 2) { // couldPlayAds failed
                mUnityCallback.onDHSDKResult (25, 1, playAdsCallbackJson);
            }
            else if (stCode == 3) { // couldPlayAds success
                mUnityCallback.onDHSDKResult (25, 0, playAdsCallbackJson);
            }
        } else {
            mUnityCallback.onDHSDKResult (7, 1, playAdsCallbackJson);
            mUnityCallback.onDHSDKResult (25, 1, playAdsCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback (typeof(ToolDelegate))]
    static void toolCallback (int stCode, string toolCallbackJson)
    {
        Debug.Log ("toolCallBack+++ toolCallBackJson"+toolCallbackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // tool failed
                mUnityCallback.onDHSDKResult (104, 1, toolCallbackJson);
            } else if (stCode == 1) { // tool success
                mUnityCallback.onDHSDKResult (104, 0, toolCallbackJson);
            }
        } else {
            mUnityCallback.onDHSDKResult (104, 1, toolCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback (typeof(ExecDelegate))]
    static void execCallback (int stCode, string execCallbackJson)
    {
        Debug.Log ("execCallBack+++ execCallBackJson"+execCallbackJson+"code"+stCode);
        if (mUnityCallback != null) {
            if (stCode == 0) { // exec failed
                mUnityCallback.onDHSDKResult (99, 1, execCallbackJson);
            } else if (stCode == 1) { // exec success
                mUnityCallback.onDHSDKResult (99, 0, execCallbackJson);
            } else if (stCode == 2) { //  logout 
                mUnityCallback.onDHSDKResult (4, 0, execCallbackJson);
            }
        } else {
            mUnityCallback.onDHSDKResult (99, 1, execCallbackJson);
        }
    }

	public class IosError
	{
		public int errCode{ get; set; }

		public string errMsg{ get; set; }
	}

	public class TransactionInfo : IosError
	{
		public string purchaseTransactionId{ get; set; }

		public string purchaseTransactionReceipt{ get; set; }

		public string purchaseProductPrice{ get; set; }

		public long purchaseTransactionDate{ get; set; }
	}

	/**************************** ios-API-Begin ******************************************/

	[DllImport ("__Internal")]
	static extern void initIosLoginSDK (int appId,string kdkey, string regCode,string loginMainChannel,string loginSecondChannel, bool isShowTourist, bool isShowTjl,bool isTestSdk);

	[DllImport ("__Internal")]
	static extern void initIosSDK (InitDelegate initDelegate);

    [DllImport ("__Internal")]
    static extern void initIosLogin ();

	[DllImport ("__Internal")]
	static extern void initIosPaySDK (string appId, string appVersion, string areaId);

	[DllImport ("__Internal")]
	static extern void initIosChannel (string mainChannel, string secoChannel);

	[DllImport ("__Internal")]
	static extern void setIosDebug (bool isDebug);

	[DllImport ("__Internal")]
	static extern void setIosPaySDKTest (bool isPayTest);

	[DllImport ("__Internal")]
	static extern void login (LoginDelegate loginDelegate);

	[DllImport ("__Internal")]
	static extern void logout (LoginDelegate loginDelegate);

	[DllImport ("__Internal")]
	static extern void showFloat (LoginDelegate loginDelegate);

	[DllImport ("__Internal")]
	static extern void hideFloat (LoginDelegate loginDelegate);

	[DllImport ("__Internal")]
	static extern void requireProducts (string productIds , ProductDelegate productDelegate);

	[DllImport ("__Internal")]
	static extern void requireChannelId (ChannelIdDelegate channelIdDelegate);

	[DllImport ("__Internal")]
	static extern void configTrackUserId (string userId);

	[DllImport ("__Internal")]
	static extern void trackData (string eventName,string eventParams);

	[DllImport ("__Internal")]
	static extern void uploadLog (string eventId,string logParams);

	[DllImport ("__Internal")]
	static extern void share (string shareContent, ShareDelegate shareDelegate);

	[DllImport ("__Internal")]
	static extern void pay (string payInfo, PayDelegate payDelegate);

	[DllImport ("__Internal")]
	static extern void getDeviceInfo (GetDeviceInfoDelegate getDeviceInfoDelegate);

	[DllImport ("__Internal")]
	static extern string queryInfo (string key);

	[DllImport ("__Internal")]
	static extern void realNameAuth (RealNameAuthDelegate realNameAuthDelegate);

	[DllImport ("__Internal")]
	static extern void checkRealName (CheckRealNameDelegate checkRealNameDelegate);

    [DllImport ("__Internal")]
    static extern void configGameUserInfo (string type, string userinfoParams);

    [DllImport ("__Internal")]
    static extern void checkBindPhone (string parameters , CheckBindPhoneDelegate checkBindPhoneDelegate);

    [DllImport ("__Internal")]
    static extern void checkSecurityBindPhone (string parameters , CheckBindPhoneDelegate checkBindPhoneDelegate);

    [DllImport ("__Internal")]
    static extern void sendSMSCode (string parameters , SendSMSCodeDelegate sendSMSCodeDelegate);

    [DllImport ("__Internal")]
    static extern void bindPhoneNum (string parameters , BindPhoneNumDelegate bindPhoneNumDelegate);

    [DllImport ("__Internal")]
    static extern void bindSecurityPhoneNum (string parameters , BindPhoneNumDelegate bindPhoneNumDelegate);

    [DllImport ("__Internal")]
    static extern void showBindPhoneNumView (string parameters , BindPhoneNumDelegate bindPhoneNumDelegate);

	[DllImport ("__Internal")]
	static extern void bindAccountWithList (BindAccountDelegate bindAccountDelegate);

	[DllImport ("__Internal")]
	static extern void bindSingleAccountWithParam (string param, BindAccountDelegate bindAccountDelegate);

    [DllImport ("__Internal")]
    static extern void openUserCenterView (string parameters);

	[DllImport ("__Internal")]
	static extern void openFAQ (string parameters);

    [DllImport ("__Internal")]
    static extern void setPushAlias (string alias);

    [DllImport ("__Internal")]
    static extern void delPushAlias (string alias);

	[DllImport ("__Internal")]
	static extern void startHeartBeat ();

	[DllImport ("__Internal")]
	static extern void stopHeartBeat ();

    [DllImport ("__Internal")]
    static extern void playAdvertisement (string param, PlayAdsDelegate playAdsDelegate);

    [DllImport ("__Internal")]
    static extern string toolFunction (string type, ToolDelegate toolDelegate);

    [DllImport ("__Internal")]
    static extern string toolExtendFunction (string type, string content, ToolDelegate toolDelegate);

    [DllImport ("__Internal")]
    static extern void execFunction (string param, ExecDelegate execDelegate);


	/**************************** ios-API-End ******************************************/
#elif MINIGAME_SDK
    //minigame login callback
    public delegate void LoginDelegate (string stCode,string payCallBackJson);

    // minigame init delegate
    public delegate void InitDelegate(string stCode, string initCallBackJson);

    // minigame createUserInfoButton delegate
    public delegate void CreateUserInfoButtonDelegate(string stCode, string createCallBackJson);

    // minigame getSetting delegate
    public delegate void GetSettingDelegate(string stCode, string getSettingCallBackJson);

    // minigame getUserInfo delegate
    public delegate void GetUserInfoDelegate(string stCode, string getUserInfoCallBackJson);

    //minigame pay delegate
    public delegate void PayDelegate(string stCode, string payCallBackJson);

    //minigame ads delegate
    public delegate void PlayAdsDelegate(string stCode, string playAdsCallBackJson);

    //minigame createFeedbutton delegate
    public delegate void CreateFeedbackButtonDelegate(string stCode, string createFeedbackButtonCallBackJson);

    //minigame service delegate
    public delegate void ServiceDelegate(string stCode, string serviceCallBackJson);

    //minigame survey delegate
    public delegate void SurveyDelegate(string stCode, string surveyCallBackJson);

    //minigame share delegate
    public delegate void ShareDelegate(string stCode, string shareCallBackJson);

    //minigame game record delegate
    public delegate void GameRecordDelegate(string stCode, string gameRecordCallBackJson);

    //minigame game record share delegate
    public delegate void GameRecordShareDelegate(string stCode, string gameRecordShareCallBackJson);
    
    //minigame create game club button delegate
    public delegate void CreateGameClubButtonDelegate(string stCode, string createGameClubButtonCallBackJson);

    //minigame game club share delegate
    public delegate void GameClubShareDelegate(string stCode, string gameClubShareCallBackJson);

    //minigame game club push seed delegate
    public delegate void GameClubPushSeedDelegate(string stCode, string gameClubPushSeedCallBackJson);

    //minigame game club show activity delegate
    public delegate void GameClubShowActivityDelegate(string stCode, string gameClubShowActivityCallBackJson);

    //minigame game club get data delegate
    public delegate void GameClubGetDataDelegate(string stCode, string gameClubGetDataCallBackJson);

    //minigame channel action delegate
    public delegate void ChannelActionDelegate(string stCode, string channelActionCallBackJson);

    //minigame subscribe action delegate
    public delegate void SubscribeActionDelegate(string stCode, string subscribeActionCallBackJson);

    //minigame privacy authorize delegate
    public delegate void PrivacyAuthorizeDelegate(string stCode, string privacyAuthorizeCallBackJson);

    //minigame secee delegate
    public delegate void SceneDelegate(string stCode, string sceneCallBackJson);

    //minigame login callback
    [AOT.MonoPInvokeCallback(typeof(LoginDelegate))]
    static void loginCallback(string stCode, string loginCallBackJson)
    {
        Debug.Log("loginCallBack+++ loginCallBackJson" + loginCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // login failed
                mUnityCallback.onDHSDKResult(1, 1, loginCallBackJson);
            }
            else if (stCode == "1")
            { // login success
                mUnityCallback.onDHSDKResult(1, 0, loginCallBackJson);
            }
            else if (stCode == "2")
            { //  logout 
                mUnityCallback.onDHSDKResult(4, 0, loginCallBackJson);
            }
            else if (stCode == "3")
            { //  防沉迷通知    
                mUnityCallback.onDHSDKResult(32, 0, loginCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(1, 1, loginCallBackJson);
        }
    }

    //minigame init callback
    [AOT.MonoPInvokeCallback(typeof(InitDelegate))]
    static void initCallback(string stCode, string initCallBackJson)
    {
        Debug.Log("initCallBack+++ initCallBackJson" + initCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // init failed
                mUnityCallback.onDHSDKResult(0, 1, initCallBackJson);
            }
            else if (stCode == "1")
            { // init success
                mUnityCallback.onDHSDKResult(0, 0, initCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(0, 1, initCallBackJson);
        }
    }

    //minigame createUserInfoButton callback
    [AOT.MonoPInvokeCallback(typeof(CreateUserInfoButtonDelegate))]
    static void createUserInfoButtonCallback(string stCode, string createUserInfoButtonCallBackJson)
    {
        Debug.Log("createUserInfoCallBack+++ createUserInfoButtonCallBackJson" + createUserInfoButtonCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // user cancel
                mUnityCallback.onDHSDKResult(108, 1, createUserInfoButtonCallBackJson);
            }
            else if (stCode == "1")
            { // user agree
                mUnityCallback.onDHSDKResult(108, 0, createUserInfoButtonCallBackJson);
            }
            else if (stCode == "2")
            { // create success
                mUnityCallback.onDHSDKResult(125, 0, createUserInfoButtonCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(108, 1, createUserInfoButtonCallBackJson);
        }
    }

    //minigame getSetting callback
    [AOT.MonoPInvokeCallback(typeof(GetSettingDelegate))]
    static void getSettingCallback(string stCode, string getSettingCallBackJson)
    {
        Debug.Log("getSettingCallBack+++ getSettingCallBackJson" + getSettingCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // init failed
                mUnityCallback.onDHSDKResult(109, 1, getSettingCallBackJson);
            }
            else if (stCode == "1")
            { // init success
                mUnityCallback.onDHSDKResult(109, 0, getSettingCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(109, 1, getSettingCallBackJson);
        }
    }

    //minigame getUserInfo callback
    [AOT.MonoPInvokeCallback(typeof(GetUserInfoDelegate))]
    static void getUserInfoCallback(string stCode, string getUserInfoCallBackJson)
    {
        Debug.Log("getUserInfoCallBack+++ getUserInfoCallBackJson" + getUserInfoCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // get userinfo failed
                mUnityCallback.onDHSDKResult(110, 1, getUserInfoCallBackJson);
            }
            else if (stCode == "1")
            { // get userinfo success
                mUnityCallback.onDHSDKResult(110, 0, getUserInfoCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(110, 1, getUserInfoCallBackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(PayDelegate))]
    static void payCallback(string stCode, string payCallBackJson)
    {
        Debug.Log("payCallBack+++ payCallBackJson" + payCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { //pay failed
                mUnityCallback.onDHSDKResult(2, 1, payCallBackJson);
            }
            else if (stCode == "1")
            {// appstore sdk callback
                mUnityCallback.onDHSDKResult(2, 0, payCallBackJson);
            }
            else if (stCode == "2")
            {//alipay sdk callback
                mUnityCallback.onDHSDKResult(2, 0, payCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(2, 1, payCallBackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(PlayAdsDelegate))]
    static void playAdsCallback(string stCode, string playAdsCallbackJson)
    {
        Debug.Log("playAdsCallBack+++ playAdsCallBackJson" + playAdsCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // playAds failed
                mUnityCallback.onDHSDKResult(7, 1, playAdsCallbackJson);
            }
            else if (stCode == "1")
            { // playAds success
                mUnityCallback.onDHSDKResult(7, 0, playAdsCallbackJson);
            }
            else if (stCode == "2")
            { // couldPlayAds failed
                mUnityCallback.onDHSDKResult(25, 1, playAdsCallbackJson);
            }
            else if (stCode == "3")
            { // couldPlayAds success
                mUnityCallback.onDHSDKResult(25, 0, playAdsCallbackJson);
            }
            else if (stCode == "4")
            { // loadAd failed
                mUnityCallback.onDHSDKResult(111, 1, playAdsCallbackJson);
            }
            else if (stCode == "5")
            { // loadAd success
                mUnityCallback.onDHSDKResult(111, 0, playAdsCallbackJson);
            }
            else if (stCode == "6")
            { // ad close
                mUnityCallback.onDHSDKResult(124, 0, playAdsCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(7, 1, playAdsCallbackJson);
            mUnityCallback.onDHSDKResult(25, 1, playAdsCallbackJson);
            mUnityCallback.onDHSDKResult(111, 1, playAdsCallbackJson);
            mUnityCallback.onDHSDKResult(124, 1, playAdsCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(CreateFeedbackButtonDelegate))]
    static void createFeedbackCallback(string stCode, string createFeedbackCallbackJson)
    {
        Debug.Log("createFeedbackCallBack+++ createFeedbackCallBackJson" + createFeedbackCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // createFeedbackButton failed
                mUnityCallback.onDHSDKResult(112, 1, createFeedbackCallbackJson);
            }
            else if (stCode == "1")
            { // createFeedbackButton tap
                mUnityCallback.onDHSDKResult(112, 0, createFeedbackCallbackJson);
            }
            else if (stCode == "2")
            { // createFeedbackButton tap
                mUnityCallback.onDHSDKResult(126, 0, createFeedbackCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(112, 1, createFeedbackCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(ServiceDelegate))]
    static void serviceCallback(string stCode, string serviceCallbackJson)
    {
        Debug.Log("serviceCallBack+++ serviceCallBackJson" + serviceCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // service open failed
                mUnityCallback.onDHSDKResult(113, 1, serviceCallbackJson);
            }
            else if (stCode == "1")
            { // service open success
                mUnityCallback.onDHSDKResult(113, 0, serviceCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(113, 1, serviceCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(SurveyDelegate))]
    static void surveyCallback(string stCode, string surveyCallbackJson)
    {
        Debug.Log("surveyCallBack+++ surveyCallBackJson" + surveyCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // service open failed
                mUnityCallback.onDHSDKResult(114, 1, surveyCallbackJson);
            }
            else if (stCode == "1")
            { // service open success
                mUnityCallback.onDHSDKResult(114, 0, surveyCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(114, 1, surveyCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(ShareDelegate))]
    static void shareCallback(string stCode, string shareCallbackJson)
    {
        Debug.Log("shareCallBack+++ shareCallBackJson" + shareCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // service open failed
                mUnityCallback.onDHSDKResult(5, 1, shareCallbackJson);
            }
            else if (stCode == "1")
            { // service open success
                mUnityCallback.onDHSDKResult(5, 0, shareCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(5, 1, shareCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameRecordDelegate))]
    static void gameRecordCallback(string stCode, string gameRecordCallbackJson)
    {
        Debug.Log("gameRecordCallBack+++ gameRecordCallBackJson" + gameRecordCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game record failed
                mUnityCallback.onDHSDKResult(115, 1, gameRecordCallbackJson);
            }
            else if (stCode == "1")
            { // game record success
                mUnityCallback.onDHSDKResult(115, 0, gameRecordCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(115, 1, gameRecordCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameRecordShareDelegate))]
    static void gameRecordShareCallback(string stCode, string gameRecordShareCallbackJson)
    {
        Debug.Log("gameRecordShareCallBack+++ gameRecordShareCallBackJson" + gameRecordShareCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game record failed
                mUnityCallback.onDHSDKResult(116, 1, gameRecordShareCallbackJson);
            }
            else if (stCode == "1")
            { // game record success
                mUnityCallback.onDHSDKResult(116, 0, gameRecordShareCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(116, 1, gameRecordShareCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(CreateGameClubButtonDelegate))]
    static void createGameClubButtonCallback(string stCode, string createGameClubButtonCallbackJson)
    {
        Debug.Log("createGameClubButtonCallBack+++ createGameClubButtonCallBackJson" + createGameClubButtonCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // create game club button failed
                mUnityCallback.onDHSDKResult(117, 1, createGameClubButtonCallbackJson);
            }
            else if (stCode == "1")
            { // create game club button success
                mUnityCallback.onDHSDKResult(117, 0, createGameClubButtonCallbackJson);
            }
            else if (stCode == "2")
            { // create game club button success
                mUnityCallback.onDHSDKResult(127, 0, createGameClubButtonCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(117, 1, createGameClubButtonCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameClubShareDelegate))]
    static void gameClubShareCallback(string stCode, string gameClubShareCallbackJson)
    {
        Debug.Log("gameClubShareCallBack+++ gameClubShareCallBackJson" + gameClubShareCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game club share failed
                mUnityCallback.onDHSDKResult(118, 1, gameClubShareCallbackJson);
            }
            else if (stCode == "1")
            { //game club share success
                mUnityCallback.onDHSDKResult(118, 0, gameClubShareCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(118, 1, gameClubShareCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameClubPushSeedDelegate))]
    static void gameClubPushSeedCallback(string stCode, string gameClubPushSeedCallbackJson)
    {
        Debug.Log("gameClubPushSeedCallBack+++ gameClubPushSeedCallBackJson" + gameClubPushSeedCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game club push seed failed
                mUnityCallback.onDHSDKResult(119, 1, gameClubPushSeedCallbackJson);
            }
            else if (stCode == "1")
            { //game club push seed success
                mUnityCallback.onDHSDKResult(119, 0, gameClubPushSeedCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(119, 1, gameClubPushSeedCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameClubShowActivityDelegate))]
    static void gameClubShowActivityCallback(string stCode, string gameClubShowActivityCallbackJson)
    {
        Debug.Log("gameClubShowActivityCallBack+++ gameClubShowActivityCallBackJson" + gameClubShowActivityCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game club show activity failed
                mUnityCallback.onDHSDKResult(120, 1, gameClubShowActivityCallbackJson);
            }
            else if (stCode == "1")
            { //game club show activity success
                mUnityCallback.onDHSDKResult(120, 0, gameClubShowActivityCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(120, 1, gameClubShowActivityCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(GameClubGetDataDelegate))]
    static void gameClubGetDataCallback(string stCode, string gameClubGetDataCallbackJson)
    {
        Debug.Log("gameClubGetDataCallBack+++ gameClubGetDataCallBackJson" + gameClubGetDataCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // game club get data failed
                mUnityCallback.onDHSDKResult(121, 1, gameClubGetDataCallbackJson);
            }
            else if (stCode == "1")
            { //game club get data success
                mUnityCallback.onDHSDKResult(121, 0, gameClubGetDataCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(121, 1, gameClubGetDataCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(ChannelActionDelegate))]
    static void channelActionCallback(string stCode, string channelActionCallbackJson)
    {
        Debug.Log("channelActionCallBack+++ channelActionCallBackJson" + channelActionCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // channel action failed
                mUnityCallback.onDHSDKResult(122, 1, channelActionCallbackJson);
            }
            else if (stCode == "1")
            { //channel action success
                mUnityCallback.onDHSDKResult(122, 0, channelActionCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(122, 1, channelActionCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(SubscribeActionDelegate))]
    static void subscribeActionCallback(string stCode, string subscribeActionCallbackJson)
    {
        Debug.Log("subscribeActionCallBack+++ subscribeActionCallBackJson" + subscribeActionCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // subscribe action failed
                mUnityCallback.onDHSDKResult(123, 1, subscribeActionCallbackJson);
            }
            else if (stCode == "1")
            { //subscribe action success
                mUnityCallback.onDHSDKResult(123, 0, subscribeActionCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(123, 1, subscribeActionCallbackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(PrivacyAuthorizeDelegate))]
    static void privacyAuthorizeCallback(string stCode, string privacyAuthorizeCallbackJson)
    {
        Debug.Log("privacyAuthorizeCallback+++ privacyAuthorizeCallbackJson" + privacyAuthorizeCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // privacy action failed
                mUnityCallback.onDHSDKResult(128, 1, privacyAuthorizeCallbackJson);
            }
            else if (stCode == "1")
            { //privacy action agree
                mUnityCallback.onDHSDKResult(128, 0, privacyAuthorizeCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(128, 1, privacyAuthorizeCallbackJson);
        }
    }
    
    [AOT.MonoPInvokeCallback(typeof(SceneDelegate))]
    static void sceneCallback(string stCode, string sceneCallbackJson)
    {
        Debug.Log("sceneCallback+++ sceneCallbackJson" + sceneCallbackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // scene action failed
                mUnityCallback.onDHSDKResult(129, 1, sceneCallbackJson);
            }
            else if (stCode == "1")
            { //scene action success
                mUnityCallback.onDHSDKResult(129, 0, sceneCallbackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(129, 1, sceneCallbackJson);
        }
    }

    /**************************** MiniGame-API-Begin ******************************************/

    //minimage setgameparam
    [DllImport("__Internal")]
    static extern void setMiniGameSDKParams(string param);

    //minigame init sdk
    [DllImport("__Internal")]
    static extern void initMiniGameSDK(InitDelegate initDelegate);

    //minigame login
    [DllImport("__Internal")]
    static extern void miniGameLogin(LoginDelegate loginDelegate);

    //minigame createUserInfoButton
    [DllImport("__Internal")]
    static extern void miniGameCreateUserInfoButton(string param,CreateUserInfoButtonDelegate createUserInfoButtonDelegate);

    //minigame getSetting
    [DllImport("__Internal")]
    static extern void miniGameGetSetting(GetSettingDelegate getSettingDelegate);

    //minigame getUserInfo
    [DllImport("__Internal")]
    static extern void miniGameGetUserInfo(string param,GetUserInfoDelegate getUserInfoDelegate);

    //minigame 请求参数
    [DllImport("__Internal")]
    static extern string minigameQuery(string key);

    //minigame 支付
    [DllImport("__Internal")]
    static extern void miniGamePay(string payInfo, PayDelegate payDelegate);

    //上报oss数据
    [DllImport("__Internal")]
    static extern void ossDataUpload(string eventName, string eventParams);

    //上报热云数据
    [DllImport("__Internal")]
    static extern void reyunUpload(string eventName, string eventParams);

    //上报漏斗图数据
    [DllImport("__Internal")]
    static extern void logUpload(string eventName, string eventParams);

    //上报角色信息数据
    [DllImport("__Internal")]
    static extern void roleInfoUpload(string eventParams);

    //上报支付数据到oss和热云
    [DllImport("__Internal")]
    static extern void payInfoUpload(string eventParams);

    //创建广告实例
    [DllImport("__Internal")]
    static extern void miniGameCreateAds(string param, PlayAdsDelegate playAdsDelegate);

    //加载广告
    [DllImport("__Internal")]
    static extern void miniGameLoadAds(string param, PlayAdsDelegate playAdsDelegate);

    //判断是否能播放广告
    [DllImport("__Internal")]
    static extern void miniGameCouldPlayAds(string param, PlayAdsDelegate playAdsDelegate);

    //播放广告
    [DllImport("__Internal")]
    static extern void miniGamePlayAds(string param, PlayAdsDelegate playAdsDelegate);

    //创建反馈按钮
    [DllImport("__Internal")]
    static extern void miniGameCreateFeedbackButton(string param, CreateFeedbackButtonDelegate createFeedbackButtonDelegate);

    //操作反馈按钮
    [DllImport("__Internal")]
    static extern void miniGameFeedbackButtonAction(string param);

    //操作用户信息按钮
    [DllImport("__Internal")]
    static extern void miniGameUserInfoButtonAction(string param);

    //打开客服
    [DllImport("__Internal")]
    static extern void miniGameService(string param, ServiceDelegate serviceDelegate);

    //打开问卷调查
    [DllImport("__Internal")]
    static extern void miniGameSurvey(string param, SurveyDelegate surveyDelegate);

    //分享
    [DllImport("__Internal")]
    static extern void miniGameShare(string param, ShareDelegate shareDelegate);

    //游戏录制视频
    [DllImport("__Internal")]
    static extern void miniGameGameRecorderAction(string param, GameRecordDelegate gameRecordDelegate);

    //游戏录制视频分享按钮创建
    [DllImport("__Internal")]
    static extern void miniGameCreateGameRecordShareButton(string param, GameRecordShareDelegate gameRecordShareDelegate);

    //游戏录制视频分享按钮操作
    [DllImport("__Internal")]
    static extern void miniGameGameRecordShareButtonAction(string param);

    //游戏录制视频
    [DllImport("__Internal")]
    static extern void miniGameGameRecordShare(string param, GameRecordShareDelegate gameRecordShareDelegate);

    //创建游戏圈按钮
    [DllImport("__Internal")]
    static extern void miniGameCreateGameClubButton(string param,CreateGameClubButtonDelegate createGameClubButtonDelegate);

    //游戏圈按钮操作
    [DllImport("__Internal")]
    static extern void miniGameGameClubButtonAction(string param);

    //游戏圈分享
    [DllImport("__Internal")]
    static extern void miniGameGameClubShare(string param, GameClubShareDelegate gameClubShareDelegate);

    //游戏圈推送小游戏动态
    [DllImport("__Internal")]
    static extern void miniGamePushSeed(string param, GameClubPushSeedDelegate gameClubPushSeedDelegate);

    //游戏圈展示R活动
    [DllImport("__Internal")]
    static extern void miniGameShowActivity(string param, GameClubShowActivityDelegate gameClubShowActivityDelegate);

    //游戏圈获得数据
    [DllImport("__Internal")]
    static extern void miniGameGetGameClubData(string param, GameClubGetDataDelegate gameClubGetDataDelegate);

    //视频号操作
    [DllImport("__Internal")]
    static extern void miniGameChannelAction(string param, ChannelActionDelegate channelActionDelegate);

    //订阅消息操作
    [DllImport("__Internal")]
    static extern void miniGameSubscribeAction(string param, SubscribeActionDelegate subscribeActionDelegate);

    //隐私授权
    [DllImport("__Internal")]
    static extern void miniGamePrivacyAuthorize(PrivacyAuthorizeDelegate privacyAuthorizeDelegate);

    //退出小程序
    [DllImport("__Internal")]
    static extern void miniGameExit();

    //抖音小程序侧边栏功能
    [DllImport("__Internal")]
    static extern void miniGameScene(string param, SceneDelegate sceneDelegate);

    /**************************** MiniGame-API-End ******************************************/
#elif H5_SDK
    //h5 login callback
    public delegate void LoginDelegate (string stCode,string loginCallBackJson);

    // h5 init delegate
    public delegate void InitDelegate(string stCode, string initCallBackJson);

    // h5 pay delegate
    public delegate void PayDelegate(string stCode, string payCallBackJson);

    // h5 exec delegate
    public delegate void ExecDelegate(string stCode, string execCallBackJson);

    //h5 login callback
    [AOT.MonoPInvokeCallback(typeof(LoginDelegate))]
    static void loginCallback(string stCode, string loginCallBackJson)
    {
        Debug.Log("loginCallBack+++ loginCallBackJson" + loginCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // login failed
                mUnityCallback.onDHSDKResult(1, 1, loginCallBackJson);
            }
            else if (stCode == "1")
            { // login success
                mUnityCallback.onDHSDKResult(1, 0, loginCallBackJson);
            }
            else if (stCode == "2")
            { //  logout 
                mUnityCallback.onDHSDKResult(4, 0, loginCallBackJson);
            }
            else if (stCode == "3")
            { //  防沉迷通知    
                mUnityCallback.onDHSDKResult(32, 0, loginCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(1, 1, loginCallBackJson);
        }
    }

    //h5 init callback
    [AOT.MonoPInvokeCallback(typeof(InitDelegate))]
    static void initCallback(string stCode, string initCallBackJson)
    {
        Debug.Log("initCallBack+++ initCallBackJson" + initCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { // init failed
                mUnityCallback.onDHSDKResult(0, 1, initCallBackJson);
            }
            else if (stCode == "1")
            { // init success
                mUnityCallback.onDHSDKResult(0, 0, initCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(0, 1, initCallBackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(PayDelegate))]
    static void payCallback(string stCode, string payCallBackJson)
    {
        Debug.Log("payCallBack+++ payCallBackJson" + payCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { //pay failed
                mUnityCallback.onDHSDKResult(2, 1, payCallBackJson);
            }
            else if (stCode == "1")
            {// appstore sdk callback
                mUnityCallback.onDHSDKResult(2, 0, payCallBackJson);
            }
            else if (stCode == "2")
            {//alipay sdk callback
                mUnityCallback.onDHSDKResult(2, 0, payCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(2, 1, payCallBackJson);
        }
    }

    [AOT.MonoPInvokeCallback(typeof(ExecDelegate))]
    static void execCallback(string stCode, string execCallBackJson)
    {
        Debug.Log("execCallBack+++ execCallBackJson" + execCallBackJson + "code" + stCode);
        if (mUnityCallback != null)
        {
            if (stCode == "0")
            { //exec failed
                mUnityCallback.onDHSDKResult(99, 1, execCallBackJson);
            }
            else if (stCode == "1")
            {// exec callback success
                mUnityCallback.onDHSDKResult(99, 0, execCallBackJson);
            }
        }
        else
        {
            mUnityCallback.onDHSDKResult(2, 1, execCallBackJson);
        }
    }

    //h5 setgameparam
    [DllImport("__Internal")]
    static extern void setH5SDKParams(string param);

    //h5 init sdk
    [DllImport("__Internal")]
    static extern void initH5SDK(InitDelegate initDelegate);

    //h5 login
    [DllImport("__Internal")]
    static extern void h5Login(LoginDelegate loginDelegate);

    //h5 logout
    [DllImport("__Internal")]
    static extern void h5Logout(LoginDelegate loginDelegate);

    //h5 请求参数
    [DllImport("__Internal")]
    static extern string h5Query(string key);

    //h5 支付
    [DllImport("__Internal")]
    static extern void h5Pay(string param, PayDelegate payDelegate);

    //h5 扩展方法
    [DllImport("__Internal")]
    static extern void h5Exec(string execInfo, ExecDelegate execDelegate);

    //h5 设置玩家信息
    [DllImport("__Internal")]
    static extern void h5SetGameUserInfo(string type,string param);

    //h5 客服
    [DllImport("__Internal")]
    static extern void h5showFAQ(string param);

    //h5 追踪数据
    [DllImport("__Internal")]
    static extern void h5Track(string eventId,string param);
    
#endif
    //    #region sdk 安卓合规新接口
    //    //设置合规试玩模式回调
    //    public static void setTryPlayModeCallback(IDHSDKUnityCallback callback)
    //    {
    //#if UNITY_ANDROID
    //        Run(delegate {
    //            mUnityCallback = callback;
    //            DHUnityHelperProxy.CallStatic("setTryPlayModeCallback", mCallbackProxy);
    //        });
    //#endif
    //    }
    //    //合规试玩模式下判断实名接口
    //    public static void tryPlayModeRealName()
    //    {
    //#if UNITY_ANDROID
    //        Run(delegate {
    //            DHUnityHelperProxy.CallStatic("tryPlayModeRealName");
    //        });
    //#endif
    //    }
    //    public static void jumpWenXinTips()
    //    {
    //#if UNITY_ANDROID
    //        Run(delegate {
    //            DHUnityHelperProxy.CallStatic("jumpWenXinTips");
    //        });
    //#endif
    //    }
    //    #endregion
}



