个人对微信和抖音小游戏SDK封装记录

前言

        纯代码记录文，甚至都没有优化的，如果你真的有需要请谨慎参考。

环境

Unity2022.3.62f3c1
Windows11
TTSDK 6.7.9
ByteGame Develop Tools 3.0.271
微信开发者工具：2.02.2608070 Stable
微信小游戏转换插件管理版本：202609161205
调试基础库：3.17.3
UniTask 2.5.11

正文

PlatformUtility

using UnityEngine;
using System;
using Newtonsoft.Json;
using System.IO;

using Cysharp.Threading.Tasks;
using System.Reflection;
using System.Collections.Generic;
#if WEIXINMINIGAME
using WeChatWASM;
#endif

#if DOUYINMINIGAME
using TTSDK;
using TTSDK.UNBridgeLib.LitJson;
using TTSDK.SimpleJSON;
#endif

namespace Common
{
    public static class PlatformUtility
    {
#if DOUYINMINIGAME
        private static string adId = "";
#else
        private static string adId = "";
#endif

        private static string platformName;

        private static string system;

        private static string deviceName;

        private static Vector2Int screenSize;

        private static Vector2Int safeScreenSize;

        private static Vector2Int safeScreenLeftTopPoint;

        private static Action adSuccess;
        private static Action adFail;

        private static Action<PlatformOnShowData> returnGameCallBack;

        private static Action hideOrExitGameCallBack;

        public static Vector2Int SafeScreenSize => safeScreenSize;
        public static Vector2Int ScreenSize => screenSize;


        public static void PlatformUtilityInit()
        {
            Debug.Log("平台初始化");

#if UNITY_EDITOR
            platformName = "编辑器";
            screenSize = new Vector2Int(Screen.width, Screen.height);
            safeScreenSize = new Vector2Int((int)Screen.safeArea.width, (int)Screen.safeArea.height);
            system = UnityEngine.SystemInfo.operatingSystem;
            deviceName = UnityEngine.SystemInfo.deviceName;

#elif DOUYINMINIGAME

            platformName = "抖音";
            if (CanIUse.GetSystemInfo)
            {
                var systemInfo = TT.GetSystemInfo();

                system = systemInfo.system;
                deviceName = systemInfo.model;
                screenSize = new Vector2Int(systemInfo.screenWidth, systemInfo.screenHeight);
                safeScreenSize = new Vector2Int(systemInfo.safeArea.width, systemInfo.safeArea.height);
                safeScreenLeftTopPoint = new Vector2Int(systemInfo.safeArea.left, systemInfo.safeArea.top);
            }
            else
            {
                screenSize = new Vector2Int(Screen.width, Screen.height);
                safeScreenSize = new Vector2Int((int)Screen.safeArea.width, (int)Screen.safeArea.height);
                Debug.Log("接口无法获取对应信息");
            }
#elif WEIXINMINIGAME
            platformName = "微信";
            /*var deviceInfo = WeChatWASM.WX.GetDeviceInfo();
            screenSize = new Vector2Int(Screen.width, Screen.height);
            safeScreenSize = new Vector2Int((int)Screen.safeArea.width, (int)Screen.safeArea.height);
            deviceName = deviceInfo.platform;
            system = deviceInfo.system;*/
            screenSize = new Vector2Int(Screen.width, Screen.height);
            safeScreenSize = new Vector2Int((int)Screen.safeArea.width, (int)Screen.safeArea.height);
            system = UnityEngine.SystemInfo.operatingSystem;
            deviceName = UnityEngine.SystemInfo.deviceName;
#else
            platformName = "其他";
            screenSize = new Vector2Int(Screen.width, Screen.height);
            safeScreenSize = new Vector2Int((int)Screen.safeArea.width, (int)Screen.safeArea.height);
            system = UnityEngine.SystemInfo.operatingSystem;
            deviceName = UnityEngine.SystemInfo.deviceName;
#endif
        }

        public static string GameVersion
        {
            get
            {
                Debug.Log("获取游戏版本");
#if UNITY_EDITOR
                return "编辑器";
#elif DOUYINMINIGAME
                return TT.GameVersion;
#elif WEIXINMINIGAME
                return WeChatWASM.WX.GetAccountInfoSync().miniProgram.version;
#else
                return "其他";
#endif
            }
        }

        public static string SystemInfo => deviceName + system;

        public static string PlatformName => platformName;

        public static void SDKInit(Action success)
        {
#if UNITY_EDITOR
            success?.Invoke();
#elif DOUYINMINIGAME
            TTSDK.TT.InitSDK((code, env) =>
            {
                success?.Invoke();
            });
#elif WEIXINMINIGAME
            WeChatWASM.WX.InitSDK((initResult) =>
            {
                Debug.Log("微信SDK初始化调用完毕，初始化值为：" + initResult);
                success?.Invoke();
                /*if (initResult == 0 || initResult == 200)
                {
                    Debug.Log("微信SDK初始化调用完毕，初始化值为：" + initResult);
                    success?.Invoke();
                }
                else
                {
                    Debug.LogError($"SDK初始化失败: {initResult}");
                }*/
            });
#else
            success?.Invoke();
#endif
        }


        public static void SetFrameLimit(int frame)
        {
            /* // 微信开发工具上说不建议使用了
#elif WEIXINMINIGAME
            WeChatWASM.WX.SetPreferredFramesPerSecond(frame);*/
            Debug.Log("帧限制");
#if UNITY_EDITOR
            Application.targetFrameRate = frame;
#elif DOUYINMINIGAME
            TT.SetPreferredFramesPerSecond(frame);
#else
            Application.targetFrameRate = frame;
#endif
        }

        public static void PlatformLogin(Action<PlatformLoginCodeInfo> success,Action<string> fail,bool forceLogin)
        {
#if UNITY_EDITOR
            success.Invoke(new PlatformLoginCodeInfo()
            {
                code = "Test",
                anonymousCode = "Test"
            });
#elif DOUYINMINIGAME
            // force 为 true 时（默认值为 true），如果用户未在端登录（例如未在头条 APP 登录），则会调起端的登录窗口，如果用户点击取消则会调用 fail 回调
            // 只有端登录的用户 success 才有 code，否则只有 anonymousCode
            // code 可以换取 openid，openid 是用户的唯一标识
            // nonymousCode 可以换取 anonymous_openid，同一台手机的 anonymous_openid 是相同的
            TT.Login((code, anonymousCode, isLogin) =>
            {
                PlatformLoginCodeInfo info = new PlatformLoginCodeInfo()
                {
                    code = code,
                    anonymousCode = anonymousCode
                };
                success.Invoke(info);
            }, (errMsg) =>
            {
                fail?.Invoke(errMsg);
            }, forceLogin);
#elif WEIXINMINIGAME
            WeChatWASM.LoginOption loginOption = new WeChatWASM.LoginOption()
            {
                success = (result) =>
                {
                    success?.Invoke(new PlatformLoginCodeInfo()
                    {
                        code = result.code
                    });
                },
                fail = (result) =>
                {
                    Debug.LogError($"登录失败: code={result.errno}, msg={result.errMsg}");
                }
            };
            WeChatWASM.WX.Login(loginOption);
#else
            success.Invoke(new PlatformLoginCodeInfo()
            {
                code = "Test",
                anonymousCode = "Test"
            });
#endif
        }

        // 检测是否得到获取用户信息授权
        public static void CheckGetUserInfoAuth(Action success, Action<string> reject, Action<string> fail)
        {
            Debug.Log("SDK获取用户授权");
#if UNITY_EDITOR
            success?.Invoke();
#elif DOUYINMINIGAME
            TT.GetUserInfoAuth(
                (auth) => {
                    if (auth)
                        success?.Invoke();
                    else reject?.Invoke("用户不给授权");
                },
                (errMsg) => { fail?.Invoke(errMsg); });
#elif WEIXINMINIGAME
            WeChatWASM.GetSettingOption option = new WeChatWASM.GetSettingOption()
            {
                success = (res) =>
                {
                    // 判断逻辑：检查 authSetting 字典中是否存在 "scope.userInfo" 且其值为 true
                    bool isAuthorized = res.authSetting != null
                                       && res.authSetting.ContainsKey("scope.userInfo")
                                       && res.authSetting["scope.userInfo"];

                    if (isAuthorized)
                    {
                        success?.Invoke();
                    }
                    else
                    {
                        reject?.Invoke("用户没给授权");
                    }
                },
                fail = (err) =>
                {
                    fail?.Invoke(err.errMsg);
                }
            };
            WeChatWASM.WX.GetSetting(option);
#else
            success?.Invoke();
#endif
        }

        // 打开用户授权界面
        public static void OpenSettingsPanel(Action success, Action<string> reject, Action<string> fail)
        {
            Debug.Log("SDK打开授权界面");
#if UNITY_EDITOR
            success?.Invoke();
#elif DOUYINMINIGAME
            TT.OpenSettingsPanel(
                (auth) => {
                    if (auth)
                        success?.Invoke();
                    else reject?.Invoke("用户不给授权");
                },
                (errMsg) => { fail?.Invoke(errMsg); });
#elif WEIXINMINIGAME
            var btn = WeChatWASM.WX.CreateUserInfoButton(0, 0, Screen.width, Screen.height, "zh_CN", false);
            btn.Show();
            btn.OnTap((res) =>
            {
                if (res.errCode == 0)
                {
                    success?.Invoke();
                }
                else
                {
                    reject?.Invoke("用户拒绝");
                }
                // 无论隐藏按钮
                btn.Destroy();
            });
#else
            success?.Invoke();
#endif
        }

        // 在画布顶层加载一个额外的用户授权点击按钮，rect.xy表示方位，rect.zw表示长宽，回调后自动销毁
        public static System.Object ShowExtraGetUserInfoBtn(Vector4 rect, Action success, Action<string> reject)
        {
#if UNITY_EDITOR
            success?.Invoke();
            return null;
#elif WEIXINMINIGAME
            var btn = WeChatWASM.WX.CreateUserInfoButton((int)rect.x, (int)rect.y, (int)rect.z, (int)rect.w, "zh_CN", false);
            btn.Show();
            btn.OnTap((res) =>
            {
                if (res.errCode == 0)
                {
                    success?.Invoke();
                }
                else
                {
                    reject?.Invoke("用户拒绝");
                }
            });
            return btn;
#else
            success?.Invoke();
            return null;
#endif
        }

        // 获取用户信息
        public static void GetUserInfo(Action<PlatformUserInfo> success, Action<string> fail)
        {
            Debug.Log("SDK获取用户信息");
#if UNITY_EDITOR
            success.Invoke(new PlatformUserInfo()
            {
                nickName = "测试",
            });
#elif DOUYINMINIGAME
            TT.GetUserInfo(true,(ref TTSDK.TTUserInfo tTUserInfo)=>
            {
                success?.Invoke(PlatformUserInfo.TransiteToInfo(tTUserInfo));
            }, (errMsg) =>
            {
                fail?.Invoke(errMsg);
            });
#elif WEIXINMINIGAME
            var option = new WeChatWASM.GetUserInfoOption()
            {
                success = (result) =>
                {
                    success?.Invoke(PlatformUserInfo.TransiteToInfo(result.userInfo));
                },
                fail = (result) =>
                {
                    fail?.Invoke(result.errMsg);
                }
            };
            WeChatWASM.WX.GetUserInfo(option);
#else
            success.Invoke(new PlatformUserInfo()
            {
                nickName = "测试",
            });
#endif
        }

        // 分享游戏

        public static void ShareGame(Action success,Action fail,Action cancel)
        {
            Debug.Log("SDK分享游戏");
#if UNITY_EDITOR
            success?.Invoke();
#elif DOUYINMINIGAME
            TT.ShareAppMessage(new JsonData(JsonConvert.SerializeObject(new PlatformShareCommonData())),
            (x) =>
            {
                success?.Invoke();
            },
            (x) =>
            {
                fail?.Invoke();
            },
            () =>
            {
                cancel?.Invoke();
            });
#elif WEIXINMINIGAME
            var option = new WeChatWASM.ShareAppMessageOption()
            {
                title = "哇！卡皮巴拉",
            };

            WeChatWASM.WX.ShareAppMessage(option);
            var shareData = new PlatformShareCommonData();
            shareData.success = success;
            shareData.failure = fail;
            // 这里做了直接移除的处理，如果后续需要onshow的操作，这个就不行了
            shareData.complete = OffReturnGameListen;
            shareData.SetDelayTime(2.5f);
            AddReturnGameListen(shareData.CallBack);
#else
            success?.Invoke();
#endif
        }

        // 激励广告
#if WEIXINMINIGAME
        private static WeChatWASM.WXRewardedVideoAd rewardedVideoAd;

        private static void WxADOnClose(WeChatWASM.WXRewardedVideoAdOnCloseResponse result)
        {
            if (result.isEnded)
            {
                adSuccess?.Invoke();
            }
            else
            {
                adFail?.Invoke();
            }
        }

        private static void WxADOnError(WeChatWASM.WXADErrorResponse result)
        {
            adFail?.Invoke();
        }

        public static void WxADOnLoad(WeChatWASM.WXADLoadResponse result)
        {
            rewardedVideoAd.Show();
        }

#elif DOUYINMINIGAME
        private static TTSDK.TTRewardedVideoAd douYinAd;

        private static void DouYinOnClose(bool result,int flag)
        {
            if (result)
                adSuccess?.Invoke();
            else adFail?.Invoke();
        }

        private static void DouYiOnError(int flag, string errMsg)
        {
            adFail?.Invoke();
        }
#endif
        public static void PlayRewardAd(Action success,Action fail)
        {
            adSuccess = success;
            adFail = fail;

#if GAMETESTMACRO
            success?.Invoke();
            bool test = true;
            if(test)
                return;
#endif

#if UNITY_EDITOR
            Debug.Log("编辑器不播放广告");
            success?.Invoke();
#elif DOUYINMINIGAME
            if(douYinAd == null)
            {
                douYinAd = TT.CreateRewardedVideoAd(new CreateRewardedVideoAdParam()
                {
                    AdUnitId = adId,

                });

                douYinAd.OnClose += DouYinOnClose;
                douYinAd.OnError += DouYiOnError;
                douYinAd.OnLoad += () =>
                {
                    douYinAd.Show();
                };
            }
            douYinAd.Load();
#elif WEIXINMINIGAME

            if (rewardedVideoAd == null)
            {
                var param = new WeChatWASM.WXCreateRewardedVideoAdParam()
                {
                    adUnitId = adId
                };

                rewardedVideoAd = WeChatWASM.WX.CreateRewardedVideoAd(param);

                rewardedVideoAd.OnError(WxADOnError);

                rewardedVideoAd.OnClose(WxADOnClose);
                rewardedVideoAd.OnLoad(WxADOnLoad);
            }

            rewardedVideoAd.Load();
#else
            Debug.Log("未适配平台");
            success?.Invoke();
#endif
        }

        // 报点
        public static void ReportPoint(string eventName, PlatformReportData reportData)
        {
#if UNITY_EDITOR
            Debug.Log("编辑器不报点");
#elif DOUYINMINIGAME
            TT.ReportAnalytics(eventName, reportData.CacheData);
#elif WEIXINMINIGAME
            WeChatWASM.WX.ReportEvent(eventName, reportData.TransformData());
#else
            Debug.Log("未适配平台");
#endif
        }

        // 震动
        public static void Vibrate()
        {
            Debug.Log("SDK震动");
#if UNITY_EDITOR
            Debug.Log("编辑器不震动");
#elif DOUYINMINIGAME
            TT.VibrateLong(new VibrateLongParam());
#elif WEIXINMINIGAME
            WeChatWASM.WX.VibrateLong(new WeChatWASM.VibrateLongOption());
#else
            Handheld.Vibrate();
#endif
        }

#if WEIXINMINIGAME
        public static void ReturnGameCallBack(WeChatWASM.OnShowListenerResult result)
        {
            returnGameCallBack?.Invoke(PlatformOnShowData.ToData(result));
        }
#endif

        // 添加小游戏界面回调
        public static void AddReturnGameListen(Action<PlatformOnShowData> action)
        {
#if UNITY_EDITOR
            Debug.Log("编辑器不存在这个");
            bool test = true;
            if (test)
                return;
#endif
            returnGameCallBack += action;
#if WEIXINMINIGAME
            WeChatWASM.WX.OffShow(ReturnGameCallBack);
            WeChatWASM.WX.OnShow(ReturnGameCallBack);
#else
            returnGameCallBack -= action;
#endif
        }

        // 移除返回游戏界面回调
        public static void RemoveReturnGameListen(Action<PlatformOnShowData> action)
        {
            returnGameCallBack -= action;
        }

        // 清除返回游戏界面回调
        public static void ClearReturnGameListen(Action<PlatformOnShowData> action)
        {
            returnGameCallBack = null;
        }

        // 关闭返回游戏界面回调
        public static void OffReturnGameListen()
        {
            returnGameCallBack = null;
#if UNITY_EDITOR
            Debug.Log("编辑器不存在这个");
#elif WEIXINMINIGAME
            WeChatWASM.WX.OffShow(ReturnGameCallBack);
#else
#endif
        }

#if WEIXINMINIGAME
        public static void HideOrExitGameCallBack(WeChatWASM.GeneralCallbackResult result)
        {
            hideOrExitGameCallBack?.Invoke();
        }
#endif

#if DOUYINMINIGAME
        private static bool SetOnBeforeExitAppListener()
        {
            hideOrExitGameCallBack?.Invoke();
            return true;
        }
#endif

        // 添加游戏退出事件回调
        public static void AddExitGameListen(Action action)
        {
#if UNITY_EDITOR
            Debug.Log("编辑器不存在这个");
            bool test = true;
            if (test)
                return;
#endif
            hideOrExitGameCallBack += action;
#if WEIXINMINIGAME
            WeChatWASM.WX.OffHide(HideOrExitGameCallBack);
            WeChatWASM.WX.OnHide(HideOrExitGameCallBack);
#elif DOUYINMINIGAME
            TTSDK.TT.SetOnBeforeExitAppListener(null);
            TTSDK.TT.SetOnBeforeExitAppListener(SetOnBeforeExitAppListener);
#else
            //returnGameCallBack -= action;
#endif
        }
    }

}

PlatformLoginCodeInfo

namespace Common
{
    public struct PlatformLoginCodeInfo
    {
#if DOUYINMINIGAME
        public string anonymousCode;
        public string code;
#elif UNITY_EDITOR
        public string anonymousCode;
        public string code;
#elif WEIXINMINIGAME
        public string code;
#else
        public string anonymousCode;
        public string code;
#endif
    }
}

PlatformOnShowData

using System.Collections.Generic;

namespace Common
{
    public class PlatformOnShowData
    {
#if WEIXINMINIGAME
        public static PlatformOnShowData ToData(WeChatWASM.OnShowListenerResult result)
        {
            var info = new PlatformOnShowData();
            info.scene = result.scene;
            info.query = result.query;
            info.shareTicket = result.shareTicket;
            if(result.chatType == null)
            {
                info.chatType = -1;
            }
            else info.chatType = (int)result.chatType;

            info.appId = result.referrerInfo.appId;
            info.extraData = result.referrerInfo.extraData;

            return info;
        }

        public double scene;
        public Dictionary<string, string> query;
        public string shareTicket;
        public string appId;
        public Dictionary<string, string> extraData;
        public int chatType;
#endif
    }
}

PlatformReportData

using System.Collections.Generic;

namespace Common
{
    public class PlatformReportData
    {
        private Dictionary<string, object> cache;

        public Dictionary<string, object> CacheData;

#if WEIXINMINIGAME
        public Dictionary<string,string> TransformData()
        {
            var data = new Dictionary<string, string>();
            foreach(var i in cache)
            {
                data.Add(i.Key, i.Value.ToString());
            }
            return data;
        }
#endif
    }
}

PlatformUserInfo

namespace Common
{
    public struct PlatformUserInfo
    {
#if DOUYINMINIGAME

        public static PlatformUserInfo TransiteToInfo(TTSDK.TTUserInfo tTUserInfo)
        {
            return new PlatformUserInfo()
            {
                //DouyinSensitiveDataUtility.DecryptSensitiveData(tTUserInfo.encryptedData,tTUserInfo)
                avatarUrl = tTUserInfo.avatarUrl,
                nickName = tTUserInfo.nickName,
                gender = tTUserInfo.gender,
                city = tTUserInfo.city,
                province = tTUserInfo.province,
                country = tTUserInfo.country,
                language = tTUserInfo.language,
                signature = tTUserInfo.signature,
                encryptedData = tTUserInfo.encryptedData,
                iv = tTUserInfo.iv,
                cloudId = tTUserInfo.cloudId
            };
        }

        public string avatarUrl; // 用户头像
        public string nickName; // 用户名
        public int gender; // 用户性别，0: 未知(默认值)；1:男性；2:女性
        public string city; // 城市
        public string province; // 省份
        public string country; // 用户国家
        public string language; // 用户语言，目前为空
        public string signature; //  加密签名
        public string encryptedData; // 加密数据
        public string iv; // 秘钥IV
        public string cloudId; // 抖音云CloudId
#elif WEIXINMINIGAME
        public static PlatformUserInfo TransiteToInfo(WeChatWASM.UserInfo userInfo)
        {
            return new PlatformUserInfo()
            {
                //DouyinSensitiveDataUtility.DecryptSensitiveData(tTUserInfo.encryptedData,tTUserInfo)
                avatarUrl = userInfo.avatarUrl,
                nickName = userInfo.nickName,
                language = userInfo.language
            };
        }

        public string nickName; // 用户昵称
        public string avatarUrl; // 用户头像
        public string language; // 用户语言，language 的合法值： en 英文 zh_CN 简体中文 zh_TW 繁体中文
#else
        public string nickName; // 用户名
#endif
    }
}

PlatformDataUtility

#if DOUYINMINIGAME
using System;
using TTSDK;
#endif
#if WEIXINMINIGAME
using WeChatWASM;
#endif

using System.Collections.Generic;

namespace Common
{
    public static class PlatformDataUtility
    {
        public static string UserDataPath
        {
            get
            {
                UnityEngine.Debug.Log("getData");
#if UNITY_EDITOR || DOUYINMINIGAME
                return UnityEngine.Application.persistentDataPath;
#else
                return UnityEngine.Application.persistentDataPath;
#endif
            }
        }

        public static string FullUserDataPath
        {
            get
            {
                UnityEngine.Debug.Log("getData");
#if UNITY_EDITOR
                return UnityEngine.Application.persistentDataPath;
#elif DOUYINMINIGAME
                UnityEngine.Debug.Log("getDataURL" + StarkSDKSpace.StarkFileSystemManager.USER_DATA_PATH);
                return StarkSDKSpace.StarkFileSystemManager.USER_DATA_PATH + UnityEngine.Application.persistentDataPath;
#elif WEIXINMINIGAME
                return WeChatWASM.WX.env.USER_DATA_PATH.TrimEnd('/') + "/__GAME_FILE_CACHE";
#else
                return UnityEngine.Application.persistentDataPath;
#endif
            }
        }

        public static void PlayerPrefsSetInt(string key, int value)
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.SetInt(key, value);
#elif DOUYINMINIGAME
            TT.PlayerPrefs.SetInt(key, value);
#elif WEIXINMINIGAME
            WeChatWASM.WX.StorageSetIntSync(key, value);
#else
            UnityEngine.PlayerPrefs.SetInt(key, value);
#endif
            PlayerPrefsSave();
        }

        public static int PlayerPrefsGetInt(string key, int defaultValue = 0)
        {
#if UNITY_EDITOR
            return UnityEngine.PlayerPrefs.GetInt(key, defaultValue);
#elif DOUYINMINIGAME
            return TT.PlayerPrefs.GetInt(key, defaultValue);
#elif WEIXINMINIGAME
            return WeChatWASM.WX.StorageGetIntSync(key,defaultValue);
#else
            return UnityEngine.PlayerPrefs.GetInt(key, defaultValue);
#endif
        }

        public static void PlayerPrefsSetFloat(string key, float value)
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.SetFloat(key, value);
#elif DOUYINMINIGAME
            TT.PlayerPrefs.SetFloat(key, value);
#elif WEIXINMINIGAME
            WeChatWASM.WX.StorageSetFloatSync(key, value);
#else
            UnityEngine.PlayerPrefs.SetFloat(key, value);
#endif
            PlayerPrefsSave();
        }

        public static float PlayerPrefsGetFloat(string key, float defaultValue = 0)
        {
#if UNITY_EDITOR
            return UnityEngine.PlayerPrefs.GetFloat(key, defaultValue);
#elif DOUYINMINIGAME
            return TT.PlayerPrefs.GetFloat(key, defaultValue);
#elif WEIXINMINIGAME
            return WeChatWASM.WX.StorageGetFloatSync(key, defaultValue);
#else
            return UnityEngine.PlayerPrefs.GetFloat(key, defaultValue);
#endif
        }

        public static void PlayerPrefsSetString(string key, string value)
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.SetString(key, value);
#elif DOUYINMINIGAME
            TT.PlayerPrefs.SetString(key, value);
#elif WEIXINMINIGAME
            WeChatWASM.WX.StorageSetStringSync(key, value);
#else
            UnityEngine.PlayerPrefs.SetString(key, value);
#endif
            PlayerPrefsSave();
        }

        public static string PlayerPrefsGetString(string key, string defaultValue = "")
        {
#if UNITY_EDITOR
            return UnityEngine.PlayerPrefs.GetString(key, defaultValue);
#elif DOUYINMINIGAME
            return TT.PlayerPrefs.GetString(key, defaultValue);
#elif WEIXINMINIGAME
            return WeChatWASM.WX.StorageGetStringSync(key, defaultValue);
#else
            return UnityEngine.PlayerPrefs.GetString(key, defaultValue);
#endif
        }

        public static bool PlayerPrefsHasKey(string key)
        {
#if UNITY_EDITOR
            return UnityEngine.PlayerPrefs.HasKey(key);
#elif DOUYINMINIGAME
            return TT.PlayerPrefs.HasKey(key);
#elif WEIXINMINIGAME
            return WeChatWASM.WX.StorageHasKeySync(key);
#else
            return UnityEngine.PlayerPrefs.HasKey(key);
#endif
        }

        public static void PlayerPrefsDeleteKey(string key)
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.DeleteKey(key);
#elif DOUYINMINIGAME
            TT.PlayerPrefs.DeleteKey(key);
#elif WEIXINMINIGAME
            WeChatWASM.WX.StorageDeleteKeySync(key);
#else
            UnityEngine.PlayerPrefs.DeleteKey(key);
#endif
        }

        public static void PlayerPrefsDeleteAll()
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.DeleteAll();
#elif DOUYINMINIGAME
            TT.PlayerPrefs.DeleteAll();
#elif WEIXINMINIGAME
            WeChatWASM.WX.StorageDeleteAllSync();
#else
            UnityEngine.PlayerPrefs.DeleteAll();
#endif
        }

        public static void PlayerPrefsSave()
        {
#if UNITY_EDITOR
            UnityEngine.PlayerPrefs.Save();
#elif DOUYINMINIGAME
            TT.PlayerPrefs.Save();
#elif WEIXINMINIGAME
            return;
#else
            UnityEngine.PlayerPrefs.Save();
#endif
        }

        public static void SetPlatformBuildInRankInfo(PlatformBuildInRankSetInfo info,System.Action<bool,string> callBack)
        {
#if UNITY_EDITOR
            callBack?.Invoke(true,"");
#elif DOUYINMINIGAME
            TTSDK.TT.SetImRankData(new TTSDK.UNBridgeLib.LitJson.JsonData
            {
                ["dataType"] = info.dataType,
                ["value"] = info.value,
                ["extra"] = info.extra,
                ["priority"] = info.priority,
                ["zoneId"] = info.zoneId
            },callBack);
#elif WEIXINMINIGAME
            var postInfo = new WeChatWASM.KVData[info.keyAndValue.Length];
            for (int i = 0; i < info.keyAndValue.Length; ++i)
            {
                postInfo[i] = new WeChatWASM.KVData()
                {
                    key = info.keyAndValue[i].Item1,
                    value = info.keyAndValue[i].Item2,
                };
            }

            WeChatWASM.WX.SetUserCloudStorage(new WeChatWASM.SetUserCloudStorageOption()
            {
                KVDataList = postInfo,
                success = (res) => {
                    callBack?.Invoke(true, "成功");
                },
                fail = (res) =>
                {
                    callBack?.Invoke(false, "失败");
                }
            });
#endif
        }

        public static void GetPlatformBuildInRankInfo(PlatformBuildInRankGetInfo info, System.Action<bool, string> callBack)
        {
#if UNITY_EDITOR
            callBack?.Invoke(true, "");
#elif DOUYINMINIGAME
            TTSDK.TT.GetImRankList(new TTSDK.UNBridgeLib.LitJson.JsonData
            {
                ["dataType"] = info.dataType,
                ["rankType"] = info.rankType,
                ["zoneId"] = info.zoneId,
                ["suffix"] = info.suffix,
                ["rankTitle"] = info.rankTitle,
                ["relationType"] = info.relationType,
                ["shareImageUrl"] = info.shareImageUrl,
                ["shareTitle"] = info.shareTitle
            }, callBack);
#endif
        }

        public static void GetPlatformFriendRankInfo(List<string> friends)
        {

        }
    }
}

闲言碎语

        我发现我越来越懒了，所以搞这种水文。如果我后面有动力去做了，我一定要把这篇文章中的代码全删了。然后我就保留一个Github地址。