public ClassLoader getClassLoader ()
{
if (mClassLoader != null)
return mClassLoader;
ContextImpl context = mActivityThread.getSystemContext();
XobotPackageManager pm = (XobotPackageManager)context.getPackageManager ();
Assembly asm = pm.GetAssembly (mPackageName);
mClassLoader = new AssemblyClassLoader (asm, mPackageName);
return mClassLoader;
}
public static object GetAssemblyClassLoader(Assembly asm)
{
return(AssemblyClassLoader.FromAssembly(asm).GetJavaClassLoader());
}
public static global::java.lang.ClassLoader GetAssemblyClassLoader(Assembly asm)
{
return(AssemblyClassLoader.FromAssembly(asm).GetJavaClassLoader());
}
public static void addBootClassPathAssembly(Assembly asm)
{
ClassLoaderWrapper.GetBootstrapClassLoader().AddDelegate(AssemblyClassLoader.FromAssembly(asm));
}
/// <summary>
/// For all explicitly and implicitly loaded assemblies the classloader
/// and the callback will be invoked, if not null. Callback and classloader
/// might be called reentrantly, if the AssemblyResolver itself is used reentrantly.
/// </summary>
public AssemblyResolver(IEnumerable <string> referenceFolders, AssemblyClassLoader classLoader, Action <AssemblyDefinition> assemblyLoaded)
{
this.classLoader = classLoader;
this.assemblyLoaded = assemblyLoaded;
this.referenceFolders = referenceFolders.Select(ToFolder).Distinct().ToList();
}
/// <summary>
/// Default ctor
/// </summary>
public TypeNameMap(ITypeMapResolver resolver, AssemblyClassLoader assemblyClassLoader)
{
this.resolver = resolver;
this.assemblyClassLoader = assemblyClassLoader;
}
/// <summary>
/// Default ctor
/// </summary>
public AssemblyCompiler(CompilationMode mode, List <AssemblyDefinition> assemblies, List <AssemblyDefinition> references, Table resources, NameConverter nameConverter, bool generateDebugInfo, AssemblyClassLoader assemblyClassLoader,
HashSet <string> rootClassNames, XModule module)
{
this.mode = mode;
this.assemblies = assemblies;
this.references = references;
this.resources = resources;
this.generateDebugInfo = generateDebugInfo;
this.assemblyClassLoader = assemblyClassLoader;
this.rootClassNames = rootClassNames;
this.module = module;
targetPackage = new Target.Dex.DexTargetPackage(nameConverter, this);
}
/// <summary>
/// Compile an assembly into a dex file.
/// </summary>
private static void CompileAssembly(CommandLineOptions options, NameConverter nsConverter)
{
// Load resource type usage info file
var usedTypeNames = LoadResourceTypeUsageInformation(options);
// Load assemblies
List <AssemblyDefinition> assemblies = new List <AssemblyDefinition>();
List <AssemblyDefinition> references = new List <AssemblyDefinition>();
var dxJarCompiler = options.EnableDxJarCompilation
? new DxClassfileMethodBodyCompiler(options.OutputFolder, options.DebugInfo)
: null;
Action <ClassSource> jarLoaded = dxJarCompiler != null ? dxJarCompiler.PreloadJar : (Action <ClassSource>)null;
var module = new XModule();
var classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var resolver = new AssemblyResolver(options.ReferenceFolders, classLoader, module.OnAssemblyLoaded);
// initialize compiler cache in background.
var ccache = options.EnableCompilerCache ? new DexMethodBodyCompilerCache(options.OutputFolder, resolver.GetFileName)
: new DexMethodBodyCompilerCache();
var readerParameters = new ReaderParameters
{
AssemblyResolver = resolver,
SymbolReaderProvider = new SafeSymbolReaderProvider(),
ReadSymbols = true,
ReadingMode = ReadingMode.Immediate
};
// load assemblies
var toLoad = options.Assemblies.Select(path => new { path, target = assemblies })
.Concat(options.References.Select(path => new { path, target = references }))
// Some micro optimizations...
// Our startup is IO bound until we have loaded first assembly from disk.
// So just load from smallest to largest.
.Select(load => new { load.path, load.target, length = new FileInfo(resolver.ResolvePath(load.path)).Length })
.OrderBy(load => load.length)
.ToList();
using (AssemblyCompiler.Profile("for loading assemblies"))
{
toLoad.AsParallel().ForAll(
//toLoad.ForEach(
load =>
{
var assm = resolver.Load(load.path, readerParameters);
lock (load.target) load.target.Add(assm);
});
}
// Load resources
Table table;
using (var stream = new FileStream(options.InputResources, FileMode.Open, FileAccess.Read))
{
table = new Table(stream);
}
// Create compiler
var compiler = new AssemblyCompiler(options.CompilationMode, assemblies, references, table, nsConverter,
options.DebugInfo, classLoader, resolver.GetFileName, ccache,
usedTypeNames, module, options.GenerateSetNextInstructionCode);
compiler.DxClassfileMethodBodyCompiler = dxJarCompiler;
using (AssemblyCompiler.Profile("total compilation time", true))
compiler.Compile();
ccache.PrintStatistics();
using (AssemblyCompiler.Profile("saving results"))
compiler.Save(options.OutputFolder, options.FreeAppsKeyPath);
}
