////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override bool ValidateParameters()
{
//
// This tool should really only expect 'AndroidManifest.xml' input. But people might change the names of these, so we can't rely on that to validate.
//
bool validParameters = true;
if (Sources.Length != 1)
{
Log.LogError("Expected single input, got: " + Sources.Length + "'.");
validParameters = false;
}
if (validParameters)
{
string sourcePath = Path.GetFullPath(Sources [0].GetMetadata("FullPath"));
if (string.IsNullOrEmpty(sourcePath) || !File.Exists(sourcePath))
{
Log.LogError("Could locate expected input: '" + sourcePath + "'.");
validParameters = false;
}
try
{
if (validParameters)
{
AndroidManifestDocument sourceManifest = new AndroidManifestDocument();
sourceManifest.Load(sourcePath);
}
}
catch (Exception e)
{
Log.LogError("Could not successfully parse '" + sourcePath + "'. Check this is a valid AndroidManifest.xml document. Reason: " + e, MessageImportance.High);
Log.LogErrorFromException(e, true);
validParameters = false;
}
}
return(validParameters && base.ValidateParameters());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override int TrackedExecuteTool(string pathToTool, string responseFileCommands, string commandLineCommands)
{
//
// Use default implementation, but ensure that any generated sources and dependency files get flagged as output appropriately.
//
int retCode = -1;
Dictionary <string, ITaskItem> processedManifestFiles = new Dictionary <string, ITaskItem> ();
List <ITaskItem> outputApkFileList = new List <ITaskItem> ();
List <ITaskItem> outputFilesList = new List <ITaskItem> ();
try
{
foreach (ITaskItem source in Sources)
{
string sourcePath = Path.GetFullPath(source.GetMetadata("FullPath"));
if (!processedManifestFiles.ContainsKey(sourcePath))
{
retCode = base.TrackedExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
processedManifestFiles.Add(sourcePath, source);
if (retCode == 0)
{
AndroidManifestDocument sourceManifest = new AndroidManifestDocument();
sourceManifest.Load(sourcePath);
//
// Determine if this manifest requested APK generation, add to output list.
//
if (!string.IsNullOrWhiteSpace(source.GetMetadata("ApkOutputFile")))
{
string apkOutputFile = source.GetMetadata("ApkOutputFile");
if (!File.Exists(apkOutputFile))
{
throw new FileNotFoundException("Requested APK output file does not exist. Error during packaging?");
}
ITaskItem outputApkItem = new TaskItem(Path.GetFullPath(apkOutputFile));
outputApkFileList.Add(outputApkItem);
outputFilesList.Add(outputApkItem);
}
if (source.GetMetadata("GenerateDependencies") == "true")
{
//
// Evaluate which resource constant source files have been exported. 'ExtraPackages' lists additional package names that also have resource ids.
//
List <string> resourceConstantSourceFiles = new List <string> ();
string resourcesDirectory = source.GetMetadata("ResourceConstantsOutputDirectory");
if (File.Exists(Path.Combine(resourcesDirectory, "R.java")))
{
resourceConstantSourceFiles.Add(Path.Combine(resourcesDirectory, "R.java"));
}
if (File.Exists(Path.Combine(resourcesDirectory, sourceManifest.PackageName.Replace('.', '\\'), "R.java")))
{
resourceConstantSourceFiles.Add(Path.Combine(resourcesDirectory, sourceManifest.PackageName.Replace('.', '\\'), "R.java"));
}
if (!string.IsNullOrWhiteSpace(source.GetMetadata("ExtraPackages")))
{
string [] extraPackages = source.GetMetadata("ExtraPackages").Split(':');
foreach (string package in extraPackages)
{
if (File.Exists(Path.Combine(resourcesDirectory, package.Replace('.', '\\'), "R.java")))
{
resourceConstantSourceFiles.Add(Path.Combine(resourcesDirectory, package.Replace('.', '\\'), "R.java"));
}
}
}
//
// When exporting an APK the R.java.d file will not properly list dependencies. Copy from ??.apk.d to solve this.
//
string dependencyFileSource = Path.Combine(resourcesDirectory, "R.java.d");
if (!string.IsNullOrWhiteSpace(source.GetMetadata("ApkOutputFile")))
{
string apkDependencyFileSource = source.GetMetadata("ApkOutputFile") + ".d";
GccUtilities.DependencyParser.ConvertJavaDependencyFileToGcc(apkDependencyFileSource);
File.Copy(apkDependencyFileSource, dependencyFileSource, true); // overwrite invalid R.java.d export
}
//
// R.java.d dependency files are not placed alongside its master file if exported using package directories. Fix this.
//
foreach (string master in resourceConstantSourceFiles)
{
string masterDependencyFile = master + ".d";
Directory.CreateDirectory(Path.GetDirectoryName(masterDependencyFile));
if (File.Exists(masterDependencyFile))
{
File.Delete(masterDependencyFile);
}
File.Copy(dependencyFileSource, masterDependencyFile);
}
//
// Finally ensure all resource constant export files are added to the output list.
//
foreach (string file in resourceConstantSourceFiles)
{
ITaskItem outputResourceFileItem = new TaskItem(Path.GetFullPath(file));
outputFilesList.Add(outputResourceFileItem);
}
}
if (retCode != 0)
{
break;
}
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true);
retCode = -1;
}
finally
{
OutputApk = outputApkFileList.ToArray();
OutputFiles = outputFilesList.ToArray();
}
return(retCode);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public override bool Execute()
{
try
{
if (PrimaryManifest.Length == 0)
{
Log.LogError("No 'PrimaryManifest' file(s) specified.");
return(false);
}
if (PrimaryManifest.Length > 1)
{
Log.LogError("Too many 'PrimaryManifest' files specified. Expected one.");
return(false);
}
if (ProjectManifests.Length == 0)
{
Log.LogError("No 'ProjectManifests' file(s) specified.");
return(false);
}
//
// Identify which is the primary AndroidManifest.xml provided.
//
MergedManifest = null;
string primaryManifestFullPath = PrimaryManifest [0].GetMetadata("FullPath");
foreach (ITaskItem manifestItem in ProjectManifests)
{
string manifestItemFullPath = manifestItem.GetMetadata("FullPath");
if (primaryManifestFullPath.Equals(manifestItemFullPath))
{
MergedManifest = manifestItem;
break;
}
}
if (MergedManifest == null)
{
Log.LogError("Could not find 'primary' manifest in provided list of project manifests. Expected: " + primaryManifestFullPath);
return(false);
}
//
// Sanity check all manifests to ensure that there's not another which defines <application> that's not 'primary'.
//
ITaskItem applicationManifest = null;
foreach (ITaskItem manifestItem in ProjectManifests)
{
AndroidManifestDocument androidManifestDocument = new AndroidManifestDocument();
androidManifestDocument.Load(manifestItem.GetMetadata("FullPath"));
if (androidManifestDocument.IsApplication)
{
if (applicationManifest == null)
{
applicationManifest = manifestItem;
break;
}
else
{
Log.LogError("Found multiple AndroidManifest files which define an <application> node.");
return(false);
}
}
}
if ((applicationManifest != null) && (applicationManifest != MergedManifest))
{
Log.LogError("Specified project manifest does not define an <application> node.");
return(false);
}
//
// Process other 'third-party' manifests merging required metadata.
//
if (MergedManifest != null)
{
HashSet <string> extraPackages = new HashSet <string> ();
HashSet <string> extraResourcePaths = new HashSet <string> ();
extraResourcePaths.Add(MergedManifest.GetMetadata("IncludeResourceDirectories"));
foreach (ITaskItem item in ProjectManifests)
{
AndroidManifestDocument androidManifestDocument = new AndroidManifestDocument();
androidManifestDocument.Load(item.GetMetadata("FullPath"));
if (item == MergedManifest)
{
PackageName = androidManifestDocument.PackageName;
}
else
{
if (!extraPackages.Contains(androidManifestDocument.PackageName))
{
extraPackages.Add(androidManifestDocument.PackageName);
}
if (!extraResourcePaths.Contains(item.GetMetadata("IncludeResourceDirectories")))
{
extraResourcePaths.Add(item.GetMetadata("IncludeResourceDirectories"));
}
}
}
MergedManifest.SetMetadata("ExtraPackages", String.Join(":", extraPackages.ToArray()));
MergedManifest.SetMetadata("IncludeResourceDirectories", String.Join(";", extraResourcePaths.ToArray()));
return(true);
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true);
}
return(false);
}
