/// <summary> /// Starts the build process /// </summary> /// <param name="buildInfo"></param> /// <returns>The <see href="https://docs.unity3d.com/ScriptReference/Build.Reporting.BuildReport.html">BuildReport</see> from Unity's <see href="https://docs.unity3d.com/ScriptReference/BuildPipeline.html">BuildPipeline</see></returns> public static BuildReport BuildUnityPlayer(IBuildInfo buildInfo) { Debug.Log($"\n\nRunning Build: \n{buildInfo.ToString()}\n\n"); // Restore these old defines post building string oldDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildInfo.BuildTargetGroup); Debug.Log($"Found pre-existing scripting define symbols: {oldDefines}"); // Clear any existing preprocessor directives in the player settings PlayerSettings.SetScriptingDefineSymbolsForGroup(buildInfo.BuildTargetGroup, string.Empty); if (buildInfo.Defines != null && buildInfo.Defines != string.Empty) { PlayerSettings.SetScriptingDefineSymbolsForGroup(buildInfo.BuildTargetGroup, buildInfo.Defines); Debug.Log($"Preprocessor directives were defined for the current player: {buildInfo.Defines}\n"); } var oldColorSpace = PlayerSettings.colorSpace; if (buildInfo.ColorSpace.HasValue) { PlayerSettings.colorSpace = buildInfo.ColorSpace.Value; } if (buildInfo.ScriptingBackend.HasValue) { PlayerSettings.SetScriptingBackend(buildInfo.BuildTargetGroup, buildInfo.ScriptingBackend.Value); #if !UNITY_2019_1_OR_NEWER // When building the .NET backend, also build the C# projects, as the // intent of this build process is to prove that it's possible build // a solution where the local dev loop can be accomplished in the // generated C# projects. if (buildInfo.ScriptingBackend == ScriptingImplementation.WinRTDotNET) { EditorUserBuildSettings.wsaGenerateReferenceProjects = true; } #endif } string unityBuildOutputDirectory = $"{buildInfo.OutputDirectory}/Unity"; BuildReport buildReport = default; try { buildReport = BuildPipeline.BuildPlayer( buildInfo.Scenes.ToArray(), unityBuildOutputDirectory, buildInfo.BuildTarget, buildInfo.BuildOptions); } catch (Exception e) { Debug.LogError($"{e.Message}\n{e.StackTrace}"); } PlayerSettings.colorSpace = oldColorSpace; PlayerSettings.SetScriptingDefineSymbolsForGroup(buildInfo.BuildTargetGroup, oldDefines); return(buildReport); }
public Tool(IPackageContext packageContext, IBuildInfo buildContext, IBuildDistributor buildDistributor, ControlViewModel viewModel) { _packageContext = packageContext; _dte = packageContext.GetDTE(); _dte2 = packageContext.GetDTE2(); if (_dte == null) { throw new InvalidOperationException("Unable to get DTE instance."); } _dteStatusBar = packageContext.GetStatusBar(); if (_dteStatusBar == null) { TraceManager.TraceError("Unable to get IVsStatusbar instance."); } _toolWindowManager = new ToolWindowManager(packageContext); _buildContext = buildContext; _buildDistributor = buildDistributor; _viewModel = viewModel; _solutionEvents = _dte.Events.SolutionEvents; Initialize(); }
/// <summary> /// Creates a new instance of the <see cref="T:Parser"/> class. /// </summary> /// <param name="appName">The friendly and readable text representation of the application name.</param> /// <param name="commandDescription"> /// This is a short description of the tool. /// Guidance is 12 words maximum. /// </param> /// <param name="displayUsageIfNoArgumentsPassed"> /// A value that determines whether the usage page will be displayed when no /// arguments are passed. /// </param> /// <param name="console">The <see cref="T:IConsole" /> on which to display output.</param> /// <param name="buildInfo">The <see cref="T:IBuildInfo" /> from which to get version and build date information.</param> public Parser([NotNull] string appName, string commandDescription, bool displayUsageIfNoArgumentsPassed, IConsole console, IBuildInfo buildInfo) : this(displayUsageIfNoArgumentsPassed, string.Empty, CLITokenizer.GetInstance(), CommandLineUsageBuilder.GetInstance(commandDescription), CommandLineOptionStore.GetInstance(), VersionFinder.GetInstance(appName, buildInfo), CommandLineExceptionHandler.GetInstance(console), console) { }
/// <summary> /// Adds capabilities according to the values in the buildInfo to the manifest file. /// </summary> /// <param name="buildInfo">An IBuildInfo containing a valid OutputDirectory and all capabilities</param> public static void AddCapabilities(IBuildInfo buildInfo, XElement rootElement = null) { var manifestFilePath = GetManifestFilePath(buildInfo); if (manifestFilePath == null) { throw new FileNotFoundException("Unable to find manifest file"); } rootElement = rootElement ?? XElement.Load(manifestFilePath); var uwpBuildInfo = buildInfo as UwpBuildInfo; Debug.Assert(uwpBuildInfo != null); if (uwpBuildInfo.DeviceCapabilities != null) { AddCapabilities(rootElement, uwpBuildInfo.DeviceCapabilities); } if (uwpBuildInfo.GazeInputCapabilityEnabled) { AddGazeInputCapability(rootElement); } if (uwpBuildInfo.ResearchModeCapabilityEnabled #if !UNITY_2021_2_OR_NEWER && EditorUserBuildSettings.wsaSubtarget == WSASubtarget.HoloLens #endif // !UNITY_2021_2_OR_NEWER ) { AddResearchModeCapability(rootElement); } rootElement.Save(manifestFilePath); }
/// <summary> /// Updates 'Assembly-CSharp.csproj' file according to the values set in buildInfo. /// </summary> /// <param name="buildInfo">An IBuildInfo containing a valid OutputDirectory</param> public static void UpdateAssemblyCSharpProject(IBuildInfo buildInfo) { string projectFilePath = GetAssemblyCSharpProjectFilePath(buildInfo); if (projectFilePath == null) { throw new FileNotFoundException("Unable to find 'Assembly-CSharp.csproj' file."); } var rootElement = XElement.Load(projectFilePath); var uwpBuildInfo = buildInfo as UwpBuildInfo; Debug.Assert(uwpBuildInfo != null); if ( #if !UNITY_2019_1_OR_NEWER EditorUserBuildSettings.wsaGenerateReferenceProjects && #endif uwpBuildInfo.AllowUnsafeCode) { AllowUnsafeCode(rootElement); } rootElement.Save(projectFilePath); }
/// <summary> /// Gets the <see cref="Microsoft.TeamFoundation.Build.Client.IBuildDetail"/> for the build with the specified key. /// </summary> /// <param name="key">The key of the build definition.</param> /// <param name="configuration"></param> /// <param name="platform"></param> /// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IBuildDetail"/> for the build with the specified key.</returns> public IBuildInfo GetBuildInfo(string key, string configuration, string platform) { string teamProject; string definitionName; ParseBuild(key, out teamProject, out definitionName); var buildDetail = this.builds.SingleOrDefault(x => x.Key.DefinitionSpec.Name == definitionName && x.Key.DefinitionSpec.TeamProject == teamProject).Value; if (buildDetail == null) { return(BuildInfo.Empty); } for (int connectionAttempt = 1; connectionAttempt <= 3; connectionAttempt++) { IBuildInfo buildInfo = CreateBuildInfo(configuration, platform, teamProject, buildDetail); if (buildInfo != null) { return(buildInfo); } Thread.Sleep(100); } return(BuildInfo.Empty); }
private static string GetActionName(IBuildInfo buildInfo) { if (buildInfo.BuildAction == null) { throw new InvalidOperationException(); } switch (buildInfo.BuildAction.Value) { case BuildActions.BuildActionBuild: return(Resources.BuildActionBuild); case BuildActions.BuildActionRebuildAll: return(Resources.BuildActionRebuildAll); case BuildActions.BuildActionClean: return(Resources.BuildActionClean); case BuildActions.BuildActionDeploy: throw new InvalidOperationException(); default: throw new ArgumentOutOfRangeException(nameof(buildInfo.BuildAction)); } }
/// <summary> /// Updates 'Assembly-CSharp.csproj' file according to the values set in buildInfo. /// </summary> /// <param name="buildInfo">An IBuildInfo containing a valid OutputDirectory</param> /// <remarks>Only used with the .NET backend in Unity 2018 or older, with Unity C# Projects enabled.</remarks> public static void UpdateAssemblyCSharpProject(IBuildInfo buildInfo) { #if !UNITY_2019_1_OR_NEWER if (!EditorUserBuildSettings.wsaGenerateReferenceProjects || PlayerSettings.GetScriptingBackend(BuildTargetGroup.WSA) != ScriptingImplementation.WinRTDotNET) { // Assembly-CSharp.csproj is only generated when the above is true return; } string projectFilePath = GetAssemblyCSharpProjectFilePath(buildInfo); if (projectFilePath == null) { throw new FileNotFoundException("Unable to find 'Assembly-CSharp.csproj' file."); } var rootElement = XElement.Load(projectFilePath); var uwpBuildInfo = buildInfo as UwpBuildInfo; Debug.Assert(uwpBuildInfo != null); if (uwpBuildInfo.AllowUnsafeCode) { AllowUnsafeCode(rootElement); } rootElement.Save(projectFilePath); #endif // !UNITY_2019_1_OR_NEWER }
/// <summary> /// Checks if the <see cref="IBuildInfo"/> has any configuration symbols (i.e. debug, release, or master). /// </summary> /// <param name="buildInfo"></param> /// <returns>True, if the <see cref="IBuildInfo.BuildSymbols"/> contains debug, release, or master.</returns> public static bool HasConfigurationSymbol(this IBuildInfo buildInfo) { return(buildInfo.HasAnySymbols( UnityPlayerBuildTools.BuildSymbolDebug, UnityPlayerBuildTools.BuildSymbolRelease, UnityPlayerBuildTools.BuildSymbolMaster)); }
private static void ParseBuildCommandLine(ref UwpBuildInfo buildInfo) { IBuildInfo iBuildInfo = buildInfo; UnityPlayerBuildTools.ParseBuildCommandLine(ref iBuildInfo); string[] arguments = Environment.GetCommandLineArgs(); for (int i = 0; i < arguments.Length; ++i) { switch (arguments[i]) { case "-buildAppx": buildInfo.BuildAppx = true; break; case "-rebuildAppx": buildInfo.RebuildAppx = true; break; case "-targetUwpSdk": // Note: the min sdk target cannot be changed. EditorUserBuildSettings.wsaUWPSDK = arguments[++i]; break; } } }
public static void ParseBuildCommandLine(ref IBuildInfo buildInfo) { string[] arguments = Environment.GetCommandLineArgs(); for (int i = 0; i < arguments.Length; ++i) { switch (arguments[i]) { case "-autoIncrement": buildInfo.AutoIncrement = true; break; case "-sceneList": buildInfo.Scenes = buildInfo.Scenes.Union(SplitSceneList(arguments[++i])); break; case "-sceneListFile": string path = arguments[++i]; if (File.Exists(path)) { buildInfo.Scenes = buildInfo.Scenes.Union(SplitSceneList(File.ReadAllText(path))); } else { Debug.LogWarning($"Scene list file at '{path}' does not exist."); } break; case "-buildOutput": buildInfo.OutputDirectory = arguments[++i]; break; case "-colorSpace": buildInfo.ColorSpace = (ColorSpace)Enum.Parse(typeof(ColorSpace), arguments[++i]); break; case "-scriptingBackend": buildInfo.ScriptingBackend = (ScriptingImplementation)Enum.Parse(typeof(ScriptingImplementation), arguments[++i]); break; case "-x86": case "-x64": case "-arm": case "-arm64": buildInfo.BuildPlatform = arguments[i].Substring(1); break; case "-debug": case "-master": case "-release": buildInfo.Configuration = arguments[i].Substring(1).ToLower(); break; case "-logDirectory": buildInfo.LogDirectory = arguments[++i]; break; } } }
/// <summary> /// Does the <see cref="IBuildInfo"/> contain any of the provided symbols in the <see cref="IBuildInfo.BuildSymbols"/>? /// </summary> /// <param name="buildInfo"></param> /// <param name="symbols">The string collection of symbols to match.</param> /// <returns>True, if any of the provided symbols are in the <see cref="IBuildInfo.BuildSymbols"/></returns> public static bool HasAnySymbols(this IBuildInfo buildInfo, IEnumerable <string> symbols) { if (string.IsNullOrEmpty(buildInfo.BuildSymbols)) { return(false); } return(buildInfo.BuildSymbols.Split(';').Intersect(symbols).Any()); }
/// <summary> /// Appends the <see cref="IBuildInfo"/>'s <see cref="IBuildInfo.BuildSymbols"/> without including debug, release or master. /// </summary> /// <param name="buildInfo"></param> /// <param name="symbols">Symbols to append.</param> public static void AppendWithoutConfigurationSymbols(this IBuildInfo buildInfo, string symbols) { buildInfo.AppendSymbols(symbols.Split(';').Except(new[] { UnityPlayerBuildTools.BuildSymbolDebug, UnityPlayerBuildTools.BuildSymbolRelease, UnityPlayerBuildTools.BuildSymbolMaster }).ToString()); }
private static void LogBuildInfo(IBuildInfo buildInfo, List <Corner> corners, Dictionary <LinkedListNode <Dot>, LinkedListNode <Event> > circleEvents, List <Border> borders, Event simpleEvent, IEnumerable <Dot> dots) { BuildCircle[] buildCircles = circleEvents.Values.Select(x => new BuildCircle() { center = x.Value.circle.center, radius = x.Value.circle.directrix - x.Value.circle.center.y }).ToArray(); BuildArc[] buildArcs; if (corners.Count > 0) { buildArcs = new BuildArc[corners.Count + 1]; for (int cornerId = 0; cornerId < corners.Count; cornerId++) { buildArcs[cornerId] = new BuildArc() { focus = corners[cornerId].leftArcNode.Value, leftX = cornerId > 0 ? corners[cornerId - 1].dot.x : -float.MaxValue, rightX = corners[cornerId].dot.x, directrixY = simpleEvent.directrix }; } buildArcs[corners.Count] = new BuildArc() { focus = corners[corners.Count - 1].rightArcNode.Value, leftX = corners[corners.Count - 1].dot.x, rightX = float.MaxValue, directrixY = simpleEvent.directrix }; } else { buildArcs = new BuildArc[0]; } List <Dot> interestPoints = new List <Dot>(); switch (simpleEvent.eventType) { case Event.EventType.Dot: interestPoints.Add(simpleEvent.dot); break; case Event.EventType.Circle: interestPoints.Add(simpleEvent.circle.center); interestPoints.Add(simpleEvent.circle.v1); interestPoints.Add(simpleEvent.circle.v2); interestPoints.Add(simpleEvent.circle.v3); break; } foreach (var dot in dots) { interestPoints.Add(dot); } buildInfo.SendState(borders, buildCircles, buildArcs, interestPoints, simpleEvent.directrix); }
protected override int?GetValue(IBuildInfo buildContext) { try { return(buildContext.BuildedProjects.BuildErrorCount); } catch (NullReferenceException) { return(null); } }
private static bool UpdateAppxManifest(IBuildInfo buildInfo) { string manifestFilePath = GetManifestFilePath(buildInfo); if (manifestFilePath == null) { // Error has already been logged return(false); } var rootNode = XElement.Load(manifestFilePath); var identityNode = rootNode.Element(rootNode.GetDefaultNamespace() + "Identity"); if (identityNode == null) { Debug.LogError($"Package.appxmanifest for build (in path - {manifestFilePath}) is missing an <Identity /> node"); return(false); } var dependencies = rootNode.Element(rootNode.GetDefaultNamespace() + "Dependencies"); if (dependencies == null) { Debug.LogError($"Package.appxmanifest for build (in path - {manifestFilePath}) is missing <Dependencies /> node."); return(false); } UpdateDependenciesElement(dependencies, rootNode.GetDefaultNamespace()); AddCapabilities(buildInfo, rootNode); // We use XName.Get instead of string -> XName implicit conversion because // when we pass in the string "Version", the program doesn't find the attribute. // Best guess as to why this happens is that implicit string conversion doesn't set the namespace to empty var versionAttr = identityNode.Attribute(XName.Get("Version")); if (versionAttr == null) { Debug.LogError($"Package.appxmanifest for build (in path - {manifestFilePath}) is missing a Version attribute in the <Identity /> node."); return(false); } // Assume package version always has a '.' between each number. // According to https://msdn.microsoft.com/library/windows/apps/br211441.aspx // Package versions are always of the form Major.Minor.Build.Revision. // Note: Revision number reserved for Windows Store, and a value other than 0 will fail WACK. var version = PlayerSettings.WSA.packageVersion; var newVersion = new Version(version.Major, version.Minor, buildInfo.AutoIncrement ? version.Build + 1 : version.Build, version.Revision); PlayerSettings.WSA.packageVersion = newVersion; versionAttr.Value = newVersion.ToString(); rootNode.Save(manifestFilePath); return(true); }
private void PrintInformations(IBuildInfo buildInfo) { Logger.Info("======================"); Logger.Info($"Installed as {Environment.CurrentDirectory}"); Logger.Info($"Run as {(Self.HaveAdminPermission ? "Administrator" : "Normal user")}"); Logger.Info($"AutumnBox version: {Self.Version}"); Logger.Info($"Core library version: {BuildInfo.SDK_VERSION}"); Logger.Info($"Windows version: {Environment.OSVersion.Version}"); Logger.Info($"Clr version: {Environment.Version}"); Logger.Info($"Commit: {buildInfo.LatestCommit}"); Logger.Info("======================"); }
private static string GetBuildDoneExtraMessage(IBuildInfo buildInfo, BuildMessagesSettings labelsSettings) { if (buildInfo?.BuildStartTime == null || buildInfo?.BuildFinishTime == null || !labelsSettings.ShowExtraMessage) { return(string.Empty); } TimeSpan timeSpan = buildInfo.BuildFinishTime.Value.Subtract(buildInfo.BuildStartTime.Value); string extraTimePartString = GetExtraTimePartString(labelsSettings, timeSpan); return(string.Format(labelsSettings.ExtraMessageStringFormat, extraTimePartString)); }
public void TestInitialize() { string teamProject = "Team Project"; string definitionName = "Definition Name"; string configuration = "Configuration"; string platform = "Platform"; this.key = string.Format("{0};{1}", teamProject, definitionName); this.mockService = new MockBuildServerService(); this.mockBuildInfo = new MockBuildInfo(BuildStatus.Stopped, "Requested For", DateTime.MinValue, true, DateTime.MinValue); this.model = new BuildInfoModel(teamProject, definitionName, configuration, platform, this.mockService); }
public static ControlTemplate GetBuildBeginImage(IBuildInfo buildInfo) { var buildAction = buildInfo.BuildAction; var buildScope = buildInfo.BuildScope; if (buildAction == null || buildScope == null) { return(null); } string actionKey = GetBuildActionResourceKey(buildAction.Value); return(VectorResources.TryGet(BuildActionResourcesUri, actionKey)); }
/// <summary> /// An overload of AddGazeInputCapability that will read the AppX manifest from /// the build output and update the manifest file with the gazeInput capability. /// </summary> /// <param name="buildInfo">An IBuildInfo containing a valid OutputDirectory</param> public static void AddGazeInputCapability(IBuildInfo buildInfo) { string manifestFilePath = GetManifestFilePath(buildInfo); if (manifestFilePath == null) { throw new FileNotFoundException("Unable to find manifest file"); } var rootElement = XElement.Load(manifestFilePath); AddGazeInputCapability(rootElement); rootElement.Save(manifestFilePath); }
private static string GetTimeString(IBuildInfo buildInfo, BuildMessagesSettings labelsSettings) { string timeString; try { timeString = buildInfo.BuildStartTime.Value.ToString(labelsSettings.DateTimeFormat); } catch (FormatException) { timeString = Resources.InvalidTimeStringFormat; } return(timeString); }
private static async void PostBuildAction(IBuildInfo buildInfo, BuildReport buildReport) { // TODO Check if installation flag is set in build window Debug.Log("Starting installation..."); var canInstall = false; try { var deviceResult = await new Process().RunAsync("mldb devices", false); if (deviceResult.ExitCode == 0) { foreach (var deviceId in deviceResult.Output) { if (!string.IsNullOrWhiteSpace(deviceId)) { Debug.Log(deviceId); if (!deviceId.Contains("List")) { canInstall = true; } } } } } catch (Exception e) { Debug.Log(e); } if (!canInstall) { Debug.Log("No devices found, skipping installation"); return; } try { await new Process().RunAsync($"mldb install -u \"{buildInfo.OutputDirectory}\"", true); } catch (Exception e) { Debug.Log(e); } }
public static string GetBuildBeginMajorMessage(SolutionItem solutionItem, IBuildInfo buildInfo, BuildMessagesSettings labelsSettings) { if (buildInfo.BuildAction == null || buildInfo.BuildScope == null || buildInfo.BuildAction.Value == BuildActions.BuildActionDeploy) { return(Resources.UnknownBuildActionOrScope_BuildBeginText); } if (buildInfo.BuildStartTime == null) { throw new InvalidOperationException(); } var mainString = GetMainString(solutionItem, buildInfo, labelsSettings); return(string.Format(labelsSettings.BuildBeginMajorMessageStringFormat, mainString)); }
public static string GetBuildBeginExtraMessage(IBuildInfo buildInfo, BuildMessagesSettings labelsSettings) { if (buildInfo == null || buildInfo.BuildStartTime == null || !labelsSettings.ShowExtraMessage || labelsSettings.ExtraMessageDelay < 0) { return(string.Empty); } TimeSpan timeSpan = DateTime.Now.Subtract(buildInfo.BuildStartTime.Value); if (timeSpan.TotalSeconds > labelsSettings.ExtraMessageDelay) { return(GetExtraTimePartString(labelsSettings, timeSpan)); } return(string.Empty); }
/// <summary> /// Remove symbols from the <see cref="IBuildInfo"/>'s <see cref="IBuildInfo.BuildSymbols"/>. /// </summary> /// <param name="buildInfo"></param> /// <param name="symbolsToRemove">The string collection to remove.</param> public static void RemoveSymbols(this IBuildInfo buildInfo, IEnumerable <string> symbolsToRemove) { var toKeep = buildInfo.BuildSymbols.Split(';').Except(symbolsToRemove).ToString(); if (!toKeep.Any()) { return; } if (!string.IsNullOrEmpty(buildInfo.BuildSymbols)) { buildInfo.BuildSymbols = string.Empty; } buildInfo.BuildSymbols += string.Join(";", toKeep); }
public static string GetBuildBeginExtraMessage(IBuildInfo buildInfo, BuildMessagesSettings labelsSettings) { if (buildInfo == null || buildInfo.BuildStartTime == null || !labelsSettings.ShowExtraMessage || labelsSettings.ExtraMessageDelay < 0) { return(string.Empty); } TimeSpan timeSpan = DateTime.Now.Subtract(buildInfo.BuildStartTime.Value); if (timeSpan.TotalSeconds > labelsSettings.ExtraMessageDelay) { string extraTimePartString; switch (labelsSettings.ExtraMessageFormat) { case BuildExtraMessageFormat.Custom: try { extraTimePartString = timeSpan.ToString(labelsSettings.TimeSpanFormat); } catch (FormatException) { extraTimePartString = Resources.InvalidTimeStringFormat; } break; case BuildExtraMessageFormat.TotalSeconds: extraTimePartString = string.Format("{0}", Math.Truncate(timeSpan.TotalSeconds)); break; case BuildExtraMessageFormat.TotalMinutes: extraTimePartString = string.Format("{0}", Math.Truncate(timeSpan.TotalMinutes)); break; case BuildExtraMessageFormat.TotalMinutesWithSeconds: extraTimePartString = string.Format("{0:00}:{1:00}", Math.Truncate(timeSpan.TotalMinutes), timeSpan.Seconds); break; default: throw new ArgumentOutOfRangeException(); } string extraString = string.Format(labelsSettings.ExtraMessageStringFormat, extraTimePartString); return(extraString); } return(string.Empty); }
/// <summary> /// Append symbols to the end of the <see cref="IBuildInfo"/>'s <see cref="IBuildInfo.BuildSymbols"/>. /// </summary> /// <param name="buildInfo"></param> /// <param name="symbols">The string collection to append.</param> public static void AppendSymbols(this IBuildInfo buildInfo, IEnumerable <string> symbols) { string[] toAdd = symbols.Except(buildInfo.BuildSymbols.Split(';')) .Where(symbol => !string.IsNullOrEmpty(symbol)).ToArray(); if (!toAdd.Any()) { return; } if (!string.IsNullOrEmpty(buildInfo.BuildSymbols)) { buildInfo.BuildSymbols += ";"; } buildInfo.BuildSymbols += string.Join(";", toAdd); }
public static ControlTemplate GetBuildDoneImage(IBuildInfo buildInfo, IEnumerable <ProjectItem> allProjects, out ControlTemplate stateImage) { if (buildInfo?.BuildAction == null || buildInfo?.BuildScope == null) { throw new ArgumentNullException(nameof(buildInfo)); } if (allProjects == null) { throw new InvalidOperationException(); } int errorProjectsCount = allProjects.Count(item => item.State.IsErrorState()); bool buildedProjectsSuccess = buildInfo.BuildedProjects.BuildWithoutErrors; string stateKey; if (buildInfo.BuildIsCancelled) { stateKey = "BuildCancelled"; } else if (!buildedProjectsSuccess) { stateKey = "BuildError"; } else if (buildedProjectsSuccess && errorProjectsCount == 0) { stateKey = "BuildDone"; } else if (buildedProjectsSuccess && errorProjectsCount != 0) { stateKey = "BuildErrorDone"; } else { throw new InvalidOperationException(); } stateImage = VectorResources.TryGet(BuildStateResourcesUri, stateKey); string actionKey = GetBuildActionResourceKey(buildInfo.BuildAction.Value); return(VectorResources.TryGet(BuildActionResourcesUri, actionKey)); }
/// <summary> /// Given the project name and build path, resolves the valid VcProject file (i.e. .vcsproj, vcxproj) /// </summary> /// <returns>A valid path if the project file exists, null otherwise</returns> private static string GetProjectFilePath(IBuildInfo buildInfo) { string projectName = PlayerSettings.productName; foreach (string extension in VcProjExtensions) { string projectFilePath = Path.Combine(Path.GetFullPath(buildInfo.OutputDirectory), projectName, $"{projectName}.{extension}"); if (File.Exists(projectFilePath)) { return(projectFilePath); } } string projectDirectory = Path.Combine(Path.GetFullPath(buildInfo.OutputDirectory), projectName); string combinedExtensions = String.Join("|", VcProjExtensions); Debug.LogError($"Cannot find project file {projectDirectory} given names {projectName}.{combinedExtensions}"); return(null); }
/// <summary> /// Parses the command like arguments. /// </summary> /// <param name="buildInfo"></param> public static void ParseBuildCommandLine(ref IBuildInfo buildInfo) { var arguments = Environment.GetCommandLineArgs(); for (int i = 0; i < arguments.Length; ++i) { switch (arguments[i]) { case "-autoIncrement": buildInfo.AutoIncrement = true; break; case "-sceneList": buildInfo.Scenes = buildInfo.Scenes.Union(SplitSceneList(arguments[++i])); break; case "-sceneListFile": buildInfo.Scenes = buildInfo.Scenes.Union(SplitSceneList(File.ReadAllText(arguments[++i]))); break; case "-buildOutput": buildInfo.OutputDirectory = arguments[++i]; break; case "-colorSpace": buildInfo.ColorSpace = (ColorSpace)Enum.Parse(typeof(ColorSpace), arguments[++i]); break; case "-x86": case "-x64": case "-ARM": case "-ARM64": buildInfo.BuildPlatform = arguments[i].Substring(1); break; case "-debug": case "-master": case "-release": buildInfo.Configuration = arguments[i].Substring(1).ToLower(); break; } } }
public ProgramImpl(IConsole console, IBuildInfo buildInfo) { _console = console; _buildInfo = buildInfo; }
public void SetBuildInfo(string key, IBuildInfo detail) { this.builds[key] = detail; }
internal static VersionFinder GetInstance(string appName, IBuildInfo info) { return new VersionFinderImpl(appName, info); }
internal VersionFinderImpl(string appName, IBuildInfo info) { ThrowHelper.IfNullOrEmptyThenThrow(() => appName); _appName = appName; _info = info; }