public override bool Execute()
{
var baseResult = base.Execute();
LogInformation("Set Ios Asset Cataloge Sets started");
//TODO probably still need to clean files out of project (debug/asset catalogue/appiconsset etc (maybe just the contents.json?)
if (AssetCatalogueName.IsDisabled())
{
LogInformation("Asset catalogue is disabled, returning from task");
return(true);
}
if (AppIconHolder.IsDisabled() && SplashHolder.IsDisabled())
{
LogInformation("App icons and splash images are disabled, not creating asset catalogue");
return(true);
}
//turns out msbuild adds to the output array itself, so if we send the output back down, and into the same
//item property it will get added
var filesToAddToModifiedProject = new List <ITaskItem>();
//this above discovery will change this
var outputImageAssets = new List <ITaskItem>();
if (ExistingOutputImageAssets != null && ExistingOutputImageAssets.Any())
{
outputImageAssets.AddRange(ExistingOutputImageAssets);
}
var existingAssets = new List <ITaskItem>();
if (ExistingImageAssets != null && ExistingImageAssets.Length != 0)
{
existingAssets.AddRange(ExistingImageAssets);
}
else if (ExistingImageAssets == null || ExistingImageAssets.Length == 0)
{
LogDebug("No existing image assets found in project");
}
if (this.IsVerbose())
{
foreach (var taskItem in existingAssets)
{
LogVerbose("Existing asset in project {0}", taskItem.ItemSpec);
}
}
//try
//{
var buildConfigAssetDir = this.GetBuildConfigurationAssetDir(BuildConfiguration);
//could handle disbled here
var firstField = AppIconFields.FirstOrDefault();
if (firstField == null)
{
Log.LogError("App Icon Field set malformed");
}
LogDebug("Asset catalogue name {0}", AssetCatalogueName.ItemSpec);
//LogDebug("AppIconSet name {0}", AppIconCatalogueName.ItemSpec);
LogDebug("Packages Output Folder {0}", PackagesOutputDir);
//get us a list of required catalogues to create/operate on here
var allFields = new List <ITaskItem>();
allFields.AddRange(AppIconFields);
allFields.AddRange(SplashFields);
var cataloguesToSet = allFields
.GroupBy(x => x.GetMetadata(MetadataType.CatalogueSetName))
.Select(x => x.Key)
.ToList();
cataloguesToSet = cataloguesToSet.Where(x => !String.IsNullOrEmpty(x)).ToList();
if (this.IsDebug())
{
foreach (var catalogue in cataloguesToSet)
{
LogDebug("Asset Catalogue set found in metadata {0}", catalogue);
}
}
//for temp testing jsut make it do app icons - till we've got the other contents.json stuff in
foreach (var catalogue in cataloguesToSet)
{
var enabledFields = allFields.Where(x => x.GetMetadata(MetadataType.CatalogueSetName) == catalogue &&
x.IsEnabled());
//TODO will still have to delete catalogue
if (!enabledFields.Any())
{
LogInformation($"Catalogue {catalogue} has no enabled fields, not creating");
continue;
}
//if all fields are disabled in this catalogue set
//continue
LogDebug("Asset Catalogue set required {0}", catalogue);
//create catalogue set folder, and contents.json
var packagesCatalogueSetDir = Path.Combine(PackagesOutputDir, AssetCatalogueName.ItemSpec, catalogue);
if (!Directory.Exists(packagesCatalogueSetDir))
{
Directory.CreateDirectory(packagesCatalogueSetDir);
LogDebug($"Created packages {catalogue} folder at {packagesCatalogueSetDir}");
}
var projectCatalogueSetDir = Path.Combine(ProjectDir, AssetCatalogueName.ItemSpec, catalogue);
if (!Directory.Exists(projectCatalogueSetDir))
{
Directory.CreateDirectory(projectCatalogueSetDir);
LogDebug($"Created project {catalogue} folder at {projectCatalogueSetDir}");
}
var packagesCatalogueSetContentsPath = Path.Combine(PackagesOutputDir, AssetCatalogueName.ItemSpec, catalogue, Consts.iOSContents);
outputImageAssets.Add(new TaskItem(packagesCatalogueSetContentsPath));
//TODO we need to have a different contents set for each type - just use string matching from extension
//this type can probably change to CatalogueSet - they're similar, and if we load them with
//the right json setting, all null fields will disapear
string defaultContents = String.Empty;
MediaAssetCatalogue mediaResourceCatalogueSetContents = null;
MediaAssetCatalogue outputCatalogueSetContents = null;
if (catalogue.Contains(".appiconset"))
{
defaultContents = Consts.AppIconCatalogueSetDefaultContents;
mediaResourceCatalogueSetContents = JsonConvert.DeserializeObject <MediaAssetCatalogue>(defaultContents);
outputCatalogueSetContents = JsonConvert.DeserializeObject <MediaAssetCatalogue>(defaultContents);
}
else if (catalogue.Contains(".launchimage"))
{
defaultContents = Consts.LaunchImageCatalogueSetDefaultContents;
mediaResourceCatalogueSetContents = new MediaAssetCatalogue();
outputCatalogueSetContents = new MediaAssetCatalogue();
}
else if (catalogue.Contains(".imageset"))
{
defaultContents = Consts.ImageCatalogueSetDefaultContents;
mediaResourceCatalogueSetContents = JsonConvert.DeserializeObject <MediaAssetCatalogue>(defaultContents);
outputCatalogueSetContents = JsonConvert.DeserializeObject <MediaAssetCatalogue>(defaultContents);
}
else
{
throw new Exception($"Cannot figure catalogue {0} default contents out");
}
foreach (var field in allFields.Where(x => x.GetMetadata(MetadataType.CatalogueSetName) == catalogue))
{
//TODO might still have to remove from catalog
if (field.IsDisabled())
{
if (field.HolderIsEnabled())
{
Log.LogMessage($"{field.GetMetadata(MetadataType.FieldDescription)} is disabled in this configuration");
}
//always continue
continue;
}
//skip itunes artwork first, something else will do that
if (String.IsNullOrEmpty(field.GetMetadata(MetadataType.Idiom)))
{
continue;
}
Image mediaResourceImageSet = null;
Image outputImageSet = null;
if (catalogue.Contains(".appiconset"))
{
mediaResourceImageSet = GetAppIconCatalogueSetReference(mediaResourceCatalogueSetContents, field);
outputImageSet = GetAppIconCatalogueSetReference(outputCatalogueSetContents, field);
}
else if (catalogue.Contains(".launchimage"))
{
mediaResourceImageSet = GetLaunchImageCatalogueSetReference(mediaResourceCatalogueSetContents, field);
outputImageSet = GetLaunchImageCatalogueSetReference(outputCatalogueSetContents, field);
}
else if (catalogue.Contains(".imageset"))
{
mediaResourceImageSet = GetImageCatalogueSetReference(mediaResourceCatalogueSetContents, field);
outputImageSet = GetImageCatalogueSetReference(outputCatalogueSetContents, field);
}
else
{
throw new Exception("Error finding catalogue");
//throw new Exception($"Cannot calculate image catalogue or field {field.GetMetadata(MetadataType.LogicalName)}, size {1}, idiom {field.GetMetadata(MetadataType.Idiom)}, scale {field.GetMetadata(MetadataType.Scale)}");
}
if (outputImageSet == null)
{
LogWarning("Image catalogue not found for field {0}, size {1}, idiom {2}, scale {3}"
, field.GetMetadata(MetadataType.LogicalName)
, field.GetMetadata(MetadataType.Size)
, field.GetMetadata(MetadataType.Idiom)
, field.GetMetadata(MetadataType.Scale));
//return false;
}
else
{
outputImageSet.filename = field.GetMetadata(MetadataType.ContentsFileName);
mediaResourceImageSet.filename = field.GetMetadata(MetadataType.MediaName).ApplyPngExt();
LogDebug("Set asset catalogue set filename to {0}", outputImageSet.filename);
//sometimes we use the same image twice in the contents.json
var outputImageCatalogue2 = outputCatalogueSetContents.images.FirstOrDefault(x => x.size == field.GetMetadata(MetadataType.Size) &&
x.idiom == field.GetMetadata(MetadataType.Idiom2) &&
x.scale == field.GetMetadata(MetadataType.Scale));
if (outputImageCatalogue2 != null)
{
outputImageCatalogue2.filename = field.GetMetadata(MetadataType.ContentsFileName);
var mediaResourceImageCatalogue2 = mediaResourceCatalogueSetContents.images.FirstOrDefault(x => x.size == field.GetMetadata(MetadataType.Size) &&
x.idiom == field.GetMetadata(MetadataType.Idiom2) &&
x.scale == field.GetMetadata(MetadataType.Scale));
mediaResourceImageCatalogue2.filename = field.GetMetadata(MetadataType.MediaName).ApplyPngExt();
LogDebug("Set second asset catalogue set filename to {0}", outputImageCatalogue2.filename);
}
var existingFilePath = Path.Combine(buildConfigAssetDir
, field.GetMetadata(MetadataType.TapAssetPath)
, field.GetMetadata(MetadataType.MediaName).ApplyPngExt());
var packagingOutputFilePath = Path.Combine(PackagesOutputDir, field.GetMetadata(MetadataType.ProjectAssetPath)
, field.GetMetadata(MetadataType.LogicalName));
var projectOutputFilePath = Path.Combine(ProjectDir, field.GetMetadata(MetadataType.ProjectAssetPath)
, field.GetMetadata(MetadataType.LogicalName));
//we want a list of existing imageassets, and itunesartwork to work of, rather than a test of file existence
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == existingFilePath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug("Adding {0} to add to project list as it is not in current project", existingFilePath);
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset, new Dictionary <string, string> {
{ MetadataType.IncludePath, existingFilePath }
}));
}
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == projectOutputFilePath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug("Adding {0} to add to project list as it is not in current project", projectOutputFilePath);
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset, new Dictionary <string, string> {
{ MetadataType.IncludePath, projectOutputFilePath }
}));
}
LogDebug("Copying file {0} to {1}", existingFilePath, projectOutputFilePath);
File.Copy(existingFilePath, projectOutputFilePath, true);
File.Copy(existingFilePath, packagingOutputFilePath, true);
outputImageAssets.Add(new TaskItem(packagingOutputFilePath));
}
}
//mediaresource (output)
mediaResourceCatalogueSetContents.images = mediaResourceCatalogueSetContents.images.Where(x => !String.IsNullOrEmpty(x.filename)).ToList();
var mediaResourceCatalogueSetJson = JsonConvert.SerializeObject(mediaResourceCatalogueSetContents, Formatting.Indented
, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var mediaResourceCatalogueSetContentsPath = Path.Combine(buildConfigAssetDir, AssetCatalogueName.ItemSpec, catalogue, Consts.iOSContents);
LogDebug($"Added media-resource {catalogue} Contents.json at path {mediaResourceCatalogueSetContentsPath}");
LogInformation($"Saving media-resources {catalogue} Contents.json to {mediaResourceCatalogueSetContentsPath}");
File.WriteAllText(mediaResourceCatalogueSetContentsPath, mediaResourceCatalogueSetJson);
//packagesAppIconSetContentsPath
//output
outputCatalogueSetContents.images = outputCatalogueSetContents.images.Where(x => !String.IsNullOrEmpty(x.filename)).ToList();
var outputCatalogueSetJson = JsonConvert.SerializeObject(outputCatalogueSetContents, Formatting.Indented
, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == mediaResourceCatalogueSetContentsPath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug("Adding {0} to add to project list as it is not in current project", mediaResourceCatalogueSetContentsPath);
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset
, new Dictionary <string, string> {
{ MetadataType.IncludePath, mediaResourceCatalogueSetContentsPath }
}));
}
var projectOutputCatalogueSetContentsPath = Path.Combine(ProjectDir, AssetCatalogueName.ItemSpec, catalogue, Consts.iOSContents);
LogDebug($"Added project output {catalogue} Contents.json at path {projectOutputCatalogueSetContentsPath}");
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == projectOutputCatalogueSetContentsPath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug("Adding {0} to add to project list as it is not in current project", projectOutputCatalogueSetContentsPath);
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset
, new Dictionary <string, string> {
{ MetadataType.IncludePath, projectOutputCatalogueSetContentsPath }
}));
}
LogInformation($"Saving project {catalogue} Contents.json to {projectOutputCatalogueSetContentsPath}");
File.WriteAllText(projectOutputCatalogueSetContentsPath, outputCatalogueSetJson);
File.WriteAllText(packagesCatalogueSetContentsPath, outputCatalogueSetJson);
}
LogInformation("Asset Catalogue Sets wants to add {0} files to the build project", filesToAddToModifiedProject.Count());
LogInformation("Asset Catalogue Sets wants to show {0} media-resources files in the final project", filesToAddToModifiedProject.Count());
FilesToAddToProject = filesToAddToModifiedProject.ToArray();
OutputImageAssets = outputImageAssets.ToArray();
return(true);
//} catch (Exception ex){
// Log.LogErrorFromException(ex);
// return false;
//}
}
public override bool Execute()
{
var baseResult = base.Execute();
LogInformation("Set Droid Media started");
var filesToAddToModifiedProject = new List <ITaskItem>();
var outputAndroidResources = new List <ITaskItem>();
var existingAssets = new List <ITaskItem>();
if (ExistingAndroidResources != null && ExistingAndroidResources.Length != 0)
{
existingAssets.AddRange(ExistingAndroidResources);
}
else if (ExistingAndroidResources == null || ExistingAndroidResources.Length == 0)
{
LogDebug("No existing android resource assets found in project");
}
if (ExistingTapAssets != null && ExistingTapAssets.Length != 0)
{
existingAssets.AddRange(ExistingTapAssets);
}
else if (ExistingTapAssets == null || ExistingTapAssets.Length == 0)
{
LogDebug("No existing tap assets found in project");
}
if (this.IsVerbose())
{
foreach (var taskItem in existingAssets)
{
LogVerbose("Existing asset in project {0}", taskItem.ItemSpec);
}
}
var allMediaFields = new List <ITaskItem>();
if (AppIconHolder.IsDisabled())
{
LogInformation($"App icons are disabled in this configuration");
}
else
{
LogDebug($"App icons are enabled in this configuration");
allMediaFields.AddRange(AppIconFields);
}
if (SplashHolder.IsDisabled())
{
LogInformation($"Splash screens are disabled in this configuration");
}
else
{
LogDebug($"Splash screens are enabled in this configuration");
allMediaFields.AddRange(SplashFields);
}
//left out because it might give us an empty array and null out
if (AppIconHolder.IsDisabled() && SplashHolder.IsDisabled())
{
Log.LogMessage($"Both media types are disabled in this configuration, SetDroidMedia does not need to continue");
return(true);
}
var buildConfigAssetDir = this.GetBuildConfigurationAssetDir(BuildConfiguration);
foreach (var field in allMediaFields)
{
if (field.IsDisabled())
{
if (field.HolderIsEnabled())
{
Log.LogMessage($"{field.GetMetadata(MetadataType.FieldDescription)} is disabled in this configuration");
}
//always continue
continue;
}
var existingFilePath = Path.Combine(buildConfigAssetDir, field.GetMetadata(MetadataType.TapAssetPath), field.GetMetadata(MetadataType.MediaName).ApplyPngExt());
var outputDir = Path.Combine(ProjectDir, field.GetMetadata(MetadataType.ProjectAssetPath));
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
LogDebug("Create asset folder at {0}", outputDir);
}
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == existingFilePath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug($"Adding {existingFilePath} as a {MSBuildItemName.TapAsset} to add to project list as it is not in current project");
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.TapAsset, new Dictionary <string, string> {
{ MetadataType.IncludePath, existingFilePath }
}));
}
var outputFilePath = Path.Combine(ProjectDir, field.GetMetadata(MetadataType.ProjectAssetPath), field.GetMetadata(MetadataType.LogicalName));
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == outputFilePath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
LogDebug($"Adding {outputFilePath} as a {MSBuildItemName.AndroidResource} to add to project list as it is not in current project");
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.AndroidResource, new Dictionary <string, string> {
{ MetadataType.IncludePath, outputFilePath }
}));
}
File.Copy(existingFilePath, outputFilePath, true);
LogDebug($"Including {MSBuildItemName.TapAsset} from {existingFilePath} to {outputFilePath} as {MSBuildItemName.AndroidResource}");
outputAndroidResources.Add(new TaskItem(outputFilePath));
}
FilesToAddToProject = filesToAddToModifiedProject.ToArray();
OutputAndroidResources = outputAndroidResources.ToArray();
return(true);
}
public override bool Execute()
{
var baseResult = base.Execute();
LogInformation("Set Ios Asset Catalogue started");
//TODO probably still need to clean files out of project (debug/asset catalogue)
if (AssetCatalogueName.IsDisabled())
{
LogInformation("Asset catalogue is disabled, returning from task");
return(true);
}
if (AppIconHolder.IsDisabled() && SplashHolder.IsDisabled())
{
LogInformation("App icons and splash images are disabled, not creating asset catalogue");
return(true);
}
var filesToAddToModifiedProject = new List <ITaskItem>();
var outputImageAssets = new List <ITaskItem>();
var outputITunesArtwork = new List <ITaskItem>();
var existingAssets = new List <ITaskItem>();
if (ExistingImageAssets != null && ExistingImageAssets.Any())
{
existingAssets.AddRange(ExistingImageAssets);
}
else if (ExistingImageAssets == null || ExistingImageAssets.Any() == false)
{
LogDebug("No existing image assets found in project");
}
//foreach (var taskItem in existingAssets)
//{
// LogDebug("Existing asset in project {0}", taskItem.ItemSpec);
//}
try
{
var buildConfigAssetDir = this.GetBuildConfigurationAssetDir(BuildConfiguration);
////could handle disbled here
//var firstField = AppIconFields.FirstOrDefault();
//if (firstField == null)
//{
// Log.LogError("App Icon Field set malformed");
//}
//if holder.disabled, bomb out - done prior
//if packaginfield.disabled bomb out done
//or if all fields disabled bomb out
LogDebug("Asset catalogue name {0}", AssetCatalogueName.ItemSpec);
LogDebug("Packages Output Folder {0}", PackagesOutputDir);
//create packages asset catalogue folder etc
var packagesAssetCatalogueDir = Path.Combine(PackagesOutputDir, AssetCatalogueName.ItemSpec);
if (!Directory.Exists(packagesAssetCatalogueDir))
{
Directory.CreateDirectory(packagesAssetCatalogueDir);
LogDebug("Created {0} folder at {1}", AssetCatalogueName, packagesAssetCatalogueDir);
}
else
{
Directory.Delete(packagesAssetCatalogueDir, true);
Directory.CreateDirectory(packagesAssetCatalogueDir);
LogDebug("Cleaned and Created {0} folder at {1}", AssetCatalogueName, packagesAssetCatalogueDir);
}
var packagesAssetCatalogueContentsPath = Path.Combine(PackagesOutputDir, AssetCatalogueName.ItemSpec, Consts.iOSContents);
if (!File.Exists(packagesAssetCatalogueContentsPath))
{
LogDebug("Creating Asset catalogue Contents.json at {0}", packagesAssetCatalogueContentsPath);
File.WriteAllText(packagesAssetCatalogueContentsPath, Consts.AssetCatalogueContents);
}
outputImageAssets.Add(new TaskItem(packagesAssetCatalogueContentsPath));
//create project asset catalogue folder, and contents.json
var projectAssetCatalogueDir = Path.Combine(ProjectDir, AssetCatalogueName.ItemSpec);
if (!Directory.Exists(projectAssetCatalogueDir))
{
Directory.CreateDirectory(projectAssetCatalogueDir);
//Don't need to add this either, it's just contents.json that gets added
LogDebug("Created {0} folder at {1}", AssetCatalogueName, projectAssetCatalogueDir);
}
var mediaResourceAssetCatalogueContentsPath = Path.Combine(buildConfigAssetDir, AssetCatalogueName.ItemSpec, Consts.iOSContents);
if (!File.Exists(mediaResourceAssetCatalogueContentsPath))
{
LogDebug("Creating Asset catalogue Contents.json at {0}", mediaResourceAssetCatalogueContentsPath);
File.WriteAllText(mediaResourceAssetCatalogueContentsPath, Consts.AssetCatalogueContents);
}
var projectAssetCatalogueContentsPath = Path.Combine(ProjectDir, AssetCatalogueName.ItemSpec, Consts.iOSContents);
if (!File.Exists(projectAssetCatalogueContentsPath))
{
LogDebug("Creating Asset catalogue Contents.json at {0}", projectAssetCatalogueContentsPath);
File.WriteAllText(projectAssetCatalogueContentsPath, Consts.AssetCatalogueContents);
Log.LogMessage("Saving {1} Contents.json to path {0}", projectAssetCatalogueContentsPath, AssetCatalogueName.ItemSpec);
}
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == mediaResourceAssetCatalogueContentsPath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset, new Dictionary <string, string> {
{ MetadataType.IncludePath, mediaResourceAssetCatalogueContentsPath }
}));
LogDebug("Adding {0} to add to project list as it is not in current project", mediaResourceAssetCatalogueContentsPath);
}
if (existingAssets.FirstOrDefault(x => x.ItemSpec.StripSlashes() == projectAssetCatalogueContentsPath.GetPathRelativeToProject(ProjectDir).StripSlashes()) == null)
{
filesToAddToModifiedProject.Add(new TaskItem(MSBuildItemName.ImageAsset, new Dictionary <string, string> {
{ MetadataType.IncludePath, projectAssetCatalogueContentsPath }
}));
LogDebug("Adding {0} to add to project list as it is not in current project", projectAssetCatalogueContentsPath);
}
LogInformation("SetAssetCatalogues wants to add {0} files to the build project", filesToAddToModifiedProject.Count());
FilesToAddToProject = filesToAddToModifiedProject.ToArray();
OutputImageAssets = outputImageAssets.ToArray();
return(true);
} catch (Exception ex) {
Log.LogErrorFromException(ex);
return(false);
}
}
