void WriteTypeMappings(List <TypeDefinition> types)
{
using (var gen = UseSharedRuntime
? new TypeNameMapGenerator(types, Log.LogDebugMessage)
: new TypeNameMapGenerator(ResolvedAssemblies.Select(p => p.ItemSpec), Log.LogDebugMessage)) {
UpdateWhenChanged(Path.Combine(OutputDirectory, "typemap.jm"), gen.WriteJavaToManaged);
UpdateWhenChanged(Path.Combine(OutputDirectory, "typemap.mj"), gen.WriteManagedToJava);
}
}
public static Type Resolve(string typeName)
{
try
{
Type resolvedType;
// If the typeName is not an assembly qualified name, load it normally
if (!IsAssemblyQualifiedName(typeName))
{
resolvedType = Type.GetType(typeName);
if (resolvedType != null)
{
return(resolvedType);
}
}
// If the typeName is an assembly qualified name, load it with custom assembly resolution
AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
try
{
// Try to load type with the given assembly qualified name
resolvedType = Type.GetType(typeName);
// Try to load type from previously resolved assemblies
if (resolvedType == null)
{
foreach (var resolvedAssembly in ResolvedAssemblies)
{
resolvedType = resolvedAssembly.GetType(typeName);
if (resolvedType != null)
{
break;
}
}
}
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= OnAssemblyResolve;
}
if (resolvedType != null)
{
return(resolvedType);
}
var resolvedAssemblies = ResolvedAssemblies.Select(a => a.GetName().Name);
throw new TypeResolveException(typeName, resolvedAssemblies);
}
catch (Exception e)
{
Log.Error(e, "Error resolving type '{0}'!", typeName);
throw;
}
}
public override bool Execute()
{
// if there are no assemblies, then we are done
if (ResolvedAssemblies == null || ResolvedAssemblies.Length == 0)
{
Log.LogMessage($"There were no assemblies to check.");
return(true);
}
var assemblyNames = ResolvedAssemblies.Select(a => Path.GetFileNameWithoutExtension(a.ItemSpec));
var orderedNames = new SortedSet <string>(assemblyNames);
var mapping = new AndroidXAssembliesCsvMapping();
bool hasError = false;
foreach (var assembly in assemblyNames)
{
// if there was no mapping found, then we don't care
if (!mapping.TryGetAndroidXAssembly(assembly, out var xAssembly))
{
continue;
}
ContainsSupportAssemblies = true;
Log.LogMessage(MessageImportance.Low, $"Making sure that the Android Support assembly '{assembly}' has a replacement Android X assembly...");
// make sure the mapped assembly is referenced
if (orderedNames.Contains(xAssembly))
{
Log.LogMessage(MessageImportance.Low, $"Correctly replacing the Android Support assembly '{assembly}' with Android X '{xAssembly}'.");
continue;
}
// the mapped assembly was not found, so this is an error
hasError = true;
mapping.TryGetAndroidXPackage(assembly, out var package);
var msg = $"Could not find the Android X replacement assembly '{xAssembly}' for '{assembly}'. Make sure the Android X NuGet package '{package}' is installed.";
if (UseWarningsInsteadOfErrors)
{
Log.LogWarning(msg);
}
else
{
Log.LogError(msg);
}
}
return(!hasError || UseWarningsInsteadOfErrors);
}
void WriteTypeMappings(List <TypeDefinition> types)
{
void logger(TraceLevel level, string value) => Log.LogDebugMessage(value);
TypeNameMapGenerator createTypeMapGenerator() => UseSharedRuntime ?
new TypeNameMapGenerator(types, logger) :
new TypeNameMapGenerator(ResolvedAssemblies.Select(p => p.ItemSpec), logger);
using (var gen = createTypeMapGenerator()) {
using (var ms = new MemoryStream()) {
UpdateWhenChanged(Path.Combine(OutputDirectory, "typemap.jm"), "jm", ms, gen.WriteJavaToManaged);
UpdateWhenChanged(Path.Combine(OutputDirectory, "typemap.mj"), "mj", ms, gen.WriteManagedToJava);
}
}
}
public override bool Execute()
{
// if there are no assemblies, then we are done
if (ResolvedAssemblies == null || ResolvedAssemblies.Length == 0)
{
Log.LogMessage($"There were no assemblies to check.");
return(true);
}
try
{
var hasMissing = false;
var assemblyNames = ResolvedAssemblies.Select(a => Path.GetFileNameWithoutExtension(a.ItemSpec));
var mapping = new AndroidXAssembliesCsvMapping();
var assemblyPairs = new Dictionary <string, string>();
var androidxAssemblies = new Dictionary <string, bool>();
foreach (var support in assemblyNames)
{
// if there was no mapping found, then we don't care
if (!mapping.TryGetAndroidXAssembly(support, out var androidx))
{
continue;
}
ContainsSupportAssemblies = true;
Log.LogMessage(MessageImportance.Low, $"Making sure that the Android Support assembly '{support}' has a replacement Android X assembly...");
// make sure the mapped assembly is referenced
var exists = assemblyNames.Contains(androidx);
androidxAssemblies[androidx] = exists;
assemblyPairs[androidx] = support;
if (exists)
{
Log.LogMessage(MessageImportance.Low, $"Found the Android X assembly '{androidx}'.");
}
else
{
Log.LogMessage(MessageImportance.Low, $"Missing the Android X assembly '{androidx}'.");
hasMissing = true;
}
}
if (hasMissing)
{
var missing = androidxAssemblies.Where(p => !p.Value).Select(p => p.Key).ToArray();
var tree = PackageDependencyTree.Load();
var reduced = tree.Reduce(missing).ToArray();
var packages = new StringBuilder();
var references = new StringBuilder();
foreach (var assembly in reduced)
{
mapping.TryGetAndroidXPackage(assembly, out var package);
mapping.TryGetAndroidXVersion(assembly, out var version);
packages.AppendLine();
packages.Append($" - {package}");
references.AppendLine();
references.Append($" <PackageReference Include=\"{package}\" Version=\"{version}\" />");
}
var msg =
$"Could not find {missing.Length} Android X assemblies, make sure to install the following NuGet packages:" +
packages + Environment.NewLine +
$"You can also copy-and-paste the following snippet into your .csproj file:" +
references;
if (UseWarningsInsteadOfErrors)
{
Log.LogWarning(msg);
}
else
{
Log.LogError(msg);
}
}
return(!hasMissing || UseWarningsInsteadOfErrors);
}
catch
{
if (UseWarningsInsteadOfErrors)
{
return(true);
}
throw;
}
}
