com.typhoon.unitysdk 1.0.34 → 1.0.36

package/Editor/PluginModuleInstaller.cs

@@ -0,0 +1,452 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEditor;
+using Debug = UnityEngine.Debug;
+
+namespace TyphoonUnitySDK
+{
+    /// <summary>
+    /// 插件模块安装器
+    /// </summary>
+    public class PluginModuleInstaller
+    {
+        //插件名
+        public enum PluginNames
+        {
+            NodeJsV10_13,
+            NodeJsV15,
+            Openssl,
+            QGToolKit, //快应用工具
+            VivoNodeModule, //vivo小游戏Node模块
+        }
+
+        //插件信息
+        public class PluginInfo
+        {
+            public PluginNames PluginName;
+            public string Url;
+            public string MD5Code;
+            public string FolderName; //模块文件名
+
+            public PluginInfo(PluginNames pluginName, string url, string md5Code, string folderName)
+            {
+                PluginName = pluginName;
+                Url = url;
+                MD5Code = md5Code;
+                FolderName = folderName;
+            }
+
+            /// <summary>
+            /// 模块文件夹
+            /// </summary>
+            public string RootPath => $"{GetPluginsFolder()}/{FolderName}";
+        }
+
+        // 插件清单
+        public static PluginInfo[] PluginsManifest = new PluginInfo[]
+        {
+            new PluginInfo(PluginNames.NodeJsV10_13, "https://mecha.nthreecats.com/plugins/node-v10.13.0.zip",
+                "4fec379039bda31dd4f5d7dee27c8f84", "node-v10.13.0"),
+            new PluginInfo(PluginNames.NodeJsV15, "https://mecha.nthreecats.com/plugins/node-v15.14.0-win-x64.zip",
+                "40d03c7c1eed5c6943cc618086adfdf6", "node-v15.14.0-win-x64"),
+            new PluginInfo(PluginNames.Openssl, "https://mecha.nthreecats.com/plugins/openssl.zip",
+                "bfeb2896c357fdeea87a16ee913e8a65", "openssl"),
+            new PluginInfo(PluginNames.QGToolKit, "https://mecha.nthreecats.com/plugins/quickgame-toolkit-unity.zip",
+                "a11318f47be10876439a88baf2776b78", ""),
+            new PluginInfo(PluginNames.VivoNodeModule,
+                "https://mecha.nthreecats.com/plugins/vivo_node_modules_v1.zip",
+                "c6ee54d0fa3dae6eca0ad6613f6c15e0", "vivo_node_modules"),
+        };
+
+        //获取插件信息
+        public static PluginInfo GetPluginInfo(PluginNames pluginName)
+        {
+            foreach (var info in PluginsManifest)
+            {
+                if (info.PluginName == pluginName)
+                {
+                    return info;
+                }
+            }
+
+            throw new Exception($"找不到PluginInfo：{pluginName}");
+        }
+
+        /// <summary>
+        /// 获取插件根目录
+        /// </summary>
+        public static string GetPluginRootPath(PluginNames plugin)
+        {
+            return $"{GetPluginsFolder()}/{GetPluginInfo(plugin).FolderName}";
+        }
+
+
+        public static string GetPluginsFolder()
+        {
+            return $"{UniEditor.GetWindowsUserFolder()}/.typhoonunitysdk/plugins";
+        }
+
+        /// <summary>
+        /// 是否安装了NodeV13
+        /// </summary>
+        public static bool IsInstallNodeV13()
+        {
+            var root = $"{GetPluginRootPath(PluginNames.NodeJsV10_13)}";
+            var check = new[] { $"{root}/node_modules", $"{root}/node.exe", $"{root}/npm.cmd", };
+            return CheckFilesOrDirectoryExists(check);
+        }
+
+        /// <summary>
+        /// 安装NodeV13
+        /// </summary>
+        public static async void InstallNodeV13Async(Action complete = null)
+        {
+            await InstallModule(PluginNames.NodeJsV10_13, complete);
+        }
+
+
+        /// <summary>
+        /// 是否安装openssl
+        /// </summary>
+        public static bool IsInstallOpenssl()
+        {
+            var root = GetPluginRootPath(PluginNames.Openssl);
+            var check = new[] { $"{root}/bin/openssl.exe" };
+            return CheckFilesOrDirectoryExists(check);
+        }
+
+        /// <summary>
+        /// 安装openssl
+        /// </summary>
+        public static async void InstallOpensslAsync(Action complete = null)
+        {
+            await InstallModule(PluginNames.Openssl, complete);
+        }
+
+        /// <summary>
+        /// 是否安装了vivo_node_modules
+        /// </summary>
+        public static bool IsInstallVivoNodeModule()
+        {
+            var root = $"{GetPluginRootPath(PluginNames.VivoNodeModule)}";
+            var check = new[] { $"{root}/node_modules/.bin", $"{root}/node_modules/ylru" };
+            return CheckFilesOrDirectoryExists(check);
+        }
+
+        /// <summary>
+        /// 安装vivo_node_modules
+        /// </summary>
+        public static async void InstallVivoNodeModuleAsync(Action complete = null)
+        {
+            await InstallModule(PluginNames.VivoNodeModule, complete);
+        }
+
+
+        public static async Task InstallModule(PluginNames pluginName, Action complete)
+        {
+            var pluginInfo = GetPluginInfo(pluginName);
+            var url = pluginInfo.Url;
+            var fileName = Path.GetFileName(url);
+            //判断是否存在安装包
+            var zip = $"{UniEditor.GetWindowsUserFolder()}/.typhoonunitysdk/download/{fileName}";
+            //创建文件夹
+            var folder = Path.GetDirectoryName(zip);
+            if (!Directory.Exists(folder))
+            {
+                Directory.CreateDirectory(folder);
+            }
+
+            if (File.Exists(zip))
+            {
+                var md5 = MD5Tool.GetMD5HashCodeFromFile(zip);
+                if (md5 != pluginInfo.MD5Code)
+                {
+                    Debug.Log($"MD5不匹配,删除{zip}");
+                    File.Delete(zip);
+                }
+            }
+
+            if (!File.Exists(zip))
+            {
+                var process = 0d;
+                var cts = new CancellationTokenSource();
+                var task = DownloadFile(url, zip, (p) => { process = p; }, cts.Token);
+                var cancel = false;
+                while (!task.IsCompleted)
+                {
+                    await Task.Delay(100);
+                    if (EditorUtility.DisplayCancelableProgressBar($"下载...{fileName}", $"请稍等...{process}%",
+                            (float)process * 0.01f))
+                    {
+                        cancel = true;
+                        //中断下载
+                        cts.Cancel();
+                        //跳出循环
+                        break;
+                    }
+                }
+
+                EditorUtility.ClearProgressBar();
+                if (cancel)
+                {
+                    Debug.LogError("已取消,安装失败");
+                    return;
+                }
+            }
+
+            if (File.Exists(zip))
+            {
+                var md5 = MD5Tool.GetMD5HashCodeFromFile(zip);
+                if (md5 != pluginInfo.MD5Code)
+                {
+                    File.Delete(zip);
+                    Debug.LogError($"安装失败,文件MD5不匹配：{zip}");
+                    return;
+                }
+            }
+
+            if (!File.Exists(zip))
+            {
+                Debug.LogError($"安装失败,找不到：{zip}");
+                return;
+            }
+
+            var zipName = Path.GetFileName(zip);
+            var step = 0f;
+            var unzipTo = GetPluginsFolder();
+            ZipTool.UnZip(zip, unzipTo, () =>
+                {
+                    EditorUtility.ClearProgressBar();
+                    Debug.Log($"安装完毕：{zipName}");
+                    if (Directory.Exists(pluginInfo.RootPath))
+                    {
+                        Explorer(pluginInfo.RootPath);
+                    }
+
+                    complete?.Invoke();
+                },
+                (p) =>
+                {
+                    if (p > step)
+                    {
+                        step = p + 0.01f;
+                        EditorUtility.DisplayProgressBar($"解压...{zipName}", $"请稍等...{(p * 100).ToString("F1")}%", p);
+                    }
+                });
+        }
+
+
+        public static async Task<bool> DownloadFileAsync(string url, string fileName, Action<double> progress = default,
+            CancellationToken cancelationToken = default)
+        {
+            try
+            {
+                // 使用HttpClient类创建一个HTTP客户端，指定不使用代理,并设置一个 CookieContainer
+                using (var httpClient = new HttpClient(new HttpClientHandler()
+                           { CookieContainer = new CookieContainer(), UseProxy = false }))
+                {
+                    // 发送GET请求，并等待响应
+                    var response = await httpClient.GetAsync(new Uri(url),
+                        HttpCompletionOption.ResponseHeadersRead);
+                    // 判断请求是否成功,如果失败则返回 false
+                    if (!response.IsSuccessStatusCode)
+                    {
+                        return (false);
+                    }
+
+                    // 获取响应内容长度
+                    long contentLength = response.Content.Headers.ContentLength ?? 0;
+                    // 创建一个文件流，并将响应内容写入文件流
+                    using (var fs = File.Open(fileName, FileMode.Create,
+                               FileAccess.ReadWrite, FileShare.Read))
+                    {
+                        // 创建一个缓冲区，大小为64KB
+                        byte[] buffer = new byte[65536];
+                        // 获取响应流
+                        var httpStream = await response.Content.ReadAsStreamAsync();
+                        // 定义变量，用于记录每次读取的字节数
+                        int readLength = 0;
+                        // 循环异步读取响应流的内容，直到读取完毕
+                        while ((readLength = await httpStream.ReadAsync(buffer, 0, buffer.Length, cancelationToken)) >
+                               0)
+                        {
+                            // 检查是否已经取消了任务
+                            if (cancelationToken.IsCancellationRequested)
+                            {
+                                // 如果任务已经取消，关闭文件流，并删除已经下载的文件
+                                fs.Close();
+                                File.Delete(fileName);
+                                return (false);
+                            }
+
+                            // 将读取到的内容写入文件流，并调用进度回调函数
+                            await fs.WriteAsync(buffer, 0, readLength, cancelationToken);
+                            progress?.Invoke(Math.Round((double)fs.Length / contentLength * 100, 2));
+                        }
+                    }
+                }
+
+                // 返回true表示文件下载成功
+                return (true);
+            }
+            catch (Exception e)
+            {
+                Debug.LogError($"下载失败：{e}");
+                // 返回false表示文件下载失败
+                return (false);
+            }
+        }
+
+        /// <summary>
+        /// 下载安装包到本地
+        /// </summary>
+        private static async Task DownloadAsync(string url, string filePath, Action<int> onProgress,
+            CancellationToken cancelationToken = default)
+        {
+            using (HttpClient client = new HttpClient(new HttpClientHandler()
+                       { CookieContainer = new CookieContainer(), UseProxy = false }))
+            {
+                try
+                {
+                    HttpResponseMessage
+                        response = await client.GetAsync(url,
+                            HttpCompletionOption.ResponseHeadersRead); // 使用ResponseHeadersRead选项获取响应头
+
+                    if (response.IsSuccessStatusCode)
+                    {
+                        long totalLength = response.Content.Headers.ContentLength ?? -1; // 获取文件总长度（如果可用）
+                        using (var stream = await response.Content.ReadAsStreamAsync()) // 异步读取响应流
+                        {
+                            using (var fileStream =
+                                   new FileStream(filePath, FileMode.Create, FileAccess.Write)) // 创建文件流
+                            {
+                                byte[] buffer = new byte[4096]; // 缓冲区大小
+                                long downloadedBytes = 0; // 已下载字节数
+
+                                int bytesRead;
+                                while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
+                                {
+                                    await fileStream.WriteAsync(buffer, 0, bytesRead); // 将数据写入文件
+
+                                    downloadedBytes += bytesRead;
+                                    double progress = (double)downloadedBytes / totalLength * 100; // 计算下载进度
+                                    onProgress?.Invoke((int)progress); // 调用进度回调
+
+                                    // 继续处理已下载的数据...
+                                    if (cancelationToken.IsCancellationRequested)
+                                    {
+                                        // 如果任务已经取消，关闭文件流，并删除已经下载的文件
+                                        fileStream.Close();
+                                        File.Delete(filePath);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (cancelationToken.IsCancellationRequested)
+                        {
+                            Debug.LogError("取消下载");
+                        }
+                        else
+                        {
+                            Debug.Log("下载完成");
+                        }
+                    }
+                    else
+                    {
+                        Debug.LogError("下载失败：" + response.StatusCode);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError("下载出错：" + ex.Message);
+                }
+            }
+        }
+
+
+        protected static async Task DownloadFile(string url, string savePath, Action<int> onProgress,
+            CancellationToken cancelationToken = default)
+        {
+            using (WebClient webClient = new WebClient())
+            {
+                webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(
+                    delegate(object sender, DownloadProgressChangedEventArgs e)
+                    {
+                        try
+                        {
+                            onProgress?.Invoke(e.ProgressPercentage);
+                        }
+                        catch (Exception exception)
+                        {
+                        }
+
+                        if (cancelationToken.IsCancellationRequested)
+                        {
+                            webClient.CancelAsync();
+                        }
+                    });
+
+                webClient.DownloadFileCompleted += new AsyncCompletedEventHandler
+                (delegate(object sender, AsyncCompletedEventArgs e)
+                {
+                    if (e.Error == null && !e.Cancelled)
+                    {
+                        try
+                        {
+                            if (File.Exists(savePath))
+                            {
+                                Debug.Log("下载成功！");
+                            }
+                        }
+                        catch (Exception exception)
+                        {
+                            Debug.LogError($"下载失败:{exception}");
+                        }
+                    }
+
+                    if (e.Cancelled)
+                    {
+                        Debug.LogError($"取消下载");
+                        if (File.Exists(savePath))
+                        {
+                            File.Delete(savePath);
+                        }
+                    }
+                });
+                await webClient.DownloadFileTaskAsync(new Uri(url), savePath);
+            }
+        }
+
+        //检查清单
+        public static bool CheckFilesOrDirectoryExists(params string[] path)
+        {
+            foreach (var element in path)
+            {
+                if (!File.Exists(element) && !Directory.Exists(element))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        //预览文件夹或文件
+        private static void Explorer(string path)
+        {
+            var fullPath = Path.GetFullPath(path);
+            Debug.Log(fullPath);
+            using (Process.Start($"explorer", $"\"{fullPath}\""))
+            {
+            }
+        }
+    }
+}

package/Editor/PluginModuleInstaller.cs.meta

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

package/Editor/PreferencesWindow.cs

@@ -39,7 +39,7 @@ namespace TyphoonUnitySDK
             if (GUI.Button(rectSave, new GUIContent("保存配置", EditorIcons.icon_save)))
             {
                 EditorUtility.SetDirty(Preferences.Default);
-                WxMiniConfig.Default.Save();
+                ApplyTool.SaveAllChannelConfig();
                 AssetDatabase.SaveAssets();
                 Debug.Log("保存完毕");
             }

package/Editor/PublishProcess.cs

@@ -8,10 +8,11 @@ namespace TyphoonUnitySDK
         Apk,
         IOS,
         Webgl,
-        ChinaAndroidAAR,//国内android
+        ChinaAndroidAAR, //国内android
         WxMini, //微信小游戏
-        DouyinAndroid,//抖音android
-        DouyinIOS,//抖音ios
-        GooglePlay,//google play
+        DouyinAndroid, //抖音android
+        DouyinIOS, //抖音ios
+        GooglePlay, //google play
+        VivoMini, //vivo小游戏
     }
 }

package/Editor/PublishSetting.cs

@@ -96,6 +96,9 @@ public AndroidSdkVersions MinApiVersion = AndroidSdkVersions.AndroidApiLevel22;
         /*抖音小游戏拓展配置*/
         public bool DouyinGUIFoldout = true;
 
+        /*vivo小游戏拓展配置*/
+        public bool VivoMiniGUIFoldout = true;
+
 
         //使用配置
         public virtual void Apply()

package/Editor/PublishSettingGUIDrawer.cs

@@ -49,8 +49,26 @@ namespace TyphoonUnitySDK
                 { nameof(PublishSetting.PresetModify), DrawProperty_PresetModify },
                 { nameof(PublishSetting.WxMiniGUIFoldout), DrawProperty_WxMiniGUIFoldout },
                 { nameof(PublishSetting.DouyinGUIFoldout), DrawProperty_DouyinGUIFoldout },
+                { nameof(PublishSetting.VivoMiniGUIFoldout), DrawProperty_VivoMiniGUIFoldout },
             };
 
+        private static bool DrawProperty_VivoMiniGUIFoldout(PublishSetting arg)
+        {
+            if (arg.Channel != AppChannel.VivoMini)
+            {
+                return true;
+            }
+
+            GUILayout.Space(10);
+            arg.DouyinGUIFoldout = GUIDrawer.DrawFoldout("vivo小游戏", arg.DouyinGUIFoldout, GUILayout.Height(26));
+            if (arg.DouyinGUIFoldout)
+            {
+                VivoMiniConfigGUIDrawer.DrawGUI();
+            }
+
+            return true;
+        }
+
         /*绘制抖音小游戏GUI*/
         private static bool DrawProperty_DouyinGUIFoldout(PublishSetting arg)
         {
@@ -81,7 +99,7 @@ namespace TyphoonUnitySDK
             arg.WxMiniGUIFoldout = GUIDrawer.DrawFoldout("微信小游戏", arg.WxMiniGUIFoldout, GUILayout.Height(26));
             if (arg.WxMiniGUIFoldout)
             {
-                WxMiniConfigGUIDrawer.DrawWxMiniConfig();
+                WxMiniConfigGUIDrawer.DrawGUI();
             }
 
             return true;
@@ -510,13 +528,13 @@ namespace TyphoonUnitySDK
                 modify.VariableValue = GUILayout.TextField(modify.VariableValue);
                 if (tem != modify.VariableValue)
                 {
-                    //修改自定义变量
                     VariablePreset.Default.Modify(modify.VariableName, modify.VariableValue);
                 }
 
                 GUILayout.EndHorizontal();
             }
 
+
             /*删除*/
             if (_cachePresetDelete != null)
             {

package/Editor/PublishTool.cs

@@ -11,7 +11,7 @@ namespace TyphoonUnitySDK
     /// </summary>
     public interface IPublish
     {
-        PublishResult Publish(PublishSetting setting);
+        void Publish(PublishSetting setting);
     }
 
     public class PublishTool
@@ -25,8 +25,8 @@ namespace TyphoonUnitySDK
             { PublishProcess.WxMini, "TyphoonUnitySDK.PublishWxMini" },
             { PublishProcess.DouyinAndroid, "TyphoonUnitySDK.PublishDouyinAndroid" },
             { PublishProcess.DouyinIOS, "TyphoonUnitySDK.PublishDouyinIOS" },
-            { PublishProcess.GooglePlay, "TyphoonUnitySDK.PublishGooglePlay" }
-            
+            { PublishProcess.GooglePlay, "TyphoonUnitySDK.PublishGooglePlay" },
+            { PublishProcess.VivoMini, "TyphoonUnitySDK.PublishVivoMini" },
         };
 
         /// <summary>

package/Editor/PublishWindow.cs

@@ -14,7 +14,7 @@ namespace TyphoonUnitySDK
             // AppChannel.GooglePlay,
             AppChannel.SeaIOS,
             // AppChannel.WxMini,
-            AppChannel.VivoMini,
+            // AppChannel.VivoMini,
             AppChannel.OppoMini,
             // AppChannel.DouyinAndroid,
             // AppChannel.DouyinIOS,
@@ -289,9 +289,7 @@ namespace TyphoonUnitySDK
                 if (GUI.Button(rectSave, new GUIContent("保存配置", EditorIcons.icon_save)))
                 {
                     EditorUtility.SetDirty(_select);
-                    //保存其它配置
-                    WxMiniConfig.Default.Save();
-                    DouyinConfig.Default.Save();
+                    ApplyTool.SaveAllChannelConfig();
                     AssetDatabase.SaveAssets();
                 }