plugin-library/Assets/00.StaryEvoTools/Editor/Build/AutoBuildPackage.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using HybridCLR.Editor.Commands;
using Newtonsoft.Json;
using Sirenix.OdinInspector;
using UnityEditor;
using UnityEngine;
using YooAsset.Editor;

namespace Stary.Evo.Editor
{
    public static class AutoBuildPackage
    {
        private static List<OneKeyBuildEntity> GetOneKeyBuildEntities()
        {
            var creatDomainAll = CreatAssetWindow.GetCreatDomainAll();
            List<OneKeyBuildEntity> oneKeyBuildEntities = new List<OneKeyBuildEntity>();
            foreach (var domainEntity in creatDomainAll)
            {
                oneKeyBuildEntities.Add(new OneKeyBuildEntity()
                {
                    DomainName = domainEntity.DomainName, isRaw = true
                });
            }

            return oneKeyBuildEntities;
        }

        public static void OneClickMark()
        {
            OneClickMark(GetOneKeyBuildEntities());
        }

        /// <summary>
        /// (一键)标记选择资源
        /// </summary>
        /// <param name="oneKeyBuildEntities"></param>
        public static void OneClickMark(List<OneKeyBuildEntity> oneKeyBuildEntities)
        {
#if HotUpdate
            //打dll 
            CompileDllCommand.CompileDllActiveBuildTarget();
            //拷贝dll
            MarkAdressable.AddHotfixAddressableDllAll(oneKeyBuildEntities);
            //标记全部资源
            MarkAdressable.AddMarkAll(oneKeyBuildEntities);
#endif
        }

        public static void OneShaderMark()
        {
            OneShaderMark(GetOneKeyBuildEntities());
        }

        /// <summary>
        /// (一键)收集shader【材质异常或资源修改】
        /// </summary>
        /// <param name="oneKeyBuildEntities"></param>
        public static void OneShaderMark(List<OneKeyBuildEntity> oneKeyBuildEntities)
        {
#if HotUpdate
            //标记全部资源
            foreach (var oneKeyBUildEntity in oneKeyBuildEntities)
            {
                if (oneKeyBUildEntity.isRaw)
                {
                    MarkAdressable.CollectSVC(MarkAdressable.DomainRoot, oneKeyBUildEntity.DomainName,
                        () => { EditorUtility.DisplayDialog("收集shader【材质异常或资源修改】", "收集成功", "确定"); });
                }
            }


#endif
        }

        public static void OneUpdatePackageVersionBuild()
        {
            OneUpdatePackageVersion(GetOneKeyBuildEntities());
            OneClickBuild(GetOneKeyBuildEntities());
        }

        /// <summary>
        /// (一键)获取服务器版本
        /// </summary>
        /// <param name="oneKeyBuildEntities"></param>
        public static async void OneUpdatePackageVersion(List<OneKeyBuildEntity> oneKeyBuildEntities)
        {
            foreach (var oneKeyBUildEntity in oneKeyBuildEntities)
            {
                if (oneKeyBUildEntity.isRaw)
                {
                    BuildAssetDataSetting buildAssetDataSetting =
                        AssetDatabase.LoadAssetAtPath<BuildAssetDataSetting>(
                            $"Assets/Domain/{oneKeyBUildEntity.DomainName}/Conf/BuildAssetDataSetting.asset");
                    if (buildAssetDataSetting != null)
                    {
                        //初始化读取资源配置表
                        HotfixMainResDomain hotfixMainResDomain =
                            Resources.Load<HotfixMainResDomain>("HotfixMainResDomain");
                        if (hotfixMainResDomain == null)
                        {
                            Debug.LogError($"UnityEvo:读取资源配置表失败【HotfixMainResDomain】...表不存在");
                            continue;
                        }

                        var ip = hotfixMainResDomain.hotfixMainResDomainEntity.ipconfig;
                        //登录
                        string loginurl = ip + "/Authentication/login";
                        await WebRequestSystem.Login(loginurl, hotfixMainResDomain.hotfixMainResDomainEntity.username,
                            hotfixMainResDomain.hotfixMainResDomainEntity.password);
                        string url = $"{ip}/ResDomain/GetResDomainByDomain";
                        var resDmainRequst = new ResDmainRequst()
                        {
                            ProductName = Application.identifier,
                            DomainName = oneKeyBUildEntity.DomainName,
                            Platform = UnityEditor.EditorUserBuildSettings.activeBuildTarget.ToString(),
                        };
                        //获取服务器版本
                        var resDmainMessageEntity =
                            await WebRequestSystem.Post(url, JsonConvert.SerializeObject(resDmainRequst));
                        if (resDmainMessageEntity.code == 200)
                        {
                            ResDmainResponse resDmainResponse =
                                JsonConvert.DeserializeObject<ResDmainResponse>(resDmainMessageEntity.data.ToString());
                            string[] versions = resDmainResponse.PackageVersion.Split('.');
                            buildAssetDataSetting.packageVersionX = int.Parse(versions[0]);
                            buildAssetDataSetting.packageVersionY = int.Parse(versions[1]);
                            buildAssetDataSetting.packageVersionZ = int.Parse(versions[2]);
                            buildAssetDataSetting.packageVersionZ++;
                            EditorUtility.SetDirty(buildAssetDataSetting);
                        }
                        else if (resDmainMessageEntity.code == 1011)
                        {
                            buildAssetDataSetting.packageVersionX = 1;
                            buildAssetDataSetting.packageVersionY = 0;
                            buildAssetDataSetting.packageVersionZ = 0;
                            EditorUtility.SetDirty(buildAssetDataSetting);
                        }
                    }
                    else
                    {
                        Debug.LogError("BuildAssetDataSetting 不存在：" + oneKeyBUildEntity.DomainName);
                    }
                }
            }

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }

        /// <summary>
        /// (一键)打包选择资源
        /// </summary>
        /// <param name="oneKeyBuildEntities"></param>
        public static void OneClickBuild(List<OneKeyBuildEntity> oneKeyBuildEntities)
        {
            //打包
            foreach (var oneKeyBUildEntity in oneKeyBuildEntities)
            {
                if (oneKeyBUildEntity.isRaw)
                {
                    BuildAssetDataSetting buildAssetDataSetting =
                        AssetDatabase.LoadAssetAtPath<BuildAssetDataSetting>(
                            $"Assets/Domain/{oneKeyBUildEntity.DomainName}/Conf/BuildAssetDataSetting.asset");
                    if (buildAssetDataSetting != null)
                    {
                        buildAssetDataSetting.environmentType = EnvironmentType.Release;
                        buildAssetDataSetting.SetEnvironmentType();
                        buildAssetDataSetting.viewer = new BuiltinBuildPipelineViewer(buildAssetDataSetting.packageName,
                            buildAssetDataSetting.selectedBuildPipelines.ToString(),
                            buildAssetDataSetting.packageVersion);
                        buildAssetDataSetting.viewer.clearBuildCacheToggle = true;
                        buildAssetDataSetting.viewer.SetBuildCacheToggle();
                        EditorApplication.delayCall += buildAssetDataSetting.viewer.ExecuteBuild;
                    }
                    else
                    {
                        Debug.LogError("BuildAssetDataSetting 不存在：" + oneKeyBUildEntity.DomainName);
                    }
                }
            }
        }

        public static void OneUpdatePackage()
        {
            OneUpdatePackage(GetOneKeyBuildEntities());
        }

        /// <summary>
        /// (一键)上传服务器版本
        /// </summary>
        /// <param name="oneKeyBuildEntities"></param>
        public static async void OneUpdatePackage(List<OneKeyBuildEntity> oneKeyBuildEntities)
        {
            //打包
            foreach (var oneKeyBUildEntity in oneKeyBuildEntities)
            {
                if (oneKeyBUildEntity.isRaw)
                {
                    BuildAssetDataSetting buildAssetDataSetting =
                        AssetDatabase.LoadAssetAtPath<BuildAssetDataSetting>(
                            $"Assets/Domain/{oneKeyBUildEntity.DomainName}/Conf/BuildAssetDataSetting.asset");
                    if (buildAssetDataSetting != null)
                    {
                        string zipFilePath = BuildAssetWindow.BuildZip(buildAssetDataSetting);
                        await BuildAssetWindow.UpdateFileDataResDomain(buildAssetDataSetting, zipFilePath);
                        await Task.Delay(1000);
                        EditorUtility.ClearProgressBar();
                    }
                    else
                    {
                        Debug.LogError("BuildAssetDataSetting 不存在：" + oneKeyBUildEntity.DomainName);
                    }
                }
            }
        }
    }
}