StarkSDKSpace.CanIUse.FollowDouYinUserProfile

通过 StarkSDK.API.GetStarkAdManager() 获取广告模块

StarkSDK.API.GetStarkAdManager().ShowVideoAdWithId(string videoAdid, Action<bool> closeCallback = null, Action<int, string> errCallback = null, VideoAdCallback adCallback = null);

/// <param name="multiton">是否开启再得广告模式（只支持安卓系统的抖音和抖音极速版）</param>
/// <param name="multitonRewardMsg">再得广告的奖励文案，玩家每看完一个广告都会展示，如【再看1个获得xx】xx就multitonRewardMsg中的文案，按顺序依次展示，单个文案最大长度为 7,multiton为true时必填</para>
/// <param name="multitonRewardTime">额外观看广告的次数，合法的数据范围为1-4，multiton为true时必填</param>
/// <param name="progressTip">是否开启进度提醒，开启时广告文案为【再看N个获得xx】，关闭时为【 再看1个获得xx】。N表示玩家当前还需额外观看广告的次数。</param>
public abstract void ShowVideoAdWithId(string videoAdid,
    bool multiton,
    string[] multitonRewardMsg,
    int multitonRewardTime,
    bool progressTip,
    Action<bool, int> closeCallback = null,
    Action<int, string> errCallback = null
);

StarkSDK.API.GetStarkAdManager().CreateBannerAd()

private int px2dp(int px) => (int)(px * (160 / Screen.dpi));

StarkAdManager.BannerStyle m_style = new StarkAdManager.BannerStyle();
StarkAdManager.BannerAd m_bannerAdIns = null;
void createBanner()
{
    m_style.width = 320;   
    m_style.left = 10;  
    m_style.top = 100;  
    m_bannerAdIns = StarkSDK.API.GetStarkAdManager().CreateBannerAd("your ad id", m_style, 60,
                    OnAdError, OnBannerLoaded, OnBannerResize); 
    //m_style.height为只读，其值将由StarkSDK自动更新
}

void OnBannerLoaded()
{
    if (m_bannerAdIns != null)
        m_bannerAdIns.Show();
}

void changeStyle()
{
    int w = m_style.width;                //获取banner宽度大小
    int h = m_style.height;               //获取banner高度大小
    int sw = px2dp(Screen.width);         //获得屏幕宽度(dp)
    int sh = px2dp(Screen.height);        //获得屏幕高度(dp)
      
    m_style.top = sh - h;                //底部
    m_style.left = sw / 2 - w / 2;       //中央
    m_style.width = w;
    
    m_bannerAdIns.ReSize(m_style);        //使用Resize函数调整位置和大小
                                         
}

/// 创建并播放插屏广告，在广告模块启动15s内不允许展示插屏广告，在任何地方调用API.GetStarkAdManager，就会启动广告模块
/// 两个插屏广告展示间隔不能少于30s
/// 插屏广告支持多实例。简单回调设置，插屏广告完成和错误的回调函数
/// 插屏广告实例只支持展示一次，出现加载错误，或 展示成功，点击关闭按钮或视频广告外的其他地方，广告实例都会自动销毁。下一次需再次创建。
/// 提供接口可以手动销毁
/// 错误码由sdk传出，原因参考
/// https://microapp.bytedance.com/docs/zh-CN/mini-game/develop/open-capacity/ads/tt-create-interstitial-ad
var m_InterAdIns = StarkSDK.API.GetStarkAdManager().CreateInterstitialAd()

void LoadInterstitialAd()
{
    if (m_InterAdIns != null)
        m_InterAdIns.Load();
    else
    {
        PrintText("插屏AD未创建");
    }
}

void ShowInterstitialAd()
{
    PrintText("显示插屏AD");
    if (m_InterAdIns != null)
        m_InterAdIns.Show();
    else
    {
        PrintText("插屏AD未创建");
    }
}

void DestoryInterstitialAd()
{
    PrintText("销毁插屏AD");
    if (m_InterAdIns != null)
        m_InterAdIns.Destory();
    m_InterAdIns = null;
}

StarkAdManager.IsShowLoadAdToast = false

StarkSDK.API.GetStarkGameRecorder().StartRecord(m_IsRecordAudio, m_MaxRecordTime, OnRecordStart, OnRecordError, OnRecordTimeout)

StarkSDK.API.FollowDouYinUserProfile(OnFollowAwemeCallback, OnFollowAwemeError)

StarkSDK.API.CreateShortcut(OnCreateShortcut)

void OnCreateShortcut(bool bSuccess)
{
    PrintText("OnCreateShortcut : {0}", bSuccess);
}

StarkSDK.API.GetStarkShare()

{
    "channel": "video",
    "title": "Some Title",
    "extra": {
        "videoPath": "/xxx/xxx.mp4",//OnRecordComplete拿到 录屏文件 所在路径
        "videoTopics": ["Some Topic1", "Some Topic2"],
        "hashtag_list": ["Some Topic1", "Some Topic2"],
    }
}

using UNBridgeLib.LitJson;

JsonData shareJson = new JsonData();
shareJson["channel"] = "video";
shareJson["title"] = "Some Title";
shareJson["extra"] = new JsonData();
shareJson["extra"]["videoPath"] = "/xxx/xxx.mp4";//OnRecordComplete拿到 录屏文件 所在路径
JsonData videoTopics = new JsonData();
videoTopics.SetJsonType(JsonType.Array);
videoTopics.Add("Some Topic1");
videoTopics.Add("Some Topic2");
shareJson["extra"]["videoTopics"] = videoTopics;
shareJson["extra"]["hashtag_list"] = videoTopics;
StarkSDK.API.GetStarkShare().ShareAppMessage(() =>
    {
        // Share succeed
    }, (errMsg) =>
    {
        // Share failed
    }, () =>
    {
       // Share cancelled
    }, 
    shareJson);

StarkSDK.API.NavigateToVideoView(string videoId)

StarkSDK.API.GetStarkShare().ShowShareMenu()

StarkSDK.API.GetStarkShare().HideShareMenu();

/// <summary>
/// 登录-获取临时登录凭证
/// 强制登录默认为true，即若当前未登录宿主，则会调起宿主的登录窗口, 如果用户点击取消则会调用 fail
/// 如果当前登录宿主，则直接返回success，获取到 code 和 anonymousCode
/// 若强制登录为false，当前登录了宿主则会返回success，可以获取到获取到 code 和 anonymousCode
/// 当前未登录宿主，则只有 anonymousCode
/// code 可以换取 openid, openid 是用户的唯一标识
/// anonymousCode 可以换取 anonymous_openid, 同一台手机 anonymous_openid 是相同的
/// </summary>
/// <param name="forceLogin">未登录时, 是否强制调起登录框</param>
/// <param name="successCallback">登录成功的回调</param>
/// <param name="failedCallback">登录失败的回调</param>
StarkSDK.API.GetAccountManager().Login(OnLoginSuccessCallback successCallback,
                           OnLoginFailedCallback failedCallback,
                           bool forceLogin = true)

if (CanIUse.StarkPayService.RequestGamePayment)// 有版本需求
{
    Dictionary<string, object> orderInfoParams = new Dictionary<string, object>();
    orderInfoParams["mode"] = "game"; //支付的类型, 目前仅为"game"
    orderInfoParams["env"] = "0"; //环境配置，目前合法值仅为"0"
    orderInfoParams["currencyType"] = "CNY"; // 固定值: CNY。币种
    orderInfoParams["platform"] = "android"; //申请接入时的平台，目前仅为"android"
    orderInfoParams["buyQuantity"] = 1; 
    //金币购买数量，金币数量必须满足：金币数量*金币单价 = 限定价格等级（详见下方 buyQuantity 限制说明。开发者可以在抖音小游戏平台的“支付”tab 设置游戏币单价）
    orderInfoParams["customId"] = (TimeUtils.GetCurrentTimeMs() / 1000).ToString();
    //游戏开发者自定义的唯一订单号，订单支付成功后通过服务端支付结果回调回传
    StarkSDK.API.GetStarkPayService().RequestGamePayment(
        orderInfoParams,
        () =>
        {
            PrintText("Pay Success " + orderInfoParams["customId"]);
        },
        (errCode, errMsg) =>
        {
            PrintText("Pay failed - errCode: " + errCode + ", errMsg: " + errMsg, true);
        }
        );
}

StarkSDK.API.OpenAwemeCustomerService(JsonData options, Action success, Action<int, string>failed);

var options = new JsonData
{
    ["buyQuantity"] = 600, // 购买游戏币数量
    ["customId"] = "QWERTYUIDFxxxxx", //开发者自定义唯一订单号。如不填，支付结果回调将不包含此字段，将导致游戏开发者无法发放游戏道具, 基础库版本低于1.55.0没有此字段
    ["currencyType"] = "DIAMOND", // 币种：目前仅为"DIAMOND"
    ["zoneId"] = "1",
    ["extraInfo"] = "{
        userId: "12xxx6", //用户自定义额外信息,支付结果回调信息包含此字段， 基础库版本低于1.55.0没有此字段
        version: "v0.0.0",
        price: "30",
    }" //extraInfo要转成字符串
};

StarkSDK.API.OpenAwemeCustomerService(options, () =>
{
    Debug.Log("OpenAwemeCustomerService success");
}, (errCode, errMsg) =>
{
    Debug.Log($"OpenAwemeCustomerService failed, errCode: {errCode}, errMsg: {errMsg}");
});

StarkSDK.API.OpenCustomerServicePage(
    (flag) =>
    {
        if (flag)
        {
            PrintTextAppended("成功");
        }
        else
        {
            PrintTextAppended("失败");
        }
    });

JsonData data = new JsonData 
{ 
    ["type"] = 2 
}; 
// data数据：type:(1：小6客服 2:抖音IM 客服(仅支持抖音))sessionFrom:(保留字段，暂时可以不填),例如{"type":1,"sessionFrom":"xxx"}
StarkSDK.API.OpenCustomerServiceConversation(data, (succ) =>{ 
    if (succ) 
    { 
        PrintTextAppended("成功"); 
    } 
    else 
    { 
        PrintTextAppended("失败"); 
    } 
});

/// <summary>
/// 替换敏感词
/// </summary>
/// <param name="word">要检查和替换的词语</param>
/// <param name="callback">回调
/// int: 返回状态码，0为成功，否则为失败
/// string: 错误信息
/// JsonData：
/// audit_result    int     1: 有敏感内容；0: 无敏感内容
/// audit_content   string  被替换的内容（无敏感内容则返回值与传入的word相同）
/// </param>
[StarkVersion(MinSCAndroidVersion = "1.0.0", IsSupportWebGL = true)]
public abstract void ReplaceSensitiveWords(string word, Action<int, string, JsonData>callback);

/// <summary>
/// 用户点击键盘确定按钮时的事件
/// <param name="value">键盘输入的当前值</param>
/// </summary>
public delegate void OnKeyboardConfirmEvent(string value);

/// <summary>
/// 键盘收起事件
/// <param name="value">键盘输入的当前值</param>
/// </summary>
public delegate void OnKeyboardCompleteEvent(string value);

/// <summary>
/// 监听用户点击键盘确定按钮时的事件
/// </summary>
public OnKeyboardConfirmEvent onKeyboardConfirmEvent;

/// <summary>
/// 监听键盘收起事件
/// </summary>
public OnKeyboardCompleteEvent onKeyboardCompleteEvent;

// 在关键的游戏场景，设置写入用户的排行榜数据（游戏成绩信息），该数据会上传到服务端
StarkSDK.API.GetStarkRank().SetImRankData();
// 获取排行榜列表，调用 API 后， 根据参数自动绘制游戏好友排行榜
StarkSDK.API.GetStarkRank().GetImRankList();

/// https://developer.open-douyin.com/docs/resource/zh-CN/mini-game/develop/open-capacity/game-rank/setImRankData
/// <summary>
/// 在关键的游戏场景，设置写入用户的排行榜数据（游戏成绩信息），该数据会上传到服务端
/// </summary>
/// <param name="dataType">0：数字类型、1：枚举类型;数字类型（0）往往适用于游戏的通关分数（103分、105分），枚举类型（1）适用于段位信息（青铜、白银）；--(Require)</param>
/// <param name="value">展示出来的数值，dataType == 0 时只能传正数的字符串，否则会报错。value为具体的值，若dataType为0，请传入数字（eg：103、105）；若dataType为1，则传入字符串（eg：青铜、白银）--(Require)</param>
/// <param name="priority">dataType 为 1 时，需要传入这个值判断权重，dataType 为 0 时，不填即可--(Require)</param>
/// <param name="extra">预留字段--(Nullable)</param>
/// <param name="zoneId">排行榜分区标识--(Nullable)默认值为default</param>
/// <param name="paramJson">以上参数使用json格式传入，例如"{"dataType":0,"value":"100","priority":0,"zoneId":"default"}"</param>
/// <param name="action">回调函数</param>
public abstract void SetImRankDataV2(
    JsonData paramJson,
    Action<bool, string> action = null);
    
    
/// <summary>
///获取排行榜列表，调用 API 后， 根据参数自动绘制游戏好友排行榜
/// </summary>
/// <param name="rankType">代表数据排序周期，day为当日写入的数据做排序；week为自然周，month为自然月，all为半年--(Require)</param>
/// <param name="dataType">由于数字类型的数据与枚举类型的数据无法同时排序，因此需要选择排序哪些类型的数据--(Require)</param>
/// <param name="relationType">选择榜单展示范围。default: 好友及总榜都展示，all：仅总榜单--(Nullable)</param>
/// <param name="suffix">数据后缀，最后展示样式为 value + suffix，若suffix传“分”，则展示 103分、104分--(Nullable)</param>
/// <param name="rankTitle">排行榜标题的文案--(Nullable)</param>
/// <param name="zoneId">排行榜分区标识--(Nullable)</param>
/// <param name="paramJson">以上参数使用json格式传入，例如"{"rankType":"week","dataType":0,"relationType":"all","suffix":"分","rankTitle":"","zoneId":"default"}"</param>
/// <param name="action">回调函数</param>
public abstract void GetImRankListV2(JsonData paramJson, 
    Action<bool, string> action = null);

void SetImRankDataNew()
{
    var dataType = dataTypeGet.text;
    var value = valueGet.text;
    var priority = priorityGet.text;
    var zoneId = zoneIdGet.text;
    var paramJson = new JsonData
    {
        ["dataType"] = int.Parse(dataType),
        ["value"] = value,
        ["priority"] = int.Parse(priority),
        ["zoneId"] = zoneId
    };
    Debug.Log($"SetImRankData param:{paramJson.ToJson()}");
    StarkSDK.API.GetStarkRank().SetImRankDataV2(paramJson, (isSuccess, errMsg) =>
    {
        if (isSuccess)
        {
        }
        else
        {
        }
    });
}


void GetImRankListNew()
{
    var rankType = rankTypeList.text;
    var dataType = dataTypeList.text;
    var relationType = relationTypeList.text;
    var suffix = suffixList.text;
    var rankTitle = rankTitleList.text;
    var zoneId = zoneIdList.text;
    var paramJson = new JsonData
    {
        ["rankType"] = rankType,
        ["dataType"] = int.Parse(dataType),
        ["relationType"] = relationType,
        ["suffix"] = suffix,
        ["rankTitle"] = rankTitle,
        ["zoneId"] = zoneId,
    }; 
    Debug.Log($"GetImRankList param:{paramJson.ToJson()}");
    StarkSDK.API.GetStarkRank().GetImRankListV2(paramJson, (isSuccess, errMsg) =>
    {
        if (isSuccess)
        {
        }
        else
        {
        }
    });
}

///创建组件模块
/// <param name="gridCount">GridGamePanelCount，表示游戏推荐组件的格子数量</param>
/// <param name="query">从组件内打开游戏时附带的query信息</param>
/// <param name="size">GridGamePanelSize，表示组件大小，large：100%，medium：90%，small：80%。仅 gridCount = one | four 时有效。</param>
/// <param name="position">控制游戏推荐组件的展示位置，不传入时默认展示在屏幕右下角。仅 gridCount = one 时有效。</param>
StarkSDK.API.GetStarkGridGamePanelManager().CreateGridGamePanel(GridGamePanelCount gridCount, JsonData query, GridGamePanelSize size, JsonData position)

gridGamePanel.Show();

gridGamePanel.Hide();

gridGamePanel.Destory();

StarkSDK.API.GetStarkClipboard().SetClipboardData(text, (isSucc, errMsg) =>
{
    if (isSucc)
    {
        PrintText("设置成功");
    }
    else
    {
        PrintText("设置失败，"+errMsg );
    }
});

StarkSDK.API.GetStarkClipboard().GetClipboardData((isSucc, contentOrErrMsg) =>
{
    if (isSucc)
    {
        PrintText("获取成功:" + contentOrErrMsg);
    }
    else
    {
        PrintText("获取失败, " + contentOrErrMsg);
    }
});

StarkSDK.API.GetStarkScreenManager().SetKeepScreenOn(true, () =>
{
    PrintText("设置屏幕常亮成功");
}, (msg) =>
{
    PrintText($"设置屏幕常亮失败,{msg}");
});

StarkSDK.API.GetStarkScreenManager().GetScreenBrightness((value) =>
{
    PrintText($"获取屏幕亮度成功,{value}");
}, (msg) =>
{
    PrintText($"获取屏幕亮度失败,{msg}");
});

StarkSDK.API.GetStarkScreenManager().SetScreenBrightness(float.Parse(inputText.text), () =>
{
    PrintText("设置屏幕亮度成功");
}, (msg) =>
{
    PrintText($"设置屏幕亮度失败，${msg}");
});

LaunchOption launchOption = StarkSDK.API.GetLaunchOptionsSync();

/// <summary>
/// 自定义场景数据上报接口
/// </summary>
/// <param name="sceneId">场景ID，int或long类型登录抖音开放平台，进入「数据」-「性能分析」-「启动监控」-「启动场景配置」模块，进入添加事件场景，新建游戏的自定义启动场景。 游戏每次启动只可以上报一次</param>
/// <param name="costTime">场景耗时，单位ms long类型</param>
/// <param name="dimension">自定义维度数据，key在抖音开放平台获取。且序列化后长度不超过1024个字符 </param>
/// <param name="metric">自定义指标数据，key在抖音开放平台获取。且序列化后长度不超过1024个字符 </param>
/// <param name="param">以上参数使用json格式传入，例如"{"sceneId":0,"costTime":10,"dimension":{},"metric":{}}"</param>
/// <param name="success"></param>
/// <param name="failed"></param>
/// <param name="complete"></param>
public void ReportScene(JsonData param,Action<JsonData> success = null,Action<int, string> failed = null, Action complete = null);

//示例
var jsonData = new JsonData();
jsonData["sceneId"] = 100000;
jsonData["costTime"] = 10;
StarkSDK.API.ReportScene(jsonData);

StarkSDK.API.CreateUDPSocket();

// 监听 TouchStart 事件
StarkSDK.API.GetStarkInput().onTouchStart((StarkTouchEvent touchEvent) => {
    Debug.Log("touchstart: " + touchEvent); 
});

using StarkSDKSpace;
 using UnityEngine;
 using UnityEngine.UI;

 public class KeyboardTest : MonoBehaviour
 {
     public InputField input;

     private void Start()
     {
         SetInputTexts();
         RegisterKeyboardEvents();
     }

     private void SetInputTexts()
     {
         input.text = "done";
         var comp = input.GetComponent<ClickableInputField>();
         if (comp == null)
         {
             comp = input.gameObject.AddComponent<ClickableInputField>();
         }
         comp.multiple = false;
         comp.confirmType = input.text;
     }

     private void OnDestroy()
     {
         UnregisterKeyboardEvents();
     }

     private void RegisterKeyboardEvents()
     {
         StarkSDK.API.GetStarkKeyboard().onKeyboardInputEvent += OnKeyboardInput;
         StarkSDK.API.GetStarkKeyboard().onKeyboardConfirmEvent += OnKeyboardConfirm;
         StarkSDK.API.GetStarkKeyboard().onKeyboardCompleteEvent += OnKeyboardComplete;
     }

     private void UnregisterKeyboardEvents()
     {
         StarkSDK.API.GetStarkKeyboard().onKeyboardInputEvent -= OnKeyboardInput;
         StarkSDK.API.GetStarkKeyboard().onKeyboardConfirmEvent -= OnKeyboardConfirm;
         StarkSDK.API.GetStarkKeyboard().onKeyboardCompleteEvent -= OnKeyboardComplete;
     }

     private void OnKeyboardInput(string value)
     {
         Debug.Log($"OnKeyboardInput: {value}");
         if (input.isFocused)
         {
             input.text = value;
         }
     }

     private void OnKeyboardConfirm(string value)
     {
         Debug.Log($"OnKeyboardConfirm: {value}");
     }

     private void OnKeyboardComplete(string value)
     {
         Debug.Log($"OnKeyboardComplete: {value}");
     }
 }
 public class ClickableInputField : EventTrigger
 {
     public string confirmType = "done"; // 可选值有: "done", "next", "search", "go", "send"
     public int maxInputLength = 100; // 最大输入长度
     public bool multiple = false; // 是否多行输入
     private InputField _inputField;
     private void Start()
     {
         _inputField = GetComponent<InputField>();
     }
     public override void OnPointerClick(PointerEventData eventData)
     {
         if (_inputField != null)
         {
             if (_inputField.isFocused)
             {
                 StarkSDK.API.GetStarkKeyboard().ShowKeyboard(new StarkKeyboard.ShowKeyboardOptions()
                 {
                     maxLength = maxInputLength,
                     multiple = multiple,
                     defaultValue = _inputField.text,
                     confirmType = confirmType
                 });
             }
         }
     }
 }

/// <summary>
/// 确认当前宿主版本是否支持跳转某个小游戏入口场景。
/// </summary>
/// <param name="scene">需要确认的入口场景（目前仅支持的入参为'sidebar'）</param>
/// <param name="success">接口调用成功的回调函数, bool为true说明支持，false表示不支持</param>
/// <param name="complete">接口调用结束的回调函数（调用成功、失败都会执行）</param>
/// <param name="error">接口调用失败的回调函数</param>
public abstract void CheckScene(SceneEnum scene, Action<bool> success, Action complete, Action<int, string> error);

StarkSDK.API.GetStarkSideBarManager().CheckScene(StarkSideBar.SceneEnum.SideBar, b =>
{
    PrintText("check scene success，"+b );
}, () =>
{
    PrintText("check scene complete");
}, (errCode, errMsg) =>
{
    PrintText($"check scene error, errCode:{errCode}, errMsg:{errMsg}");
});

/// <summary>
/// 调用该API可以跳转到某个小游戏入口场景。
/// </summary>
/// <param name="scene">需要确认的入口场景（目前仅支持的入参为'sidebar'）</param>
/// <param name="success">接口调用成功的回调函数, bool为true说明支持，false表示不支持</param>
/// <param name="complete">接口调用结束的回调函数（调用成功、失败都会执行）</param>
/// <param name="error">接口调用失败的回调函数</param>
public abstract void NavigateToScene(SceneEnum scene, Action success, Action complete, Action<int, string> error);

StarkSDK.API.GetStarkSideBarManager().NavigateToScene(StarkSideBar.SceneEnum.SideBar, () =>
{
    PrintText("navigate to scene success");
}, () =>
{
    PrintText("navigate to scene complete");
}, (errCode,errMsg) =>
{
    PrintText($"navigate to scene error, errCode:{errCode}, errMsg:{errMsg}");
});

StarkSDK.API.GetStarkAppLifeCycle().OnShowWithDict += OnShowOneParam;


private void OnShowOneParam(Dictionary<string, object> param)
{
    PrintTextAppended($"OnShowOneParam-->${param.ToJson()}");
}

StarkSDK.s_ContainerEnv.GetLaunchFrom()
StarkSDK.s_ContainerEnv.GetLocation()

/// 请求订阅消息
/// 可以参考 小游戏相关文档 https://developer.open-douyin.com/docs/resource/zh-CN/mini-game/develop/open-capacity/subscribe-message/tt-request-subscribe-message/
/// </summary>
/// <param name="tmplIds">需要订阅的消息模板的 id 的集合，最多支持传入三个 tmplId</param>
/// <param name="success">接口调用成功的回调函数</param>
/// <param name="complete">接口调用结束的回调函数（调用成功、失败都会执行）</param>
/// <param name="failed">接口调用结束的回调函数（调用成功、失败都会执行）</param>
public abstract void RequestSubscribeMessage(List<string> tmplIds,Action<Dictionary<string, string>> success = null,Action complete = null, Action<int, string> failed = null);

StarkSDK.API.RequestSubscribeMessage(tmplIds, (data) =>
{
    Debug.Log($"success call request subscribe message, {data.ToJson()}");
    PrintText("success call request subscribe message");
    PrintText(data.ToJson());
    
}, () =>
{
    PrintText("complete call request subscribe message");
}, (errCode, errMsg) =>
{
    PrintText($"complete call requestSubscribeMessage fail,errCode -->{errCode},errMsg-->{errMsg}");
});

/// <summary>
/// 监听游戏切到后台，统一所有平台
/// </summary>
public OnAppHideEvent OnHide;

/// <summary>
/// 监听游戏到前台，统一所有平台，携带参数的格式为字典，可以根据指定key获取指定数据
/// https://bytedance.feishu.cn/docx/NkzOdcUPXo02bdxl6zqcemGinzb
/// </summary>
public OnShowEventWithDict OnShowWithDict;

StarkSDK.API.GetStarkAppLifeCycle().OnShowWithDict = (param) =>
{
    Debug.Log($"OnShowOneParam: ${param.ToJson()}");
};

StarkSDK.API.GetStarkAppLifeCycle().OnHide = () => {
    Debug.Log("OnHide");
};

public class ContainerEnv
{
    public          string              GameAppId               = null;                         // 游戏id
    public          HostEnum            m_HostEnum;                                             // 运行的宿主
    public          LaunchFromEnum      m_LaunchFromEnum;                                       // 启动入口
    
    public SCRuntime GetSCRuntime();
    
    public VersionType GetVersionType();
    
    public string GetLaunchFromStr();
    
    /// <summary>
    /// 获取query字段，即小程序的启动参数，可能为空，使用时需判空
    /// </summary>
    public IReadOnlyDictionary<string, string> GetQueryFromScheme();
    
    /// <summary>
    /// 启动场景（该字段目前只有在「侧边栏」启动场景才会返回，返回的属性值为：sidebar_card）
    /// </summary>
    /// <returns></returns>
    public string GetLocation();
    
    /// <summary>
    /// 启动场景（该字段目前只有在「侧边栏」启动场景才会返回，返回的属性值为：homepage）
    /// </summary>
    /// <returns></returns>
    public string GetLaunchFrom()
    
    /// <summary>
    /// 获取小程序启动时的参数，里面的参数可能为空，使用时需判空; 可以在StarkSDK.init()之后调用，确保得到非空值
    /// </summary>
    public LaunchOption GetLaunchOptionsSync();
}

public delegate void OnStarkContainerInitCallback(ContainerEnv env);

/// <summary>
/// 设置Container初始化成功的回调。获取宿主及入口信息
/// 需要在调用其他api之前调用
/// 非Container下不会有此回调
/// </summary>
/// <param name="callback">初始化完成的回调.</param>
public abstract void SetContainerInitCallback(OnStarkContainerInitCallback callback);

/// <summary>
/// 获取菜单按钮（右上角胶囊按钮）的布局位置信息。坐标信息以屏幕左上角为原点。
/// https://developer.open-douyin.com/docs/resource/zh-CN/mini-game/develop/api/interface/menu/tt-get-menu-button-layout/
/// </summary>
/// <returns>
/// JsonData
/// width  number 宽度，单位：px
/// height number 高度，单位：px
/// top        number 上边界坐标，单位：px
/// right  number 右边界坐标，单位：px
/// bottom number 下边界坐标，单位：px
/// left   number 左边界坐标，单位：px
/// </returns>
public abstract JsonData GetMenuButtonLayout();

var layoutData = StarkSDK.API.GetMenuButtonLayout();
var width = layoutData.OptGetInt("width");
var height = layoutData.OptGetInt("height");
var top = layoutData.OptGetInt("top");
var left = layoutData.OptGetInt("left");
var pxLeft= Dp2Px(left); 
var pxTop = Dp2Px(top); 
var pxHeight = Dp2Px(height); 
var pxWidth = Dp2Px(width);
GUI.Button(new Rect(pxLeft, pxTop, pxWidth, pxHeight), "不可放置UI", labStyles);

/// <summary>
/// 金币发放or扣除
/// </summary>
/// <param name="type">订单类型,1-发放金币，2-消耗金币, int</param>
/// <param name="bizId">点位ID，在开发者后台中金币配置中获取, string</param>
/// <param name="goldNum">金币数量, int</param>
/// <param name="customId">开发者自定义的订单号, string</param>
/// <param name="paramJson">以上参数使用json的形式传入，例如：{"type":1,"bizId":"xxxxx","goldNum":1,"customId":"xxxx"}</param>
/// <param name="successCallback">执行成功的回调函数，会返回平台订单号,例如：{"orderId":"xxxxx"}</param>
/// <param name="completeCallback">接口调用成功的回调函数</param>
/// <param name="errorCallback">接口调用失败的回调函数</param>
public abstract void RequestGoldOrder(JsonData paramJson,
    Action<JsonData> successCallback, Action completeCallback,
    Action<int, string> errorCallback);

var bizId = xxx;
var goldNum = xxx;
var customId = xxx;
var paramJson = new JsonData
{
    ["type"] = dropdownEnumsList[dropdownSelectIndex],
    ["bizId"] = bizId,
    ["goldNum"] = goldNum,
    ["customId"] = customId
};
Debug.Log($"RequestGoldOrder param :{paramJson.ToJson()}");
StarkSDK.API.GetStarkGoldCoinGameManager().RequestGoldOrder(paramJson,
    orderId =>
    {
        var printText = $"requestGoldOrder success, {orderId}";
        Debug.Log(printText);
        PrintText(printText);
    }, () =>
    {
        var printText = $"requestGoldOrder complete";
        Debug.Log(printText);
        PrintText(printText);
    },
    (errorCode, errorMsg) =>
    {
        var printText = $"requestGoldOrder error, errorCode :{errorCode}, errorMsg:{errorMsg}";
        Debug.Log(printText);
        PrintText(printText);
    });

/// <summary>
/// 获取系统字体,仅支持WebGL,AndroidNative方案无需调用此接口，使用默认字体时，便会自动使用系统字体。
/// </summary>
/// <param name="callback">字体资源回调，可为null，开发者需要做好兜底</param>
/// <returns></returns>
public abstract void GetSystemFont(Action<Font> callback);

public class SystemFont : MonoBehaviour
{
    public Text txt;
    
    void Start()
    {
        StarkSDK.API.GetSystemFont(font =>
            {
                txt.font = font; //将获取到的font赋值给Text组件的font
            }); 
    }
}

/// <summary>
/// 在平台创建群聊，获得 groupid 后，游戏内通过这个方法引导用户加入抖音群
/// </summary>
/// <param name="groupId">群 ID  必填</param>
/// <param name="callback">接口调用成功/失败的回调函数  必填</param>
/// <param name="sessionFrom">会话来源 可空</param>
/// <param name="extraInfo">附加信息 可空</param>
public abstract void JoinGroup(string groupId, Action<bool, string> callback,string sessionFrom = null,string extraInfo = null);

StarkSDK.API.GetStarkGroup().JoinGroup(groupId, (isSuccess, data) =>
{
    if (isSuccess)
    {
        PrintText($"Call JoinGroup success, {data}");
    }
    else
    {
        PrintText($"Call JoinGroup fail, {data}");
    }
});

/// <summary>
///查询用户通过小游戏平台创建的群的信息
/// 如游戏开发者在平台创建了群聊 ABC，那么游戏侧可以基于游戏开发者在这个游戏中的 openid，查询其在小游戏平台创建了哪些群，群的状态如何，做游戏内的加群逻辑优化
/// </summary>
/// <param name="openId">建群用户的 openid 必填</param>
/// <param name="onCheckGroupInfoSuccessCallback">接口调用成功的回调函数 必填</param>
/// <param name="onCheckGroupInfoFailCallback">接口调用失败的回调函数 必填</param>
/// <param name="sessionFrom">会话来源 可空</param>
/// <param name="extraInfo">附加信息 可空</param>
public abstract void CheckGroupInfo(string openId,
    OnCheckGroupInfoSuccessCallback onCheckGroupInfoSuccessCallback,
    OnCheckGroupInfoFailCallback onCheckGroupInfoFailCallback,
    string sessionFrom = null,
    string extraInfo = null);

StarkSDK.API.GetStarkGroup().CheckGroupInfo(openId, (ref List<StarkGroup.GroupInfo> list) =>
{
    PrintText($"Call CheckGroupInfo success, {list.ToJson()}");
}, errMsg =>
{
    PrintText($"Call CheckGroupInfo fail, {errMsg}");
});

/// <summary>
/// 重启小游戏
/// </summary>
/// <param name="failCallback">接口调用失败时的回调</param>
public abstract void RestartApp(Action failCallback = null);

StarkSDK.API.RestartApp(() =>
{
    Debug.LogError("重启程序失败");
});

/// <summary>
/// 收藏引导
/// <param name="style">弹窗类型，默认为底部弹窗</param>
/// <param name="content">弹窗文案，仅style为 Tip 时可修改，最多显示 12 个字符。</param>
/// </summary>
public abstract void ShowFavoriteGuide(Style style = Style.BottomBar, string content = "");

StarkSDK.API.GetStarkFavorite().ShowFavoriteGuide(StarkFavorite.Style.TopBar);

/// <summary>
/// 获取用户已经授权过的配置。
/// 结果中只会包含向用户请求过的权限。
/// 与 OpenSetting 的区别是 GetSetting 只会获取配置，而不会打开配置页面。
/// </summary>
/// <param name="onGetSettingSuccess">接口调用成功的回调函数</param>
/// <param name="onGetSettingFail">接口调用失败的回调函数</param>
public abstract void GetSetting(OnGetSettingSuccess onGetSettingSuccess,
    OnGetSettingFail onGetSettingFail);

StarkSDK.API.GetAccountManager().GetSetting(
    (auth) => { PrintText($"TestGetSetting info auth: {auth}"); },
    (errMsg) => { PrintText($"TestGetSetting fail: {errMsg}"); });

/// <summary>
/// 打开设置页面，返回用户设置过的授权结果。
/// 结果中只会包含用户请求过的权限。
/// 与 GetSetting 的区别是，OpenSetting 会打开设置页面，而 GetSetting 只会返回用户授权的设置信息。
/// <param name="onOpenSettingSuccess">接口调用成功的回调函数</param>
/// <param name="onOpenSettingFail">接口调用失败的回调函数</param>
/// </summary>
public abstract void OpenSetting(OnOpenSettingSuccess onOpenSettingSuccess,
    OnOpenSettingFail onOpenSettingFail);

StarkSDK.API.GetAccountManager().OpenSetting(
    (auth) => { PrintText($"TestOpenSetting info new auth: {auth}"); },
    (errMsg) => { PrintText($"TestOpenSetting fail: {errMsg}"); });

/// <summary>
/// 提供小游戏获取抖音权限的能力，展示出抖音权限授权弹窗。
/// 在使用在接口前，需要小游戏拥有者登录抖音开发平台申请开通小游戏需要的权限。
/// </summary>
public abstract void ShowDouyinOpenAuth(Dictionary<string, DouyinPermissionScopeStatus> scopes,
    OnShowDouyinOpenAuthSuccessCallback successCallback, 
    OnShowDouyinOpenAuthFailedCallback failedCallback);

StarkSDK.API.GetAccountManager().ShowDouyinOpenAuth(new Dictionary<string, DouyinPermissionScopeStatus>()
    {
        {"im", DouyinPermissionScopeStatus.Required},
        {"im.media", DouyinPermissionScopeStatus.OptionalUnselected}, 
    },
    (errMsg, ticket, grantPermissions) =>
    {
        PrintText($"TestShowDouyinOpenAuth success. errMsg: {errMsg}, ticket: {ticket}, grantPermissions: {grantPermissions}");
    },
    (errNo, errMsg) =>
    {
        PrintText($"TestShowDouyinOpenAuth fail: {errNo} {errMsg}");
    });

/// <summary>
/// 拉起实名认证窗口。
/// 注意：调用该接口前请确保用户已登录。
/// </summary>
/// <param name="successCallback">实名认证窗口拉起成功回调</param>
/// <param name="failedCallback">实名认证窗口拉起失败回调</param>
public abstract void AuthenticateRealName(OnAuthenticateRealNameSuccessCallback successCallback,
    OnAuthenticateRealNameFailedCallback failedCallback);

StarkSDK.API.GetAccountManager().AuthenticateRealName(
    (errMsg) => { PrintText($"TestAuthenticateRealName success: {errMsg}"); },
    (errMsg) => { PrintText($"TestAuthenticateRealName fail: {errMsg}"); });

/// <summary>
/// 调起引导用户复访的提示弹窗，目前仅抖音宿主支持。
/// 为了更好的玩家体验，建议在按钮的点击回调中使用。
/// </summary>
/// <param name="callback">调起复访提示回调，true表示成功，false表示失败</param>
public abstract void ShowRevisitGuide(Action<bool> callback);

StarkSDK.API.GetStarkFavorite().ShowRevisitGuide((res) => Debug.Log($"ShowRevisitGuide result: {res}"));

//开启关注抖音号API的MOCK
StarkSDKSpace.MockSetting.SwithMockModule(StarkSDKSpace.MockModule.FollowDouyin, true)

//调用API时会弹出调试框
StarkSDK.API.FollowDouYinUserProfile(OnFollowCallback, OnFollowError)