diff options
Diffstat (limited to 'apkbuilder/src/com/android/apkbuilder/ApkBuilder.java')
-rw-r--r-- | apkbuilder/src/com/android/apkbuilder/ApkBuilder.java | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/apkbuilder/src/com/android/apkbuilder/ApkBuilder.java b/apkbuilder/src/com/android/apkbuilder/ApkBuilder.java new file mode 100644 index 0000000..0f31ef5 --- /dev/null +++ b/apkbuilder/src/com/android/apkbuilder/ApkBuilder.java @@ -0,0 +1,460 @@ +/* + * Copyright (C) 2008 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.apkbuilder; + +import com.android.jarutils.DebugKeyProvider; +import com.android.jarutils.JavaResourceFilter; +import com.android.jarutils.SignedJarBuilder; +import com.android.jarutils.DebugKeyProvider.KeytoolException; +import com.android.prefs.AndroidLocation.AndroidLocationException; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FilenameFilter; +import java.io.IOException; +import java.security.PrivateKey; +import java.security.cert.X509Certificate; +import java.text.DateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.regex.Pattern; + +/** + * Command line APK builder with signing support. + */ +public final class ApkBuilder { + + private final static Pattern PATTERN_JAR_EXT = Pattern.compile("^.+\\.jar$", + Pattern.CASE_INSENSITIVE); + private final static Pattern PATTERN_NATIVELIB_EXT = Pattern.compile("^.+\\.so$", + Pattern.CASE_INSENSITIVE); + + private final static String NATIVE_LIB_ROOT = "lib/"; + + /** + * A File to be added to the APK archive. + * <p/>This includes the {@link File} representing the file and its path in the archive. + */ + private final static class ApkFile { + String archivePath; + File file; + + ApkFile(File file, String path) { + this.file = file; + this.archivePath = path; + } + } + + private JavaResourceFilter mResourceFilter = new JavaResourceFilter(); + private boolean mVerbose = false; + private boolean mSignedPackage = true; + + /** + * @param args + */ + public static void main(String[] args) { + new ApkBuilder().run(args); + } + + private void run(String[] args) { + if (args.length < 1) { + printUsageAndQuit(); + } + + // read the first args that should be a file path + File outFile = getOutFile(args[0]); + + ArrayList<FileInputStream> zipArchives = new ArrayList<FileInputStream>(); + ArrayList<File> archiveFiles = new ArrayList<File>(); + ArrayList<ApkFile> javaResources = new ArrayList<ApkFile>(); + ArrayList<FileInputStream> resourcesJars = new ArrayList<FileInputStream>(); + ArrayList<ApkFile> nativeLibraries = new ArrayList<ApkFile>(); + + // optional store type. + String storeType = null; + + int index = 1; + do { + String argument = args[index++]; + + if ("-v".equals(argument)) { + mVerbose = true; + } else if ("-u".equals(argument)) { + mSignedPackage = false; + } else if ("-z".equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + try { + FileInputStream input = new FileInputStream(args[index++]); + zipArchives.add(input); + } catch (FileNotFoundException e) { + printAndExit(e.getMessage()); + } + } else if ("-f". equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + archiveFiles.add(getInputFile(args[index++])); + } else if ("-rf". equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + processSourceFolderForResource(args[index++], javaResources); + } else if ("-rj". equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + String parameter = args[index++]; + File f = new File(parameter); + if (f.isDirectory()) { + String[] files = f.list(new FilenameFilter() { + public boolean accept(File dir, String name) { + return PATTERN_JAR_EXT.matcher(name).matches(); + } + }); + + for (String file : files) { + try { + String path = f.getAbsolutePath() + File.separator + file; + FileInputStream input = new FileInputStream(path); + resourcesJars.add(input); + } catch (FileNotFoundException e) { + printAndExit(e.getMessage()); + } + } + } else { + try { + FileInputStream input = new FileInputStream(parameter); + resourcesJars.add(input); + } catch (FileNotFoundException e) { + printAndExit(e.getMessage()); + } + } + } else if ("-nf".equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + String parameter = args[index++]; + File f = new File(parameter); + + // compute the offset to get the relative path + int offset = parameter.length(); + if (parameter.endsWith(File.separator) == false) { + offset++; + } + + processNativeFolder(offset, f, nativeLibraries); + } else if ("-storetype".equals(argument)) { + // quick check on the next argument. + if (index == args.length) printUsageAndQuit(); + + storeType = args[index++]; + } else { + printAndExit("Unknown argument: " + argument); + } + } while (index < args.length); + + createPackage(outFile, zipArchives, archiveFiles, javaResources, resourcesJars, + nativeLibraries, storeType); + } + + private File getOutFile(String filepath) { + File f = new File(filepath); + + if (f.isDirectory()) { + printAndExit(filepath + " is a directory!"); + } + + if (f.exists()) { // will be a file in this case. + if (f.canWrite() == false) { + printAndExit("Cannot write " + filepath); + } + } else { + try { + if (f.createNewFile() == false) { + printAndExit("Failed to create " + filepath); + } + } catch (IOException e) { + printAndExit("Failed to create '" + filepath + "' : " + e.getMessage()); + } + } + + return f; + } + + private File getInputFile(String filepath) { + File f = new File(filepath); + + if (f.isDirectory()) { + printAndExit(filepath + " is a directory!"); + } + + if (f.exists()) { + if (f.canRead() == false) { + printAndExit("Cannot read " + filepath); + } + } else { + printAndExit(filepath + " does not exists!"); + } + + return f; + } + + /** + * Processes a source folder and add its java resources to the list of {@link ApkFile} to + * write into the {@link SignedJarBuilder}. + * @param folderPath the path to the source folder. + * @param javaResources the list of {@link ApkFile} to fill. + */ + private void processSourceFolderForResource(String folderPath, + ArrayList<ApkFile> javaResources) { + + File folder = new File(folderPath); + + if (folder.isDirectory()) { + // file is a directory, process its content. + File[] files = folder.listFiles(); + for (File file : files) { + processFileForResource(file, null, javaResources); + } + } else { + // not a directory? output error and quit. + if (folder.exists()) { + printAndExit(folderPath + " is not a folder!"); + } else { + printAndExit(folderPath + " does not exist!"); + } + } + } + + /** + * Processes a {@link File} that could be a {@link ApkFile}, or a folder containing + * java resources. + * @param file the {@link File} to process. + * @param path the relative path of this file to the source folder. Can be <code>null</code> to + * identify a root file. + * @param javaResources the list of {@link ApkFile} object to fill. + */ + private void processFileForResource(File file, String path, + ArrayList<ApkFile> javaResources) { + if (file.isDirectory()) { + // a directory? we check it + if (JavaResourceFilter.checkFolderForPackaging(file.getName())) { + // if it's valid, we append its name to the current path. + if (path == null) { + path = file.getName(); + } else { + path = path + "/" + file.getName(); + } + + // and process its content. + File[] files = file.listFiles(); + for (File contentFile : files) { + processFileForResource(contentFile, path, javaResources); + } + } + } else { + // a file? we check it + if (JavaResourceFilter.checkFileForPackaging(file.getName())) { + // we append its name to the current path + if (path == null) { + path = file.getName(); + } else { + path = path + "/" + file.getName(); + } + + // and add it to the list. + javaResources.add(new ApkFile(file, path)); + } + } + } + + /** + * Process a {@link File} for native library inclusion. + * @param offset the length of the root folder (used to compute relative path) + * @param f the {@link File} to process + * @param nativeLibraries the array to add native libraries. + */ + private void processNativeFolder(int offset, File f, ArrayList<ApkFile> nativeLibraries) { + if (f.isDirectory()) { + File[] children = f.listFiles(); + + if (children != null) { + for (File child : children) { + processNativeFolder(offset, child, nativeLibraries); + } + } + } else if (f.isFile()) { + if (PATTERN_NATIVELIB_EXT.matcher(f.getName()).matches()) { + String path = NATIVE_LIB_ROOT + + f.getAbsolutePath().substring(offset).replace('\\', '/'); + + nativeLibraries.add(new ApkFile(f, path)); + } + } + } + + /** + * Creates the application package + * @param outFile + * @param zipArchives + * @param resourcesJars + * @param files + * @param javaResources + * @param storeType the optional type of the debug keystore. If <code>null</code>, the default + * keystore type of the VM is used. + */ + private void createPackage(File outFile, ArrayList<FileInputStream> zipArchives, + ArrayList<File> files, ArrayList<ApkFile> javaResources, + ArrayList<FileInputStream> resourcesJars, ArrayList<ApkFile> nativeLibraries, + String storeType) { + + // get the debug key + try { + SignedJarBuilder builder; + + if (mSignedPackage) { + System.err.println(String.format("Using keystore: %s", + DebugKeyProvider.getDefaultKeyStoreOsPath())); + + + DebugKeyProvider keyProvider = new DebugKeyProvider(storeType, + null /* IKeyGenOutput */); + PrivateKey key = keyProvider.getDebugKey(); + X509Certificate certificate = (X509Certificate)keyProvider.getCertificate(); + + if (key == null) { + printAndExit("Unable to get debug signature key"); + } + + // compare the certificate expiration date + if (certificate != null && certificate.getNotAfter().compareTo(new Date()) < 0) { + // TODO, regenerate a new one. + printAndExit("Debug Certificate expired on " + + DateFormat.getInstance().format(certificate.getNotAfter())); + } + + builder = new SignedJarBuilder( + new FileOutputStream(outFile.getAbsolutePath(), false /* append */), key, + certificate); + } else { + builder = new SignedJarBuilder( + new FileOutputStream(outFile.getAbsolutePath(), false /* append */), + null /* key */, null /* certificate */); + } + + // add the archives + for (FileInputStream input : zipArchives) { + builder.writeZip(input, null /* filter */); + } + + // add the single files + for (File input : files) { + // always put the file at the root of the archive in this case + builder.writeFile(input, input.getName()); + if (mVerbose) { + System.err.println(String.format("%1$s => %2$s", input.getAbsolutePath(), + input.getName())); + } + } + + // add the java resource from the source folders. + for (ApkFile resource : javaResources) { + builder.writeFile(resource.file, resource.archivePath); + if (mVerbose) { + System.err.println(String.format("%1$s => %2$s", + resource.file.getAbsolutePath(), resource.archivePath)); + } + } + + // add the java resource from jar files. + for (FileInputStream input : resourcesJars) { + builder.writeZip(input, mResourceFilter); + } + + // add the native files + for (ApkFile file : nativeLibraries) { + builder.writeFile(file.file, file.archivePath); + if (mVerbose) { + System.err.println(String.format("%1$s => %2$s", file.file.getAbsolutePath(), + file.archivePath)); + } + } + + // close and sign the application package. + builder.close(); + } catch (KeytoolException e) { + if (e.getJavaHome() == null) { + printAndExit(e.getMessage(), + "JAVA_HOME seems undefined, setting it will help locating keytool automatically", + "You can also manually execute the following command:", + e.getCommandLine()); + } else { + printAndExit(e.getMessage(), + "JAVA_HOME is set to: " + e.getJavaHome(), + "Update it if necessary, or manually execute the following command:", + e.getCommandLine()); + } + System.err.println(e.getMessage()); + } catch (AndroidLocationException e) { + printAndExit(e.getMessage()); + } catch (Exception e) { + printAndExit(e.getMessage()); + } + } + + private void printUsageAndQuit() { + // 80 cols marker: 01234567890123456789012345678901234567890123456789012345678901234567890123456789 + System.err.println("A command line tool to package an Android application from various sources."); + System.err.println("Usage: apkbuilder <out archive> [-v][-u][-storetype STORE_TYPE] [-z inputzip]"); + System.err.println(" [-f inputfile] [-rf input-folder] [-rj -input-path]"); + System.err.println(""); + System.err.println(" -v Verbose."); + System.err.println(" -u Creates an unsigned package."); + System.err.println(" -storetype Forces the KeyStore type. If ommited the default is used."); + System.err.println(""); + System.err.println(" -z Followed by the path to a zip archive."); + System.err.println(" Adds the content of the application package."); + System.err.println(""); + System.err.println(" -f Followed by the path to a file."); + System.err.println(" Adds the file to the application package."); + System.err.println(""); + System.err.println(" -rf Followed by the path to a source folder."); + System.err.println(" Adds the java resources found in that folder to the application"); + System.err.println(" package, while keeping their path relative to the source folder."); + System.err.println(""); + System.err.println(" -rj Followed by the path to a jar file or a folder containing"); + System.err.println(" jar files."); + System.err.println(" Adds the java resources found in the jar file(s) to the application"); + System.err.println(" package."); + System.err.println(""); + System.err.println(" -nf Followed by the root folder containing native libraries to"); + System.err.println(" include in the application package."); + + System.exit(1); + } + + private void printAndExit(String... messages) { + for (String message : messages) { + System.err.println(message); + } + System.exit(1); + } +} |