C# AutomationTool.ProjectParams类代码示例

    static string GetBlueprintPluginPathArgument(ProjectParams Params, bool Client, UnrealTargetPlatform TargetPlatform)
    {
        string ScriptPluginArgs = "";

        // if we're utilizing an auto-generated code plugin/module (a product of 
        // the cook process), make sure to compile it along with the targets here

        if (Params.RunAssetNativization)
        {
            ProjectParams.BlueprintPluginKey PluginKey = new ProjectParams.BlueprintPluginKey();
            PluginKey.Client = Client;
            PluginKey.TargetPlatform = TargetPlatform;
            FileReference CodePlugin = null;
            if(Params.BlueprintPluginPaths.TryGetValue(PluginKey, out CodePlugin))
            {
                ScriptPluginArgs += "-PLUGIN \"" + CodePlugin + "\" ";
            }
            else
            {
                LogWarning("BlueprintPluginPath for " + TargetPlatform + " " + (Client ? "client" : "server") + " was not found");
            }
        }

        return ScriptPluginArgs;
    }

    public static void CopyBuildToStagingDirectory(ProjectParams Params)
    {
        if (ShouldCreatePak(Params) || (Params.Stage && !Params.SkipStage))
        {
            Params.ValidateAndLog();

            Log("********** STAGE COMMAND STARTED **********");

            if (!Params.NoClient)
            {
                var DeployContextList = CreateDeploymentContext(Params, false, true);
                foreach (var SC in DeployContextList)
                {
                    // write out the commandline file now so it can go into the manifest
                    WriteStageCommandline(Params, SC);
                    CreateStagingManifest(Params, SC);
                    ApplyStagingManifest(Params, SC);
                }
            }

            if (Params.DedicatedServer)
            {
                var DeployContextList = CreateDeploymentContext(Params, true, true);
                foreach (var SC in DeployContextList)
                {
                    CreateStagingManifest(Params, SC);
                    ApplyStagingManifest(Params, SC);
                }
            }
            Log("********** STAGE COMMAND COMPLETED **********");
        }
    }

    public override void GetFilesToArchive(ProjectParams Params, DeploymentContext SC)
    {
        if (SC.StageTargetConfigurations.Count != 1)
        {
            throw new AutomationException("iOS is currently only able to package one target configuration at a time, but StageTargetConfigurations contained {0} configurations", SC.StageTargetConfigurations.Count);
        }

        string PackagePath = Path.Combine(Path.GetDirectoryName(Params.RawProjectPath), "Binaries", "HTML5");
        string FinalDataLocation = Path.Combine(PackagePath, Params.ShortProjectName) + ".data";

        // copy the "Executable" to the archive directory
        string GameExe = Path.GetFileNameWithoutExtension(Params.ProjectGameExeFilename);
        if (Params.ClientConfigsToBuild[0].ToString() != "Development")
        {
            GameExe += "-HTML5-" + Params.ClientConfigsToBuild[0].ToString();
        }
        GameExe += ".js";

        // put the HTML file to the package directory
        string OutputFile = Path.Combine(PackagePath, (Params.ClientConfigsToBuild[0].ToString() != "Development" ? (Params.ShortProjectName + "-HTML5-" + Params.ClientConfigsToBuild[0].ToString()) : Params.ShortProjectName)) + ".html";

        SC.ArchiveFiles(PackagePath, Path.GetFileName(FinalDataLocation));
        SC.ArchiveFiles(PackagePath, Path.GetFileName(FinalDataLocation + ".js"));
        SC.ArchiveFiles(PackagePath, Path.GetFileName(GameExe));
        SC.ArchiveFiles(PackagePath, Path.GetFileName(GameExe + ".mem"));
        SC.ArchiveFiles(PackagePath, Path.GetFileName("json2.js"));
        SC.ArchiveFiles(PackagePath, Path.GetFileName("jstorage.js"));
        SC.ArchiveFiles(PackagePath, Path.GetFileName("moz_binarystring.js"));
        SC.ArchiveFiles(PackagePath, Path.GetFileName(OutputFile));
    }

	public static void Package(ProjectParams Params, int WorkingCL=-1)
	{
		Params.ValidateAndLog();
		List<DeploymentContext> DeployContextList = new List<DeploymentContext>();
		if (!Params.NoClient)
		{
			DeployContextList.AddRange(CreateDeploymentContext(Params, false, false));
		}
		if (Params.DedicatedServer)
		{
			DeployContextList.AddRange(CreateDeploymentContext(Params, true, false));
		}
		if (DeployContextList.Count > 0 && !Params.SkipStage)
		{
			Log("********** PACKAGE COMMAND STARTED **********");

			foreach (var SC in DeployContextList)
			{
				if (Params.Package || (SC.StageTargetPlatform.RequiresPackageToDeploy && Params.Deploy))
				{
					SC.StageTargetPlatform.Package(Params, SC, WorkingCL);
				}
			}

			Log("********** PACKAGE COMMAND COMPLETED **********");
		}
	}

 public static void Archive(ProjectParams Params)
 {
     Params.ValidateAndLog();
     if (!Params.Archive)
     {
         return;
     }
     if (!Params.NoClient)
     {
         var DeployContextList = CreateDeploymentContext(Params, false, false);
         foreach ( var SC in DeployContextList )
         {
             CreateArchiveManifest(Params, SC);
             ApplyArchiveManifest(Params, SC);
         }
     }
     if (Params.DedicatedServer)
     {
         ProjectParams ServerParams = new ProjectParams(Params);
         ServerParams.Device = ServerParams.ServerDevice;
         var DeployContextList = CreateDeploymentContext(ServerParams, true, false);
         foreach ( var SC in DeployContextList )
         {
             CreateArchiveManifest(Params, SC);
             ApplyArchiveManifest(Params, SC);
         }
     }
 }

    public static void Archive(ProjectParams Params)
    {
        Params.ValidateAndLog();
        if (!Params.Archive)
        {
            return;
        }

        Log("********** ARCHIVE COMMAND STARTED **********");

        if (!Params.NoClient)
        {
            var DeployContextList = CreateDeploymentContext(Params, false, false);
            foreach ( var SC in DeployContextList )
            {
                CreateArchiveManifest(Params, SC);
                ApplyArchiveManifest(Params, SC);
                SC.StageTargetPlatform.ProcessArchivedProject(Params, SC);
            }
        }
        if (Params.DedicatedServer)
        {
            ProjectParams ServerParams = new ProjectParams(Params);
            ServerParams.Device = ServerParams.ServerDevice;
            var DeployContextList = CreateDeploymentContext(ServerParams, true, false);
            foreach ( var SC in DeployContextList )
            {
                CreateArchiveManifest(Params, SC);
                ApplyArchiveManifest(Params, SC);
                SC.StageTargetPlatform.ProcessArchivedProject(Params, SC);
            }
        }
        Log("********** ARCHIVE COMMAND COMPLETED **********");
    }

    public HTMLPakAutomation(ProjectParams InParam, DeploymentContext InSC)
    {
        Params = InParam;
        SC = InSC;

        var PakOrderFileLocationBase = CommandUtils.CombinePaths(SC.ProjectRoot, "Build", SC.FinalCookPlatform, "FileOpenOrder");
        PakOrderFileLocation = CommandUtils.CombinePaths(PakOrderFileLocationBase, "GameOpenOrder.log");
        if (!CommandUtils.FileExists_NoExceptions(PakOrderFileLocation))
        {
            // Use a fall back, it doesn't matter if this file exists or not. GameOpenOrder.log is preferred however
            PakOrderFileLocation = CommandUtils.CombinePaths(PakOrderFileLocationBase, "EditorOpenOrder.log");
        }

        string PakPath = Path.Combine(new string[] { Path.GetDirectoryName(Params.RawProjectPath), "Binaries", "HTML5", SC.ShortProjectName});
        if (Directory.Exists(PakPath))
        {
            Directory.Delete(PakPath,true);
        }

        // read in the json file. 
        string JsonFile = CommandUtils.CombinePaths(new string[] { SC.ProjectRoot, "Saved", "Cooked", "HTML5", Params.ShortProjectName, "MapDependencyGraph.json" });
        string text = File.ReadAllText(JsonFile);

        DependencyJson = fastJSON.JSON.Instance.ToObject<Dictionary<string, object>>(text);

    }

    public static void Run(ProjectParams Params)
    {
        Params.ValidateAndLog();
        if (!Params.Run)
        {
            return;
        }

        Log("********** RUN COMMAND STARTED **********");

        var LogFolderOutsideOfSandbox = GetLogFolderOutsideOfSandbox();
        if (!GlobalCommandLine.Installed && ServerProcess == null)
        {
            // In the installed runs, this is the same folder as CmdEnv.LogFolder so delete only in not-installed
            DeleteDirectory(LogFolderOutsideOfSandbox);
            CreateDirectory(LogFolderOutsideOfSandbox);
        }
        var ServerLogFile = CombinePaths(LogFolderOutsideOfSandbox, "Server.log");
        var ClientLogFile = CombinePaths(LogFolderOutsideOfSandbox, Params.EditorTest ? "Editor.log" : "Client.log");

        try
        {
            RunInternal(Params, ServerLogFile, ClientLogFile);
        }
        catch
        {
            throw;
        }
        finally
        {
            CopyLogsBackToLogFolder();
        }

        Log("********** RUN COMMAND COMPLETED **********");
    }

    public static void ApplyStagingManifest(ProjectParams Params, DeploymentContext SC)
    {
        MaybeConvertToLowerCase(Params, SC);
        if (SC.Stage && !Params.NoCleanStage && !Params.SkipStage)
        {
            DeleteDirectory(SC.StageDirectory);
        }
        if (ShouldCreatePak(Params, SC))
        {
            if (Params.Manifests && DoesChunkPakManifestExist(Params, SC))
            {
                CreatePaksUsingChunkManifests(Params, SC);
            }
            else
            {
                CreatePakUsingStagingManifest(Params, SC);
            }
        }
        if (!SC.Stage || Params.SkipStage)
        {
            return;
        }
        DumpManifest(SC, CombinePaths(CmdEnv.LogFolder, "FinalCopy" + (SC.DedicatedServer ? "_Server" : "")), !Params.UsePak(SC.StageTargetPlatform));
        CopyUsingStagingManifest(Params, SC);

        var ThisPlatform = SC.StageTargetPlatform;
        ThisPlatform.PostStagingFileCopy(Params, SC);
    }

	public static void Deploy(ProjectParams Params)
	{
		Params.ValidateAndLog();
		if (!Params.Deploy)
		{
			return;
		}

		Log("********** DEPLOY COMMAND STARTED **********");
		
		if (!Params.NoClient)
		{
			var DeployContextList = CreateDeploymentContext(Params, false, false);
			foreach ( var SC in DeployContextList )
			{
				if (SC.StageTargetPlatform.DeployViaUFE)
				{
					string ClientCmdLine = "-run=Deploy ";
					ClientCmdLine += "-Device=" + string.Join("+", Params.Devices) + " ";
					ClientCmdLine += "-Targetplatform=" + SC.StageTargetPlatform.PlatformType.ToString() + " ";
					ClientCmdLine += "-SourceDir=\"" + CombinePaths(Params.BaseStageDirectory, SC.StageTargetPlatform.PlatformType.ToString()) + "\" ";
					string ClientApp = CombinePaths(CmdEnv.LocalRoot, "Engine/Binaries/Win64/UnrealFrontend.exe");

					Log("Deploying via UFE:");
					Log("\tClientCmdLine: " + ClientCmdLine + "");

					//@todo UAT: Consolidate running of external applications like UFE (See 'RunProjectCommand' for other instances)
					PushDir(Path.GetDirectoryName(ClientApp));
					// Always start client process and don't wait for exit.
					IProcessResult ClientProcess = Run(ClientApp, ClientCmdLine, null, ERunOptions.NoWaitForExit);
					PopDir();
					if (ClientProcess != null)
					{
						do
						{
							Thread.Sleep(100);
						}
						while (ClientProcess.HasExited == false);
					}
				}
				else
				{
					SC.StageTargetPlatform.Deploy(Params, SC);
				}
			}
		}
		if (Params.DedicatedServer)
		{
			ProjectParams ServerParams = new ProjectParams(Params);
			ServerParams.Devices = new ParamList<string>(ServerParams.ServerDevice);
			var DeployContextList = CreateDeploymentContext(ServerParams, true, false);
			foreach ( var SC in DeployContextList )
			{
				SC.StageTargetPlatform.Deploy(ServerParams, SC);
			}
		}

		Log("********** DEPLOY COMMAND COMPLETED **********");
	}

    public override void GetFilesToDeployOrStage(ProjectParams Params, DeploymentContext SC)
    {
        SC.StageFiles(StagedFileType.NonUFS, CombinePaths(SC.ProjectRoot, "Binaries", SC.PlatformDir), "*", false, null, CommandUtils.CombinePaths(SC.RelativeProjectRootForStage, "Binaries", SC.PlatformDir), false);

        if (SC.bStageCrashReporter)
        {
            SC.StageFiles(StagedFileType.NonUFS, CombinePaths(SC.LocalRoot, "Engine/Binaries", SC.PlatformDir), "CrashReportClient", false);
        }
    }

	public override void GetFilesToDeployOrStage(ProjectParams Params, DeploymentContext SC)
	{
		// Engine non-ufs (binaries)

		if (SC.bStageCrashReporter)
		{
			StageExecutable("exe", SC, CommandUtils.CombinePaths(SC.LocalRoot, "Engine/Binaries", SC.PlatformDir), "CrashReportClient.");
		}

		// Stage all the build products
		foreach(TargetReceipt Receipt in SC.StageTargetReceipts)
		{
			SC.StageBuildProductsFromReceipt(Receipt);
		}

		// Copy the splash screen, windows specific
		SC.StageFiles(StagedFileType.NonUFS, CombinePaths(SC.ProjectRoot, "Content/Splash"), "Splash.bmp", false, null, null, true);

		// Stage the bootstrap executable
		if(!Params.NoBootstrapExe)
		{
			foreach(TargetReceipt Receipt in SC.StageTargetReceipts)
			{
				BuildProduct Executable = Receipt.BuildProducts.FirstOrDefault(x => x.Type == BuildProductType.Executable);
				if(Executable != null)
				{
					// only create bootstraps for executables
					if (SC.NonUFSStagingFiles.ContainsKey(Executable.Path) && Path.GetExtension(Executable.Path) == ".exe")
					{
						string BootstrapArguments = "";
						if (!SC.IsCodeBasedProject && !ShouldStageCommandLine(Params, SC))
						{
							BootstrapArguments = String.Format("..\\..\\..\\{0}\\{0}.uproject", SC.ShortProjectName);
						}

						string BootstrapExeName;
						if(SC.StageTargetConfigurations.Count > 1)
						{
							BootstrapExeName = Path.GetFileName(Executable.Path);
						}
						else if(Params.IsCodeBasedProject)
						{
							BootstrapExeName = Receipt.GetProperty("TargetName", SC.ShortProjectName) + ".exe";
						}
						else
						{
							BootstrapExeName = SC.ShortProjectName + ".exe";
						}

						StageBootstrapExecutable(SC, BootstrapExeName, Executable.Path, SC.NonUFSStagingFiles[Executable.Path], BootstrapArguments);
					}
				}
			}
		}
	}

    public static bool CanCreateMapPaks(ProjectParams Param)
    {
        bool UseAsyncLevelLoading = false;
        var ConfigCache = new UnrealBuildTool.ConfigCacheIni(UnrealTargetPlatform.HTML5, "Engine", Path.GetDirectoryName(Param.RawProjectPath), CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine"));
        ConfigCache.GetBool("/Script/HTML5PlatformEditor.HTML5TargetSettings", "UseAsyncLevelLoading", out UseAsyncLevelLoading);

        if (Param.Run)
            return false; 

        return UseAsyncLevelLoading;
    }

    public static void CreateArchiveManifest(ProjectParams Params, DeploymentContext SC)
    {
        if (!Params.Archive)
        {
            return;
        }
        var ThisPlatform = SC.StageTargetPlatform;

        ThisPlatform.GetFilesToArchive(Params, SC);

        //@todo add any archive meta data files as needed
    }

    public override void Deploy(ProjectParams Params, DeploymentContext SC)
    {
        string AdbCommand = GetAdbCommand(Params);
        string ApkName = GetFinalApkName(Params, SC.StageExecutables[0], false);
        string DeviceObbName = GetDeviceObbName(ApkName);
        string PackageName = GetPackageInfo(ApkName, false);

        // install the apk
        string UninstallCommandline = AdbCommand + "uninstall " + PackageName;
        RunAndLog(CmdEnv, CmdEnv.CmdExe, UninstallCommandline);

        string InstallCommandline = AdbCommand + "install \"" + ApkName + "\"";
        RunAndLog(CmdEnv, CmdEnv.CmdExe, InstallCommandline);

        // copy files to device if we were staging
        if (SC.Stage)
        {
            // cache some strings
            string BaseCommandline = AdbCommand + "push";
            string RemoteDir = "/mnt/sdcard/" + Params.ShortProjectName;
            string UE4GameRemoteDir = "/mnt/sdcard/" + Params.ShortProjectName;

            // make sure device is at a clean state
            Run(CmdEnv.CmdExe, AdbCommand + "shell rm -rf " + RemoteDir);
            Run(CmdEnv.CmdExe, AdbCommand + "shell rm -rf " + UE4GameRemoteDir);

            string[] Files = Directory.GetFiles(SC.StageDirectory, "*", SearchOption.AllDirectories);
            // copy each UFS file
            foreach (string Filename in Files)
            {
                // don't push the apk, we install it
                if (Path.GetExtension(Filename).Equals(".apk", StringComparison.InvariantCultureIgnoreCase))
                {
                    continue;
                }

                string FinalRemoteDir = RemoteDir;
                // handle the special case of the UE4Commandline.txt when using content only game (UE4Game)
                if (!Params.IsCodeBasedProject &&
                    Path.GetFileName(Filename).Equals("UE4CommandLine.txt", StringComparison.InvariantCultureIgnoreCase))
                {
                    FinalRemoteDir = "/mnt/sdcard/UE4Game";
                }

                string RemoteFilename = Filename.Replace(SC.StageDirectory, FinalRemoteDir).Replace("\\", "/");
         				string Commandline = string.Format("{0} \"{1}\" \"{2}\"", BaseCommandline, Filename, RemoteFilename);
         				Run(CmdEnv.CmdExe, Commandline);
            }

            // delete the .obb file, since it will cause nothing we just deployed to be used
            Run(CmdEnv.CmdExe, AdbCommand + "shell rm -f " + DeviceObbName);
        }
    }