com.xd.sdk.common 0.0.1

package/Mobile/XDGCommonMobileImpl.cs

@@ -0,0 +1,547 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+using TapTap.Bootstrap;
+using TapTap.Common;
+using UnityEngine;
+using XD.SDK.Common.MiniJSON;
+
+namespace  XD.SDK.Common{
+    public class XDGCommonMobileImpl{
+        private static readonly string COMMON_MODULE_UNITY_BRIDGE_NAME = "XDGCoreService";
+        private static volatile XDGCommonMobileImpl _instance;
+        private static readonly object locker = new object();
+
+        private static string Channel = "";
+        private static string GameVersion = "";
+
+        private XDGCommonMobileImpl(){
+            XDGLogger.Debug("===> Init XDG Bridge Service");
+            EngineBridge.GetInstance()
+                .Register(XDGUnityBridge.COMMON_SERVICE_NAME, XDGUnityBridge.COMMON_SERVICE_IMPL);
+        }
+
+        public static XDGCommonMobileImpl GetInstance(){
+            if (_instance != null) return _instance;
+            lock (locker){
+                if (_instance == null){
+                    _instance = new XDGCommonMobileImpl();
+                }
+            }
+
+            return _instance;
+        }
+
+        public void InitSDK(Action<bool, string> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("initSDK")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+
+            EngineBridge.GetInstance().CallHandler(command, (result) => {
+                XDGLogger.Debug("===> Init XDG SDK result: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback(false, "Init SDK Fail");
+                    XDGLogger.Error("初始化失败 result：" + result.ToJSON());
+                    return;
+                }
+
+                var wrapper = new XDGInitResultWrapper(result.content);
+                if (wrapper.localConfigInfo.tapSdkConfig != null && wrapper.isSuccess){
+                    var info = wrapper.localConfigInfo.tapSdkConfig;
+                    var region = RegionType.CN;
+                    if (info.region != 0){ //0国内，否则海外
+                        region = RegionType.IO;
+                    }
+                    
+                    //替换channel, gameVersion
+                    if (!string.IsNullOrEmpty(Channel)){
+                        info.channel = Channel;
+                    }
+                    if (!string.IsNullOrEmpty(GameVersion)){
+                        info.gameVersion = GameVersion;
+                    }
+
+                    if (string.IsNullOrEmpty(info.gameVersion)){
+                        info.gameVersion = ""; //不可以null 否则3.9.0 tapdb初始化不了
+                    }
+                    
+                    var config = new TapConfig.Builder()
+                        .ClientID(info.clientId) // 必须，开发者中心对应 Client ID
+                        .ClientToken(info.clientToken) // 必须，开发者中心对应 Client Token
+                        .ServerURL(info.serverUrl) // 开发者中心 > 你的游戏 > 游戏服务 > 云服务 > 数据存储 > 服务设置 > 自定义域名 绑定域名
+                        .RegionType(region) // 非必须，默认 CN 表示国内, IO国外
+                        .TapDBConfig(info.enableTapDB, info.channel, info.gameVersion, info.idfa)
+                        .ConfigBuilder();
+                    TapCommon.SetDurationStatisticsEnabled(false);
+                    TapBootstrap.Init(config);
+                    XDGLogger.Debug(
+                        $"初始化 TapBootstrap 成功：{JsonUtility.ToJson(info)}");
+                }
+
+                callback(wrapper.isSuccess, wrapper.message);
+            });
+        }
+
+        public void IsInitialized(Action<bool> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("isInitialized")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> IsInitialized: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback(false);
+                    return;
+                }
+
+                callback("true".Equals(result.content.ToLower()));
+            });
+        }
+
+        public void SetLanguage(LangType langType){
+            XDGLogger.Debug("===> SetLanguage langType: " + langType);
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("setLanguage")
+                .Args("langType", (int) langType)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void Share(ShareFlavors shareFlavors, string imagePath, XDGShareCallback callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("shareWithImage")
+                .Args("shareFlavors", (int) shareFlavors)
+                .Args("imagePath", imagePath)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> share with type: " + shareFlavors + " result: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback.ShareFailed($"Share Failed:{result.message}");
+                    return;
+                }
+
+                var shareWrapper = new XDGShareResultWrapper(result.content);
+                if (shareWrapper.cancel){
+                    callback.ShareCancel();
+                    return;
+                }
+
+                if (shareWrapper.error != null){
+                    if (!string.IsNullOrEmpty(shareWrapper.error.error_msg)){
+                        callback.ShareFailed(shareWrapper.error.error_msg);
+                        return;
+                    }
+                }
+
+                callback.ShareSuccess();
+            });
+        }
+
+        public void Share(ShareFlavors shareFlavors, string uri, string message, XDGShareCallback callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("shareWithUriMessage")
+                .Args("shareFlavors", (int) shareFlavors)
+                .Args("uri", uri)
+                .Args("message", message)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> share with type: " + shareFlavors + " result: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback.ShareFailed($"Share Failed:{result.message}");
+                    return;
+                }
+
+                var shareWrapper = new XDGShareResultWrapper(result.content);
+                if (shareWrapper.cancel){
+                    callback.ShareCancel();
+                    return;
+                }
+
+                if (shareWrapper.error != null){
+                    if (!string.IsNullOrEmpty(shareWrapper.error.error_msg)){
+                        callback.ShareFailed(shareWrapper.error.error_msg);
+                        return;
+                    }
+                }
+
+                callback.ShareSuccess();
+            });
+        }
+
+        public void Report(string serverId, string roleId, string roleName){
+            var argsDic = new Dictionary<string, object>{
+                {"serverId", serverId},
+                {"roleId", roleId},
+                {"roleName", roleName}
+            };
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("report")
+                .Args(argsDic)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug($"===> Report:  {serverId} -- {roleId} -- {roleName}");
+        }
+
+        public void TrackRole(string serverId, string roleId, string roleName, int level){
+            var argsDic = new Dictionary<string, object>{
+                {"serverId", serverId},
+                {"roleId", roleId},
+                {"roleName", roleName},
+                {"level", level}
+            };
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("trackRole")
+                .Args(argsDic)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug($"===> TrackRole:  {serverId} -- {roleId} -- {roleName} -- {level}");
+        }
+
+        public void TrackUser(string userId){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("trackUser")
+                .Args("userId", userId)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug($"===> TrackUser:  {userId}");
+        }
+
+        public void TrackEvent(string eventName, Dictionary<string,object> properties = null){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("trackEvent")
+                .Args("eventName", eventName)
+                .Args("properties", properties)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug($"===> TrackEvent:  {eventName} {properties}");
+        }
+        
+        public void EventCompletedTutorial(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("eventCompletedTutorial")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> eventCompletedTutorial");
+        }
+
+        public void EventCreateRole(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("eventCreateRole")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> eventCreateRole");
+        }
+
+        public void GetVersionName(Action<string> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("getSDKVersionName")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> GetVersionName: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback($"GetVersionName Failed:{result.message}");
+                    return;
+                }
+
+                callback(result.content);
+            });
+        }
+
+        public void TrackAchievement(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("trackAchievement")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> trackAchievement");
+        }
+
+        public void SetCurrentUserPushServiceEnable(bool enable){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("setCurrentUserPushServiceEnable")
+                .Args("enable", enable)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> SetCurrentUserPushServiceEnable");
+        }
+
+        public void IsCurrentUserPushServiceEnable(Action<bool> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("isCurrentUserPushServiceEnable")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> isCurrentUserPushServiceEnable: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback(false);
+                    return;
+                }
+
+                callback("true".Equals(result.content.ToLower()));
+            });
+        }
+
+        public void StoreReview(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("storeReview")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+            XDGLogger.Debug("===> StoreReview");
+        }
+
+        public void GetRegionInfo(Action<XDGRegionInfoWrapper> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("getRegionInfo")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("GetRegionInfo result --> " + JsonUtility.ToJson(result));
+                var tmp = new XDGRegionInfoWrapperMobile(result.content) as XDGRegionInfoWrapper;
+                callback(tmp);
+            });
+        }
+
+        public void ShowLoading(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("showLoading")
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void HideLoading(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("hideLoading")
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void LoginSuccessEvent(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("loginSuccessEvent")
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void LoginFailEvent(string loginFailMsg){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("loginFailEvent")
+                .Args("loginFailMsg", loginFailMsg)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void SetDebugMode(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("setDebugMode")
+                .Args("setDebugMode", 1)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void setTargetCountryOrRegion(string range){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("setTargetCountryOrRegion")
+                .Args("setTargetCountryOrRegion", range)
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void disableAgreementUI(){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("disableAgreementUI")
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+
+        public void updateConfigFileName(string fileName){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("updateConfigFileName")
+                .Args("updateConfigFileName", fileName)
+                .Callback(false)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+        }
+        
+        public void ReplaceChannelAndVersion(string channel, string gameVersion){
+            Channel = channel;
+            GameVersion = gameVersion;
+        }
+
+        public void clearAllUserDefaultsData(){
+#if UNITY_IOS
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("clearAllUserDefaultsData")
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command);
+#endif
+        }
+        
+        public void GetDid(Action<string> callback){
+            var command = new Command.Builder()
+                .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                .Method("getDid")
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder();
+            EngineBridge.GetInstance().CallHandler(command, result => {
+                XDGLogger.Debug("===> getDid: " + result.ToJSON());
+                if (!checkResultSuccess(result)){
+                    callback($"getDid Failed:{result.message}");
+                    return;
+                }
+                callback(result.content);
+            });
+        }
+
+        private bool checkResultSuccess(Result result){
+            return result.code == Result.RESULT_SUCCESS && !string.IsNullOrEmpty(result.content);
+        }
+        
+        public void GetAgreementList(Action<List<XDGAgreement>> callback)
+        {
+            try
+            {
+                var command = new Command.Builder()
+                    .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                    .Method("getAgreementList")
+                    .Callback(true)
+                    .OnceTime(true)
+                    .CommandBuilder();
+                EngineBridge.GetInstance().CallHandler(command, result => {
+                    XDGLogger.Debug("===> GetAgreementList: " + result.ToJSON());
+                    if (!checkResultSuccess(result)){
+                        return;
+                    }
+                    var content = result.content;
+                    var list = GetAgreementList(content);
+                    var tmp = list.ConvertAll<XDGAgreement>(input => input as XDGAgreement);
+                    callback ?.Invoke(tmp);
+                });
+            }
+            catch (Exception e)
+            {
+                Debug.LogErrorFormat($"获取 AgreementList 遇到错误!\n{e.Message}\n{e.StackTrace}");
+            }
+        }
+
+        private List<XDGAgreementMobile> GetAgreementList (string jsonStr)
+        {
+            XDGLogger.Debug("[GetAgreementList] jsonStr:\n" + jsonStr);
+            List<XDGAgreementMobile> result = null;
+            var dicStrStr = TapTap.Common.Json.Deserialize(jsonStr);
+            var dic = dicStrStr as Dictionary<string, object>;
+            var list = SafeDictionary.GetValue<List<object>>(dic, "list");
+            if (list == null)  return result;
+            result = new List<XDGAgreementMobile>();
+            foreach (var agreementStr in list)
+            {
+                var agreement = new XDGAgreementMobile(agreementStr as Dictionary<string, object>);
+                result.Add(agreement);
+            }
+
+            return result;
+        }
+        
+        public void ShowDetailAgreement(string agreementUrl)
+        {
+            try
+            {
+                var command = new Command.Builder()
+                    .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                    .Method("showDetailAgreement")
+                    .Args("showDetailAgreement", agreementUrl)
+                    .OnceTime(true)
+                    .CommandBuilder();
+                EngineBridge.GetInstance().CallHandler(command);
+                XDGLogger.Debug($"===> ShowDetailAgreement:  {agreementUrl}");
+            }
+            catch (Exception e)
+            {
+                Debug.LogErrorFormat($"显示详细Agreement遇到错误!\n{e.Message}\n{e.StackTrace}");
+            }
+        }
+        
+        public void SetExitHandler(Action onExitHandler)
+        {
+            try
+            {
+                XDGLogger.Debug("[unity 设置 exitHandler:");
+                var command = new Command.Builder()
+                    .Service(COMMON_MODULE_UNITY_BRIDGE_NAME)
+                    .Method("setExitHandler")
+                    .Callback(true)
+                    .OnceTime(true)
+                    .CommandBuilder();
+                EngineBridge.GetInstance().CallHandler(command, result => {
+                    XDGLogger.Debug("===> setExitHandler: " + result.ToJSON());
+                    if (!checkResultSuccess(result)){
+                        return;
+                    }
+                    if (onExitHandler == null)
+                        Application.Quit();
+                    else
+                        onExitHandler.Invoke();
+                });
+            }
+            catch (Exception e)
+            {
+                Debug.LogErrorFormat($"SetExitHandler遇到错误!\n{e.Message}\n{e.StackTrace}");
+            }
+        }
+    }
+}

package/Mobile/XDGCommonMobileImpl.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4202b1be65a664089a445957d0d4e888
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/XDGErrorMobile.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LC.Newtonsoft.Json;
+using LC.Newtonsoft.Json.Serialization;
+using TapTap.Common;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace XD.SDK.Common{
+    [Serializable]
+    public class XDGErrorMobile : XDGError{
+        public int _code; //40021: 邮箱未做验证, 40902: 邮箱冲突，第三方登录方式绑定邮箱关联账号已存在当前登录方式的另一个账号绑定。这两个code游戏需要弹框提示！！
+        public string _error_msg;
+        public Dictionary<string, object> _extra_data; //参考： https://stg-xdsdk.ap-sg.tdsapps.com/docs/account/account-server#taptap-%E7%BB%91%E5%AE%9A%E9%82%AE%E7%AE%B1%E6%9C%AA%E9%AA%8C%E8%AF%81
+
+        public XDGErrorMobile(Dictionary<string, object> dic){
+            if (dic != null){
+                _code = SafeDictionary.GetValue<int>(dic, "code");
+                _error_msg = SafeDictionary.GetValue<string>(dic, "error_msg");
+                if (string.IsNullOrEmpty(_error_msg)){
+                    _error_msg = SafeDictionary.GetValue<string>(dic, "errorMsg");
+                }
+
+                if (dic.ContainsKey(@"extra_data")){
+                    var dataObj = dic["extra_data"]; //有可能空字符串
+                    if (dataObj != null && dataObj.GetType() == typeof(Dictionary<string, object>)){
+                        _extra_data = dataObj as Dictionary<string, object>;
+                    }
+                }
+            }
+        }
+
+        public XDGErrorMobile(int code, string errorMsg){
+            this._code = code;
+            this._error_msg = errorMsg;
+        }
+
+        public string ToJSON(){
+            return JsonUtility.ToJson(this);
+        }
+
+        public int code => _code;
+        public string error_msg => _error_msg;
+        public Dictionary<string, object> extra_data => _extra_data;
+    }
+}

package/Mobile/XDGErrorMobile.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6aacadea342d548da9124804588d30dc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/XDGRegionInfoMobile.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using TapTap.Common;
+
+namespace  XD.SDK.Common
+{
+    public class XDGRegionInfoMobile : XDGRegionInfo
+    {
+        private string _city;
+        private string _countryCode;
+        private string _timeZone;
+        private string _locationInfoType;
+
+        public XDGRegionInfoMobile(Dictionary<string, object> dic)
+        {
+            if (dic == null) return;
+            _city = SafeDictionary.GetValue<string>(dic, "city");
+            _countryCode = SafeDictionary.GetValue<string>(dic, "countryCode");
+            _timeZone = SafeDictionary.GetValue<string>(dic, "timeZone");
+            _locationInfoType = SafeDictionary.GetValue<string>(dic, "locationInfoType");
+        }
+
+        public string city => _city;
+        public string countryCode => _countryCode;
+        public string timeZone => _timeZone;
+        public string locationInfoType => _locationInfoType;
+    }
+}

package/Mobile/XDGRegionInfoMobile.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5624422c8b4c6447e90a06f3d040b38e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/XDGSettingsMobile.cs

@@ -0,0 +1,13 @@
+#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
+
+namespace XD.SDK.Common
+{
+    public class XDGSettingsMobile : IXDGSettings
+    {
+        public void SetTargetCountryOrRegion(string region)
+        {
+            XDGCommonMobileImpl.GetInstance().setTargetCountryOrRegion(region);
+        }
+    }
+}
+#endif

package/Mobile/XDGSettingsMobile.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 61096a79267d457fa3bfab2ffda8c109
+timeCreated: 1719483855