private static DirectoryPath GetFrameworkPath(ICakeEnvironment environment, PlatformTarget target, string version)
{
// Get the Microsoft .NET folder.
var windowsFolder = environment.GetSpecialPath(SpecialPath.Windows);
var netFolder = windowsFolder.Combine("Microsoft.NET");
if (target == PlatformTarget.MSIL)
{
// Get the framework folder.
var is64Bit = environment.Is64BitOperativeSystem();
var frameWorkFolder = is64Bit ? netFolder.Combine("Framework64") : netFolder.Combine("Framework");
return(frameWorkFolder.Combine(version));
}
if (target == PlatformTarget.x86)
{
return(netFolder.Combine("Framework").Combine(version));
}
if (target == PlatformTarget.x64)
{
return(netFolder.Combine("Framework64").Combine(version));
}
throw new NotSupportedException();
}
ParsedProject(ExtProjectParserResult parsedProject, FilePath p, string configuration, PlatformTarget platform)
{
Configuration = configuration;
Platform = platform;
ProjectFile = p;
Project = parsedProject;
}
static FilePath PreProcessProject(ICakeContext context, PlatformTarget target, FilePath input)
{
var targetDirName = string.Format("{0}/build-analysis/{1}/{2}",
BuildConfig.TargetDirectory,
target,
BuildConfig.Configuration);
var directory = context.Directory(targetDirName);
context.CreateDirectory(directory);
var targetFile = directory.Path.CombineWithFilePath(input.GetFilename().ChangeExtension("tmp.xml"))
.MakeAbsolute(context.Environment);
if (XBuildHelper.DotNetExists)
{
var buildSettings = CreatePreProcessingMSBuildSettings(target, targetFile);
var tool = new DotNetGeneralTool(context.FileSystem,
context.Environment,
context.ProcessRunner,
context.Tools);
tool.DotNetMSBuild(input, buildSettings);
return(targetFile);
}
if (context.Environment.Platform.Family == PlatformFamily.Windows)
{
var buildSettings = CreatePreProcessingMSBuildSettings(target, targetFile);
context.MSBuild(input, buildSettings);
return(targetFile);
}
return(input);
}
protected async override Task SetTargetAsync(ISelfDisposingBitmapDrawable image, bool animated)
{
ThrowIfCancellationRequested();
var ffDrawable = image as FFBitmapDrawable;
if (ffDrawable != null)
{
if (ffDrawable.IsAnimationRunning)
{
await Task.Delay(ffDrawable.FadeDuration + 25);
}
if (animated)
{
ISelfDisposingBitmapDrawable placeholderDrawable = null;
if (_loadingPlaceholderWeakReference != null && _loadingPlaceholderWeakReference.TryGetTarget(out placeholderDrawable) && placeholderDrawable != null)
{
int fadeDuration = Parameters.FadeAnimationDuration.HasValue ?
Parameters.FadeAnimationDuration.Value : Configuration.FadeAnimationDuration;
placeholderDrawable?.SetIsRetained(true);
ffDrawable?.SetPlaceholder(placeholderDrawable as BitmapDrawable, fadeDuration);
placeholderDrawable?.SetIsRetained(false);
}
}
}
await MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}).ConfigureAwait(false);
}
private static string GetPlatformName(PlatformTarget platform, bool isSolution)
{
switch (platform)
{
case PlatformTarget.MSIL:
// Solutions expect "Any CPU", but projects expect "AnyCPU"
return(isSolution ? "\"Any CPU\"" : "AnyCPU");
case PlatformTarget.x86:
return("x86");
case PlatformTarget.x64:
return("x64");
case PlatformTarget.ARM:
return("arm");
case PlatformTarget.ARM64:
return("arm64");
case PlatformTarget.Win32:
return("Win32");
default:
throw new ArgumentOutOfRangeException(nameof(platform), platform, "Invalid platform");
}
}
static string PlatformAsString(PlatformTarget t)
{
if (t == PlatformTarget.MSIL)
{
return("AnyCPU");
}
return(t.ToString());
}
public static string ConvertPlatformTargetToString(PlatformTarget target)
{
if (PlatformTarget.MSIL == target)
{
return("AnyCPU");
}
return(target.ToString());
}
protected override Task SetTargetAsync(UIImage image, bool animated)
{
return(MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}));
}
protected async override Task SetTargetAsync(SelfDisposingBitmapDrawable image, bool animated)
{
if (Target == null)
{
return;
}
ThrowIfCancellationRequested();
var ffDrawable = image as FFBitmapDrawable;
if (ffDrawable != null)
{
if (ffDrawable.IsAnimationRunning)
{
var mut = new FFBitmapDrawable(Context.Resources, ffDrawable.Bitmap, ffDrawable);
ffDrawable = mut as FFBitmapDrawable;
image = ffDrawable;
// old hacky workaround
//await Task.Delay(ffDrawable.FadeDuration + 50).ConfigureAwait(false);
}
if (animated)
{
SelfDisposingBitmapDrawable placeholderDrawable = null;
PlaceholderWeakReference?.TryGetTarget(out placeholderDrawable);
if (placeholderDrawable == null)
{
// Enable fade animation when no placeholder is set and the previous image is not null
var imageView = PlatformTarget.Control as ImageViewAsync;
placeholderDrawable = imageView?.Drawable as SelfDisposingBitmapDrawable;
}
if (placeholderDrawable.IsValidAndHasValidBitmap())
{
int fadeDuration = Parameters.FadeAnimationDuration.HasValue ?
Parameters.FadeAnimationDuration.Value : Configuration.FadeAnimationDuration;
placeholderDrawable?.SetIsRetained(true);
ffDrawable?.SetPlaceholder(placeholderDrawable, fadeDuration);
placeholderDrawable?.SetIsRetained(false);
}
}
else
{
ffDrawable?.SetPlaceholder(null, 0);
}
}
await MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}).ConfigureAwait(false);
}
public ProjectBuildConfiguration(
string configurationName,
string platformName,
PlatformTarget platformTarget,
string outputPath)
{
ConfigurationName = configurationName;
PlatformName = platformName;
PlatformTarget = platformTarget;
OutputPath = outputPath;
}
protected override async Task SetTargetAsync(SharedEvasImage image, bool animated)
{
if (Target == null)
{
return;
}
await MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}).ConfigureAwait(false);
}
protected override Task SetTargetAsync(PImage image, bool animated)
{
if (Target == null)
{
return(Task.FromResult(true));
}
return(MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}));
}
public static string GetCompilerArgument(PlatformTarget target)
{
switch (target)
{
case PlatformTarget.AnyCPU:
return "/platform:anycpu";
case PlatformTarget.Itanium:
return "/platform:Itanium";
case PlatformTarget.x64:
return "/platform:x64";
case PlatformTarget.x86:
return "/platform:x86";
}
throw new NotSupportedException("Unknown platform target specified");
}
public static string ToSolutionFileToken(this PlatformTarget platformTarget)
{
switch (platformTarget)
{
case PlatformTarget.AnyCPU:
return(SolutionFileUtilities.AnyCpuSolutionFileReleasePlatformToken);
case PlatformTarget.x32:
return(SolutionFileUtilities.x86SolutionFileReleasePlatformToken); // x32 is x86.
case PlatformTarget.x64:
return(SolutionFileUtilities.x64SolutionFileReleasePlatformToken);
default:
throw new Exception(EnumHelper.UnexpectedEnumerationValueMessage(platformTarget));
}
}
private static string GetPlatformName(PlatformTarget platform)
{
switch (platform)
{
case PlatformTarget.MSIL:
return("\"Any CPU\"");
case PlatformTarget.x86:
return("x86");
case PlatformTarget.x64:
return("x64");
default:
throw new InvalidEnumArgumentException("platform", (int)platform, typeof(PlatformTarget));
}
}
protected async override Task SetTargetAsync(SelfDisposingBitmapDrawable image, bool animated)
{
ThrowIfCancellationRequested();
var ffDrawable = image as FFBitmapDrawable;
if (ffDrawable != null)
{
if (ffDrawable.IsAnimationRunning)
{
var mut = new FFBitmapDrawable(Context.Resources, ffDrawable.Bitmap, ffDrawable);
ffDrawable = mut as FFBitmapDrawable;
image = ffDrawable;
// old hacky workaround
//await Task.Delay(ffDrawable.FadeDuration + 50).ConfigureAwait(false);
}
if (animated)
{
SelfDisposingBitmapDrawable placeholderDrawable = null;
if (PlaceholderWeakReference != null && PlaceholderWeakReference.TryGetTarget(out placeholderDrawable) && placeholderDrawable != null)
{
int fadeDuration = Parameters.FadeAnimationDuration.HasValue ?
Parameters.FadeAnimationDuration.Value : Configuration.FadeAnimationDuration;
placeholderDrawable?.SetIsRetained(true);
ffDrawable?.SetPlaceholder(placeholderDrawable, fadeDuration);
placeholderDrawable?.SetIsRetained(false);
}
}
else
{
ffDrawable?.SetPlaceholder(null, 0);
}
}
await MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}).ConfigureAwait(false);
}
static MSBuildSettings CreatePreProcessingMSBuildSettings(PlatformTarget target, FilePath targetFile)
{
var settings = new AnyBuildSettings(BuildConfig.BuildSettings);
settings.PlatformTarget = target;
var buildSettings = XBuildHelper.CreateMSBuildSettings(settings);
var argsCustomizer = buildSettings.ArgumentCustomization;
buildSettings.ArgumentCustomization = args =>
{
if (argsCustomizer != null)
{
args = argsCustomizer.Invoke(args);
}
args.AppendQuoted("/preprocess:" + targetFile.FullPath);
return(args);
};
return(buildSettings);
}
public static string GetCompilerArgument(PlatformTarget target)
{
switch (target)
{
case PlatformTarget.AnyCPU:
return("/platform:anycpu");
case PlatformTarget.Itanium:
return("/platform:Itanium");
case PlatformTarget.x64:
return("/platform:x64");
case PlatformTarget.x86:
return("/platform:x86");
}
throw new NotSupportedException("Unknown platform target specified");
}
/// <summary>
/// Gets the cpu target for the application.
/// </summary>
/// <param name="appInfo">The application info structure.</param>
/// <returns>CPU target</returns>
private CpuTarget GetCpuTarget(ApplicationInfo appInfo)
{
this.startupLogger.Info(Strings.DetectingCpuTarget);
string[] allAssemblies = Directory.GetFiles(appInfo.Path, "*.dll", SearchOption.AllDirectories);
CpuTarget target = CpuTarget.X64;
foreach (string assembly in allAssemblies)
{
target = PlatformTarget.DetectPlatform(assembly);
if (target == CpuTarget.X86)
{
break;
}
}
this.startupLogger.Info(Strings.DetectedCpuTarget, target.ToString());
return(target);
}
private static string GetPlatformName(PlatformTarget platform)
{
switch (platform)
{
case PlatformTarget.MSIL:
return("\"Any CPU\"");
case PlatformTarget.x86:
return("x86");
case PlatformTarget.x64:
return("x64");
case PlatformTarget.ARM:
return("arm");
case PlatformTarget.Win32:
return("Win32");
default:
throw new ArgumentOutOfRangeException("platform", platform, "Invalid platform");
}
}
public static void InvokeXBuild(FilePath path, AnyBuildSettings settings, PlatformTarget platformTarget)
{
settings = new AnyBuildSettings(settings);
settings.PlatformTarget = platformTarget;
if (settings == null)
{
throw new ArgumentNullException("settings");
}
var targets = new List <string>();
targets.AddRange(settings.Targets);
if (targets.Count == 0)
{
targets.Add("Build");
}
var relativeProjectFile = Context.Environment.WorkingDirectory.GetRelativePath(path);
Context.Log.Verbose(string.Format("Starting build for {0} with platform {1}", relativeProjectFile,
platformTarget));
foreach (var target in targets)
{
if (Context.Environment.Platform.Family == PlatformFamily.Windows && !BuildConfig.UseXBuildOnWindows)
{
Context.MSBuild(path, XBuildHelper.CreateMSBuildSettings(settings, target));
}
else
{
Context.XBuild(path, XBuildHelper.CreateXBuildSettings(settings, path, target));
}
}
Context.Log.Verbose(string.Format("Finished build for {0} with platform {1}", relativeProjectFile,
platformTarget));
}
/// <summary>
/// Compiles a scene graph into a windows platform .NET executable.
/// </summary>
/// <param name="graph">
/// The specified scene graph to compile source from.
/// </param>
/// <returns>
/// A Stream comprising the compilation output
/// </returns>
public static Stream Compile(SceneGraph graph, PlatformTarget platform = PlatformTarget.Windows)
{
Stream s;
MemoryStream ms;
ILRepack repack;
RepackOptions options;
string source;
bool compiled;
string tmpExeFile;
string tmpExeFileRepacked;
byte[] data;
source = CompileAsObjects(graph);
compiled = CompileCSharp(source, out tmpExeFile);
tmpExeFileRepacked = Path.GetTempFileName() + ".exe";
options = new RepackOptions()
{
TargetKind = ILRepack.Kind.Exe,
Parallel = true,
Internalize = true,
InputAssemblies = new string[] { tmpExeFile },
OutputFile = tmpExeFileRepacked
};
repack = new ILRepack(options);
data = File.ReadAllBytes(tmpExeFileRepacked);
ms = new MemoryStream(data);
s = ms;
return(s);
}
public void Should_Get_Correct_Path_To_MSBuild_Version_35(MSBuildToolVersion version, PlatformTarget target, bool is64BitOperativeSystem, string expected)
{
// Given
var fixture = new MSBuildRunnerFixture(is64BitOperativeSystem, true);
fixture.Settings.ToolVersion = version;
fixture.Settings.PlatformTarget = target;
// When
fixture.Run();
// Then
fixture.AssertReceivedFilePath(expected);
}
public void Should_Get_Correct_Path_To_MSBuild_Version_35(MSBuildToolVersion version, PlatformTarget target, bool is64BitOperativeSystem, string expected)
{
// Given
var fixture = new MSBuildRunnerFixture(is64BitOperativeSystem);
var runner = fixture.CreateRunner();
// When
runner.Run(new MSBuildSettings("./src/Solution.sln")
{
ToolVersion = version,
PlatformTarget = target
});
// Then
fixture.ProcessRunner.Received(1).Start(Arg.Is <ProcessStartInfo>(
p => p.FileName == expected));
}
public static FilePath GetMSBuildPath(ICakeEnvironment environment, MSBuildToolVersion version, PlatformTarget target)
{
// Get the bin path for MSBuild.
var binPath = GetMSBuildPath(environment, (MSBuildVersion)version, target);
if (binPath == null)
{
throw new CakeException("Could not resolve MSBuild.");
}
// Get the MSBuild path.
return(binPath.CombineWithFilePath("MSBuild.exe"));
}
private static DirectoryPath GetHighestAvailableMSBuildVersion(IFileSystem fileSystem, ICakeEnvironment environment, PlatformTarget target)
{
var versions = new[]
{
MSBuildVersion.MSBuild14,
MSBuildVersion.MSBuild12,
MSBuildVersion.MSBuild4,
MSBuildVersion.MSBuild35,
MSBuildVersion.MSBuild20
};
foreach (var version in versions)
{
var path = GetMSBuildPath(environment, version, target);
if (fileSystem.Exist(path))
{
return(path);
}
}
return(null);
}
private static DirectoryPath GetMSBuildPath(ICakeEnvironment environment, MSBuildVersion version, PlatformTarget target)
{
switch (version)
{
case MSBuildVersion.MSBuild14:
return(GetVisualStudioPath(environment, target, "14.0"));
case MSBuildVersion.MSBuild12:
return(GetVisualStudioPath(environment, target, "12.0"));
case MSBuildVersion.MSBuild4:
return(GetFrameworkPath(environment, target, "v4.0.30319"));
case MSBuildVersion.MSBuild35:
return(GetFrameworkPath(environment, target, "v3.5"));
case MSBuildVersion.MSBuild20:
return(GetFrameworkPath(environment, target, "v2.0.50727"));
default:
return(null);
}
}
/// <summary>
/// Sets the platform target.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="target">The target.</param>
/// <returns>The same <see cref="MSBuildSettings"/> instance so that multiple calls can be chained.</returns>
public static MSBuildSettings SetPlatformTarget(this MSBuildSettings settings, PlatformTarget target)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
settings.PlatformTarget = target;
return(settings);
}
private static DirectoryPath GetVisualStudioPath(ICakeEnvironment environment, PlatformTarget target, string version)
{
// Get the bin path.
var programFilesPath = environment.GetSpecialPath(SpecialPath.ProgramFilesX86);
var binPath = programFilesPath.Combine(string.Concat("MSBuild/", version, "/Bin"));
if (target == PlatformTarget.MSIL)
{
if (environment.Is64BitOperativeSystem())
{
binPath = binPath.Combine("amd64");
}
}
if (target == PlatformTarget.x64)
{
binPath = binPath.Combine("amd64");
}
return(binPath);
}
public static FilePath GetMSBuildPath(IFileSystem fileSystem, ICakeEnvironment environment, MSBuildToolVersion version, PlatformTarget target)
{
var binPath = (version == MSBuildToolVersion.Default)
? GetHighestAvailableMSBuildVersion(fileSystem, environment, target)
: GetMSBuildPath(environment, (MSBuildVersion)version, target);
if (binPath == null)
{
throw new CakeException("Could not resolve MSBuild.");
}
// Get the MSBuild path.
return(binPath.CombineWithFilePath("MSBuild.exe"));
}
protected async override Task SetTargetAsync(SelfDisposingBitmapDrawable image, bool animated)
{
if (Target == null)
{
return;
}
ThrowIfCancellationRequested();
if (image is FFBitmapDrawable ffDrawable)
{
if (ffDrawable.IsAnimationRunning)
{
var mut = new FFBitmapDrawable(Context.Resources, ffDrawable.Bitmap, ffDrawable);
ffDrawable = mut as FFBitmapDrawable;
image = ffDrawable;
// old hacky workaround
//await Task.Delay(ffDrawable.FadeDuration + 50).ConfigureAwait(false);
}
if (animated)
{
SelfDisposingBitmapDrawable placeholderDrawable = null;
PlaceholderWeakReference?.TryGetTarget(out placeholderDrawable);
if (placeholderDrawable == null)
{
// Enable fade animation when no placeholder is set and the previous image is not null
var imageView = PlatformTarget.Control as ImageViewAsync;
placeholderDrawable = imageView?.Drawable as SelfDisposingBitmapDrawable;
}
var fadeDuration = Parameters.FadeAnimationDuration ?? Configuration.FadeAnimationDuration;
if (placeholderDrawable.IsValidAndHasValidBitmap())
{
placeholderDrawable?.SetIsRetained(true);
ffDrawable?.SetPlaceholder(placeholderDrawable, fadeDuration);
placeholderDrawable?.SetIsRetained(false);
}
else if (ffDrawable.IsValidAndHasValidBitmap())
{
var width = ffDrawable.Bitmap.Width;
var height = ffDrawable.Bitmap.Height;
var bitmap = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888);
using (var canvas = new Canvas(bitmap))
using (var paint = new Paint()
{
Color = _placeholderHelperColor
})
{
canvas.DrawRect(0, 0, width, height, paint);
}
ffDrawable?.SetPlaceholder(new SelfDisposingBitmapDrawable(Context.Resources, bitmap), fadeDuration);
}
}
else
{
ffDrawable?.SetPlaceholder(null, 0);
}
}
await MainThreadDispatcher.PostAsync(() =>
{
ThrowIfCancellationRequested();
PlatformTarget.Set(this, image, animated);
}).ConfigureAwait(false);
}
