Merge Android Pie into master
Bug: 112104996
Change-Id: Ie05d3082adfc859729dfd395e80c597fe4e5e496
diff --git a/bundletool/Android.mk b/bundletool/Android.mk
new file mode 100644
index 0000000..b6c20f8
--- /dev/null
+++ b/bundletool/Android.mk
@@ -0,0 +1,37 @@
+LOCAL_PATH:= $(call my-dir)
+
+## bundletool script
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bundletool
+LOCAL_MODULE_TAG := optional
+LOCAL_MODULE_CLASS := EXECUTABLES
+LOCAL_IS_HOST_MODULE := true
+
+include $(BUILD_SYSTEM)/base_rules.mk
+
+$(LOCAL_BUILT_MODULE): $(HOST_OUT_JAVA_LIBRARIES)/bundletool$(COMMON_JAVA_PACKAGE_SUFFIX)
+$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/etc/bundletool | $(ACP)
+ @echo "Copy: $(PRIVATE_MODULE) ($@)"
+ $(copy-file-to-new-target)
+ $(hide) chmod 755 $@
+
+## tool jar
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := bundletool
+
+LOCAL_SRC_FILES := $(call all-java-files-under, java)
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_STATIC_JAVA_LIBRARIES := guavalib jsr305lib dagger2-auto-value-host error_prone_annotations-2.0.18
+
+LOCAL_ANNOTATION_PROCESSORS := dagger2-auto-value-host
+LOCAL_ANNOTATION_PROCESSOR_CLASSES := com.google.auto.value.processor.AutoValueProcessor
+
+LOCAL_JAR_MANIFEST := manifest.txt
+
+include $(BUILD_HOST_JAVA_LIBRARY)
diff --git a/bundletool/etc/bundletool b/bundletool/etc/bundletool
new file mode 100644
index 0000000..ac7cac3
--- /dev/null
+++ b/bundletool/etc/bundletool
@@ -0,0 +1,89 @@
+#!/bin/bash
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Set up prog to be the path of this script, including following symlinks,
+# and set up progdir to be the fully-qualified pathname of its directory.
+prog="$0"
+while [ -h "${prog}" ]; do
+ newProg=`/bin/ls -ld "${prog}"`
+ newProg=`expr "${newProg}" : ".* -> \(.*\)$"`
+ if expr "x${newProg}" : 'x/' >/dev/null; then
+ prog="${newProg}"
+ else
+ progdir=`dirname "${prog}"`
+ prog="${progdir}/${newProg}"
+ fi
+done
+oldwd=`pwd`
+progdir=`dirname "${prog}"`
+cd "${progdir}"
+progdir=`pwd`
+prog="${progdir}"/`basename "${prog}"`
+cd "${oldwd}"
+
+jarfile=bundletool.jar
+libdir="$progdir"
+
+if [ ! -r "$libdir/$jarfile" ]; then
+ # set bundletool.jar location for the SDK case
+ libdir="$libdir/lib"
+fi
+
+
+if [ ! -r "$libdir/$jarfile" ]; then
+ # set bundletool.jar location for the Android tree case
+ libdir=`dirname "$progdir"`/framework
+fi
+
+if [ ! -r "$libdir/$jarfile" ]; then
+ echo `basename "$prog"`": can't find $jarfile"
+ exit 1
+fi
+
+# By default, give bundletool a max heap size of 1 gig. This can be overridden
+# by using a "-J" option (see below).
+defaultMx="-Xmx1024M"
+
+# The following will extract any initial parameters of the form
+# "-J<stuff>" from the command line and pass them to the Java
+# invocation (instead of to bundletool). This makes it possible for you to add
+# a command-line parameter such as "-JXmx256M" in your scripts, for
+# example. "java" (with no args) and "java -X" give a summary of
+# available options.
+
+javaOpts=""
+
+while expr "x$1" : 'x-J' >/dev/null; do
+ opt=`expr "x$1" : 'x-J\(.*\)'`
+ javaOpts="${javaOpts} -${opt}"
+ if expr "x${opt}" : "xXmx[0-9]" >/dev/null; then
+ defaultMx="no"
+ fi
+ shift
+done
+
+if [ "${defaultMx}" != "no" ]; then
+ javaOpts="${javaOpts} ${defaultMx}"
+fi
+
+if [ "$OSTYPE" = "cygwin" ]; then
+ # For Cygwin, convert the jarfile path into native Windows style.
+ jarpath=`cygpath -w "$libdir/$jarfile"`
+else
+ jarpath="$libdir/$jarfile"
+fi
+
+exec java $javaOpts -jar "$jarpath" "$@"
diff --git a/bundletool/etc/bundletool.bat b/bundletool/etc/bundletool.bat
new file mode 100644
index 0000000..09a9d36
--- /dev/null
+++ b/bundletool/etc/bundletool.bat
@@ -0,0 +1,88 @@
+@echo off↵
+REM Copyright (C) 2017 The Android Open Source Project↵
+REM↵
+REM Licensed under the Apache License, Version 2.0 (the "License");↵
+REM you may not use this file except in compliance with the License.↵
+REM You may obtain a copy of the License at↵
+REM↵
+REM http://www.apache.org/licenses/LICENSE-2.0↵
+REM↵
+REM Unless required by applicable law or agreed to in writing, software↵
+REM distributed under the License is distributed on an "AS IS" BASIS,↵
+REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.↵
+REM See the License for the specific language governing permissions and↵
+REM limitations under the License.↵
+↵
+REM don't modify the caller's environment↵
+setlocal↵
+↵
+REM Locate bundletool.jar in the directory where bundletool.bat was found and start it.↵
+↵
+REM Set up prog to be the path of this script, including following symlinks,↵
+REM and set up progdir to be the fully-qualified pathname of its directory.↵
+set prog=%~f0↵
+↵
+rem Check we have a valid Java.exe in the path.↵
+set java_exe=↵
+if exist "%~dp0..\tools\lib\find_java.bat" call "%~dp0..\tools\lib\find_java.bat"↵
+if exist "%~dp0..\..\tools\lib\find_java.bat" call "%~dp0..\..\tools\lib\find_java.bat"↵
+if not defined java_exe goto :EOF↵
+↵
+set jarfile=bundletool.jar↵
+set "frameworkdir=%~dp0"↵
+rem frameworkdir must not end with a dir sep.↵
+set "frameworkdir=%frameworkdir:~0,-1%"↵
+↵
+if exist "%frameworkdir%\%jarfile%" goto JarFileOk↵
+ set "frameworkdir=%~dp0lib"↵
+↵
+if exist "%frameworkdir%\%jarfile%" goto JarFileOk↵
+ set "frameworkdir=%~dp0..\framework"↵
+↵
+:JarFileOk↵
+↵
+set "jarpath=%frameworkdir%\%jarfile%"↵
+↵
+set javaOpts=↵
+set args=↵
+↵
+REM By default, give bundletool a max heap size of 1 gig and a stack size of 1meg.↵
+rem This can be overridden by using "-JXmx..." and "-JXss..." options below.↵
+set defaultXmx=-Xmx1024M↵
+set defaultXss=-Xss1m↵
+↵
+REM Capture all arguments that are not -J options.↵
+REM Note that when reading the input arguments with %1, the cmd.exe↵
+REM automagically converts --name=value arguments into 2 arguments "--name"↵
+REM followed by "value". Dx has been changed to know how to deal with that.↵
+set params=↵
+↵
+:firstArg↵
+if [%1]==[] goto endArgs↵
+set a=%~1↵
+↵
+ if [%defaultXmx%]==[] goto notXmx↵
+ if %a:~0,5% NEQ -JXmx goto notXmx↵
+ set defaultXmx=↵
+ :notXmx↵
+↵
+ if [%defaultXss%]==[] goto notXss↵
+ if %a:~0,5% NEQ -JXss goto notXss↵
+ set defaultXss=↵
+ :notXss↵
+↵
+ if %a:~0,2% NEQ -J goto notJ↵
+ set javaOpts=%javaOpts% -%a:~2%↵
+ shift /1↵
+ goto firstArg↵
+↵
+ :notJ↵
+ set params=%params% %1↵
+ shift /1↵
+ goto firstArg↵
+↵
+:endArgs↵
+↵
+set javaOpts=%javaOpts% %defaultXmx% %defaultXss%↵
+call "%java_exe%" %javaOpts% -Djava.ext.dirs="%frameworkdir%" -jar "%jarpath%" %params%↵
+↵
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/AppBundle.java b/bundletool/java/com/android/tools/appbundle/bundletool/AppBundle.java
new file mode 100644
index 0000000..cbdf4e1
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/AppBundle.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/** Represents an app bundle. */
+public class AppBundle {
+
+ private ZipFile bundleFile;
+ private Map<String, BundleModule> modules;
+
+ public AppBundle(ZipFile bundleFile) {
+ this.bundleFile = bundleFile;
+ this.modules = new HashMap<>();
+ open();
+ }
+
+ private void open() {
+ Map<String, BundleModule.Builder> moduleBuilders = new HashMap<>();
+ Enumeration<? extends ZipEntry> entries = bundleFile.entries();
+ while (entries.hasMoreElements()) {
+ ZipEntry entry = entries.nextElement();
+ Path path = Paths.get(entry.getName());
+ if (path.getNameCount() > 1) {
+ String moduleName = path.getName(0).toString();
+ BundleModule.Builder moduleBuilder =
+ moduleBuilders.computeIfAbsent(
+ moduleName, name -> new BundleModule.Builder(name, this));
+ moduleBuilder.addZipEntry(entry);
+ }
+ }
+ modules.putAll(Maps.transformValues(moduleBuilders, BundleModule.Builder::build));
+ }
+
+ public Map<String, BundleModule> getModules() {
+ return ImmutableMap.copyOf(modules);
+ }
+
+ public BundleModule getModule(String moduleName) {
+ return modules.get(moduleName);
+ }
+
+ public InputStream getEntryInputStream(ZipEntry entry) throws IOException {
+ return bundleFile.getInputStream(entry);
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/BuildModuleCommand.java b/bundletool/java/com/android/tools/appbundle/bundletool/BuildModuleCommand.java
new file mode 100644
index 0000000..8e30d9a
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/BuildModuleCommand.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package com.android.tools.appbundle.bundletool;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.android.tools.appbundle.bundletool.utils.FlagParser;
+import com.google.auto.value.AutoValue;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+
+/** Command responsible for building an App Bundle module. */
+@AutoValue
+public abstract class BuildModuleCommand {
+
+ public static final String COMMAND_NAME = "build-module";
+
+ private static final String OUTPUT_FLAG = "output";
+ private static final String MANIFEST_FLAG = "manifest";
+ private static final String MANIFEST_DIR_FLAG = "manifest-dir";
+ private static final String DEX_FLAG = "dex";
+ private static final String DEX_DIR_FLAG = "dex-dir";
+ private static final String RESOURCES_DIR_FLAG = "resources-dir";
+ private static final String ASSETS_DIR_FLAG = "assets-dir";
+ private static final String NATIVE_DIR_FLAG = "native-dir";
+
+ abstract Path getOutputPath();
+
+ abstract Optional<Path> getManifestPath();
+
+ abstract Optional<Path> getManifestDirPath();
+
+ abstract Optional<Path> getDexPath();
+
+ abstract Optional<Path> getDexDirPath();
+
+ abstract Optional<Path> getResourcesDirPath();
+
+ abstract Optional<Path> getAssetsDirPath();
+
+ abstract Optional<Path> getNativeDirPath();
+
+ public static Builder builder() {
+ return new AutoValue_BuildModuleCommand.Builder();
+ }
+
+ /** Builder for the {@link BuildModuleCommand} */
+ @AutoValue.Builder
+ public abstract static class Builder {
+ abstract Builder setOutputPath(Path outputPath);
+
+ abstract Builder setManifestPath(Path manifestPath);
+
+ abstract Builder setManifestDirPath(Path manifestDirPath);
+
+ abstract Builder setDexPath(Path dexPath);
+
+ abstract Builder setDexDirPath(Path dexDirPath);
+
+ abstract Builder setResourcesDirPath(Path resourcesDirPath);
+
+ abstract Builder setAssetsDirPath(Path assetsDirPath);
+
+ abstract Builder setNativeDirPath(Path nativeDirPath);
+
+ abstract BuildModuleCommand build();
+ }
+
+ static BuildModuleCommand fromFlags(FlagParser flagParser) {
+ Builder builder =
+ builder().setOutputPath(Paths.get(flagParser.getRequiredFlagValue(OUTPUT_FLAG)));
+ flagParser.getFlagValueAsPath(MANIFEST_FLAG).ifPresent(builder::setManifestPath);
+ flagParser.getFlagValueAsPath(MANIFEST_DIR_FLAG).ifPresent(builder::setManifestDirPath);
+ flagParser.getFlagValueAsPath(DEX_FLAG).ifPresent(builder::setDexPath);
+ flagParser.getFlagValueAsPath(DEX_DIR_FLAG).ifPresent(builder::setDexDirPath);
+ flagParser.getFlagValueAsPath(RESOURCES_DIR_FLAG).ifPresent(builder::setResourcesDirPath);
+ flagParser.getFlagValueAsPath(ASSETS_DIR_FLAG).ifPresent(builder::setAssetsDirPath);
+ flagParser.getFlagValueAsPath(NATIVE_DIR_FLAG).ifPresent(builder::setNativeDirPath);
+
+ return builder.build();
+ }
+
+ public void execute() {
+ validateInput();
+
+
+ }
+
+ private void validateInput() {
+ checkArgument(
+ getManifestPath().isPresent() || getManifestDirPath().isPresent(),
+ "One of --%s or --%s is required.",
+ MANIFEST_FLAG,
+ MANIFEST_DIR_FLAG);
+ checkArgument(
+ !getManifestPath().isPresent() || !getManifestDirPath().isPresent(),
+ "Cannot set both --%s and --%s flags.",
+ MANIFEST_FLAG,
+ MANIFEST_DIR_FLAG);
+ checkArgument(
+ !getDexPath().isPresent() || !getDexDirPath().isPresent(),
+ "Cannot set both --%s and --%s flags.",
+ DEX_FLAG,
+ DEX_DIR_FLAG);
+
+ checkArgument(!Files.exists(getOutputPath()), "File %s already exists.", getOutputPath());
+ checkFileExistsAndReadable(getManifestPath());
+ checkDirectoryExists(getManifestDirPath());
+ checkFileExistsAndReadable(getDexPath());
+ checkDirectoryExists(getDexDirPath());
+ checkDirectoryExists(getResourcesDirPath());
+ checkDirectoryExists(getAssetsDirPath());
+ checkDirectoryExists(getNativeDirPath());
+ }
+
+ private static void checkFileExistsAndReadable(Optional<Path> pathOptional) {
+ if (pathOptional.isPresent()) {
+ Path path = pathOptional.get();
+ checkArgument(Files.exists(path), "File '%s' was not found.", path);
+ checkArgument(Files.isReadable(path), "File '%s' is not readable.", path);
+ }
+ }
+
+ private static void checkDirectoryExists(Optional<Path> pathOptional) {
+ if (pathOptional.isPresent()) {
+ Path path = pathOptional.get();
+ checkArgument(Files.exists(path), "Directory '%s' was not found.", path);
+ checkArgument(Files.isDirectory(path), "'%s' is not a directory.");
+ }
+ }
+
+ public static void help() {
+ System.out.println(
+ String.format(
+ "bundletool %s --output=<path/to/module.zip> "
+ + "[--%s=<path/to/AndroidManifest.flat>|--%s=<path/to/manifest-dir/>] "
+ + "[--%s=<path/to/classes.dex>|--%s=<path/to/dex-dir/>] "
+ + "[--%s=<path/to/res/>] "
+ + "[--%s=<path/to/assets/>] "
+ + "[--%s=<path/to/lib/>] ",
+ COMMAND_NAME,
+ MANIFEST_FLAG,
+ MANIFEST_DIR_FLAG,
+ DEX_FLAG,
+ DEX_DIR_FLAG,
+ RESOURCES_DIR_FLAG,
+ ASSETS_DIR_FLAG,
+ NATIVE_DIR_FLAG));
+ System.out.println();
+ System.out.println(
+ "Builds a module as a zip from an app's project. Note that the resources and the "
+ + "AndroidManifest.xml must already have been compiled with aapt2.");
+ System.out.println();
+ System.out.println("--output: Path to the zip file to build.");
+ System.out.printf(
+ "--%s: Path to the AndroidManifest.flat compiled by aapt2. Use --%s if there "
+ + "are more than one.\n",
+ MANIFEST_FLAG, MANIFEST_DIR_FLAG);
+ System.out.printf(
+ "--%s: Path to the directory containing multiple Android manifests compiled by aapt2. "
+ + "A file named 'manifest-targeting.xml' must be present in the directory "
+ + "describing the targeting of each manifest present.\n",
+ MANIFEST_DIR_FLAG);
+ System.out.printf(
+ "--%s: Path to the dex file. Use --%s if there are more than one.\n",
+ DEX_FLAG, DEX_DIR_FLAG);
+ System.out.printf(
+ "--%s: Path to the directory containing multiple dex files. Unless all dex files must "
+ + "be included in the generated APKs (for MultiDex), a file named "
+ + "'dex-targeting.xml' must be present in the directory describing the targeting "
+ + "of the different dex files.\n",
+ DEX_DIR_FLAG);
+ System.out.printf(
+ "--%s: Path to the directory containing the resources file(s). A file named "
+ + "'resources.flat' must be present in that directory corresponding to the output "
+ + "of the aapt2 compilation of the resources.\n",
+ RESOURCES_DIR_FLAG);
+ System.out.printf("--%s: Path to the directory containing the assets.\n", ASSETS_DIR_FLAG);
+ System.out.printf(
+ "--%s: Path to the directory containing the native libraries.\n", NATIVE_DIR_FLAG);
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/BundleModule.java b/bundletool/java/com/android/tools/appbundle/bundletool/BundleModule.java
new file mode 100644
index 0000000..c88d287
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/BundleModule.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool;
+
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipEntry;
+
+/** Represents a single module inside App Bundle. */
+public class BundleModule {
+
+ private AppBundle parent;
+ private String name;
+ private List<ZipEntry> entries;
+
+ private BundleModule(String name, AppBundle parent, List<ZipEntry> entries) {
+ this.parent = parent;
+ this.name = name;
+ this.entries = entries;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public AppBundle getParent() {
+ return parent;
+ }
+
+ public List<ZipEntry> getEntries() {
+ return ImmutableList.copyOf(entries);
+ }
+
+ /** Builder for BundleModule. */
+ public static class Builder {
+ private List<ZipEntry> entries;
+ private String name;
+ private AppBundle parent;
+
+ public Builder(String name, AppBundle parent) {
+ this.name = name;
+ this.parent = parent;
+ this.entries = new ArrayList<>();
+ }
+
+ public Builder addZipEntry(ZipEntry entry) {
+ this.entries.add(entry);
+ return this;
+ }
+
+ public BundleModule build() {
+ return new BundleModule(name, parent, entries);
+ }
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/BundleToolMain.java b/bundletool/java/com/android/tools/appbundle/bundletool/BundleToolMain.java
new file mode 100644
index 0000000..330a991
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/BundleToolMain.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool;
+
+import com.android.tools.appbundle.bundletool.utils.FlagParser;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Main entry point of the bundle tool.
+ *
+ * <p>Consider running with -Dsun.zip.disableMemoryMapping when dealing with large bundles.
+ */
+public class BundleToolMain {
+
+ public static final String LINK_CMD = "link";
+ public static final String HELP_CMD = "help";
+
+ /** Parses the flags and routes to the appropriate command handler */
+ public static void main(String[] args) throws IOException {
+
+ FlagParser flagParser = new FlagParser();
+ try {
+ flagParser.parse(args);
+ } catch (FlagParser.ParseException e) {
+ System.out.println(String.format("Error while parsing the flags: %s", e.getMessage()));
+ return;
+ }
+ List<String> commands = flagParser.getCommands();
+
+ if (commands.isEmpty()) {
+ System.out.println("Error: you have to specify a command");
+ help();
+ return;
+ }
+
+ try {
+ switch (commands.get(0)) {
+ case BuildModuleCommand.COMMAND_NAME:
+ BuildModuleCommand.fromFlags(flagParser).execute();
+ break;
+ case SplitModuleCommand.COMMAND_NAME:
+ new SplitModuleCommand(flagParser).execute();
+ break;
+ case LINK_CMD:
+ throw new UnsupportedOperationException("Not implemented.");
+ case HELP_CMD:
+ if (commands.size() > 1) {
+ help(commands.get(1));
+ } else {
+ help();
+ }
+ return;
+ default:
+ System.out.println("Error: unrecognized command.");
+ help();
+ }
+ } catch (Exception e) {
+ System.out.println("Error: " + e.getMessage());
+ }
+ }
+
+ /** Displays a general help. */
+ public static void help() {
+ System.out.println(
+ String.format(
+ "bundletool [%s|%s|%s|%s] ...",
+ BuildModuleCommand.COMMAND_NAME, SplitModuleCommand.COMMAND_NAME, LINK_CMD, HELP_CMD));
+ System.out.println("Type: bundletool help [command] to learn more about a given command.");
+ }
+
+ /** Displays help about a given command. */
+ public static void help(String commandName) {
+ switch (commandName) {
+ case BuildModuleCommand.COMMAND_NAME:
+ BuildModuleCommand.help();
+ break;
+ case SplitModuleCommand.COMMAND_NAME:
+ SplitModuleCommand.help();
+ break;
+ case LINK_CMD:
+ System.out.println("Help is not yet available.");
+ break;
+ default:
+ System.out.println("Unrecognized command.");
+ help();
+ break;
+ }
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/Command.java b/bundletool/java/com/android/tools/appbundle/bundletool/Command.java
new file mode 100644
index 0000000..670c0dc
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/Command.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool;
+
+/** Interface for command implementations. */
+public interface Command {
+
+ void execute() throws ExecutionException;
+
+ /** Error indicating something went wrong during executing the command. */
+ class ExecutionException extends RuntimeException {
+
+ public ExecutionException(String message) {
+ super(message);
+ }
+
+ public ExecutionException(String message, Throwable cause) {
+ super(message, cause);
+ }
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/SplitModuleCommand.java b/bundletool/java/com/android/tools/appbundle/bundletool/SplitModuleCommand.java
new file mode 100644
index 0000000..f6909af
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/SplitModuleCommand.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool;
+
+import com.android.tools.appbundle.bundletool.utils.FlagParser;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.zip.ZipException;
+import java.util.zip.ZipFile;
+
+/** Implementation of the command to generate module splits. */
+public class SplitModuleCommand implements Command {
+
+ private final String bundleLocation;
+ private final String outputDirectory;
+ private final String moduleName;
+
+ public static final String COMMAND_NAME = "split-module";
+
+ private static final String BUNDLE_LOCATION_FLAG = "bundle";
+ private static final String OUTPUT_DIRECTORY_FLAG = "output";
+ private static final String MODULE_FLAG = "module";
+
+ public SplitModuleCommand(FlagParser parsedFlags) {
+ bundleLocation = parsedFlags.getRequiredFlagValue(BUNDLE_LOCATION_FLAG);
+ outputDirectory = parsedFlags.getRequiredFlagValue(OUTPUT_DIRECTORY_FLAG);
+ moduleName = parsedFlags.getRequiredFlagValue(MODULE_FLAG);
+ }
+
+ @Override
+ public void execute() throws ExecutionException {
+ try {
+ AppBundle appBundle = new AppBundle(new ZipFile(bundleLocation));
+ BundleModule module = appBundle.getModule(moduleName);
+ if (module == null) {
+ throw new ExecutionException(
+ String.format("Cannot find the %s module in the bundle", moduleName));
+ }
+ splitModule(moduleName, module, outputDirectory);
+ } catch (ZipException e) {
+ throw new ExecutionException("Zip error while opening the bundle " + e.getMessage(), e);
+ } catch (FileNotFoundException e) {
+ throw new ExecutionException("Bundle file not found", e);
+ } catch (IOException e) {
+ throw new ExecutionException("I/O error while processing the bundle " + e.getMessage(), e);
+ }
+ }
+
+ private void splitModule(String moduleName, BundleModule module, String outputDirectory) {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ public static void help() {
+ System.out.printf(
+ "bundletool %s --%s=[bundle.zip] --%s=[module-name] --%s=[output-dir]\n",
+ BUNDLE_LOCATION_FLAG, MODULE_FLAG, OUTPUT_DIRECTORY_FLAG, COMMAND_NAME);
+ System.out.println("Generates module splits for the given module of the bundle.");
+ System.out.println("For now, one split is generated containing all module's resources.");
+ System.out.println();
+ System.out.printf("--%s: the zip file containing an App Bundle.\n", BUNDLE_LOCATION_FLAG);
+ System.out.printf("--%s: module for which generate the splits.\n", MODULE_FLAG);
+ System.out.printf(
+ "--%s: the directory where the module zip files should be written to.\n",
+ OUTPUT_DIRECTORY_FLAG);
+ }
+}
diff --git a/bundletool/java/com/android/tools/appbundle/bundletool/utils/FlagParser.java b/bundletool/java/com/android/tools/appbundle/bundletool/utils/FlagParser.java
new file mode 100644
index 0000000..5f42165
--- /dev/null
+++ b/bundletool/java/com/android/tools/appbundle/bundletool/utils/FlagParser.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.tools.appbundle.bundletool.utils;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Utility for flag parsing, specific to the Bundle Tool.
+ *
+ * <p>The flags follow the below convention:
+ *
+ * <p>[bundle-tool] [command1] [command2] .. [command-n] [--flag1] [--flag2=v2].. [--flagn] where:
+ *
+ * <ul>
+ * <li>commands: cannot start with "-".
+ * <li>flags: have to start with "--". If they have "=" anything after the first occurrence is
+ * considered a flag value. By default the flag value is an empty string.
+ * </ul>
+ */
+public class FlagParser {
+
+ private List<String> commands = new ArrayList<>();
+ private Map<String, String> flags = new HashMap<>();
+
+ /**
+ * Parses the given arguments populating the structures.
+ *
+ * <p>Calling this function removes any previous parsing results.
+ */
+ public FlagParser parse(String[] args) throws ParseException {
+ this.commands.clear();
+ // Need to wrap it into a proper list implementation to be able to remove elements.
+ List<String> argsToProcess = new ArrayList<>(Arrays.asList(args));
+ while (argsToProcess.size() > 0 && !argsToProcess.get(0).startsWith("-")) {
+ commands.add(argsToProcess.get(0));
+ argsToProcess.remove(0);
+ }
+ this.flags = parseFlags(argsToProcess);
+ return this;
+ }
+
+ private Map<String, String> parseFlags(List<String> args) throws ParseException {
+ Map<String, String> flagMap = new HashMap<>();
+ for (String arg : args) {
+ if (!arg.startsWith("--")) {
+ throw new ParseException(
+ String.format("Syntax error: flags should start with -- (%s)", arg));
+ }
+ String[] segments = arg.substring(2).split("=", 2);
+ String value = "";
+ if (segments.length == 2) {
+ value = segments[1];
+ }
+ if (flagMap.putIfAbsent(segments[0], value) != null) {
+ throw new ParseException(
+ String.format("Flag %s has been set more than once.", segments[0]));
+ }
+ }
+ return flagMap;
+ }
+
+ /** Returns true if a given flag has been set. */
+ public boolean isFlagSet(String flagName) {
+ return flags.containsKey(flagName);
+ }
+
+ /** Returns the flag value wrapped in the Optional class. */
+ public Optional<String> getFlagValue(String flagName) {
+ return Optional.ofNullable(flags.get(flagName));
+ }
+
+ /**
+ * Returns a flag value. If absent throws IllegalStateException.
+ *
+ * @param flagName name of the flag to fetch
+ * @return string, the value of the flag
+ * @throws IllegalStateException if the flag was not set.
+ */
+ public String getRequiredFlagValue(String flagName) {
+ return getFlagValue(flagName)
+ .orElseThrow(
+ () ->
+ new IllegalArgumentException(
+ String.format("Missing the required --%s flag.", flagName)));
+ }
+
+ /** Returns the string value of the flag or the default if has not been set. */
+ public String getFlagValueOrDefault(String flagName, String defaultValue) {
+ return flags.getOrDefault(flagName, defaultValue);
+ }
+
+ public Optional<Path> getFlagValueAsPath(String flagName) {
+ return Optional.ofNullable(flags.get(flagName)).map(Paths::get);
+ }
+
+ /**
+ * Returns the value of the flag as list of strings.
+ *
+ * <p>It converts the string flag value to the list assuming it's delimited by a comma. The list
+ * is empty if the flag has not been set.
+ */
+ public List<String> getFlagListValue(String flagName) {
+ if (!isFlagSet(flagName)) {
+ return Collections.emptyList();
+ }
+ return Arrays.asList(flags.get(flagName).split(","));
+ }
+
+ /**
+ * Returns the list of commands that were parsed.
+ *
+ * @return the immutable list of commands.
+ */
+ public List<String> getCommands() {
+ return Collections.unmodifiableList(commands);
+ }
+
+ /** Exception encapsulating any flag parsing errors. */
+ public static class ParseException extends RuntimeException {
+
+ public ParseException(String message) {
+ super(message);
+ }
+ }
+}
diff --git a/bundletool/manifest.txt b/bundletool/manifest.txt
new file mode 100644
index 0000000..b8a4c92
--- /dev/null
+++ b/bundletool/manifest.txt
@@ -0,0 +1 @@
+Main-Class: com.android.tools.appbundle.bundletool.BundleToolMain
