public void ProcessParameterDeserializer_ConvertsExportedBuildSettings()
{
var buildSettings = new BuildSettings
{
PlatformConfigurations = PlatformConfigurationList.Default,
ProjectsToBuild = new StringList("projectA,projectB")
};
var expBuildDef = this.Serialize(new { ProjectsToBuild = buildSettings.ProjectsToBuild, ConfigurationsToBuild = buildSettings.PlatformConfigurations });
var procParam = new[] { "BuildSettings", expBuildDef };
ExportedProcessParameterTransformer.ProcessParameterDeserializer(procParam).ShouldBeEquivalentTo(buildSettings);
}
public async Task Stamp_Test_StampV2XMLV4WithAddenda307Async()
{
var build = new BuildSettings();
StampV2 stamp = new StampV2(build.Url, build.Token);
var xml = GetXml(build);
var response = (StampResponseV4)await stamp.TimbrarV4Async(xml);
Assert.True(response.data != null, "El resultado data viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.cfdi), "El resultado data.cfdi viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.cadenaOriginalSAT), "El resultado data.cadenaOriginalSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.noCertificadoSAT), "El resultado data.noCertificadoSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.noCertificadoCFDI), "El resultado data.noCertificadoCFDI viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.uuid), "El resultado data.uuid viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.selloSAT), "El resultado data.selloSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.selloCFDI), "El resultado data.selloCFDI viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.fechaTimbrado), "El resultado data.fechaTimbrado viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.qrCode), "El resultado data.qrCode viene vacio.");
response = (StampResponseV4)await stamp.TimbrarV4Async(xml);
Assert.True(response.status == "error" && response.message == "307. El comprobante contiene un timbre previo.");
Assert.Contains("cfdi:Addenda", response.data.cfdi);
}
/// <summary>
/// Gets the build config.
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="scope">The scope.</param>
/// <param name="documentType">Type of the document.</param>
/// <returns></returns>
private BuildSettings GetBuildConfig(IBuildSettingsRepository repository, string scope, string documentType)
{
Contract.Requires(repository != null);
Contract.Requires(!String.IsNullOrEmpty(documentType));
Contract.Requires(!String.IsNullOrEmpty(scope));
var key = String.Format("build_{0}_{1}", scope, documentType);
var buildConfig = repository.BuildSettings.Where(x => (x.Scope.Equals(scope, StringComparison.OrdinalIgnoreCase) && x.DocumentType.Equals(documentType, StringComparison.OrdinalIgnoreCase))).FirstOrDefault();
if (buildConfig == null)
{
buildConfig = new BuildSettings(scope, documentType)
{
BuildSettingId = key,
Status = BuildStatus.NeverStarted.GetHashCode()
};
repository.Add(buildConfig);
}
return(buildConfig);
}
public void MultipleStampXMLV1byToken()
{
var build = new BuildSettings();
var resultExpect = false;
int iterations = 10;
Stamp stamp = new Stamp(build.Url, build.Token);
List <StampResponseV1> listXmlResult = new List <StampResponseV1>();
for (int i = 0; i < iterations; i++)
{
string xml = Encoding.UTF8.GetString(File.ReadAllBytes("Resources/file.xml"));
xml = SignTools.SigXml(xml, Convert.FromBase64String(build.Pfx), build.CerPassword);
var response = (StampResponseV1)stamp.TimbrarV1(xml);
listXmlResult.Add(response);
}
if (listXmlResult != null)
{
resultExpect = listXmlResult.FindAll(w => w.status == ResponseType.success.ToString() || w.message.Contains("72 horas")).Count == iterations;
}
Assert.IsTrue((bool)resultExpect);
}
private static void PrepareBuild(BuildSettings settings)
{
NukeBuild();
Directory.CreateDirectory(OutputPath);
var defines = "USES_NOTIFICATION_SERVICE;";
// Do not include Google Play Games on iOS.
if (settings.Target == BuildTarget.iOS)
{
defines += "NO_GPGS;";
PlayerSettings.iOS.buildNumber = BuildNumber;
}
switch (settings.Environment)
{
case BuildSettingsEnvironment.Dev:
defines += "DEBUG;";
break;
case BuildSettingsEnvironment.Prod:
defines += "LIVE;RELEASE;";
break;
default:
throw new ArgumentOutOfRangeException();
}
Debug.Log("Defines for " + settings.TargetGroup + ": " + defines);
PlayerSettings.SetScriptingDefineSymbolsForGroup(settings.TargetGroup, defines);
// Build with Gradle.
if (settings.Target == BuildTarget.Android)
{
EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
}
}
public override RunStepResult Start(BuildSettings settings)
{
var artifact = BuildArtifacts.GetBuildArtifact <BuildArtifactDesktop>(settings);
var process = new Process();
#if UNITY_EDITOR_OSX
process.StartInfo.FileName = "open";
process.StartInfo.Arguments = '\"' + artifact.OutputTargetFile.FullName.Trim('\"') + '\"';
#else
process.StartInfo.FileName = artifact.OutputTargetFile.FullName;
#endif
process.StartInfo.WorkingDirectory = artifact.OutputTargetFile.Directory?.FullName ?? string.Empty;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = true;
if (!process.Start())
{
return(Failure(settings, $"Failed to start process at '{process.StartInfo.FileName}'."));
}
return(Success(settings, new RunInstanceDesktop(process)));
}
public async Task Issue_Test_StampXMLV4byTokenAsync()
{
var build = new BuildSettings();
SW.Services.Issue.IssueV2 issue = new SW.Services.Issue.IssueV2(build.Url, build.Token);
var xml = GetXml(build);
var response = (StampResponseV4)await issue.TimbrarV4Async(xml);
Assert.True(response.data != null, "El resultado data viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.cfdi), "El resultado data.cfdi viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.cadenaOriginalSAT), "El resultado data.cadenaOriginalSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.noCertificadoSAT), "El resultado data.noCertificadoSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.noCertificadoCFDI), "El resultado data.noCertificadoCFDI viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.uuid), "El resultado data.uuid viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.selloSAT), "El resultado data.selloSAT viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.selloCFDI), "El resultado data.selloCFDI viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.fechaTimbrado), "El resultado data.fechaTimbrado viene vacio.");
Assert.True(!string.IsNullOrEmpty(response.data.qrCode), "El resultado data.qrCode viene vacio.");
response = (StampResponseV4)await issue.TimbrarV4Async(xml);
Assert.True(response.status == "error" && response.message == "307. El comprobante contiene un timbre previo.");
}
/// <summary>
/// Do a build configured for the HoloLens, returns the error from BuildPipeline.BuildPlayer
/// </summary>
public static string BuildForHololens()
{
// Cache the current settings
BuildSettings oldBuildSettings = BuildSettings.Current;
// Define and apply the desired settings
BuildSettings newBuildSettings = oldBuildSettings;
newBuildSettings.BuildTarget = BuildTarget.WSAPlayer;
newBuildSettings.WSASDK = WSASDK.UWP;
newBuildSettings.WSAUWPBuildType = WSAUWPBuildType.D3D;
newBuildSettings.Apply();
// Capture the active scenes, and build
var scenes = EditorBuildSettings.scenes.Where(s => s.enabled).Select(s => s.path);
string error = BuildPipeline.BuildPlayer(scenes.ToArray(), BuildLocation, newBuildSettings.BuildTarget, BuildOptions.None);
// Restore old build settings
oldBuildSettings.Apply();
return(error);
}
private void makeReleaseToolStripMenuItem_Click(object sender, EventArgs e)
{
var curr = Application.StartupPath + "/";
var loc = Application.StartupPath + "/DMTv" + BuildSettings.GetVersion() + "/";
Directory.CreateDirectory(loc);
BuildFile(curr, loc, "DMTViewer.exe");
BuildFile(curr, loc, "DMTViewer.exe.config");
BuildFile(curr, loc, "UpdateMover.exe");
foreach (var f in Directory.GetFiles(curr))
{
if (f.ToLower().EndsWith(".dll"))
{
var name = Path.GetFileName(f);
BuildFile(curr, loc, name);
}
}
Helper.CopyFolder(curr + "UnityResources", loc + "UnityResources", true);
}
public void CreateBuilderProfile(string name, BuildSettings settings)
{
var xmlDoc = XDocument.Load("settings.xml", LoadOptions.None);
if (xmlDoc.Root.Elements().FirstOrDefault(e => e.Name == "BuilderProfiles") == null)
{
var rootElem = new XElement("BuilderProfiles");
var profile =
new XElement("Profile",
new XAttribute("Name", name),
new XElement("Hostname", settings.Hostname),
new XElement("Port", settings.Port.ToString()),
new XElement("ReconnectDelay", settings.ReconnectDelay.ToString()),
new XElement("InstallationPath", ((int)settings.InstallationPath).ToString()),
new XElement("Filename", settings.Filename),
new XElement("MergeDependencies", settings.MergeDependencies ? "True" : "False")
);
rootElem.Add(profile);
xmlDoc.Root.Add(rootElem);
}
else
{
var profile =
new XElement("Profile",
new XAttribute("Name", name),
new XElement("Hostname", settings.Hostname),
new XElement("Port", settings.Port.ToString()),
new XElement("ReconnectDelay", settings.ReconnectDelay.ToString()),
new XElement("InstallationPath", ((int)settings.InstallationPath).ToString()),
new XElement("Filename", settings.Filename),
new XElement("MergeDependencies", settings.MergeDependencies ? "True" : "False")
);
xmlDoc.Root.Element("BuilderProfiles").Add(profile);
}
xmlDoc.Save("settings.xml");
}
private void Form1_Load(object sender, EventArgs e)
{
this.Icon = Resources.HAL9000;
LoadModsUI();
Helper.ClearTempFolder();
if (!Directory.Exists(BuildSettings.Instance.ModFolder))
{
this.BeginInvoke((MethodInvoker)this.ShowSettings);
}
this.Text += " " + BuildSettings.GetVersion();
if (BuildSettings.Instance.AutoCheckForUpdates)
{
new Thread(() => { UpdateCheckThread(true); }).Start();
}
if (Helper.IsDevBuild == false)
{
makeReleaseToolStripMenuItem.Visible = false;
}
frmMain_Resize(null, null);
}
public override IList <SharedItem> PrepareShared(BuildContext context)
{
IList <SharedItem> listShared = base.PrepareShared(context);
if (listShared == null)
{
listShared = new List <SharedItem>();
}
if (_changeHistory == ConceptualChangeHistory.ShowFreshnessDate)
{
if (_freshnessDate != DateTime.MinValue &&
_freshnessDate != DateTime.MaxValue)
{
BuildSettings settings = context.Settings;
listShared.Add(new SharedItem("defaultFreshnessDate",
_freshnessDate.ToString(_freshnessFormat, settings.CultureInfo)));
}
}
return(listShared);
}
public async Task Account_Test_45_ConsultaDeSaldoByUserAsync()
{
var build = new BuildSettings();
BalanceAccount account = new BalanceAccount("http://services.test.sw.com.mx", "demo", "123456789");
AccountResponse response = await account.ConsultarSaldoAsync();
if (response.status != "error")
{
//saldo timbres
Console.WriteLine(response.data.saldoTimbres);
//timbres utilizados
Console.WriteLine(response.data.timbresUtilizados);
//En caso de tener timbres infinitos (para cuentas hijo)
Console.WriteLine(response.data.unlimited);
}
else
{
//errores
Console.WriteLine(response.message);
Console.WriteLine(response.messageDetail);
}
Assert.True(response.status == "success", response.messageDetail);
}
public override void Initialize(BuildContext context)
{
base.Initialize(context);
if (this.IsInitialized)
{
if (_format == null)
{
this.IsInitialized = false;
return;
}
_settings = context.Settings;
Debug.Assert(_settings != null);
if (_settings == null)
{
this.IsInitialized = false;
return;
}
_context = context;
}
}
public override BuildPipelineCodes Convert(BuildCommandSet commandSet, BuildSettings settings, out List <WriteResult> output)
{
StartProgressBar("Writing Resource Files", commandSet.commands.Count);
CacheDataForCommandSet(commandSet);
output = new List <WriteResult>();
foreach (var command in commandSet.commands)
{
if (!UpdateProgressBar(string.Format("Bundle: {0}", command.assetBundleName)))
{
EndProgressBar();
return(BuildPipelineCodes.Canceled);
}
BuildOutput result;
Hash128 hash = CalculateInputHash(command, settings);
if (UseCache && BuildCache.TryLoadCachedResults(hash, out result))
{
output.AddRange(result.results);
continue;
}
result = BundleBuildInterface.WriteResourceFilesForBundle(commandSet, command.assetBundleName, settings, GetBuildPath(hash));
output.AddRange(result.results);
if (UseCache && !BuildCache.SaveCachedResults(hash, result))
{
BuildLogger.LogWarning("Unable to cache CommandSetWriter results for command '{0}'.", command.assetBundleName);
}
}
if (!EndProgressBar())
{
return(BuildPipelineCodes.Canceled);
}
return(BuildPipelineCodes.Success);
}
public override bool CanRun(BuildSettings settings, out string reason)
{
var artifact = BuildArtifacts.GetBuildArtifact <DotsRuntimeBuildArtifact>(settings);
if (artifact == null)
{
reason = $"Could not retrieve build artifact '{nameof(DotsRuntimeBuildArtifact)}'.";
return(false);
}
if (artifact.OutputTargetFile == null)
{
reason = $"{nameof(DotsRuntimeBuildArtifact.OutputTargetFile)} is null.";
return(false);
}
if (!File.Exists(artifact.OutputTargetFile.FullName))
{
reason = $"Output target file '{artifact.OutputTargetFile.FullName}' not found.";
return(false);
}
if (!settings.TryGetComponent <DotsRuntimeBuildProfile>(out var profile))
{
reason = $"Could not retrieve component '{nameof(DotsRuntimeBuildProfile)}'.";
return(false);
}
if (profile.Target == null)
{
reason = $"{nameof(DotsRuntimeBuildProfile)} target is null.";
return(false);
}
reason = null;
return(true);
}
public static BuildPipelineCodes Build(BuildInput input, BuildSettings settings, out BuildDependencyInfo buildInfo, bool useCache = false, BuildProgressTracker progressTracker = null)
{
buildInfo = null;
// Rebuild sprite atlas cache for correct dependency calculation & writing
var spriteCacher = new SpriteAtlasCacher(useCache, progressTracker);
var exitCode = spriteCacher.Convert(settings.target);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
// Generate dependency information for all assets in BuildInput
var buildInputDependency = new BuildInputDependency(useCache, progressTracker);
exitCode = buildInputDependency.Convert(input, settings, out buildInfo);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
return(exitCode);
}
public override void Initialize(ConceptualGroup group,
BuildContext context)
{
_group = group;
_context = context;
string workingDir = context.WorkingDirectory;
BuildSettings settings = context.Settings;
BuildGroupContext groupContext = context.GroupContexts[group.Id];
string manifestFile = Path.Combine(workingDir,
groupContext["$ManifestFile"]);
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.Indent = true;
xmlSettings.Encoding = Encoding.UTF8;
_manifestWriter = XmlWriter.Create(manifestFile, xmlSettings);
_manifestWriter.WriteStartDocument();
_manifestWriter.WriteStartElement("topics"); // start - topics
}
public virtual void Initialize(BuildContext context,
BuildEngineType engineType)
{
BuildExceptions.NotNull(context, "context");
base.Initialize(context.Logger);
BuildSettings settings = context.Settings;
if (settings == null)
{
this.IsInitialized = false;
return;
}
_nsmgr = null;
_context = context;
_settings = settings;
_style = Settings.Style;
_engineType = engineType;
this.IsInitialized = true;
this.WarnIfNotFound = true;
this.DeleteIfNotFound = true;
}
public async Task Cancelation_Test_CancelationByCSDAsync()
{
var build = new BuildSettings();
Cancelation cancelation = new Cancelation("http://services.test.sw.com.mx", "demo", "123456789");
//Al igual que el objeto de stamp, se indica url del ambiente al cual apuntara y credenciales de acceso o token.
string csdBase64 = build.Cer; //.Cer en Base64
string keyBase64 = build.Key; //.Key en Base64
string password = build.CerPassword; //password del CSD
string rfc = "LAN8507268IA";
string uuid = "7028573d-5a18-4331-8285-cd97b156c901";
var response = await cancelation.CancelarByCSDAsync(csdBase64, keyBase64, rfc, password, uuid);
if (response.status != "error")
{
//acuse de cancelación
Console.WriteLine(response.data.acuse);
}
else
{
Console.WriteLine(response.message);
Console.WriteLine(response.messageDetail);
}
Assert.True(response.data.acuse != null && response.status == "success");
}
public override void Initialize(BuildContext context)
{
base.Initialize(context);
if (base.IsInitialized)
{
_context = context;
BuildSettings settings = context.Settings;
Debug.Assert(settings != null);
if (settings == null || settings.Style == null)
{
this.IsInitialized = false;
return;
}
_style = settings.Style;
Debug.Assert(_style != null);
if (_style == null)
{
this.IsInitialized = false;
return;
}
}
}
protected override async Task <int> BuildInternal(BuildSettings settings)
{
var filesToCreate = EntityHelper.EntityTypes.Where(e => Roots.Contains(e.Name) && !Enums.Contains(e.Name));
BuilderFileCountUpdate(filesToCreate.Count());
await Pause.WaitWhilePausedAsync();
foreach (var file in filesToCreate)
{
var filePath = string.Concat(settings.ServicePath, file.Name, "Service", settings.FileExtension);
await BuildFile <eBuildSectionService>(filePath, file, settings);
await Pause.WaitWhilePausedAsync();
if (Cancellation.IsCancellationRequested)
{
break;
}
}
return(filesToCreate.Count());
}
protected override async Task <int> BuildInternal(BuildSettings settings)
{
var filesToCreate = EntityHelper.EntityTypes.Where(i => !settings.EntityExclusions.Any(e => i.Name.StartsWith(e, StringComparison.CurrentCultureIgnoreCase)));
BuilderFileCountUpdate(filesToCreate.Count());
await Pause.WaitWhilePausedAsync();
foreach (var file in filesToCreate)
{
var filePath = string.Concat(settings.ContractPath, file.Name, settings.ContractName, settings.FileExtension);
await BuildFile <eBuildSectionContract>(filePath, file, settings);
await Pause.WaitWhilePausedAsync();
if (Cancellation.IsCancellationRequested)
{
break;
}
}
return(filesToCreate.Count());
}
protected StringBuilder <T> CreateStringBuilder <T>(EntityType entityType, EntityHelper entityHelper, BuildSettings settings, IBuilder builder,
List <string> roots, List <string> enumerations, PauseToken pause, CancellationToken cancellation)
where T : struct, IConvertible
{
var returnValue = new StringBuilder <T>(entityType, entityHelper, settings, builder, roots, enumerations, pause, cancellation);
returnValue.OnBuilderPassComplete += BuilderPassComplete;
return(returnValue);
}
public bool Build(string[] targetNames, System.Collections.IDictionary targetOutputs, BuildSettings buildFlags)
{
}
public virtual WriteResult Write(string outputFolder, List <WriteCommand> dependencies, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet buildUsage)
{
return(BundleBuildInterface.WriteSerializedFile(outputFolder, command, dependencies, settings, globalUsage, buildUsage));
}
public CachedBuildSetting(string path, BuildSettings asset)
{
Path = path;
Asset = asset;
}
public override RunStepResult Start(BuildSettings settings)
{
return(Success(settings, null));
}
bool BuildProjectFileInternal(string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags, string toolsVersion)
{
if ((buildFlags & BuildSettings.DoNotResetPreviouslyBuiltTargets) != BuildSettings.DoNotResetPreviouslyBuiltTargets)
builtTargetsOutputByName.Clear ();
Project project;
bool newProject = false;
if (!projects.TryGetValue (projectFile, out project)) {
project = CreateNewProject ();
newProject = true;
}
BuildPropertyGroup engine_old_grp = null;
BuildPropertyGroup project_old_grp = null;
if (globalProperties != null) {
engine_old_grp = GlobalProperties.Clone (true);
project_old_grp = project.GlobalProperties.Clone (true);
// Override project's global properties with the
// ones explicitlcur_y specified here
foreach (BuildProperty bp in globalProperties)
project.GlobalProperties.AddProperty (bp);
if (!newProject)
project.NeedToReevaluate ();
}
if (newProject)
project.Load (projectFile);
try {
string oldProjectToolsVersion = project.ToolsVersion;
if (String.IsNullOrEmpty (toolsVersion) && defaultToolsVersion != null)
// no tv specified, let the project inherit it from the
// engine. 'defaultToolsVersion' will be effective only
// it has been overridden. Otherwise, the project's own
// tv will be used.
project.ToolsVersion = defaultToolsVersion;
else
project.ToolsVersion = toolsVersion;
try {
return project.Build (targetNames, targetOutputs, buildFlags);
} finally {
project.ToolsVersion = oldProjectToolsVersion;
}
} finally {
if (globalProperties != null) {
GlobalProperties = engine_old_grp;
project.GlobalProperties = project_old_grp;
}
}
}
public bool BuildProjectFile(string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags)
{
return BuildProjectFile (projectFile, targetNames, globalProperties, targetOutputs, buildFlags, null);
}
/**
* Private post-export method
* --------------------------
*
* This is being executed in two separate fashions as seen above,
* based on whether or not the build is occurring in the Cloud.
*
* - Path parameter points to root XCode project directory
* where xcodeproj file is located
* - Uses XCode Manipulation API to:
* - Force Debug configuration before XCode build step is executed
* - Disable ENABLE_BITCODE to prevent large app filesizes
**/
private static void ProcessPostBuild(BuildTarget buildTarget, string path)
{
// Restricting post-export behavior to only builds where specific Scene is active
if (buildTarget == BuildTarget.iOS && IsSceneActive ("Assets/Scenes/CounterScene.unity"))
{
// Initialize build settings
var buildSettings = new BuildSettings {
configuration = "Debug"
};
/**
* Manual manipulation of .xcscheme file
* -------------------------------------
*
* .xcscheme file contains all information related to build schemes as seen
* in Project -> Schemes -> Edit Schemes dialog in XCode. In this case, we
* are forcing Debug configuration.
**/
// Access xcscheme file and ingest xml
string schemePath = path + "/Unity-iPhone.xcodeproj/xcshareddata/xcschemes/Unity-iPhone.xcscheme";
var schemeReader = new StreamReader (schemePath);
var xDoc = XDocument.Load(schemeReader);
schemeReader.Close();
Debug.Log(string.Format("Loaded scheme file: {0}", schemePath));
// Set debug configuration for launch action
foreach (XElement element in xDoc.Descendants("LaunchAction")) {
element.SetAttributeValue("buildConfiguration", buildSettings.configuration);
Debug.Log(string.Format("Set launch configuration to {0}", buildSettings.configuration));
}
// Write file back out
xDoc.Save(schemePath);
Debug.Log(string.Format("Saved scheme file: {0}", schemePath));
/**
* XCode Project manipulation examples
* -----------------------------------
*
* .pbxproj file contains information related to frameworks, build properties
* and other settings within an XCode project. See the Manipulation API docs:
*
* http://docs.unity3d.com/ScriptReference/iOS.Xcode.PBXProject.html
**/
// Access pbxproj file to add frameworks and build properties
string projPath = path + "/Unity-iPhone.xcodeproj/project.pbxproj";
PBXProject proj = new PBXProject();
proj.ReadFromString(File.ReadAllText(projPath));
string target = proj.TargetGuidByName("Unity-iPhone");
// Add user packages to project. Most other source or resource files and packages
// can be added the same way.
//CopyAndReplaceDirectory ("NativeAssets/TestLib.bundle", Path.Combine (path, "Frameworks/TestLib.bundle"));
//proj.AddFileToBuild (target, proj.AddFile ("Frameworks/TestLib.bundle",
// "Frameworks/TestLib.bundle", PBXSourceTree.Source));
//CopyAndReplaceDirectory ("NativeAssets/TestLib.framework", Path.Combine (path, "Frameworks/TestLib.framework"));
//proj.AddFileToBuild (target, proj.AddFile ("Frameworks/TestLib.framework",
// "Frameworks/TestLib.framework", PBXSourceTree.Source));
// Add custom system frameworks. Duplicate frameworks are ignored.
// needed by our native plugin in Assets/Plugins/iOS
//proj.AddFrameworkToProject (target, "AssetsLibrary.framework", false /*not weak*/);
// Add our framework directory to the framework include path
//proj.SetBuildProperty (target, "FRAMEWORK_SEARCH_PATHS", "$(inherited)");
//proj.AddBuildProperty (target, "FRAMEWORK_SEARCH_PATHS", "$(PROJECT_DIR)/Frameworks");
// Set a custom link flag
//proj.AddBuildProperty (target, "OTHER_LDFLAGS", "-ObjC");
// Write changes back to file
File.WriteAllText(projPath, proj.WriteToString());
}
}
/// <summary>
/// Loads a set of project files from disk, and builds the given list of targets for each one. This overload
/// takes a set of global properties for each project to use for the build, returns the target outputs,
/// and also allows the caller to specify additional build flags.
/// </summary>
/// <param name="projectFiles">Array of project files to build (can't be null)</param>
/// <param name="targetNamesPerProject">Array of targets for each project(can't be null)</param>
/// <param name="globalPropertiesPerProject">Array of properties for each project (can't be null)</param>
/// <param name="targetOutputsPerProject">Array of tables for target outputs (can't be null)</param>
/// <param name="buildFlags"></param>
/// <param name="toolsVersions">Tools version to impose on the project in this build</param>
/// <returns>True if all given project build successfully</returns>
public bool BuildProjectFiles
(
string[] projectFiles,
string[][] targetNamesPerProject,
BuildPropertyGroup[] globalPropertiesPerProject,
IDictionary[] targetOutputsPerProject,
BuildSettings buildFlags,
string [] toolsVersions
)
{
// Verify the arguments to the API
error.VerifyThrowArgumentArraysSameLength(projectFiles, targetNamesPerProject, "projectFiles", "targetNamesPerProject");
error.VerifyThrowArgument(projectFiles.Length > 0, "projectFilesEmpty");
error.VerifyThrowArgumentArraysSameLength(projectFiles, globalPropertiesPerProject, "projectFiles", "globalPropertiesPerProject");
error.VerifyThrowArgumentArraysSameLength(projectFiles, targetOutputsPerProject, "projectFiles", "targetOutputsPerProject");
error.VerifyThrowArgumentArraysSameLength(projectFiles, toolsVersions, "projectFiles", "toolsVersions");
// Verify the entries in the project file array
for (int i = 0; i < projectFiles.Length; i++)
{
error.VerifyThrowArgumentNull(projectFiles[i], "projectFiles[" + i +"]");
error.VerifyThrowArgument(projectFiles[i].Length > 0, "projectFilesEmptyElement", i);
}
return PostProjectEvaluationRequests
(null, projectFiles, targetNamesPerProject, globalPropertiesPerProject, targetOutputsPerProject,
buildFlags, toolsVersions);
}
internal bool PostProjectEvaluationRequests
(
Project project,
string[] projectFiles,
string[][] targetNames,
BuildPropertyGroup[] globalPropertiesPerProject,
IDictionary[] targetOutputsPerProject,
BuildSettings buildFlags,
string [] toolVersions
)
{
string currentDirectory = Environment.CurrentDirectory;
string currentPerThreadProjectDirectory = Project.PerThreadProjectDirectory;
fatalErrorContext = null;
BuildEventContext buildEventContext;
// Already have an instantiated project in the OM and it has not fired a project started event for itself yet
if (project != null && !project.HaveUsedInitialProjectContextId)
{
buildEventContext = project.ProjectBuildEventContext;
}
else // Dont have an already instantiated project, need to make a new context
{
buildEventContext = new BuildEventContext(
this.nodeId,
BuildEventContext.InvalidTargetId,
BuildEventContext.InvalidProjectContextId,
BuildEventContext.InvalidTaskId
);
}
// Currently, MSBuild requires that the calling thread be marked "STA" -- single
// threaded apartment. This is because today we are calling the tasks' Execute()
// method on this main thread, and there are tasks out there that create unmarshallable
// COM objects that require the "Apartment" threading model. Once the engine supports
// multi-threaded builds, and is spinning up its own threads to call the tasks, then
// we don't care so much about the STA vs. MTA designation on the main thread. But for
// now, we do.
if (Environment.GetEnvironmentVariable("MSBUILDOLDOM") != "1" && Thread.CurrentThread.GetApartmentState() != ApartmentState.STA)
{
// Bug VSWhidbey 126031. Really, we would like to,
//
// error.VerifyThrowInvalidOperation((Thread.CurrentThread.ApartmentState == ApartmentState.STA),"STARequired");
//
// But NUnit-console.exe is not in the STA and so we would get some assert dialogs
// and build failures. If we ever upgrade to NUnit 2.1 or later, there is an option
// to tell NUnit to run in STA mode, and then maybe we can be more strict here.
primaryLoggingServices.LogWarning(buildEventContext, new BuildEventFileInfo(/* there is truly no file associated with this warning */ String.Empty),
"STARequired", Thread.CurrentThread.GetApartmentState());
}
BuildRequest[] buildRequests = new BuildRequest[projectFiles.Length];
Hashtable[] targetOutputsWorkingCopy = new Hashtable[buildRequests.Length];
for (int i = 0; i < buildRequests.Length; i++)
{
// if the caller wants to retrieve target outputs, create a working copy to avoid clobbering
// other data in the hashtable
if (targetOutputsPerProject[i] != null)
{
targetOutputsWorkingCopy[i] = new Hashtable(StringComparer.OrdinalIgnoreCase);
}
buildRequests[i] =
CreateLocalBuildRequest(buildEventContext, project, projectFiles[i], targetNames[i],
globalPropertiesPerProject[i], targetOutputsWorkingCopy[i], buildFlags,
toolVersions[i]);
}
bool overallResult = true;
bool exitedDueToError = true;
try
{
// Reset the current directory stored in the per thread variable for the current thread
Project.PerThreadProjectDirectory = null;
// Initialize the scheduler with the current information
Scheduler.Initialize(NodeManager.GetNodeDescriptions());
// Fire the event that says the overall build is beginning.
LoggingServices.LogBuildStarted();
LoggingServices.ProcessPostedLoggingEvents();
// Post all the build requests into the engine queue
PostBuildRequests(buildRequests);
// Trigger the actual build (this call will not return until build is complete)
EngineBuildLoop(null);
for (int i = 0; i < buildRequests.Length; i++)
{
// Collect the outputs
BuildResult buildResult = buildRequests[i].GetBuildResult();
if (buildResult.OutputsByTarget != null && targetOutputsPerProject[i] != null)
{
buildResult.ConvertToTaskItems();
foreach (DictionaryEntry de in buildResult.OutputsByTarget)
{
targetOutputsPerProject[i][de.Key] = de.Value;
}
}
overallResult = overallResult && buildRequests[i].BuildSucceeded;
}
exitedDueToError = false;
}
catch (Exception e)
{
// Only log the error once at the root of the recursion for unhandled exceptions, instead of
// logging the error multiple times for each level of project-to-project
// recursion until we get to the top of the stack.
if (fatalErrorContext != null)
{
primaryLoggingServices.LogFatalBuildError(fatalErrorContext, e, new BuildEventFileInfo(fatalErrorProjectName));
}
else
{
primaryLoggingServices.LogFatalBuildError(buildEventContext, e, new BuildEventFileInfo(String.Empty));
}
// Rethrow so that the host can catch it and possibly rethrow it again
// so that Watson can give the user the option to send us an error report.
throw;
}
finally
{
// Post build finished event if the finally is not being executed due to an exception
EndingEngineExecution(overallResult, exitedDueToError);
// Reset the current directory to the value before this
// project built
Environment.CurrentDirectory = currentDirectory;
// We reset the path back to the original value in case the
// host is depending on the current directory to find projects
Project.PerThreadProjectDirectory = currentPerThreadProjectDirectory;
}
return overallResult;
}
/// <summary>
/// Create a build request which will be posted to the local engine queue, having a HandleId of -1 meaning it came from the local
/// engine rather than an engine call back
/// </summary>
/// <returns></returns>
private BuildRequest CreateLocalBuildRequest(BuildEventContext buildEventContext, Project project, string projectFile, string[] targetNames, BuildPropertyGroup globalProperties, IDictionary targetOutputs, BuildSettings buildFlags, string toolsVersion)
{
// Global Properties should not be null as this will cause a crash when we try and cache the build result of the project.
// Whidby also set global properties to empty if they were null.
if (globalProperties == null)
{
globalProperties = new BuildPropertyGroup();
}
BuildRequest buildRequest = new BuildRequest(EngineCallback.invalidEngineHandle, projectFile, targetNames, globalProperties, toolsVersion, -1, true, false);
buildRequest.ParentBuildEventContext = buildEventContext;
// Set the project object to the passed in project
buildRequest.ProjectToBuild = project;
// Set the request build flags
buildRequest.BuildSettings = buildFlags;
// Set the boolean requesting the project start/finish events
buildRequest.FireProjectStartedFinishedEvents = true;
// Set the dictionary to return target outputs in, if any
buildRequest.OutputsByTarget = targetOutputs;
// If the tools version is null and we have a project object then use the project's tools version
// If we do not have a project and we have a null tools version then the build request's tools version will be null, which will later be set in BuildProjectFileInternal
if (String.IsNullOrEmpty(toolsVersion) && project != null)
{
buildRequest.ToolsetVersion = project.ToolsVersion;
}
// Set project filename correctly if only the project object is passed in
if (buildRequest.ProjectFileName == null)
{
buildRequest.ProjectFileName = project.FullFileName;
}
return buildRequest;
}
public bool BuildProjectFile(string projectFile, string[] targetNames, BuildPropertyGroup globalProperties, System.Collections.IDictionary targetOutputs, BuildSettings buildFlags) {}
public bool BuildProject (Project project,
string[] targetNames,
IDictionary targetOutputs,
BuildSettings buildFlags)
{
if (project == null)
throw new ArgumentException ("project");
if (targetNames == null)
return false;
return project.Build (targetNames, targetOutputs, buildFlags);
}
/// <summary>
/// Builds the specified list of targets in this project using the specified
/// flags, and returns the target outputs.
/// </summary>
/// <remarks>
/// This is the public method that host IDEs can call to build a project.
/// It just turns around and calls "BuildProject" on the engine object.
/// All builds must go through the engine object, because it needs to
/// keep track of the projects that are currently in progress, so that
/// we don't end up in infinite loops when we have circular project-to-
/// project dependencies.
/// </remarks>
/// <param name="targetNames"></param>
/// <param name="targetOutputs"></param>
/// <param name="buildFlags"></param>
/// <returns></returns>
/// <owner>RGoel</owner>
public bool Build
(
string[] targetNames, // can be null to build the default targets
IDictionary targetOutputs, // can be null if outputs are not needed
BuildSettings buildFlags
)
{
return this.ParentEngine.BuildProject(this, targetNames, targetOutputs, buildFlags);
}
public static void ParseOptionsAndFindScenes(
string[] args,
out BuildPlayerOptions player_options,
out BuildSettings settings)
{
try
{
ConfigurationType configuration_type;
string main_scene;
string[] scene_paths;
{
var path = GetArgumentValueOrDefault(args, "-config", "configurations.json");
var file = ParseConfigurationsFile(path);
var type_str = GetArgumentValue(args, "-configuration");
configuration_type = (ConfigurationType)Enum.Parse(typeof(ConfigurationType), type_str);
//var configuration_options = file.Configurations[configuration_type];
var configuration_options = file.GetConfiguration(configuration_type);
main_scene = configuration_options.MainScene;
scene_paths = configuration_options.Scenes;
}
var platform = GetArgumentValue(args, "-platform");
var target = GetPrimaryBuildTarget(platform);
var product_file_name = GetProductFileName(target);
var build_path = "Build/" + platform + "/" + configuration_type;
var location_path_name =
GetArgumentValueOrDefault(args, "-buildPath", build_path) +
"/" +
product_file_name;
// Locate the scenes to be used for this build configuration
string[] configuration_scenes;
try
{
configuration_scenes =
FindScenes(main_scene)
.Concat(FindScenes(scene_paths)).
ToArray();
}
catch (FileNotFoundException ex)
{
throw new Exception("Scene file or directory not found: " + ex.FileName);
}
player_options = new BuildPlayerOptions()
{
locationPathName = location_path_name,
target = target,
scenes = configuration_scenes,
};
settings = new BuildSettings()
{
ConfigurationType = configuration_type,
};
}
catch (ArgumentException ex)
{
throw new Exception("Missing required build argument: " + ex.ParamName, ex);
}
}
public bool BuildProject(Project project,
string[] targetNames,
IDictionary targetOutputs,
BuildSettings buildFlags)
{
if (project == null)
throw new ArgumentException ("project");
if (targetNames == null)
return false;
if ((buildFlags & BuildSettings.DoNotResetPreviouslyBuiltTargets) != BuildSettings.DoNotResetPreviouslyBuiltTargets)
builtTargetsOutputByName.Clear ();
if (defaultToolsVersion != null)
// it has been explicitly set, xbuild does this..
project.ToolsVersion = defaultToolsVersion;
return project.Build (targetNames, targetOutputs, buildFlags);
}
/// <summary>
/// Loads a project file from disk, and builds the specified list of targets. This overload
/// takes a set of global properties to use for the build, returns the target outputs, and also
/// allows the caller to specify additional build flags.
/// </summary>
/// <remarks>
/// If this project file is already in our list of in-progress projects, we use the
/// existing Project object instead of instantiating a new one. Always use this method to
/// build projects within projects, otherwise the build won't be optimized.
/// </remarks>
/// <param name="projectFile"></param>
/// <param name="targetNames">Can be null, if caller wants to build the default targets for the project.</param>
/// <param name="globalProperties">Can be null if no global properties are needed.</param>
/// <param name="targetOutputs">Can be null if outputs are not needed.</param>
/// <param name="buildFlags">Specifies additional options to alter the behavior of the build.</param>
/// <param name="toolsVersion">Tools version to impose on the project in this build</param>
/// <returns>true, if build succeeds</returns>
public bool BuildProjectFile
(
string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags,
string toolsVersion
)
{
return PostProjectEvaluationRequests
(null, new string[] { projectFile }, new string[][] { targetNames },
new BuildPropertyGroup[] { globalProperties }, new IDictionary[] { targetOutputs }, buildFlags,
new string[] {toolsVersion});
}
//FIXME: add a test for null @toolsVersion
public bool BuildProjectFile(string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags, string toolsVersion)
{
bool result = false;
try {
StartEngineBuild ();
result = BuildProjectFileInternal (projectFile, targetNames, globalProperties, targetOutputs, buildFlags, toolsVersion);
return result;
} catch (InvalidProjectFileException ie) {
this.LogErrorWithFilename (projectFile, ie.Message);
this.LogMessage (MessageImportance.Low, String.Format ("{0}: {1}", projectFile, ie.ToString ()));
return false;
} catch (Exception e) {
if (buildStarted) {
this.LogErrorWithFilename (projectFile, e.Message);
this.LogMessage (MessageImportance.Low, String.Format ("{0}: {1}", projectFile, e.ToString ()));
}
throw;
} finally {
EndEngineBuild (result);
}
}
/// <summary>
/// Loads a project file from disk, and builds the specified list of targets. This overload
/// takes a set of global properties to use for the build, returns the target outputs, and also
/// allows the caller to specify additional build flags.
/// </summary>
/// <remarks>
/// If this project file is already in our list of in-progress projects, we use the
/// existing Project object instead of instantiating a new one. Always use this method to
/// build projects within projects, otherwise the build won't be optimized.
/// </remarks>
/// <param name="projectFile"></param>
/// <param name="targetNames">Can be null, if caller wants to build the default targets for the project.</param>
/// <param name="globalProperties">Can be null if no global properties are needed.</param>
/// <param name="targetOutputs">Can be null if outputs are not needed.</param>
/// <param name="buildFlags">Specifies additional options to alter the behavior of the build.</param>
/// <returns>true, if build succeeds</returns>
public bool BuildProjectFile
(
string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags
)
{
error.VerifyThrowArgumentNull(projectFile, "projectFileName");
error.VerifyThrowArgument(projectFile.Length > 0, "EmptyProjectFileName");
return BuildProjectFile(projectFile, targetNames, globalProperties, targetOutputs, buildFlags, null);
}
public override bool CanRun(BuildSettings settings, out string reason)
{
reason = null;
return(true);
}
//FIXME: add a test for null @toolsVersion
public bool BuildProjectFile (string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags, string toolsVersion)
{
Project project;
if (projects.ContainsKey (projectFile)) {
project = (Project) projects [projectFile];
} else {
project = CreateNewProject ();
project.Load (projectFile);
}
BuildPropertyGroup engine_old_grp = null;
BuildPropertyGroup project_old_grp = null;
if (globalProperties != null) {
engine_old_grp = GlobalProperties.Clone (true);
project_old_grp = project.GlobalProperties.Clone (true);
// Override project's global properties with the
// ones explicitlcur_y specified here
foreach (BuildProperty bp in globalProperties)
project.GlobalProperties.AddProperty (bp);
project.NeedToReevaluate ();
}
try {
string oldProjectToolsVersion = project.ToolsVersion;
if (String.IsNullOrEmpty (toolsVersion) && defaultToolsVersion != null)
// no tv specified, let the project inherit it from the
// engine. 'defaultToolsVersion' will be effective only
// it has been overridden. Otherwise, the project's own
// tv will be used.
project.ToolsVersion = defaultToolsVersion;
else
project.ToolsVersion = toolsVersion;
try {
return project.Build (targetNames, targetOutputs, buildFlags);
} finally {
project.ToolsVersion = oldProjectToolsVersion;
}
} finally {
if (globalProperties != null) {
GlobalProperties = engine_old_grp;
project.GlobalProperties = project_old_grp;
}
}
}
public void Initialize(BuildContext context, string defaultAttrFile)
{
BuildExceptions.NotNull(context, "context");
base.Initialize(context.Logger);
BuildSettings settings = context.Settings;
if (settings == null)
{
this.IsInitialized = false;
return;
}
_engineSettings = (ReferenceEngineSettings)settings.EngineSettings[
BuildEngineType.Reference];
Debug.Assert(_engineSettings != null,
"The settings does not include the reference engine settings.");
if (_engineSettings == null)
{
return;
}
_settings = settings;
_context = context;
_defaultAttrFile = defaultAttrFile;
if (!String.IsNullOrEmpty(_defaultAttrFile) &&
File.Exists(_defaultAttrFile))
{
string configDir = Path.GetDirectoryName(_defaultAttrFile);
string apiFilterFile = Path.Combine(configDir, DefaultApiFilterFile);
if (File.Exists(apiFilterFile))
{
_compilerRootFilter = new ReferenceRootFilter();
_compilerRootFilter.Load(apiFilterFile);
}
}
_assistComponents = null;
if (_context.IsDirectSandcastle)
{
string sandcastleAssist = _settings.SandAssistDirectory;
if (!String.IsNullOrEmpty(sandcastleAssist) &&
Directory.Exists(sandcastleAssist))
{
// If the Sandcastle Assist component assembly is in the same
// directory as the Sandcastle Helpers...
string tempText = Path.Combine(sandcastleAssist,
"Sandcastle.Reflection.dll");
if (File.Exists(tempText))
{
_assistComponents = tempText;
}
}
}
// 1. The reference ...
this.RegisterItem(KeywordNamer,
new Action <string, XPathNavigator>(OnNamerItem));
// 2. The reference ...
this.RegisterItem(KeywordAddins,
new Action <string, XPathNavigator>(OnAddinsItem));
// 3. The reference ...
this.RegisterItem(KeywordPlatform,
new Action <string, XPathNavigator>(OnPlatformItem));
// 4. The reference ...
this.RegisterItem(KeywordResolver,
new Action <string, XPathNavigator>(OnResolverItem));
// 5. The reference ...
this.RegisterItem(KeywordOptions,
new Action <string, XPathNavigator>(OnOptionsItem));
// 6. The reference ...
this.RegisterItem(KeywordApiFilter,
new Action <string, XPathNavigator>(OnApiFilterItem));
// 7. The reference ...
this.RegisterItem(KeywordAttributeFilter,
new Action <string, XPathNavigator>(OnAttributeFilterItem));
this.IsInitialized = true;
}
/// <summary>
/// Builds a list of targets in an already-loaded project using the specified
/// flags, and returns the target outputs.
/// </summary>
/// <owner>RGoel</owner>
/// <param name="project"></param>
/// <param name="targetNames"></param>
/// <param name="targetOutputs"></param>
/// <param name="buildFlags">whether previously built targets should be reset or not</param>
/// <returns>true, if build succeeds</returns>
public bool BuildProject
(
Project project,
string[] targetNames,
IDictionary targetOutputs, // can be null if outputs are not needed
BuildSettings buildFlags
)
{
return PostProjectEvaluationRequests(project, new string[] { null }, new string[1][] { targetNames },
new BuildPropertyGroup[] { null }, new IDictionary[] { targetOutputs }, buildFlags, new string[] { null });
}
public virtual void Uninitialize()
{
_group = null;
_format = null;
_settings = null;
}
public bool BuildProjectFile (string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags)
{
Project project;
if (projects.ContainsKey (projectFile)) {
project = (Project) projects [projectFile];
} else {
project = CreateNewProject ();
project.Load (projectFile);
}
BuildPropertyGroup engine_old_grp = null;
BuildPropertyGroup project_old_grp = null;
if (globalProperties != null) {
engine_old_grp = GlobalProperties.Clone (true);
project_old_grp = project.GlobalProperties.Clone (true);
// Override project's global properties with the
// ones explicitlcur_y specified here
foreach (BuildProperty bp in globalProperties)
project.GlobalProperties.AddProperty (bp);
project.NeedToReevaluate ();
}
try {
return project.Build (targetNames, targetOutputs, buildFlags);
} finally {
if (globalProperties != null) {
GlobalProperties = engine_old_grp;
project.GlobalProperties = project_old_grp;
}
}
}
//FIXME: add a test for null @toolsVersion
public bool BuildProjectFile (string projectFile,
string[] targetNames,
BuildPropertyGroup globalProperties,
IDictionary targetOutputs,
BuildSettings buildFlags, string toolsVersion)
{
Project project;
if (projects.ContainsKey (projectFile)) {
project = (Project) projects [projectFile];
} else {
project = CreateNewProject ();
project.Load (projectFile);
}
BuildPropertyGroup engine_old_grp = null;
BuildPropertyGroup project_old_grp = null;
if (globalProperties != null) {
engine_old_grp = GlobalProperties.Clone (true);
project_old_grp = project.GlobalProperties.Clone (true);
// Override project's global properties with the
// ones explicitlcur_y specified here
foreach (BuildProperty bp in globalProperties)
project.GlobalProperties.AddProperty (bp);
project.NeedToReevaluate ();
}
try {
if (String.IsNullOrEmpty (toolsVersion) && defaultToolsVersion != null)
// it has been explicitly set, xbuild does this..
//FIXME: should this be cleared after building?
project.ToolsVersion = defaultToolsVersion;
else
project.ToolsVersion = toolsVersion;
return project.Build (targetNames, targetOutputs, buildFlags);
} finally {
if (globalProperties != null) {
GlobalProperties = engine_old_grp;
project.GlobalProperties = project_old_grp;
}
}
}
// Methods
public virtual BuildResults Build(BuildSettings settings) {}
