Make Build Process Automation Friendlier about gdk-unity-package HOT 5 CLOSED

copy %WORKSPACE%\Assets\GDK-Tools\ProjectMetadata\MicrosoftGame.Config D:\OutputDir\Jenkins\ProjectName\StandaloneWindows64_GDK\
copy %WORKSPACE%\Assets\GDK-Tools\ProjectMetadata\*.png D:\OutputDir\Jenkins\ProjectName\StandaloneWindows64_GDK\

rmdir D:\OutputDir\Jenkins\ProjectName\PC_GDK\ /s /q 
mkdir D:\OutputDir\Jenkins\ProjectName\PC_GDK
rmdir D:\OutputDir\Jenkins\ProjectName\StandaloneWindows64_GDK\ProjectName_BackUpThisFolder_ButDontShipItWithYourGame /s /q 
move D:\OutputDir\Jenkins\ProjectName\StandaloneWindows64_GDK D:\OutputDir\Jenkins\ProjectName\PC_GDK\Win32

"C:\Program Files (x86)\Microsoft GDK\bin\makepkg.exe" genmap /f D:\OutputDir\Jenkins\ProjectName\PC_GDK\Win32\layout.xml /d D:\OutputDir\Jenkins\ProjectName\PC_GDK\Win32\

mkdir D:\OutputDir\Jenkins\ProjectName\PC_GDK\GDK

"C:\Program Files (x86)\Microsoft GDK\bin\makepkg.exe" pack /f D:\OutputDir\Jenkins\ProjectName\PC_GDK\Win32\layout.xml /d D:\OutputDir\Jenkins\ProjectName\PC_GDK\Win32\ /pd D:\OutputDir\Jenkins\ProjectName\PC_GDK\GDK /pc /CorrelationId Unity /l

using Microsoft.GameCore.Utilities;
using System.Collections.Generic;
using System.Xml.Linq;
using System;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;


public class PreBuild : IPreprocessBuildWithReport
{

    public static string contentIdOverride;
    public static string originalSquare150x150LogoPath;
    public static string originalSquare44x44LogoPath;
    public static string originalSquare480x480LogoPath;
    public static string originalSplashScreenImagePath;
    public static string originalStoreLogoPath;


    public int callbackOrder => 0;
    public void OnPreprocessBuild(BuildReport report)
    {
        Setup(Path.GetDirectoryName(report.summary.outputPath));
    }


    private void Setup(string pcStandaloneBuildPath)
    {

        PlayerSettings.forceSingleInstance = true;

        GdkUtilities.PullGdkDlls();

        CopyManifestFiles(pcStandaloneBuildPath);

   
    }

    private void CopyManifestFiles(string buildWin32OutputFolderPath)
    {
        string square150x150LogoPath = string.Empty;
        string square44x44LogoPath = string.Empty;
        string square480x480LogoPath = string.Empty;
        string splashScreenImagePath = string.Empty;
        string storeLogoPath = string.Empty;

        string gameConfigFilePath = GdkUtilities.GameConfigPath;


        XDocument gameConfigXmlDoc = XDocument.Load(gameConfigFilePath);
        try
        {
            string imagesPath = gameConfigFilePath.Replace("MicrosoftGame.Config", string.Empty);
            XElement executableEl = (from executable in gameConfigXmlDoc.Descendants("Executable")
                                     select executable).First();
            executableEl.SetAttributeValue("Name", PlayerSettings.productName + ".exe");

            // Find the images
            XElement shellVisualsEl = (from shellVisual in gameConfigXmlDoc.Descendants("ShellVisuals")
                                       select shellVisual).First();

            XAttribute square150x150LogoAttribute = shellVisualsEl.Attribute("Square150x150Logo");
            originalSquare150x150LogoPath = square150x150LogoAttribute.Value;
            square150x150LogoPath = (imagesPath + originalSquare150x150LogoPath).Replace("/", "\\");

            XAttribute square44x44LogoAttribute = shellVisualsEl.Attribute("Square44x44Logo");
            originalSquare44x44LogoPath = square44x44LogoAttribute.Value;
            square44x44LogoPath = (imagesPath + originalSquare44x44LogoPath).Replace("/", "\\");

            XAttribute square480x480LogoAttribute = shellVisualsEl.Attribute("Square480x480Logo");
            originalSquare480x480LogoPath = square480x480LogoAttribute.Value;
            square480x480LogoPath = (imagesPath + originalSquare480x480LogoPath).Replace("/", "\\");

            XAttribute splashScreenImageAttribute = shellVisualsEl.Attribute("SplashScreenImage");
            originalSplashScreenImagePath = splashScreenImageAttribute.Value;
            splashScreenImagePath = (imagesPath + originalSplashScreenImagePath).Replace("/", "\\");

            XAttribute storeLogoAttribute = shellVisualsEl.Attribute("StoreLogo");
            originalStoreLogoPath = storeLogoAttribute.Value;
            storeLogoPath = (imagesPath + originalStoreLogoPath).Replace("/", "\\");

            // Check for a Content ID override
            XElement contentIdOverrideEl = (from contentIdOverride in gameConfigXmlDoc.Descendants("ContentIdOverride")
                                            select contentIdOverride).First();
            contentIdOverride = contentIdOverrideEl.Value;

            gameConfigXmlDoc.Save(gameConfigFilePath);
        }
        catch (Exception)
        {
            Debug.LogError("Invalid or corrupt MicrosoftGame.Config.");
            return;
        }

        List<string> storeAssetsToCopy = new List<string>
        {
            gameConfigFilePath,
            square150x150LogoPath,
            square44x44LogoPath,
            square480x480LogoPath,
            splashScreenImagePath,
            storeLogoPath
        };

        foreach (string storeAssetToCopy in storeAssetsToCopy)
        {
            string fileName = Path.GetFileName(storeAssetToCopy);
            string fullSourcePath = storeAssetToCopy;
            string destinationPath = buildWin32OutputFolderPath + "\\" + fileName;
            File.Copy(fullSourcePath, destinationPath, true);
        }

    }

}

using Microsoft.GameCore.Tools;
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using Debug = UnityEngine.Debug;


public class PostBuild : IPostprocessBuildWithReport
{

    private string buildWin32OutputFolderPath;
    private string buildMsixvcOutputFolderPath;

    private const string MsixvcOutputDirectory = "MSIXVC";

    public int callbackOrder => 0;

    public void OnPostprocessBuild(BuildReport report)
    {

        string standaloneBuildPath = Path.GetDirectoryName(report.summary.outputPath);

        string gdkBuildOutputPath = Path.Combine(Directory.GetParent(standaloneBuildPath).FullName, MsixvcOutputDirectory).Replace('/','\\');

        Debug.Log($"GDK Build Path:{gdkBuildOutputPath}");

        Setup(standaloneBuildPath, gdkBuildOutputPath);
        OpenBuildOutputFolder();
    }

    private  bool Setup(string pcStandaloneBuildPath, string gdkBuildOutputFolderPath, bool createPackageForStoreUpload=true)
    {
        try
        {
            if (!Directory.Exists(gdkBuildOutputFolderPath))
            {
                Directory.CreateDirectory(gdkBuildOutputFolderPath);
            }
        }
        catch (Exception)
        {
            Debug.LogError("Could not find or create GDK Build output directory: " + gdkBuildOutputFolderPath);
        }

        buildWin32OutputFolderPath = pcStandaloneBuildPath;
        buildMsixvcOutputFolderPath = gdkBuildOutputFolderPath;

        bool succeeded = PostWin32BuildCleanup();
        if (succeeded)
        {
            succeeded = CreateAndConfigureLayoutFile();
        }
        if (succeeded)
        {
            succeeded = MakePackage(createPackageForStoreUpload);
        }

        return succeeded;
    }


    private  bool PostWin32BuildCleanup()
    {
        bool succeeded = true;

        string gameConfigFilePath = Path.Combine(buildWin32OutputFolderPath, "MicrosoftGame.Config");
        string cleanedGameConfigFilePath = gameConfigFilePath.Replace("/", "\\");

        XDocument gameConfigXmlDoc = XDocument.Load(cleanedGameConfigFilePath);
        XElement shellVisualsEl = (from shellVisual in gameConfigXmlDoc.Descendants("ShellVisuals")
            select shellVisual).First();

        // We need to rewrite the manifest to point at where the images will be placed
        // in the build directory.
        shellVisualsEl.SetAttributeValue("Square150x150Logo", Path.GetFileName(PreBuild.originalSquare150x150LogoPath));
        shellVisualsEl.SetAttributeValue("Square44x44Logo", Path.GetFileName(PreBuild.originalSquare44x44LogoPath));
        shellVisualsEl.SetAttributeValue("Square480x480Logo", Path.GetFileName(PreBuild.originalSquare480x480LogoPath));
        shellVisualsEl.SetAttributeValue("SplashScreenImage", Path.GetFileName(PreBuild.originalSplashScreenImagePath));
        shellVisualsEl.SetAttributeValue("StoreLogo", Path.GetFileName(PreBuild.originalStoreLogoPath));

        gameConfigXmlDoc.Save(cleanedGameConfigFilePath);

        return succeeded;
    }


    private bool CreateAndConfigureLayoutFile()
    {
        string arguments = string.Format("/c makepkg.exe genmap /f \"{0}\\layout.xml\" /d \"{0}\"", buildWin32OutputFolderPath);

        if (!GdkEditorHelpers.StartCmdProcess(arguments))
        {
            return false;
        }

        string layoutPath = buildWin32OutputFolderPath + @"\layout.xml";

        var doc = XDocument.Load(layoutPath);
        var ignoredNodes = (from node in doc.Descendants()
            where node.Name == "FileGroup" && node.Attribute("SourcePath").Value.Contains("Package_BackUpThisFolder_ButDontShipItWithYourGame")
            select node).ToArray();

        for (int i = 0; i < ignoredNodes.Length; ++i)
        {
            ignoredNodes[i].Remove();
        }

        doc.Save(layoutPath);

        return true;
    }

    private bool MakePackage(bool createForStoreUpload=true)
    {
        string makePkgExtraArgs = string.Empty;
        if (!string.IsNullOrEmpty(PreBuild.contentIdOverride))
        {
            makePkgExtraArgs = "/contentid " + PreBuild.contentIdOverride;
        }

        string arguments = string.Format("/c makepkg.exe pack /f \"{0}\\layout.xml\" /d \"{0}\" /pd \"{1}\" /pc /CorrelationId Unity " + makePkgExtraArgs, buildWin32OutputFolderPath, buildMsixvcOutputFolderPath);
        if (createForStoreUpload)
        {
            arguments += " /l";
        }

        return GdkEditorHelpers.StartCmdProcess(arguments);
    }


    private  bool OpenBuildOutputFolder()
    {
        bool succeeded = true;
        Process.Start("explorer.exe", buildMsixvcOutputFolderPath);
        return succeeded;
    }


}