@VisibleForTesting
public static PackageParserOptions parseArgs(String[] args) {
args = parseParamFileIfUsed(args);
OptionsParser optionsParser = OptionsParser.newOptionsParser(PackageParserOptions.class);
optionsParser.parseAndExitUponError(args);
return optionsParser.getOptions(PackageParserOptions.class);
}
public static void main(String[] args) throws Exception {
OptionsParser parser =
OptionsParser.newOptionsParser(RemoteOptions.class, RemoteWorkerOptions.class);
parser.parseAndExitUponError(args);
RemoteOptions remoteOptions = parser.getOptions(RemoteOptions.class);
RemoteWorkerOptions remoteWorkerOptions = parser.getOptions(RemoteWorkerOptions.class);
if (remoteWorkerOptions.workPath == null) {
printUsage(parser);
return;
}
System.out.println("*** Starting Hazelcast server.");
ConcurrentMap<String, byte[]> cache = new HazelcastCacheFactory().create(remoteOptions);
System.out.println(
"*** Starting grpc server on all locally bound IPs on port "
+ remoteWorkerOptions.listenPort
+ ".");
Path workPath = getFileSystem().getPath(remoteWorkerOptions.workPath);
FileSystemUtils.createDirectoryAndParents(workPath);
RemoteWorker worker = new RemoteWorker(workPath, remoteOptions, remoteWorkerOptions, cache);
final Server server =
ServerBuilder.forPort(remoteWorkerOptions.listenPort).addService(worker).build();
server.start();
final Path pidFile;
if (remoteWorkerOptions.pidFile != null) {
pidFile = getFileSystem().getPath(remoteWorkerOptions.pidFile);
PrintWriter writer = new PrintWriter(pidFile.getOutputStream());
writer.append(Integer.toString(ProcessUtils.getpid()));
writer.append("\n");
writer.close();
} else {
pidFile = null;
}
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
@Override
public void run() {
System.err.println("*** Shutting down grpc server.");
server.shutdown();
if (pidFile != null) {
try {
pidFile.delete();
} catch (IOException e) {
System.err.println("Cannot remove pid file: " + pidFile.toString());
}
}
System.err.println("*** Server shut down.");
}
});
server.awaitTermination();
}
public static void main(String[] args) {
Stopwatch timer = Stopwatch.createStarted();
OptionsParser optionsParser = OptionsParser.newOptionsParser(Options.class);
optionsParser.parseAndExitUponError(args);
Options options = optionsParser.getOptions(Options.class);
checkFlags(options);
FileSystem fileSystem = FileSystems.getDefault();
Path working = fileSystem.getPath("").toAbsolutePath();
AndroidResourceProcessor resourceProcessor =
new AndroidResourceProcessor(new StdLogger(com.android.utils.StdLogger.Level.VERBOSE));
try {
Path resourcesOut = Files.createTempDirectory("tmp-resources");
resourcesOut.toFile().deleteOnExit();
Path assetsOut = Files.createTempDirectory("tmp-assets");
assetsOut.toFile().deleteOnExit();
logger.fine(String.format("Setup finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));
ImmutableList<DirectoryModifier> modifiers =
ImmutableList.of(
new PackedResourceTarExpander(working.resolve("expanded"), working),
new FileDeDuplicator(
Hashing.murmur3_128(), working.resolve("deduplicated"), working));
MergedAndroidData mergedData =
resourceProcessor.mergeData(
options.mainData,
options.dependencyData,
resourcesOut,
assetsOut,
modifiers,
null,
options.strictMerge);
logger.info(String.format("Merging finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));
writeAar(options.aarOutput, mergedData, options.manifest, options.rtxt, options.classes);
logger.info(
String.format("Packaging finished at %dms", timer.elapsed(TimeUnit.MILLISECONDS)));
} catch (IOException | MergingException e) {
logger.log(Level.SEVERE, "Error during merging resources", e);
System.exit(1);
}
System.exit(0);
}
public static void main(String[] args) throws Exception {
final Stopwatch timer = Stopwatch.createStarted();
OptionsParser optionsParser =
OptionsParser.newOptionsParser(Options.class, AaptConfigOptions.class);
optionsParser.parseAndExitUponError(args);
aaptConfigOptions = optionsParser.getOptions(AaptConfigOptions.class);
options = optionsParser.getOptions(Options.class);
FileSystem fileSystem = FileSystems.getDefault();
Path working = fileSystem.getPath("").toAbsolutePath();
final AndroidResourceProcessor resourceProcessor = new AndroidResourceProcessor(STD_LOGGER);
try {
final Path tmp = Files.createTempDirectory("android_resources_tmp");
// Clean up the tmp file on exit to keep diskspace low.
tmp.toFile().deleteOnExit();
final Path expandedOut = tmp.resolve("tmp-expanded");
final Path deduplicatedOut = tmp.resolve("tmp-deduplicated");
final Path mergedAssets = tmp.resolve("merged_assets");
final Path mergedResources = tmp.resolve("merged_resources");
final Path filteredResources = tmp.resolve("resources-filtered");
final Path densityManifest = tmp.resolve("manifest-filtered/AndroidManifest.xml");
final Path processedManifest = tmp.resolve("manifest-processed/AndroidManifest.xml");
Path generatedSources = null;
if (options.srcJarOutput != null
|| options.rOutput != null
|| options.symbolsTxtOut != null) {
generatedSources = tmp.resolve("generated_resources");
}
LOGGER.fine(String.format("Setup finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
final ImmutableList<DirectoryModifier> modifiers =
ImmutableList.of(
new PackedResourceTarExpander(expandedOut, working),
new FileDeDuplicator(Hashing.murmur3_128(), deduplicatedOut, working));
// Resources can appear in both the direct dependencies and transitive -- use a set to
// ensure depeduplication.
List<DependencyAndroidData> data =
ImmutableSet.<DependencyAndroidData>builder()
.addAll(options.directData)
.addAll(options.transitiveData)
.build()
.asList();
final MergedAndroidData mergedData =
resourceProcessor.mergeData(
options.primaryData,
data,
mergedResources,
mergedAssets,
modifiers,
selectPngCruncher(),
true);
LOGGER.fine(String.format("Merging finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
final DensityFilteredAndroidData filteredData =
mergedData.filter(
new DensitySpecificResourceFilter(
options.densities, filteredResources, mergedResources),
new DensitySpecificManifestProcessor(options.densities, densityManifest));
LOGGER.fine(
String.format(
"Density filtering finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
final MergedAndroidData processedManifestData =
resourceProcessor.processManifest(
options.packageType,
options.packageForR,
options.applicationId,
options.versionCode,
options.versionName,
filteredData,
processedManifest);
resourceProcessor.processResources(
aaptConfigOptions.aapt,
aaptConfigOptions.androidJar,
aaptConfigOptions.buildToolsVersion,
options.packageType,
aaptConfigOptions.debug,
options.packageForR,
new FlagAaptOptions(aaptConfigOptions),
aaptConfigOptions.resourceConfigs,
aaptConfigOptions.splits,
processedManifestData,
data,
generatedSources,
options.packagePath,
options.proguardOutput,
options.mainDexProguardOutput,
options.resourcesOutput != null
? processedManifestData.getResourceDir().resolve("values").resolve("public.xml")
: null);
LOGGER.fine(String.format("aapt finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
if (options.manifestOutput != null) {
resourceProcessor.copyManifestToOutput(processedManifestData, options.manifestOutput);
}
if (options.srcJarOutput != null) {
resourceProcessor.createSrcJar(
generatedSources,
options.srcJarOutput,
VariantConfiguration.Type.LIBRARY == options.packageType);
}
if (options.rOutput != null) {
resourceProcessor.copyRToOutput(
generatedSources,
options.rOutput,
VariantConfiguration.Type.LIBRARY == options.packageType);
}
if (options.symbolsTxtOut != null) {
resourceProcessor.copyRToOutput(
generatedSources,
options.symbolsTxtOut,
VariantConfiguration.Type.LIBRARY == options.packageType);
}
if (options.resourcesOutput != null) {
resourceProcessor.createResourcesZip(
processedManifestData.getResourceDir(),
processedManifestData.getAssetDir(),
options.resourcesOutput);
}
LOGGER.fine(
String.format("Packaging finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
} catch (MergingException e) {
LOGGER.log(java.util.logging.Level.SEVERE, "Error during merging resources", e);
throw e;
} catch (IOException | InterruptedException | LoggedErrorException e) {
LOGGER.log(java.util.logging.Level.SEVERE, "Error during processing resources", e);
throw e;
} catch (Exception e) {
LOGGER.log(java.util.logging.Level.SEVERE, "Unexpected", e);
throw e;
} finally {
resourceProcessor.shutdown();
}
LOGGER.fine(String.format("Resources processed in %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
}
