Main.cpp revision 90964040cabfc67f92a7c3322a02401bb6f8ae82
1//
2// Copyright 2006 The Android Open Source Project
3//
4// Android Asset Packaging Tool main entry point.
5//
6#include "Main.h"
7#include "Bundle.h"
8
9#include <utils/Log.h>
10#include <utils/threads.h>
11#include <utils/List.h>
12#include <utils/Errors.h>
13
14#include <stdlib.h>
15#include <getopt.h>
16#include <assert.h>
17
18using namespace android;
19
20static const char* gProgName = "aapt";
21
22/*
23 * When running under Cygwin on Windows, this will convert slash-based
24 * paths into back-slash-based ones. Otherwise the ApptAssets file comparisons
25 * fail later as they use back-slash separators under Windows.
26 *
27 * This operates in-place on the path string.
28 */
29void convertPath(char *path) {
30  if (path != NULL && OS_PATH_SEPARATOR != '/') {
31    for (; *path; path++) {
32      if (*path == '/') {
33        *path = OS_PATH_SEPARATOR;
34      }
35    }
36  }
37}
38
39/*
40 * Print usage info.
41 */
42void usage(void)
43{
44    fprintf(stderr, "Android Asset Packaging Tool\n\n");
45    fprintf(stderr, "Usage:\n");
46    fprintf(stderr,
47        " %s l[ist] [-v] [-a] file.{zip,jar,apk}\n"
48        "   List contents of Zip-compatible archive.\n\n", gProgName);
49    fprintf(stderr,
50        " %s d[ump] [--values] WHAT file.{apk} [asset [asset ...]]\n"
51        "   badging          Print the label and icon for the app declared in APK.\n"
52        "   permissions      Print the permissions from the APK.\n"
53        "   resources        Print the resource table from the APK.\n"
54        "   configurations   Print the configurations in the APK.\n"
55        "   xmltree          Print the compiled xmls in the given assets.\n"
56        "   xmlstrings       Print the strings of the given compiled xml assets.\n\n", gProgName);
57    fprintf(stderr,
58        " %s p[ackage] [-d][-f][-m][-u][-v][-x][-z][-M AndroidManifest.xml] \\\n"
59        "        [-0 extension [-0 extension ...]] [-g tolerance] [-j jarfile] \\\n"
60        "        [--debug-mode] [--min-sdk-version VAL] [--target-sdk-version VAL] \\\n"
61        "        [--app-version VAL] [--app-version-name TEXT] [--custom-package VAL] \\\n"
62        "        [--rename-manifest-package PACKAGE] \\\n"
63        "        [--rename-instrumentation-target-package PACKAGE] \\\n"
64        "        [--utf16] [--auto-add-overlay] \\\n"
65        "        [--max-res-version VAL] \\\n"
66        "        [-I base-package [-I base-package ...]] \\\n"
67        "        [-A asset-source-dir]  [-G class-list-file] [-P public-definitions-file] \\\n"
68        "        [-S resource-sources [-S resource-sources ...]] "
69        "        [-F apk-file] [-J R-file-dir] \\\n"
70        "        [--product product1,product2,...] \\\n"
71        "        [raw-files-dir [raw-files-dir] ...]\n"
72        "\n"
73        "   Package the android resources.  It will read assets and resources that are\n"
74        "   supplied with the -M -A -S or raw-files-dir arguments.  The -J -P -F and -R\n"
75        "   options control which files are output.\n\n"
76        , gProgName);
77    fprintf(stderr,
78        " %s r[emove] [-v] file.{zip,jar,apk} file1 [file2 ...]\n"
79        "   Delete specified files from Zip-compatible archive.\n\n",
80        gProgName);
81    fprintf(stderr,
82        " %s a[dd] [-v] file.{zip,jar,apk} file1 [file2 ...]\n"
83        "   Add specified files to Zip-compatible archive.\n\n", gProgName);
84    fprintf(stderr,
85        " %s v[ersion]\n"
86        "   Print program version.\n\n", gProgName);
87    fprintf(stderr,
88        " Modifiers:\n"
89        "   -a  print Android-specific data (resources, manifest) when listing\n"
90        "   -c  specify which configurations to include.  The default is all\n"
91        "       configurations.  The value of the parameter should be a comma\n"
92        "       separated list of configuration values.  Locales should be specified\n"
93        "       as either a language or language-region pair.  Some examples:\n"
94        "            en\n"
95        "            port,en\n"
96        "            port,land,en_US\n"
97        "       If you put the special locale, zz_ZZ on the list, it will perform\n"
98        "       pseudolocalization on the default locale, modifying all of the\n"
99        "       strings so you can look for strings that missed the\n"
100        "       internationalization process.  For example:\n"
101        "            port,land,zz_ZZ\n"
102        "   -d  one or more device assets to include, separated by commas\n"
103        "   -f  force overwrite of existing files\n"
104        "   -g  specify a pixel tolerance to force images to grayscale, default 0\n"
105        "   -j  specify a jar or zip file containing classes to include\n"
106        "   -k  junk path of file(s) added\n"
107        "   -m  make package directories under location specified by -J\n"
108#if 0
109        "   -p  pseudolocalize the default configuration\n"
110#endif
111        "   -u  update existing packages (add new, replace older, remove deleted files)\n"
112        "   -v  verbose output\n"
113        "   -x  create extending (non-application) resource IDs\n"
114        "   -z  require localization of resource attributes marked with\n"
115        "       localization=\"suggested\"\n"
116        "   -A  additional directory in which to find raw asset files\n"
117        "   -G  A file to output proguard options into.\n"
118        "   -F  specify the apk file to output\n"
119        "   -I  add an existing package to base include set\n"
120        "   -J  specify where to output R.java resource constant definitions\n"
121        "   -M  specify full path to AndroidManifest.xml to include in zip\n"
122        "   -P  specify where to output public resource definitions\n"
123        "   -S  directory in which to find resources.  Multiple directories will be scanned\n"
124        "       and the first match found (left to right) will take precedence.\n"
125        "   -0  specifies an additional extension for which such files will not\n"
126        "       be stored compressed in the .apk.  An empty string means to not\n"
127        "       compress any files at all.\n"
128        "   --debug-mode\n"
129        "       inserts android:debuggable=\"true\" in to the application node of the\n"
130        "       manifest, making the application debuggable even on production devices.\n"
131        "   --min-sdk-version\n"
132        "       inserts android:minSdkVersion in to manifest.  If the version is 7 or\n"
133        "       higher, the default encoding for resources will be in UTF-8.\n"
134        "   --target-sdk-version\n"
135        "       inserts android:targetSdkVersion in to manifest.\n"
136        "   --max-res-version\n"
137        "       ignores versioned resource directories above the given value.\n"
138        "   --values\n"
139        "       when used with \"dump resources\" also includes resource values.\n"
140        "   --version-code\n"
141        "       inserts android:versionCode in to manifest.\n"
142        "   --version-name\n"
143        "       inserts android:versionName in to manifest.\n"
144        "   --custom-package\n"
145        "       generates R.java into a different package.\n"
146        "   --auto-add-overlay\n"
147        "       Automatically add resources that are only in overlays.\n"
148        "   --rename-manifest-package\n"
149        "       Rewrite the manifest so that its package name is the package name\n"
150        "       given here.  Relative class names (for example .Foo) will be\n"
151        "       changed to absolute names with the old package so that the code\n"
152        "       does not need to change.\n"
153        "   --rename-instrumentation-target-package\n"
154        "       Rewrite the manifest so that all of its instrumentation\n"
155        "       components target the given package.  Useful when used in\n"
156        "       conjunction with --rename-manifest-package to fix tests against\n"
157        "       a package that has been renamed.\n"
158        "   --product\n"
159        "       Specifies which variant to choose for strings that have\n"
160        "       product variants\n"
161        "   --utf16\n"
162        "       changes default encoding for resources to UTF-16.  Only useful when API\n"
163        "       level is set to 7 or higher where the default encoding is UTF-8.\n");
164}
165
166/*
167 * Dispatch the command.
168 */
169int handleCommand(Bundle* bundle)
170{
171    //printf("--- command %d (verbose=%d force=%d):\n",
172    //    bundle->getCommand(), bundle->getVerbose(), bundle->getForce());
173    //for (int i = 0; i < bundle->getFileSpecCount(); i++)
174    //    printf("  %d: '%s'\n", i, bundle->getFileSpecEntry(i));
175
176    switch (bundle->getCommand()) {
177    case kCommandVersion:   return doVersion(bundle);
178    case kCommandList:      return doList(bundle);
179    case kCommandDump:      return doDump(bundle);
180    case kCommandAdd:       return doAdd(bundle);
181    case kCommandRemove:    return doRemove(bundle);
182    case kCommandPackage:   return doPackage(bundle);
183    default:
184        fprintf(stderr, "%s: requested command not yet supported\n", gProgName);
185        return 1;
186    }
187}
188
189/*
190 * Parse args.
191 */
192int main(int argc, char* const argv[])
193{
194    char *prog = argv[0];
195    Bundle bundle;
196    bool wantUsage = false;
197    int result = 1;    // pessimistically assume an error.
198    int tolerance = 0;
199
200    /* default to compression */
201    bundle.setCompressionMethod(ZipEntry::kCompressDeflated);
202
203    if (argc < 2) {
204        wantUsage = true;
205        goto bail;
206    }
207
208    if (argv[1][0] == 'v')
209        bundle.setCommand(kCommandVersion);
210    else if (argv[1][0] == 'd')
211        bundle.setCommand(kCommandDump);
212    else if (argv[1][0] == 'l')
213        bundle.setCommand(kCommandList);
214    else if (argv[1][0] == 'a')
215        bundle.setCommand(kCommandAdd);
216    else if (argv[1][0] == 'r')
217        bundle.setCommand(kCommandRemove);
218    else if (argv[1][0] == 'p')
219        bundle.setCommand(kCommandPackage);
220    else {
221        fprintf(stderr, "ERROR: Unknown command '%s'\n", argv[1]);
222        wantUsage = true;
223        goto bail;
224    }
225    argc -= 2;
226    argv += 2;
227
228    /*
229     * Pull out flags.  We support "-fv" and "-f -v".
230     */
231    while (argc && argv[0][0] == '-') {
232        /* flag(s) found */
233        const char* cp = argv[0] +1;
234
235        while (*cp != '\0') {
236            switch (*cp) {
237            case 'v':
238                bundle.setVerbose(true);
239                break;
240            case 'a':
241                bundle.setAndroidList(true);
242                break;
243            case 'c':
244                argc--;
245                argv++;
246                if (!argc) {
247                    fprintf(stderr, "ERROR: No argument supplied for '-c' option\n");
248                    wantUsage = true;
249                    goto bail;
250                }
251                bundle.addConfigurations(argv[0]);
252                break;
253            case 'f':
254                bundle.setForce(true);
255                break;
256            case 'g':
257                argc--;
258                argv++;
259                if (!argc) {
260                    fprintf(stderr, "ERROR: No argument supplied for '-g' option\n");
261                    wantUsage = true;
262                    goto bail;
263                }
264                tolerance = atoi(argv[0]);
265                bundle.setGrayscaleTolerance(tolerance);
266                printf("%s: Images with deviation <= %d will be forced to grayscale.\n", prog, tolerance);
267                break;
268            case 'k':
269                bundle.setJunkPath(true);
270                break;
271            case 'm':
272                bundle.setMakePackageDirs(true);
273                break;
274#if 0
275            case 'p':
276                bundle.setPseudolocalize(true);
277                break;
278#endif
279            case 'u':
280                bundle.setUpdate(true);
281                break;
282            case 'x':
283                bundle.setExtending(true);
284                break;
285            case 'z':
286                bundle.setRequireLocalization(true);
287                break;
288            case 'j':
289                argc--;
290                argv++;
291                if (!argc) {
292                    fprintf(stderr, "ERROR: No argument supplied for '-j' option\n");
293                    wantUsage = true;
294                    goto bail;
295                }
296                convertPath(argv[0]);
297                bundle.addJarFile(argv[0]);
298                break;
299            case 'A':
300                argc--;
301                argv++;
302                if (!argc) {
303                    fprintf(stderr, "ERROR: No argument supplied for '-A' option\n");
304                    wantUsage = true;
305                    goto bail;
306                }
307                convertPath(argv[0]);
308                bundle.setAssetSourceDir(argv[0]);
309                break;
310            case 'G':
311                argc--;
312                argv++;
313                if (!argc) {
314                    fprintf(stderr, "ERROR: No argument supplied for '-G' option\n");
315                    wantUsage = true;
316                    goto bail;
317                }
318                convertPath(argv[0]);
319                bundle.setProguardFile(argv[0]);
320                break;
321            case 'I':
322                argc--;
323                argv++;
324                if (!argc) {
325                    fprintf(stderr, "ERROR: No argument supplied for '-I' option\n");
326                    wantUsage = true;
327                    goto bail;
328                }
329                convertPath(argv[0]);
330                bundle.addPackageInclude(argv[0]);
331                break;
332            case 'F':
333                argc--;
334                argv++;
335                if (!argc) {
336                    fprintf(stderr, "ERROR: No argument supplied for '-F' option\n");
337                    wantUsage = true;
338                    goto bail;
339                }
340                convertPath(argv[0]);
341                bundle.setOutputAPKFile(argv[0]);
342                break;
343            case 'J':
344                argc--;
345                argv++;
346                if (!argc) {
347                    fprintf(stderr, "ERROR: No argument supplied for '-J' option\n");
348                    wantUsage = true;
349                    goto bail;
350                }
351                convertPath(argv[0]);
352                bundle.setRClassDir(argv[0]);
353                break;
354            case 'M':
355                argc--;
356                argv++;
357                if (!argc) {
358                    fprintf(stderr, "ERROR: No argument supplied for '-M' option\n");
359                    wantUsage = true;
360                    goto bail;
361                }
362                convertPath(argv[0]);
363                bundle.setAndroidManifestFile(argv[0]);
364                break;
365            case 'P':
366                argc--;
367                argv++;
368                if (!argc) {
369                    fprintf(stderr, "ERROR: No argument supplied for '-P' option\n");
370                    wantUsage = true;
371                    goto bail;
372                }
373                convertPath(argv[0]);
374                bundle.setPublicOutputFile(argv[0]);
375                break;
376            case 'S':
377                argc--;
378                argv++;
379                if (!argc) {
380                    fprintf(stderr, "ERROR: No argument supplied for '-S' option\n");
381                    wantUsage = true;
382                    goto bail;
383                }
384                convertPath(argv[0]);
385                bundle.addResourceSourceDir(argv[0]);
386                break;
387            case '0':
388                argc--;
389                argv++;
390                if (!argc) {
391                    fprintf(stderr, "ERROR: No argument supplied for '-e' option\n");
392                    wantUsage = true;
393                    goto bail;
394                }
395                if (argv[0][0] != 0) {
396                    bundle.addNoCompressExtension(argv[0]);
397                } else {
398                    bundle.setCompressionMethod(ZipEntry::kCompressStored);
399                }
400                break;
401            case '-':
402                if (strcmp(cp, "-debug-mode") == 0) {
403                    bundle.setDebugMode(true);
404                } else if (strcmp(cp, "-min-sdk-version") == 0) {
405                    argc--;
406                    argv++;
407                    if (!argc) {
408                        fprintf(stderr, "ERROR: No argument supplied for '--min-sdk-version' option\n");
409                        wantUsage = true;
410                        goto bail;
411                    }
412                    bundle.setMinSdkVersion(argv[0]);
413                } else if (strcmp(cp, "-target-sdk-version") == 0) {
414                    argc--;
415                    argv++;
416                    if (!argc) {
417                        fprintf(stderr, "ERROR: No argument supplied for '--target-sdk-version' option\n");
418                        wantUsage = true;
419                        goto bail;
420                    }
421                    bundle.setTargetSdkVersion(argv[0]);
422                } else if (strcmp(cp, "-max-sdk-version") == 0) {
423                    argc--;
424                    argv++;
425                    if (!argc) {
426                        fprintf(stderr, "ERROR: No argument supplied for '--max-sdk-version' option\n");
427                        wantUsage = true;
428                        goto bail;
429                    }
430                    bundle.setMaxSdkVersion(argv[0]);
431                } else if (strcmp(cp, "-max-res-version") == 0) {
432                    argc--;
433                    argv++;
434                    if (!argc) {
435                        fprintf(stderr, "ERROR: No argument supplied for '--max-res-version' option\n");
436                        wantUsage = true;
437                        goto bail;
438                    }
439                    bundle.setMaxResVersion(argv[0]);
440                } else if (strcmp(cp, "-version-code") == 0) {
441                    argc--;
442                    argv++;
443                    if (!argc) {
444                        fprintf(stderr, "ERROR: No argument supplied for '--version-code' option\n");
445                        wantUsage = true;
446                        goto bail;
447                    }
448                    bundle.setVersionCode(argv[0]);
449                } else if (strcmp(cp, "-version-name") == 0) {
450                    argc--;
451                    argv++;
452                    if (!argc) {
453                        fprintf(stderr, "ERROR: No argument supplied for '--version-name' option\n");
454                        wantUsage = true;
455                        goto bail;
456                    }
457                    bundle.setVersionName(argv[0]);
458                } else if (strcmp(cp, "-values") == 0) {
459                    bundle.setValues(true);
460                } else if (strcmp(cp, "-custom-package") == 0) {
461                    argc--;
462                    argv++;
463                    if (!argc) {
464                        fprintf(stderr, "ERROR: No argument supplied for '--custom-package' option\n");
465                        wantUsage = true;
466                        goto bail;
467                    }
468                    bundle.setCustomPackage(argv[0]);
469                } else if (strcmp(cp, "-utf16") == 0) {
470                    bundle.setWantUTF16(true);
471                } else if (strcmp(cp, "-rename-manifest-package") == 0) {
472                    argc--;
473                    argv++;
474                    if (!argc) {
475                        fprintf(stderr, "ERROR: No argument supplied for '--rename-manifest-package' option\n");
476                        wantUsage = true;
477                        goto bail;
478                    }
479                    bundle.setManifestPackageNameOverride(argv[0]);
480                } else if (strcmp(cp, "-rename-instrumentation-target-package") == 0) {
481                    argc--;
482                    argv++;
483                    if (!argc) {
484                        fprintf(stderr, "ERROR: No argument supplied for '--rename-instrumentation-target-package' option\n");
485                        wantUsage = true;
486                        goto bail;
487                    }
488                    bundle.setInstrumentationPackageNameOverride(argv[0]);
489                } else if (strcmp(cp, "-auto-add-overlay") == 0) {
490                    bundle.setAutoAddOverlay(true);
491                } else if (strcmp(cp, "-product") == 0) {
492                    argc--;
493                    argv++;
494                    if (!argc) {
495                        fprintf(stderr, "ERROR: No argument supplied for '--product' option\n");
496                        wantUsage = true;
497                        goto bail;
498                    }
499                    bundle.setProduct(argv[0]);
500                } else {
501                    fprintf(stderr, "ERROR: Unknown option '-%s'\n", cp);
502                    wantUsage = true;
503                    goto bail;
504                }
505                cp += strlen(cp) - 1;
506                break;
507            default:
508                fprintf(stderr, "ERROR: Unknown flag '-%c'\n", *cp);
509                wantUsage = true;
510                goto bail;
511            }
512
513            cp++;
514        }
515        argc--;
516        argv++;
517    }
518
519    /*
520     * We're past the flags.  The rest all goes straight in.
521     */
522    bundle.setFileSpec(argv, argc);
523
524    result = handleCommand(&bundle);
525
526bail:
527    if (wantUsage) {
528        usage();
529        result = 2;
530    }
531
532    //printf("--> returning %d\n", result);
533    return result;
534}
535