/// <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 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;
}
