Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / base / 7dd9c237785fe3e904f0c018b517e66ef3e8b462 / . / tools / aapt / AaptAssets.cpp
blob: 6a3c506ab15778fe3591a174adb6d2ada625788f [file] [log] [blame]
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1//
2// Copyright 2006 The Android Open Source Project
3//
4
5#include "AaptAssets.h"
6#include "ResourceFilter.h"
7#include "Main.h"
8
9#include <utils/misc.h>
10#include <utils/SortedVector.h>
11
12#include <ctype.h>
13#include <dirent.h>
14#include <errno.h>
15
16static const char* kDefaultLocale = "default";
17static const char* kWildcardName = "any";
18static const char* kAssetDir = "assets";
19static const char* kResourceDir = "res";
20static const char* kValuesDir = "values";
21static const char* kMipmapDir = "mipmap";
22static const char* kInvalidChars = "/\\:";
23static const size_t kMaxAssetFileName = 100;
24
25static const String8 kResString(kResourceDir);
26
27/*
28 * Names of asset files must meet the following criteria:
29 *
30 * - the filename length must be less than kMaxAssetFileName bytes long
31 * (and can't be empty)
32 * - all characters must be 7-bit printable ASCII
33 * - none of { '/' '\\' ':' }
34 *
35 * Pass in just the filename, not the full path.
36 */
37static bool validateFileName(const char* fileName)
38{
39 const char* cp = fileName;
40 size_t len = 0;
41
42 while (*cp != '\0') {
43 if ((*cp & 0x80) != 0)
44 return false; // reject high ASCII
45 if (*cp < 0x20 || *cp >= 0x7f)
46 return false; // reject control chars and 0x7f
47 if (strchr(kInvalidChars, *cp) != NULL)
48 return false; // reject path sep chars
49 cp++;
50 len++;
51 }
52
53 if (len < 1 || len > kMaxAssetFileName)
54 return false; // reject empty or too long
55
56 return true;
57}
58
59// The default to use if no other ignore pattern is defined.
60const char * const gDefaultIgnoreAssets =
61 "!.svn:!.git:!.ds_store:!*.scc:.*:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~";
62// The ignore pattern that can be passed via --ignore-assets in Main.cpp
63const char * gUserIgnoreAssets = NULL;
64
65static bool isHidden(const char *root, const char *path)
66{
67 // Patterns syntax:
68 // - Delimiter is :
69 // - Entry can start with the flag ! to avoid printing a warning
70 // about the file being ignored.
71 // - Entry can have the flag "<dir>" to match only directories
72 // or <file> to match only files. Default is to match both.
73 // - Entry can be a simplified glob "<prefix>*" or "*<suffix>"
74 // where prefix/suffix must have at least 1 character (so that
75 // we don't match a '*' catch-all pattern.)
76 // - The special filenames "." and ".." are always ignored.
77 // - Otherwise the full string is matched.
78 // - match is not case-sensitive.
79
80 if (strcmp(path, ".") == 0 || strcmp(path, "..") == 0) {
81 return true;
82 }
83
84 const char *delim = ":";
85 const char *p = gUserIgnoreAssets;
86 if (!p || !p[0]) {
87 p = getenv("ANDROID_AAPT_IGNORE");
88 }
89 if (!p || !p[0]) {
90 p = gDefaultIgnoreAssets;
91 }
92 char *patterns = strdup(p);
93
94 bool ignore = false;
95 bool chatty = true;
96 char *matchedPattern = NULL;
97
98 String8 fullPath(root);
99 fullPath.appendPath(path);
100 FileType type = getFileType(fullPath);
101
102 int plen = strlen(path);
103
104 // Note: we don't have strtok_r under mingw.
105 for(char *token = strtok(patterns, delim);
106 !ignore && token != NULL;
107 token = strtok(NULL, delim)) {
108 chatty = token[0] != '!';
109 if (!chatty) token++; // skip !
110 if (strncasecmp(token, "<dir>" , 5) == 0) {
111 if (type != kFileTypeDirectory) continue;
112 token += 5;
113 }
114 if (strncasecmp(token, "<file>", 6) == 0) {
115 if (type != kFileTypeRegular) continue;
116 token += 6;
117 }
118
119 matchedPattern = token;
120 int n = strlen(token);
121
122 if (token[0] == '*') {
123 // Match *suffix
124 token++;
125 n--;
126 if (n <= plen) {
127 ignore = strncasecmp(token, path + plen - n, n) == 0;
128 }
129 } else if (n > 1 && token[n - 1] == '*') {
130 // Match prefix*
131 ignore = strncasecmp(token, path, n - 1) == 0;
132 } else {
133 ignore = strcasecmp(token, path) == 0;
134 }
135 }
136
137 if (ignore && chatty) {
138 fprintf(stderr, " (skipping %s '%s' due to ANDROID_AAPT_IGNORE pattern '%s')\n",
139 type == kFileTypeDirectory ? "dir" : "file",
140 path,
141 matchedPattern ? matchedPattern : "");
142 }
143
144 free(patterns);
145 return ignore;
146}
147
148// =========================================================================
149// =========================================================================
150// =========================================================================
151
152status_t
153AaptGroupEntry::parseNamePart(const String8& part, int* axis, uint32_t* value)
154{
155 ResTable_config config;
156
157 // IMSI - MCC
158 if (getMccName(part.string(), &config)) {
159 *axis = AXIS_MCC;
160 *value = config.mcc;
161 return 0;
162 }
163
164 // IMSI - MNC
165 if (getMncName(part.string(), &config)) {
166 *axis = AXIS_MNC;
167 *value = config.mnc;
168 return 0;
169 }
170
171 // locale - language
172 if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
173 *axis = AXIS_LANGUAGE;
174 *value = part[1] << 8 | part[0];
175 return 0;
176 }
177
178 // locale - language_REGION
179 if (part.length() == 5 && isalpha(part[0]) && isalpha(part[1])
180 && part[2] == '_' && isalpha(part[3]) && isalpha(part[4])) {
181 *axis = AXIS_LANGUAGE;
182 *value = (part[4] << 24) | (part[3] << 16) | (part[1] << 8) | (part[0]);
183 return 0;
184 }
185
186 // layout direction
187 if (getLayoutDirectionName(part.string(), &config)) {
188 *axis = AXIS_LAYOUTDIR;
189 *value = (config.screenLayout&ResTable_config::MASK_LAYOUTDIR);
190 return 0;
191 }
192
193 // smallest screen dp width
194 if (getSmallestScreenWidthDpName(part.string(), &config)) {
195 *axis = AXIS_SMALLESTSCREENWIDTHDP;
196 *value = config.smallestScreenWidthDp;
197 return 0;
198 }
199
200 // screen dp width
201 if (getScreenWidthDpName(part.string(), &config)) {
202 *axis = AXIS_SCREENWIDTHDP;
203 *value = config.screenWidthDp;
204 return 0;
205 }
206
207 // screen dp height
208 if (getScreenHeightDpName(part.string(), &config)) {
209 *axis = AXIS_SCREENHEIGHTDP;
210 *value = config.screenHeightDp;
211 return 0;
212 }
213
214 // screen layout size
215 if (getScreenLayoutSizeName(part.string(), &config)) {
216 *axis = AXIS_SCREENLAYOUTSIZE;
217 *value = (config.screenLayout&ResTable_config::MASK_SCREENSIZE);
218 return 0;
219 }
220
221 // screen layout long
222 if (getScreenLayoutLongName(part.string(), &config)) {
223 *axis = AXIS_SCREENLAYOUTLONG;
224 *value = (config.screenLayout&ResTable_config::MASK_SCREENLONG);
225 return 0;
226 }
227
228 // orientation
229 if (getOrientationName(part.string(), &config)) {
230 *axis = AXIS_ORIENTATION;
231 *value = config.orientation;
232 return 0;
233 }
234
235 // ui mode type
236 if (getUiModeTypeName(part.string(), &config)) {
237 *axis = AXIS_UIMODETYPE;
238 *value = (config.uiMode&ResTable_config::MASK_UI_MODE_TYPE);
239 return 0;
240 }
241
242 // ui mode night
243 if (getUiModeNightName(part.string(), &config)) {
244 *axis = AXIS_UIMODENIGHT;
245 *value = (config.uiMode&ResTable_config::MASK_UI_MODE_NIGHT);
246 return 0;
247 }
248
249 // density
250 if (getDensityName(part.string(), &config)) {
251 *axis = AXIS_DENSITY;
252 *value = config.density;
253 return 0;
254 }
255
256 // touchscreen
257 if (getTouchscreenName(part.string(), &config)) {
258 *axis = AXIS_TOUCHSCREEN;
259 *value = config.touchscreen;
260 return 0;
261 }
262
263 // keyboard hidden
264 if (getKeysHiddenName(part.string(), &config)) {
265 *axis = AXIS_KEYSHIDDEN;
266 *value = config.inputFlags;
267 return 0;
268 }
269
270 // keyboard
271 if (getKeyboardName(part.string(), &config)) {
272 *axis = AXIS_KEYBOARD;
273 *value = config.keyboard;
274 return 0;
275 }
276
277 // navigation hidden
278 if (getNavHiddenName(part.string(), &config)) {
279 *axis = AXIS_NAVHIDDEN;
280 *value = config.inputFlags;
281 return 0;
282 }
283
284 // navigation
285 if (getNavigationName(part.string(), &config)) {
286 *axis = AXIS_NAVIGATION;
287 *value = config.navigation;
288 return 0;
289 }
290
291 // screen size
292 if (getScreenSizeName(part.string(), &config)) {
293 *axis = AXIS_SCREENSIZE;
294 *value = config.screenSize;
295 return 0;
296 }
297
298 // version
299 if (getVersionName(part.string(), &config)) {
300 *axis = AXIS_VERSION;
301 *value = config.version;
302 return 0;
303 }
304
305 return 1;
306}
307
308uint32_t
309AaptGroupEntry::getConfigValueForAxis(const ResTable_config& config, int axis)
310{
311 switch (axis) {
312 case AXIS_MCC:
313 return config.mcc;
314 case AXIS_MNC:
315 return config.mnc;
316 case AXIS_LANGUAGE:
317 return (((uint32_t)config.country[1]) << 24) | (((uint32_t)config.country[0]) << 16)
318 | (((uint32_t)config.language[1]) << 8) | (config.language[0]);
319 case AXIS_LAYOUTDIR:
320 return config.screenLayout&ResTable_config::MASK_LAYOUTDIR;
321 case AXIS_SCREENLAYOUTSIZE:
322 return config.screenLayout&ResTable_config::MASK_SCREENSIZE;
323 case AXIS_ORIENTATION:
324 return config.orientation;
325 case AXIS_UIMODETYPE:
326 return (config.uiMode&ResTable_config::MASK_UI_MODE_TYPE);
327 case AXIS_UIMODENIGHT:
328 return (config.uiMode&ResTable_config::MASK_UI_MODE_NIGHT);
329 case AXIS_DENSITY:
330 return config.density;
331 case AXIS_TOUCHSCREEN:
332 return config.touchscreen;
333 case AXIS_KEYSHIDDEN:
334 return config.inputFlags;
335 case AXIS_KEYBOARD:
336 return config.keyboard;
337 case AXIS_NAVIGATION:
338 return config.navigation;
339 case AXIS_SCREENSIZE:
340 return config.screenSize;
341 case AXIS_SMALLESTSCREENWIDTHDP:
342 return config.smallestScreenWidthDp;
343 case AXIS_SCREENWIDTHDP:
344 return config.screenWidthDp;
345 case AXIS_SCREENHEIGHTDP:
346 return config.screenHeightDp;
347 case AXIS_VERSION:
348 return config.version;
349 }
350 return 0;
351}
352
353bool
354AaptGroupEntry::configSameExcept(const ResTable_config& config,
355 const ResTable_config& otherConfig, int axis)
356{
357 for (int i=AXIS_START; i<=AXIS_END; i++) {
358 if (i == axis) {
359 continue;
360 }
361 if (getConfigValueForAxis(config, i) != getConfigValueForAxis(otherConfig, i)) {
362 return false;
363 }
364 }
365 return true;
366}
367
368bool
369AaptGroupEntry::initFromDirName(const char* dir, String8* resType)
370{
371 mParamsChanged = true;
372
373 Vector<String8> parts;
374
375 String8 mcc, mnc, loc, layoutsize, layoutlong, orient, den;
376 String8 touch, key, keysHidden, nav, navHidden, size, layoutDir, vers;
377 String8 uiModeType, uiModeNight, smallestwidthdp, widthdp, heightdp;
378
379 const char *p = dir;
380 const char *q;
381 while (NULL != (q = strchr(p, '-'))) {
382 String8 val(p, q-p);
383 val.toLower();
384 parts.add(val);
385 //printf("part: %s\n", parts[parts.size()-1].string());
386 p = q+1;
387 }
388 String8 val(p);
389 val.toLower();
390 parts.add(val);
391 //printf("part: %s\n", parts[parts.size()-1].string());
392
393 const int N = parts.size();
394 int index = 0;
395 String8 part = parts[index];
396
397 // resource type
398 if (!isValidResourceType(part)) {
399 return false;
400 }
401 *resType = part;
402
403 index++;
404 if (index == N) {
405 goto success;
406 }
407 part = parts[index];
408
409 // imsi - mcc
410 if (getMccName(part.string())) {
411 mcc = part;
412
413 index++;
414 if (index == N) {
415 goto success;
416 }
417 part = parts[index];
418 } else {
419 //printf("not mcc: %s\n", part.string());
420 }
421
422 // imsi - mnc
423 if (getMncName(part.string())) {
424 mnc = part;
425
426 index++;
427 if (index == N) {
428 goto success;
429 }
430 part = parts[index];
431 } else {
432 //printf("not mcc: %s\n", part.string());
433 }
434
435 // locale - language
436 if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
437 loc = part;
438
439 index++;
440 if (index == N) {
441 goto success;
442 }
443 part = parts[index];
444 } else {
445 //printf("not language: %s\n", part.string());
446 }
447
448 // locale - region
449 if (loc.length() > 0
450 && part.length() == 3 && part[0] == 'r' && part[0] && part[1]) {
451 loc += "-";
452 part.toUpper();
453 loc += part.string() + 1;
454
455 index++;
456 if (index == N) {
457 goto success;
458 }
459 part = parts[index];
460 } else {
461 //printf("not region: %s\n", part.string());
462 }
463
464 if (getLayoutDirectionName(part.string())) {
465 layoutDir = part;
466
467 index++;
468 if (index == N) {
469 goto success;
470 }
471 part = parts[index];
472 } else {
473 //printf("not layout direction: %s\n", part.string());
474 }
475
476 if (getSmallestScreenWidthDpName(part.string())) {
477 smallestwidthdp = part;
478
479 index++;
480 if (index == N) {
481 goto success;
482 }
483 part = parts[index];
484 } else {
485 //printf("not smallest screen width dp: %s\n", part.string());
486 }
487
488 if (getScreenWidthDpName(part.string())) {
489 widthdp = part;
490
491 index++;
492 if (index == N) {
493 goto success;
494 }
495 part = parts[index];
496 } else {
497 //printf("not screen width dp: %s\n", part.string());
498 }
499
500 if (getScreenHeightDpName(part.string())) {
501 heightdp = part;
502
503 index++;
504 if (index == N) {
505 goto success;
506 }
507 part = parts[index];
508 } else {
509 //printf("not screen height dp: %s\n", part.string());
510 }
511
512 if (getScreenLayoutSizeName(part.string())) {
513 layoutsize = part;
514
515 index++;
516 if (index == N) {
517 goto success;
518 }
519 part = parts[index];
520 } else {
521 //printf("not screen layout size: %s\n", part.string());
522 }
523
524 if (getScreenLayoutLongName(part.string())) {
525 layoutlong = part;
526
527 index++;
528 if (index == N) {
529 goto success;
530 }
531 part = parts[index];
532 } else {
533 //printf("not screen layout long: %s\n", part.string());
534 }
535
536 // orientation
537 if (getOrientationName(part.string())) {
538 orient = part;
539
540 index++;
541 if (index == N) {
542 goto success;
543 }
544 part = parts[index];
545 } else {
546 //printf("not orientation: %s\n", part.string());
547 }
548
549 // ui mode type
550 if (getUiModeTypeName(part.string())) {
551 uiModeType = part;
552
553 index++;
554 if (index == N) {
555 goto success;
556 }
557 part = parts[index];
558 } else {
559 //printf("not ui mode type: %s\n", part.string());
560 }
561
562 // ui mode night
563 if (getUiModeNightName(part.string())) {
564 uiModeNight = part;
565
566 index++;
567 if (index == N) {
568 goto success;
569 }
570 part = parts[index];
571 } else {
572 //printf("not ui mode night: %s\n", part.string());
573 }
574
575 // density
576 if (getDensityName(part.string())) {
577 den = part;
578
579 index++;
580 if (index == N) {
581 goto success;
582 }
583 part = parts[index];
584 } else {
585 //printf("not density: %s\n", part.string());
586 }
587
588 // touchscreen
589 if (getTouchscreenName(part.string())) {
590 touch = part;
591
592 index++;
593 if (index == N) {
594 goto success;
595 }
596 part = parts[index];
597 } else {
598 //printf("not touchscreen: %s\n", part.string());
599 }
600
601 // keyboard hidden
602 if (getKeysHiddenName(part.string())) {
603 keysHidden = part;
604
605 index++;
606 if (index == N) {
607 goto success;
608 }
609 part = parts[index];
610 } else {
611 //printf("not keysHidden: %s\n", part.string());
612 }
613
614 // keyboard
615 if (getKeyboardName(part.string())) {
616 key = part;
617
618 index++;
619 if (index == N) {
620 goto success;
621 }
622 part = parts[index];
623 } else {
624 //printf("not keyboard: %s\n", part.string());
625 }
626
627 // navigation hidden
628 if (getNavHiddenName(part.string())) {
629 navHidden = part;
630
631 index++;
632 if (index == N) {
633 goto success;
634 }
635 part = parts[index];
636 } else {
637 //printf("not navHidden: %s\n", part.string());
638 }
639
640 if (getNavigationName(part.string())) {
641 nav = part;
642
643 index++;
644 if (index == N) {
645 goto success;
646 }
647 part = parts[index];
648 } else {
649 //printf("not navigation: %s\n", part.string());
650 }
651
652 if (getScreenSizeName(part.string())) {
653 size = part;
654
655 index++;
656 if (index == N) {
657 goto success;
658 }
659 part = parts[index];
660 } else {
661 //printf("not screen size: %s\n", part.string());
662 }
663
664 if (getVersionName(part.string())) {
665 vers = part;
666
667 index++;
668 if (index == N) {
669 goto success;
670 }
671 part = parts[index];
672 } else {
673 //printf("not version: %s\n", part.string());
674 }
675
676 // if there are extra parts, it doesn't match
677 return false;
678
679success:
680 this->mcc = mcc;
681 this->mnc = mnc;
682 this->locale = loc;
683 this->screenLayoutSize = layoutsize;
684 this->screenLayoutLong = layoutlong;
685 this->smallestScreenWidthDp = smallestwidthdp;
686 this->screenWidthDp = widthdp;
687 this->screenHeightDp = heightdp;
688 this->orientation = orient;
689 this->uiModeType = uiModeType;
690 this->uiModeNight = uiModeNight;
691 this->density = den;
692 this->touchscreen = touch;
693 this->keysHidden = keysHidden;
694 this->keyboard = key;
695 this->navHidden = navHidden;
696 this->navigation = nav;
697 this->screenSize = size;
698 this->layoutDirection = layoutDir;
699 this->version = vers;
700
701 // what is this anyway?
702 this->vendor = "";
703
704 return true;
705}
706
707String8
708AaptGroupEntry::toString() const
709{
710 String8 s = this->mcc;
711 s += ",";
712 s += this->mnc;
713 s += ",";
714 s += this->locale;
715 s += ",";
716 s += layoutDirection;
717 s += ",";
718 s += smallestScreenWidthDp;
719 s += ",";
720 s += screenWidthDp;
721 s += ",";
722 s += screenHeightDp;
723 s += ",";
724 s += screenLayoutSize;
725 s += ",";
726 s += screenLayoutLong;
727 s += ",";
728 s += this->orientation;
729 s += ",";
730 s += uiModeType;
731 s += ",";
732 s += uiModeNight;
733 s += ",";
734 s += density;
735 s += ",";
736 s += touchscreen;
737 s += ",";
738 s += keysHidden;
739 s += ",";
740 s += keyboard;
741 s += ",";
742 s += navHidden;
743 s += ",";
744 s += navigation;
745 s += ",";
746 s += screenSize;
747 s += ",";
748 s += version;
749 return s;
750}
751
752String8
753AaptGroupEntry::toDirName(const String8& resType) const
754{
755 String8 s = resType;
756 if (this->mcc != "") {
757 if (s.length() > 0) {
758 s += "-";
759 }
760 s += mcc;
761 }
762 if (this->mnc != "") {
763 if (s.length() > 0) {
764 s += "-";
765 }
766 s += mnc;
767 }
768 if (this->locale != "") {
769 if (s.length() > 0) {
770 s += "-";
771 }
772 s += locale;
773 }
774 if (this->layoutDirection != "") {
775 if (s.length() > 0) {
776 s += "-";
777 }
778 s += layoutDirection;
779 }
780 if (this->smallestScreenWidthDp != "") {
781 if (s.length() > 0) {
782 s += "-";
783 }
784 s += smallestScreenWidthDp;
785 }
786 if (this->screenWidthDp != "") {
787 if (s.length() > 0) {
788 s += "-";
789 }
790 s += screenWidthDp;
791 }
792 if (this->screenHeightDp != "") {
793 if (s.length() > 0) {
794 s += "-";
795 }
796 s += screenHeightDp;
797 }
798 if (this->screenLayoutSize != "") {
799 if (s.length() > 0) {
800 s += "-";
801 }
802 s += screenLayoutSize;
803 }
804 if (this->screenLayoutLong != "") {
805 if (s.length() > 0) {
806 s += "-";
807 }
808 s += screenLayoutLong;
809 }
810 if (this->orientation != "") {
811 if (s.length() > 0) {
812 s += "-";
813 }
814 s += orientation;
815 }
816 if (this->uiModeType != "") {
817 if (s.length() > 0) {
818 s += "-";
819 }
820 s += uiModeType;
821 }
822 if (this->uiModeNight != "") {
823 if (s.length() > 0) {
824 s += "-";
825 }
826 s += uiModeNight;
827 }
828 if (this->density != "") {
829 if (s.length() > 0) {
830 s += "-";
831 }
832 s += density;
833 }
834 if (this->touchscreen != "") {
835 if (s.length() > 0) {
836 s += "-";
837 }
838 s += touchscreen;
839 }
840 if (this->keysHidden != "") {
841 if (s.length() > 0) {
842 s += "-";
843 }
844 s += keysHidden;
845 }
846 if (this->keyboard != "") {
847 if (s.length() > 0) {
848 s += "-";
849 }
850 s += keyboard;
851 }
852 if (this->navHidden != "") {
853 if (s.length() > 0) {
854 s += "-";
855 }
856 s += navHidden;
857 }
858 if (this->navigation != "") {
859 if (s.length() > 0) {
860 s += "-";
861 }
862 s += navigation;
863 }
864 if (this->screenSize != "") {
865 if (s.length() > 0) {
866 s += "-";
867 }
868 s += screenSize;
869 }
870 if (this->version != "") {
871 if (s.length() > 0) {
872 s += "-";
873 }
874 s += version;
875 }
876
877 return s;
878}
879
880bool AaptGroupEntry::getMccName(const char* name,
881 ResTable_config* out)
882{
883 if (strcmp(name, kWildcardName) == 0) {
884 if (out) out->mcc = 0;
885 return true;
886 }
887 const char* c = name;
888 if (tolower(*c) != 'm') return false;
889 c++;
890 if (tolower(*c) != 'c') return false;
891 c++;
892 if (tolower(*c) != 'c') return false;
893 c++;
894
895 const char* val = c;
896
897 while (*c >= '0' && *c <= '9') {
898 c++;
899 }
900 if (*c != 0) return false;
901 if (c-val != 3) return false;
902
903 int d = atoi(val);
904 if (d != 0) {
905 if (out) out->mcc = d;
906 return true;
907 }
908
909 return false;
910}
911
912bool AaptGroupEntry::getMncName(const char* name,
913 ResTable_config* out)
914{
915 if (strcmp(name, kWildcardName) == 0) {
916 if (out) out->mcc = 0;
917 return true;
918 }
919 const char* c = name;
920 if (tolower(*c) != 'm') return false;
921 c++;
922 if (tolower(*c) != 'n') return false;
923 c++;
924 if (tolower(*c) != 'c') return false;
925 c++;
926
927 const char* val = c;
928
929 while (*c >= '0' && *c <= '9') {
930 c++;
931 }
932 if (*c != 0) return false;
933 if (c-val == 0 || c-val > 3) return false;
934
935 if (out) {
936 out->mnc = atoi(val);
937 if (out->mnc == 0) {
938 out->mnc = ACONFIGURATION_MNC_ZERO;
939 }
940 }
941
942 return true;
943}
944
945/*
946 * Does this directory name fit the pattern of a locale dir ("en-rUS" or
947 * "default")?
948 *
949 * TODO: Should insist that the first two letters are lower case, and the
950 * second two are upper.
951 */
952bool AaptGroupEntry::getLocaleName(const char* fileName,
953 ResTable_config* out)
954{
955 if (strcmp(fileName, kWildcardName) == 0
956 || strcmp(fileName, kDefaultLocale) == 0) {
957 if (out) {
958 out->language[0] = 0;
959 out->language[1] = 0;
960 out->country[0] = 0;
961 out->country[1] = 0;
962 }
963 return true;
964 }
965
966 if (strlen(fileName) == 2 && isalpha(fileName[0]) && isalpha(fileName[1])) {
967 if (out) {
968 out->language[0] = fileName[0];
969 out->language[1] = fileName[1];
970 out->country[0] = 0;
971 out->country[1] = 0;
972 }
973 return true;
974 }
975
976 if (strlen(fileName) == 5 &&
977 isalpha(fileName[0]) &&
978 isalpha(fileName[1]) &&
979 fileName[2] == '-' &&
980 isalpha(fileName[3]) &&
981 isalpha(fileName[4])) {
982 if (out) {
983 out->language[0] = fileName[0];
984 out->language[1] = fileName[1];
985 out->country[0] = fileName[3];
986 out->country[1] = fileName[4];
987 }
988 return true;
989 }
990
991 return false;
992}
993
994bool AaptGroupEntry::getLayoutDirectionName(const char* name, ResTable_config* out)
995{
996 if (strcmp(name, kWildcardName) == 0) {
997 if (out) out->screenLayout =
998 (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR)
999 | ResTable_config::LAYOUTDIR_ANY;
1000 return true;
1001 } else if (strcmp(name, "ldltr") == 0) {
1002 if (out) out->screenLayout =
1003 (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR)
1004 | ResTable_config::LAYOUTDIR_LTR;
1005 return true;
1006 } else if (strcmp(name, "ldrtl") == 0) {
1007 if (out) out->screenLayout =
1008 (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR)
1009 | ResTable_config::LAYOUTDIR_RTL;
1010 return true;
1011 }
1012
1013 return false;
1014}
1015
1016bool AaptGroupEntry::getScreenLayoutSizeName(const char* name,
1017 ResTable_config* out)
1018{
1019 if (strcmp(name, kWildcardName) == 0) {
1020 if (out) out->screenLayout =
1021 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
1022 | ResTable_config::SCREENSIZE_ANY;
1023 return true;
1024 } else if (strcmp(name, "small") == 0) {
1025 if (out) out->screenLayout =
1026 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
1027 | ResTable_config::SCREENSIZE_SMALL;
1028 return true;
1029 } else if (strcmp(name, "normal") == 0) {
1030 if (out) out->screenLayout =
1031 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
1032 | ResTable_config::SCREENSIZE_NORMAL;
1033 return true;
1034 } else if (strcmp(name, "large") == 0) {
1035 if (out) out->screenLayout =
1036 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
1037 | ResTable_config::SCREENSIZE_LARGE;
1038 return true;
1039 } else if (strcmp(name, "xlarge") == 0) {
1040 if (out) out->screenLayout =
1041 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
1042 | ResTable_config::SCREENSIZE_XLARGE;
1043 return true;
1044 }
1045
1046 return false;
1047}
1048
1049bool AaptGroupEntry::getScreenLayoutLongName(const char* name,
1050 ResTable_config* out)
1051{
1052 if (strcmp(name, kWildcardName) == 0) {
1053 if (out) out->screenLayout =
1054 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
1055 | ResTable_config::SCREENLONG_ANY;
1056 return true;
1057 } else if (strcmp(name, "long") == 0) {
1058 if (out) out->screenLayout =
1059 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
1060 | ResTable_config::SCREENLONG_YES;
1061 return true;
1062 } else if (strcmp(name, "notlong") == 0) {
1063 if (out) out->screenLayout =
1064 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
1065 | ResTable_config::SCREENLONG_NO;
1066 return true;
1067 }
1068
1069 return false;
1070}
1071
1072bool AaptGroupEntry::getOrientationName(const char* name,
1073 ResTable_config* out)
1074{
1075 if (strcmp(name, kWildcardName) == 0) {
1076 if (out) out->orientation = out->ORIENTATION_ANY;
1077 return true;
1078 } else if (strcmp(name, "port") == 0) {
1079 if (out) out->orientation = out->ORIENTATION_PORT;
1080 return true;
1081 } else if (strcmp(name, "land") == 0) {
1082 if (out) out->orientation = out->ORIENTATION_LAND;
1083 return true;
1084 } else if (strcmp(name, "square") == 0) {
1085 if (out) out->orientation = out->ORIENTATION_SQUARE;
1086 return true;
1087 }
1088
1089 return false;
1090}
1091
1092bool AaptGroupEntry::getUiModeTypeName(const char* name,
1093 ResTable_config* out)
1094{
1095 if (strcmp(name, kWildcardName) == 0) {
1096 if (out) out->uiMode =
1097 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
1098 | ResTable_config::UI_MODE_TYPE_ANY;
1099 return true;
1100 } else if (strcmp(name, "desk") == 0) {
1101 if (out) out->uiMode =
1102 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
1103 | ResTable_config::UI_MODE_TYPE_DESK;
1104 return true;
1105 } else if (strcmp(name, "car") == 0) {
1106 if (out) out->uiMode =
1107 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
1108 | ResTable_config::UI_MODE_TYPE_CAR;
1109 return true;
1110 } else if (strcmp(name, "television") == 0) {
1111 if (out) out->uiMode =
1112 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
1113 | ResTable_config::UI_MODE_TYPE_TELEVISION;
1114 return true;
1115 } else if (strcmp(name, "appliance") == 0) {
1116 if (out) out->uiMode =
1117 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
1118 | ResTable_config::UI_MODE_TYPE_APPLIANCE;
1119 return true;
1120 }
1121
1122 return false;
1123}
1124
1125bool AaptGroupEntry::getUiModeNightName(const char* name,
1126 ResTable_config* out)
1127{
1128 if (strcmp(name, kWildcardName) == 0) {
1129 if (out) out->uiMode =
1130 (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
1131 | ResTable_config::UI_MODE_NIGHT_ANY;
1132 return true;
1133 } else if (strcmp(name, "night") == 0) {
1134 if (out) out->uiMode =
1135 (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
1136 | ResTable_config::UI_MODE_NIGHT_YES;
1137 return true;
1138 } else if (strcmp(name, "notnight") == 0) {
1139 if (out) out->uiMode =
1140 (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
1141 | ResTable_config::UI_MODE_NIGHT_NO;
1142 return true;
1143 }
1144
1145 return false;
1146}
1147
1148bool AaptGroupEntry::getDensityName(const char* name,
1149 ResTable_config* out)
1150{
1151 if (strcmp(name, kWildcardName) == 0) {
1152 if (out) out->density = ResTable_config::DENSITY_DEFAULT;
1153 return true;
1154 }
1155
1156 if (strcmp(name, "nodpi") == 0) {
1157 if (out) out->density = ResTable_config::DENSITY_NONE;
1158 return true;
1159 }
1160
1161 if (strcmp(name, "ldpi") == 0) {
1162 if (out) out->density = ResTable_config::DENSITY_LOW;
1163 return true;
1164 }
1165
1166 if (strcmp(name, "mdpi") == 0) {
1167 if (out) out->density = ResTable_config::DENSITY_MEDIUM;
1168 return true;
1169 }
1170
1171 if (strcmp(name, "tvdpi") == 0) {
1172 if (out) out->density = ResTable_config::DENSITY_TV;
1173 return true;
1174 }
1175
1176 if (strcmp(name, "hdpi") == 0) {
1177 if (out) out->density = ResTable_config::DENSITY_HIGH;
1178 return true;
1179 }
1180
1181 if (strcmp(name, "xhdpi") == 0) {
1182 if (out) out->density = ResTable_config::DENSITY_XHIGH;
1183 return true;
1184 }
1185
1186 if (strcmp(name, "xxhdpi") == 0) {
1187 if (out) out->density = ResTable_config::DENSITY_XXHIGH;
1188 return true;
1189 }
1190
1191 if (strcmp(name, "xxxhdpi") == 0) {
1192 if (out) out->density = ResTable_config::DENSITY_XXXHIGH;
1193 return true;
1194 }
1195
1196 char* c = (char*)name;
1197 while (*c >= '0' && *c <= '9') {
1198 c++;
1199 }
1200
1201 // check that we have 'dpi' after the last digit.
1202 if (toupper(c[0]) != 'D' ||
1203 toupper(c[1]) != 'P' ||
1204 toupper(c[2]) != 'I' ||
1205 c[3] != 0) {
1206 return false;
1207 }
1208
1209 // temporarily replace the first letter with \0 to
1210 // use atoi.
1211 char tmp = c[0];
1212 c[0] = '\0';
1213
1214 int d = atoi(name);
1215 c[0] = tmp;
1216
1217 if (d != 0) {
1218 if (out) out->density = d;
1219 return true;
1220 }
1221
1222 return false;
1223}
1224
1225bool AaptGroupEntry::getTouchscreenName(const char* name,
1226 ResTable_config* out)
1227{
1228 if (strcmp(name, kWildcardName) == 0) {
1229 if (out) out->touchscreen = out->TOUCHSCREEN_ANY;
1230 return true;
1231 } else if (strcmp(name, "notouch") == 0) {
1232 if (out) out->touchscreen = out->TOUCHSCREEN_NOTOUCH;
1233 return true;
1234 } else if (strcmp(name, "stylus") == 0) {
1235 if (out) out->touchscreen = out->TOUCHSCREEN_STYLUS;
1236 return true;
1237 } else if (strcmp(name, "finger") == 0) {
1238 if (out) out->touchscreen = out->TOUCHSCREEN_FINGER;
1239 return true;
1240 }
1241
1242 return false;
1243}
1244
1245bool AaptGroupEntry::getKeysHiddenName(const char* name,
1246 ResTable_config* out)
1247{
1248 uint8_t mask = 0;
1249 uint8_t value = 0;
1250 if (strcmp(name, kWildcardName) == 0) {
1251 mask = ResTable_config::MASK_KEYSHIDDEN;
1252 value = ResTable_config::KEYSHIDDEN_ANY;
1253 } else if (strcmp(name, "keysexposed") == 0) {
1254 mask = ResTable_config::MASK_KEYSHIDDEN;
1255 value = ResTable_config::KEYSHIDDEN_NO;
1256 } else if (strcmp(name, "keyshidden") == 0) {
1257 mask = ResTable_config::MASK_KEYSHIDDEN;
1258 value = ResTable_config::KEYSHIDDEN_YES;
1259 } else if (strcmp(name, "keyssoft") == 0) {
1260 mask = ResTable_config::MASK_KEYSHIDDEN;
1261 value = ResTable_config::KEYSHIDDEN_SOFT;
1262 }
1263
1264 if (mask != 0) {
1265 if (out) out->inputFlags = (out->inputFlags&~mask) | value;
1266 return true;
1267 }
1268
1269 return false;
1270}
1271
1272bool AaptGroupEntry::getKeyboardName(const char* name,
1273 ResTable_config* out)
1274{
1275 if (strcmp(name, kWildcardName) == 0) {
1276 if (out) out->keyboard = out->KEYBOARD_ANY;
1277 return true;
1278 } else if (strcmp(name, "nokeys") == 0) {
1279 if (out) out->keyboard = out->KEYBOARD_NOKEYS;
1280 return true;
1281 } else if (strcmp(name, "qwerty") == 0) {
1282 if (out) out->keyboard = out->KEYBOARD_QWERTY;
1283 return true;
1284 } else if (strcmp(name, "12key") == 0) {
1285 if (out) out->keyboard = out->KEYBOARD_12KEY;
1286 return true;
1287 }
1288
1289 return false;
1290}
1291
1292bool AaptGroupEntry::getNavHiddenName(const char* name,
1293 ResTable_config* out)
1294{
1295 uint8_t mask = 0;
1296 uint8_t value = 0;
1297 if (strcmp(name, kWildcardName) == 0) {
1298 mask = ResTable_config::MASK_NAVHIDDEN;
1299 value = ResTable_config::NAVHIDDEN_ANY;
1300 } else if (strcmp(name, "navexposed") == 0) {
1301 mask = ResTable_config::MASK_NAVHIDDEN;
1302 value = ResTable_config::NAVHIDDEN_NO;
1303 } else if (strcmp(name, "navhidden") == 0) {
1304 mask = ResTable_config::MASK_NAVHIDDEN;
1305 value = ResTable_config::NAVHIDDEN_YES;
1306 }
1307
1308 if (mask != 0) {
1309 if (out) out->inputFlags = (out->inputFlags&~mask) | value;
1310 return true;
1311 }
1312
1313 return false;
1314}
1315
1316bool AaptGroupEntry::getNavigationName(const char* name,
1317 ResTable_config* out)
1318{
1319 if (strcmp(name, kWildcardName) == 0) {
1320 if (out) out->navigation = out->NAVIGATION_ANY;
1321 return true;
1322 } else if (strcmp(name, "nonav") == 0) {
1323 if (out) out->navigation = out->NAVIGATION_NONAV;
1324 return true;
1325 } else if (strcmp(name, "dpad") == 0) {
1326 if (out) out->navigation = out->NAVIGATION_DPAD;
1327 return true;
1328 } else if (strcmp(name, "trackball") == 0) {
1329 if (out) out->navigation = out->NAVIGATION_TRACKBALL;
1330 return true;
1331 } else if (strcmp(name, "wheel") == 0) {
1332 if (out) out->navigation = out->NAVIGATION_WHEEL;
1333 return true;
1334 }
1335
1336 return false;
1337}
1338
1339bool AaptGroupEntry::getScreenSizeName(const char* name, ResTable_config* out)
1340{
1341 if (strcmp(name, kWildcardName) == 0) {
1342 if (out) {
1343 out->screenWidth = out->SCREENWIDTH_ANY;
1344 out->screenHeight = out->SCREENHEIGHT_ANY;
1345 }
1346 return true;
1347 }
1348
1349 const char* x = name;
1350 while (*x >= '0' && *x <= '9') x++;
1351 if (x == name || *x != 'x') return false;
1352 String8 xName(name, x-name);
1353 x++;
1354
1355 const char* y = x;
1356 while (*y >= '0' && *y <= '9') y++;
1357 if (y == name || *y != 0) return false;
1358 String8 yName(x, y-x);
1359
1360 uint16_t w = (uint16_t)atoi(xName.string());
1361 uint16_t h = (uint16_t)atoi(yName.string());
1362 if (w < h) {
1363 return false;
1364 }
1365
1366 if (out) {
1367 out->screenWidth = w;
1368 out->screenHeight = h;
1369 }
1370
1371 return true;
1372}
1373
1374bool AaptGroupEntry::getSmallestScreenWidthDpName(const char* name, ResTable_config* out)
1375{
1376 if (strcmp(name, kWildcardName) == 0) {
1377 if (out) {
1378 out->smallestScreenWidthDp = out->SCREENWIDTH_ANY;
1379 }
1380 return true;
1381 }
1382
1383 if (*name != 's') return false;
1384 name++;
1385 if (*name != 'w') return false;
1386 name++;
1387 const char* x = name;
1388 while (*x >= '0' && *x <= '9') x++;
1389 if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1390 String8 xName(name, x-name);
1391
1392 if (out) {
1393 out->smallestScreenWidthDp = (uint16_t)atoi(xName.string());
1394 }
1395
1396 return true;
1397}
1398
1399bool AaptGroupEntry::getScreenWidthDpName(const char* name, ResTable_config* out)
1400{
1401 if (strcmp(name, kWildcardName) == 0) {
1402 if (out) {
1403 out->screenWidthDp = out->SCREENWIDTH_ANY;
1404 }
1405 return true;
1406 }
1407
1408 if (*name != 'w') return false;
1409 name++;
1410 const char* x = name;
1411 while (*x >= '0' && *x <= '9') x++;
1412 if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1413 String8 xName(name, x-name);
1414
1415 if (out) {
1416 out->screenWidthDp = (uint16_t)atoi(xName.string());
1417 }
1418
1419 return true;
1420}
1421
1422bool AaptGroupEntry::getScreenHeightDpName(const char* name, ResTable_config* out)
1423{
1424 if (strcmp(name, kWildcardName) == 0) {
1425 if (out) {
1426 out->screenHeightDp = out->SCREENWIDTH_ANY;
1427 }
1428 return true;
1429 }
1430
1431 if (*name != 'h') return false;
1432 name++;
1433 const char* x = name;
1434 while (*x >= '0' && *x <= '9') x++;
1435 if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1436 String8 xName(name, x-name);
1437
1438 if (out) {
1439 out->screenHeightDp = (uint16_t)atoi(xName.string());
1440 }
1441
1442 return true;
1443}
1444
1445bool AaptGroupEntry::getVersionName(const char* name, ResTable_config* out)
1446{
1447 if (strcmp(name, kWildcardName) == 0) {
1448 if (out) {
1449 out->sdkVersion = out->SDKVERSION_ANY;
1450 out->minorVersion = out->MINORVERSION_ANY;
1451 }
1452 return true;
1453 }
1454
1455 if (*name != 'v') {
1456 return false;
1457 }
1458
1459 name++;
1460 const char* s = name;
1461 while (*s >= '0' && *s <= '9') s++;
1462 if (s == name || *s != 0) return false;
1463 String8 sdkName(name, s-name);
1464
1465 if (out) {
1466 out->sdkVersion = (uint16_t)atoi(sdkName.string());
1467 out->minorVersion = 0;
1468 }
1469
1470 return true;
1471}
1472
1473int AaptGroupEntry::compare(const AaptGroupEntry& o) const
1474{
1475 int v = mcc.compare(o.mcc);
1476 if (v == 0) v = mnc.compare(o.mnc);
1477 if (v == 0) v = locale.compare(o.locale);
1478 if (v == 0) v = layoutDirection.compare(o.layoutDirection);
1479 if (v == 0) v = vendor.compare(o.vendor);
1480 if (v == 0) v = smallestScreenWidthDp.compare(o.smallestScreenWidthDp);
1481 if (v == 0) v = screenWidthDp.compare(o.screenWidthDp);
1482 if (v == 0) v = screenHeightDp.compare(o.screenHeightDp);
1483 if (v == 0) v = screenLayoutSize.compare(o.screenLayoutSize);
1484 if (v == 0) v = screenLayoutLong.compare(o.screenLayoutLong);
1485 if (v == 0) v = orientation.compare(o.orientation);
1486 if (v == 0) v = uiModeType.compare(o.uiModeType);
1487 if (v == 0) v = uiModeNight.compare(o.uiModeNight);
1488 if (v == 0) v = density.compare(o.density);
1489 if (v == 0) v = touchscreen.compare(o.touchscreen);
1490 if (v == 0) v = keysHidden.compare(o.keysHidden);
1491 if (v == 0) v = keyboard.compare(o.keyboard);
1492 if (v == 0) v = navHidden.compare(o.navHidden);
1493 if (v == 0) v = navigation.compare(o.navigation);
1494 if (v == 0) v = screenSize.compare(o.screenSize);
1495 if (v == 0) v = version.compare(o.version);
1496 return v;
1497}
1498
1499const ResTable_config& AaptGroupEntry::toParams() const
1500{
1501 if (!mParamsChanged) {
1502 return mParams;
1503 }
1504
1505 mParamsChanged = false;
1506 ResTable_config& params(mParams);
1507 memset(&params, 0, sizeof(params));
1508 getMccName(mcc.string(), &params);
1509 getMncName(mnc.string(), &params);
1510 getLocaleName(locale.string(), &params);
1511 getLayoutDirectionName(layoutDirection.string(), &params);
1512 getSmallestScreenWidthDpName(smallestScreenWidthDp.string(), &params);
1513 getScreenWidthDpName(screenWidthDp.string(), &params);
1514 getScreenHeightDpName(screenHeightDp.string(), &params);
1515 getScreenLayoutSizeName(screenLayoutSize.string(), &params);
1516 getScreenLayoutLongName(screenLayoutLong.string(), &params);
1517 getOrientationName(orientation.string(), &params);
1518 getUiModeTypeName(uiModeType.string(), &params);
1519 getUiModeNightName(uiModeNight.string(), &params);
1520 getDensityName(density.string(), &params);
1521 getTouchscreenName(touchscreen.string(), &params);
1522 getKeysHiddenName(keysHidden.string(), &params);
1523 getKeyboardName(keyboard.string(), &params);
1524 getNavHiddenName(navHidden.string(), &params);
1525 getNavigationName(navigation.string(), &params);
1526 getScreenSizeName(screenSize.string(), &params);
1527 getVersionName(version.string(), &params);
1528
1529 // Fix up version number based on specified parameters.
1530 int minSdk = 0;
1531 if (params.smallestScreenWidthDp != ResTable_config::SCREENWIDTH_ANY
1532 || params.screenWidthDp != ResTable_config::SCREENWIDTH_ANY
1533 || params.screenHeightDp != ResTable_config::SCREENHEIGHT_ANY) {
1534 minSdk = SDK_HONEYCOMB_MR2;
1535 } else if ((params.uiMode&ResTable_config::MASK_UI_MODE_TYPE)
1536 != ResTable_config::UI_MODE_TYPE_ANY
1537 || (params.uiMode&ResTable_config::MASK_UI_MODE_NIGHT)
1538 != ResTable_config::UI_MODE_NIGHT_ANY) {
1539 minSdk = SDK_FROYO;
1540 } else if ((params.screenLayout&ResTable_config::MASK_SCREENSIZE)
1541 != ResTable_config::SCREENSIZE_ANY
1542 || (params.screenLayout&ResTable_config::MASK_SCREENLONG)
1543 != ResTable_config::SCREENLONG_ANY
1544 || params.density != ResTable_config::DENSITY_DEFAULT) {
1545 minSdk = SDK_DONUT;
1546 }
1547
1548 if (minSdk > params.sdkVersion) {
1549 params.sdkVersion = minSdk;
1550 }
1551
1552 return params;
1553}
1554
1555// =========================================================================
1556// =========================================================================
1557// =========================================================================
1558
1559void* AaptFile::editData(size_t size)
1560{
1561 if (size <= mBufferSize) {
1562 mDataSize = size;
1563 return mData;
1564 }
1565 size_t allocSize = (size*3)/2;
1566 void* buf = realloc(mData, allocSize);
1567 if (buf == NULL) {
1568 return NULL;
1569 }
1570 mData = buf;
1571 mDataSize = size;
1572 mBufferSize = allocSize;
1573 return buf;
1574}
1575
1576void* AaptFile::editData(size_t* outSize)
1577{
1578 if (outSize) {
1579 *outSize = mDataSize;
1580 }
1581 return mData;
1582}
1583
1584void* AaptFile::padData(size_t wordSize)
1585{
1586 const size_t extra = mDataSize%wordSize;
1587 if (extra == 0) {
1588 return mData;
1589 }
1590
1591 size_t initial = mDataSize;
1592 void* data = editData(initial+(wordSize-extra));
1593 if (data != NULL) {
1594 memset(((uint8_t*)data) + initial, 0, wordSize-extra);
1595 }
1596 return data;
1597}
1598
1599status_t AaptFile::writeData(const void* data, size_t size)
1600{
1601 size_t end = mDataSize;
1602 size_t total = size + end;
1603 void* buf = editData(total);
1604 if (buf == NULL) {
1605 return UNKNOWN_ERROR;
1606 }
1607 memcpy(((char*)buf)+end, data, size);
1608 return NO_ERROR;
1609}
1610
1611void AaptFile::clearData()
1612{
1613 if (mData != NULL) free(mData);
1614 mData = NULL;
1615 mDataSize = 0;
1616 mBufferSize = 0;
1617}
1618
1619String8 AaptFile::getPrintableSource() const
1620{
1621 if (hasData()) {
1622 String8 name(mGroupEntry.toDirName(String8()));
1623 name.appendPath(mPath);
1624 name.append(" #generated");
1625 return name;
1626 }
1627 return mSourceFile;
1628}
1629
1630// =========================================================================
1631// =========================================================================
1632// =========================================================================
1633
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1634status_t AaptGroup::addFile(const sp<AaptFile>& file, const bool overwriteDuplicate)
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1635{
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1636 ssize_t index = mFiles.indexOfKey(file->getGroupEntry());
1637 if (index >= 0 && overwriteDuplicate) {
1638 fprintf(stderr, "warning: overwriting '%s' with '%s'\n",
1639 mFiles[index]->getSourceFile().string(),
1640 file->getSourceFile().string());
1641 removeFile(index);
1642 index = -1;
1643 }
1644
1645 if (index < 0) {
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1646 file->mPath = mPath;
1647 mFiles.add(file->getGroupEntry(), file);
1648 return NO_ERROR;
1649 }
1650
1651#if 0
1652 printf("Error adding file %s: group %s already exists in leaf=%s path=%s\n",
1653 file->getSourceFile().string(),
1654 file->getGroupEntry().toDirName(String8()).string(),
1655 mLeaf.string(), mPath.string());
1656#endif
1657
1658 SourcePos(file->getSourceFile(), -1).error("Duplicate file.\n%s: Original is here.",
1659 getPrintableSource().string());
1660 return UNKNOWN_ERROR;
1661}
1662
1663void AaptGroup::removeFile(size_t index)
1664{
1665 mFiles.removeItemsAt(index);
1666}
1667
1668void AaptGroup::print(const String8& prefix) const
1669{
1670 printf("%s%s\n", prefix.string(), getPath().string());
1671 const size_t N=mFiles.size();
1672 size_t i;
1673 for (i=0; i<N; i++) {
1674 sp<AaptFile> file = mFiles.valueAt(i);
1675 const AaptGroupEntry& e = file->getGroupEntry();
1676 if (file->hasData()) {
1677 printf("%s Gen: (%s) %d bytes\n", prefix.string(), e.toDirName(String8()).string(),
1678 (int)file->getSize());
1679 } else {
1680 printf("%s Src: (%s) %s\n", prefix.string(), e.toDirName(String8()).string(),
1681 file->getPrintableSource().string());
1682 }
1683 //printf("%s File Group Entry: %s\n", prefix.string(),
1684 // file->getGroupEntry().toDirName(String8()).string());
1685 }
1686}
1687
1688String8 AaptGroup::getPrintableSource() const
1689{
1690 if (mFiles.size() > 0) {
1691 // Arbitrarily pull the first source file out of the list.
1692 return mFiles.valueAt(0)->getPrintableSource();
1693 }
1694
1695 // Should never hit this case, but to be safe...
1696 return getPath();
1697
1698}
1699
1700// =========================================================================
1701// =========================================================================
1702// =========================================================================
1703
1704status_t AaptDir::addFile(const String8& name, const sp<AaptGroup>& file)
1705{
1706 if (mFiles.indexOfKey(name) >= 0) {
1707 return ALREADY_EXISTS;
1708 }
1709 mFiles.add(name, file);
1710 return NO_ERROR;
1711}
1712
1713status_t AaptDir::addDir(const String8& name, const sp<AaptDir>& dir)
1714{
1715 if (mDirs.indexOfKey(name) >= 0) {
1716 return ALREADY_EXISTS;
1717 }
1718 mDirs.add(name, dir);
1719 return NO_ERROR;
1720}
1721
1722sp<AaptDir> AaptDir::makeDir(const String8& path)
1723{
1724 String8 name;
1725 String8 remain = path;
1726
1727 sp<AaptDir> subdir = this;
1728 while (name = remain.walkPath(&remain), remain != "") {
1729 subdir = subdir->makeDir(name);
1730 }
1731
1732 ssize_t i = subdir->mDirs.indexOfKey(name);
1733 if (i >= 0) {
1734 return subdir->mDirs.valueAt(i);
1735 }
1736 sp<AaptDir> dir = new AaptDir(name, subdir->mPath.appendPathCopy(name));
1737 subdir->mDirs.add(name, dir);
1738 return dir;
1739}
1740
1741void AaptDir::removeFile(const String8& name)
1742{
1743 mFiles.removeItem(name);
1744}
1745
1746void AaptDir::removeDir(const String8& name)
1747{
1748 mDirs.removeItem(name);
1749}
1750
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1751status_t AaptDir::addLeafFile(const String8& leafName, const sp<AaptFile>& file,
1752 const bool overwrite)
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1753{
1754 sp<AaptGroup> group;
1755 if (mFiles.indexOfKey(leafName) >= 0) {
1756 group = mFiles.valueFor(leafName);
1757 } else {
1758 group = new AaptGroup(leafName, mPath.appendPathCopy(leafName));
1759 mFiles.add(leafName, group);
1760 }
1761
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1762 return group->addFile(file, overwrite);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1763}
1764
1765ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
1766 const AaptGroupEntry& kind, const String8& resType,
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1767 sp<FilePathStore>& fullResPaths, const bool overwrite)
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1768{
1769 Vector<String8> fileNames;
1770 {
1771 DIR* dir = NULL;
1772
1773 dir = opendir(srcDir.string());
1774 if (dir == NULL) {
1775 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
1776 return UNKNOWN_ERROR;
1777 }
1778
1779 /*
1780 * Slurp the filenames out of the directory.
1781 */
1782 while (1) {
1783 struct dirent* entry;
1784
1785 entry = readdir(dir);
1786 if (entry == NULL)
1787 break;
1788
1789 if (isHidden(srcDir.string(), entry->d_name))
1790 continue;
1791
1792 String8 name(entry->d_name);
1793 fileNames.add(name);
1794 // Add fully qualified path for dependency purposes
1795 // if we're collecting them
1796 if (fullResPaths != NULL) {
1797 fullResPaths->add(srcDir.appendPathCopy(name));
1798 }
1799 }
1800 closedir(dir);
1801 }
1802
1803 ssize_t count = 0;
1804
1805 /*
1806 * Stash away the files and recursively descend into subdirectories.
1807 */
1808 const size_t N = fileNames.size();
1809 size_t i;
1810 for (i = 0; i < N; i++) {
1811 String8 pathName(srcDir);
1812 FileType type;
1813
1814 pathName.appendPath(fileNames[i].string());
1815 type = getFileType(pathName.string());
1816 if (type == kFileTypeDirectory) {
1817 sp<AaptDir> subdir;
1818 bool notAdded = false;
1819 if (mDirs.indexOfKey(fileNames[i]) >= 0) {
1820 subdir = mDirs.valueFor(fileNames[i]);
1821 } else {
1822 subdir = new AaptDir(fileNames[i], mPath.appendPathCopy(fileNames[i]));
1823 notAdded = true;
1824 }
1825 ssize_t res = subdir->slurpFullTree(bundle, pathName, kind,
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1826 resType, fullResPaths, overwrite);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1827 if (res < NO_ERROR) {
1828 return res;
1829 }
1830 if (res > 0 && notAdded) {
1831 mDirs.add(fileNames[i], subdir);
1832 }
1833 count += res;
1834 } else if (type == kFileTypeRegular) {
1835 sp<AaptFile> file = new AaptFile(pathName, kind, resType);
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]1836 status_t err = addLeafFile(fileNames[i], file, overwrite);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]1837 if (err != NO_ERROR) {
1838 return err;
1839 }
1840
1841 count++;
1842
1843 } else {
1844 if (bundle->getVerbose())
1845 printf(" (ignoring non-file/dir '%s')\n", pathName.string());
1846 }
1847 }
1848
1849 return count;
1850}
1851
1852status_t AaptDir::validate() const
1853{
1854 const size_t NF = mFiles.size();
1855 const size_t ND = mDirs.size();
1856 size_t i;
1857 for (i = 0; i < NF; i++) {
1858 if (!validateFileName(mFiles.valueAt(i)->getLeaf().string())) {
1859 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1860 "Invalid filename. Unable to add.");
1861 return UNKNOWN_ERROR;
1862 }
1863
1864 size_t j;
1865 for (j = i+1; j < NF; j++) {
1866 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1867 mFiles.valueAt(j)->getLeaf().string()) == 0) {
1868 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1869 "File is case-insensitive equivalent to: %s",
1870 mFiles.valueAt(j)->getPrintableSource().string());
1871 return UNKNOWN_ERROR;
1872 }
1873
1874 // TODO: if ".gz", check for non-.gz; if non-, check for ".gz"
1875 // (this is mostly caught by the "marked" stuff, below)
1876 }
1877
1878 for (j = 0; j < ND; j++) {
1879 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1880 mDirs.valueAt(j)->getLeaf().string()) == 0) {
1881 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1882 "File conflicts with dir from: %s",
1883 mDirs.valueAt(j)->getPrintableSource().string());
1884 return UNKNOWN_ERROR;
1885 }
1886 }
1887 }
1888
1889 for (i = 0; i < ND; i++) {
1890 if (!validateFileName(mDirs.valueAt(i)->getLeaf().string())) {
1891 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1892 "Invalid directory name, unable to add.");
1893 return UNKNOWN_ERROR;
1894 }
1895
1896 size_t j;
1897 for (j = i+1; j < ND; j++) {
1898 if (strcasecmp(mDirs.valueAt(i)->getLeaf().string(),
1899 mDirs.valueAt(j)->getLeaf().string()) == 0) {
1900 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1901 "Directory is case-insensitive equivalent to: %s",
1902 mDirs.valueAt(j)->getPrintableSource().string());
1903 return UNKNOWN_ERROR;
1904 }
1905 }
1906
1907 status_t err = mDirs.valueAt(i)->validate();
1908 if (err != NO_ERROR) {
1909 return err;
1910 }
1911 }
1912
1913 return NO_ERROR;
1914}
1915
1916void AaptDir::print(const String8& prefix) const
1917{
1918 const size_t ND=getDirs().size();
1919 size_t i;
1920 for (i=0; i<ND; i++) {
1921 getDirs().valueAt(i)->print(prefix);
1922 }
1923
1924 const size_t NF=getFiles().size();
1925 for (i=0; i<NF; i++) {
1926 getFiles().valueAt(i)->print(prefix);
1927 }
1928}
1929
1930String8 AaptDir::getPrintableSource() const
1931{
1932 if (mFiles.size() > 0) {
1933 // Arbitrarily pull the first file out of the list as the source dir.
1934 return mFiles.valueAt(0)->getPrintableSource().getPathDir();
1935 }
1936 if (mDirs.size() > 0) {
1937 // Or arbitrarily pull the first dir out of the list as the source dir.
1938 return mDirs.valueAt(0)->getPrintableSource().getPathDir();
1939 }
1940
1941 // Should never hit this case, but to be safe...
1942 return mPath;
1943
1944}
1945
1946// =========================================================================
1947// =========================================================================
1948// =========================================================================
1949
1950status_t AaptSymbols::applyJavaSymbols(const sp<AaptSymbols>& javaSymbols)
1951{
1952 status_t err = NO_ERROR;
1953 size_t N = javaSymbols->mSymbols.size();
1954 for (size_t i=0; i<N; i++) {
1955 const String8& name = javaSymbols->mSymbols.keyAt(i);
1956 const AaptSymbolEntry& entry = javaSymbols->mSymbols.valueAt(i);
1957 ssize_t pos = mSymbols.indexOfKey(name);
1958 if (pos < 0) {
1959 entry.sourcePos.error("Symbol '%s' declared with <java-symbol> not defined\n", name.string());
1960 err = UNKNOWN_ERROR;
1961 continue;
1962 }
1963 //printf("**** setting symbol #%d/%d %s to isJavaSymbol=%d\n",
1964 // i, N, name.string(), entry.isJavaSymbol ? 1 : 0);
1965 mSymbols.editValueAt(pos).isJavaSymbol = entry.isJavaSymbol;
1966 }
1967
1968 N = javaSymbols->mNestedSymbols.size();
1969 for (size_t i=0; i<N; i++) {
1970 const String8& name = javaSymbols->mNestedSymbols.keyAt(i);
1971 const sp<AaptSymbols>& symbols = javaSymbols->mNestedSymbols.valueAt(i);
1972 ssize_t pos = mNestedSymbols.indexOfKey(name);
1973 if (pos < 0) {
1974 SourcePos pos;
1975 pos.error("Java symbol dir %s not defined\n", name.string());
1976 err = UNKNOWN_ERROR;
1977 continue;
1978 }
1979 //printf("**** applying java symbols in dir %s\n", name.string());
1980 status_t myerr = mNestedSymbols.valueAt(pos)->applyJavaSymbols(symbols);
1981 if (myerr != NO_ERROR) {
1982 err = myerr;
1983 }
1984 }
1985
1986 return err;
1987}
1988
1989// =========================================================================
1990// =========================================================================
1991// =========================================================================
1992
1993AaptAssets::AaptAssets()
1994 : AaptDir(String8(), String8()),
1995 mChanged(false), mHaveIncludedAssets(false), mRes(NULL)
1996{
1997}
1998
1999const SortedVector<AaptGroupEntry>& AaptAssets::getGroupEntries() const {
2000 if (mChanged) {
2001 }
2002 return mGroupEntries;
2003}
2004
2005status_t AaptAssets::addFile(const String8& name, const sp<AaptGroup>& file)
2006{
2007 mChanged = true;
2008 return AaptDir::addFile(name, file);
2009}
2010
2011sp<AaptFile> AaptAssets::addFile(
2012 const String8& filePath, const AaptGroupEntry& entry,
2013 const String8& srcDir, sp<AaptGroup>* outGroup,
2014 const String8& resType)
2015{
2016 sp<AaptDir> dir = this;
2017 sp<AaptGroup> group;
2018 sp<AaptFile> file;
2019 String8 root, remain(filePath), partialPath;
2020 while (remain.length() > 0) {
2021 root = remain.walkPath(&remain);
2022 partialPath.appendPath(root);
2023
2024 const String8 rootStr(root);
2025
2026 if (remain.length() == 0) {
2027 ssize_t i = dir->getFiles().indexOfKey(rootStr);
2028 if (i >= 0) {
2029 group = dir->getFiles().valueAt(i);
2030 } else {
2031 group = new AaptGroup(rootStr, filePath);
2032 status_t res = dir->addFile(rootStr, group);
2033 if (res != NO_ERROR) {
2034 return NULL;
2035 }
2036 }
2037 file = new AaptFile(srcDir.appendPathCopy(filePath), entry, resType);
2038 status_t res = group->addFile(file);
2039 if (res != NO_ERROR) {
2040 return NULL;
2041 }
2042 break;
2043
2044 } else {
2045 ssize_t i = dir->getDirs().indexOfKey(rootStr);
2046 if (i >= 0) {
2047 dir = dir->getDirs().valueAt(i);
2048 } else {
2049 sp<AaptDir> subdir = new AaptDir(rootStr, partialPath);
2050 status_t res = dir->addDir(rootStr, subdir);
2051 if (res != NO_ERROR) {
2052 return NULL;
2053 }
2054 dir = subdir;
2055 }
2056 }
2057 }
2058
2059 mGroupEntries.add(entry);
2060 if (outGroup) *outGroup = group;
2061 return file;
2062}
2063
2064void AaptAssets::addResource(const String8& leafName, const String8& path,
2065 const sp<AaptFile>& file, const String8& resType)
2066{
2067 sp<AaptDir> res = AaptDir::makeDir(kResString);
2068 String8 dirname = file->getGroupEntry().toDirName(resType);
2069 sp<AaptDir> subdir = res->makeDir(dirname);
2070 sp<AaptGroup> grr = new AaptGroup(leafName, path);
2071 grr->addFile(file);
2072
2073 subdir->addFile(leafName, grr);
2074}
2075
2076
2077ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
2078{
2079 int count;
2080 int totalCount = 0;
2081 FileType type;
2082 const Vector<const char *>& resDirs = bundle->getResourceSourceDirs();
2083 const size_t dirCount =resDirs.size();
2084 sp<AaptAssets> current = this;
2085
2086 const int N = bundle->getFileSpecCount();
2087
2088 /*
2089 * If a package manifest was specified, include that first.
2090 */
2091 if (bundle->getAndroidManifestFile() != NULL) {
2092 // place at root of zip.
2093 String8 srcFile(bundle->getAndroidManifestFile());
2094 addFile(srcFile.getPathLeaf(), AaptGroupEntry(), srcFile.getPathDir(),
2095 NULL, String8());
2096 totalCount++;
2097 }
2098
2099 /*
2100 * If a directory of custom assets was supplied, slurp 'em up.
2101 */
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2102 const Vector<const char*>& assetDirs = bundle->getAssetSourceDirs();
2103 const int AN = assetDirs.size();
2104 for (int i = 0; i < AN; i++) {
2105 FileType type = getFileType(assetDirs[i]);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2106 if (type == kFileTypeNonexistent) {
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2107 fprintf(stderr, "ERROR: asset directory '%s' does not exist\n", assetDirs[i]);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2108 return UNKNOWN_ERROR;
2109 }
2110 if (type != kFileTypeDirectory) {
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2111 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDirs[i]);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2112 return UNKNOWN_ERROR;
2113 }
2114
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2115 String8 assetRoot(assetDirs[i]);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2116 sp<AaptDir> assetAaptDir = makeDir(String8(kAssetDir));
2117 AaptGroupEntry group;
2118 count = assetAaptDir->slurpFullTree(bundle, assetRoot, group,
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2119 String8(), mFullAssetPaths, true);
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2120 if (count < 0) {
2121 totalCount = count;
2122 goto bail;
2123 }
2124 if (count > 0) {
2125 mGroupEntries.add(group);
2126 }
2127 totalCount += count;
2128
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2129 if (bundle->getVerbose()) {
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2130 printf("Found %d custom asset file%s in %s\n",
Adam Lesinski09384302014-01-22 16:07:42 -0800[diff] [blame]2131 count, (count==1) ? "" : "s", assetDirs[i]);
2132 }
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2133 }
2134
2135 /*
2136 * If a directory of resource-specific assets was supplied, slurp 'em up.
2137 */
2138 for (size_t i=0; i<dirCount; i++) {
2139 const char *res = resDirs[i];
2140 if (res) {
2141 type = getFileType(res);
2142 if (type == kFileTypeNonexistent) {
2143 fprintf(stderr, "ERROR: resource directory '%s' does not exist\n", res);
2144 return UNKNOWN_ERROR;
2145 }
2146 if (type == kFileTypeDirectory) {
2147 if (i>0) {
2148 sp<AaptAssets> nextOverlay = new AaptAssets();
2149 current->setOverlay(nextOverlay);
2150 current = nextOverlay;
2151 current->setFullResPaths(mFullResPaths);
2152 }
2153 count = current->slurpResourceTree(bundle, String8(res));
Bryan Mawhinney9ab9b932014-01-24 16:18:13 +0000[diff] [blame]2154 if (i > 0 && count > 0) {
2155 count = current->filter(bundle);
2156 }
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2157
2158 if (count < 0) {
2159 totalCount = count;
2160 goto bail;
2161 }
2162 totalCount += count;
2163 }
2164 else {
2165 fprintf(stderr, "ERROR: '%s' is not a directory\n", res);
2166 return UNKNOWN_ERROR;
2167 }
2168 }
2169
2170 }
2171 /*
2172 * Now do any additional raw files.
2173 */
2174 for (int arg=0; arg<N; arg++) {
2175 const char* assetDir = bundle->getFileSpecEntry(arg);
2176
2177 FileType type = getFileType(assetDir);
2178 if (type == kFileTypeNonexistent) {
2179 fprintf(stderr, "ERROR: input directory '%s' does not exist\n", assetDir);
2180 return UNKNOWN_ERROR;
2181 }
2182 if (type != kFileTypeDirectory) {
2183 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir);
2184 return UNKNOWN_ERROR;
2185 }
2186
2187 String8 assetRoot(assetDir);
2188
2189 if (bundle->getVerbose())
2190 printf("Processing raw dir '%s'\n", (const char*) assetDir);
2191
2192 /*
2193 * Do a recursive traversal of subdir tree. We don't make any
2194 * guarantees about ordering, so we're okay with an inorder search
2195 * using whatever order the OS happens to hand back to us.
2196 */
2197 count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8(), mFullAssetPaths);
2198 if (count < 0) {
2199 /* failure; report error and remove archive */
2200 totalCount = count;
2201 goto bail;
2202 }
2203 totalCount += count;
2204
2205 if (bundle->getVerbose())
2206 printf("Found %d asset file%s in %s\n",
2207 count, (count==1) ? "" : "s", assetDir);
2208 }
2209
2210 count = validate();
2211 if (count != NO_ERROR) {
2212 totalCount = count;
2213 goto bail;
2214 }
2215
2216 count = filter(bundle);
2217 if (count != NO_ERROR) {
2218 totalCount = count;
2219 goto bail;
2220 }
2221
2222bail:
2223 return totalCount;
2224}
2225
2226ssize_t AaptAssets::slurpFullTree(Bundle* bundle, const String8& srcDir,
2227 const AaptGroupEntry& kind,
2228 const String8& resType,
2229 sp<FilePathStore>& fullResPaths)
2230{
2231 ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType, fullResPaths);
2232 if (res > 0) {
2233 mGroupEntries.add(kind);
2234 }
2235
2236 return res;
2237}
2238
2239ssize_t AaptAssets::slurpResourceTree(Bundle* bundle, const String8& srcDir)
2240{
2241 ssize_t err = 0;
2242
2243 DIR* dir = opendir(srcDir.string());
2244 if (dir == NULL) {
2245 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
2246 return UNKNOWN_ERROR;
2247 }
2248
2249 status_t count = 0;
2250
2251 /*
2252 * Run through the directory, looking for dirs that match the
2253 * expected pattern.
2254 */
2255 while (1) {
2256 struct dirent* entry = readdir(dir);
2257 if (entry == NULL) {
2258 break;
2259 }
2260
2261 if (isHidden(srcDir.string(), entry->d_name)) {
2262 continue;
2263 }
2264
2265 String8 subdirName(srcDir);
2266 subdirName.appendPath(entry->d_name);
2267
2268 AaptGroupEntry group;
2269 String8 resType;
2270 bool b = group.initFromDirName(entry->d_name, &resType);
2271 if (!b) {
2272 fprintf(stderr, "invalid resource directory name: %s/%s\n", srcDir.string(),
2273 entry->d_name);
2274 err = -1;
2275 continue;
2276 }
2277
2278 if (bundle->getMaxResVersion() != NULL && group.getVersionString().length() != 0) {
2279 int maxResInt = atoi(bundle->getMaxResVersion());
2280 const char *verString = group.getVersionString().string();
2281 int dirVersionInt = atoi(verString + 1); // skip 'v' in version name
2282 if (dirVersionInt > maxResInt) {
2283 fprintf(stderr, "max res %d, skipping %s\n", maxResInt, entry->d_name);
2284 continue;
2285 }
2286 }
2287
2288 FileType type = getFileType(subdirName.string());
2289
2290 if (type == kFileTypeDirectory) {
2291 sp<AaptDir> dir = makeDir(resType);
2292 ssize_t res = dir->slurpFullTree(bundle, subdirName, group,
2293 resType, mFullResPaths);
2294 if (res < 0) {
2295 count = res;
2296 goto bail;
2297 }
2298 if (res > 0) {
2299 mGroupEntries.add(group);
2300 count += res;
2301 }
2302
2303 // Only add this directory if we don't already have a resource dir
2304 // for the current type. This ensures that we only add the dir once
2305 // for all configs.
2306 sp<AaptDir> rdir = resDir(resType);
2307 if (rdir == NULL) {
2308 mResDirs.add(dir);
2309 }
2310 } else {
2311 if (bundle->getVerbose()) {
2312 fprintf(stderr, " (ignoring file '%s')\n", subdirName.string());
2313 }
2314 }
2315 }
2316
2317bail:
2318 closedir(dir);
2319 dir = NULL;
2320
2321 if (err != 0) {
2322 return err;
2323 }
2324 return count;
2325}
2326
2327ssize_t
2328AaptAssets::slurpResourceZip(Bundle* bundle, const char* filename)
2329{
2330 int count = 0;
2331 SortedVector<AaptGroupEntry> entries;
2332
2333 ZipFile* zip = new ZipFile;
2334 status_t err = zip->open(filename, ZipFile::kOpenReadOnly);
2335 if (err != NO_ERROR) {
2336 fprintf(stderr, "error opening zip file %s\n", filename);
2337 count = err;
2338 delete zip;
2339 return -1;
2340 }
2341
2342 const int N = zip->getNumEntries();
2343 for (int i=0; i<N; i++) {
2344 ZipEntry* entry = zip->getEntryByIndex(i);
2345 if (entry->getDeleted()) {
2346 continue;
2347 }
2348
2349 String8 entryName(entry->getFileName());
2350
2351 String8 dirName = entryName.getPathDir();
2352 sp<AaptDir> dir = dirName == "" ? this : makeDir(dirName);
2353
2354 String8 resType;
2355 AaptGroupEntry kind;
2356
2357 String8 remain;
2358 if (entryName.walkPath(&remain) == kResourceDir) {
2359 // these are the resources, pull their type out of the directory name
2360 kind.initFromDirName(remain.walkPath().string(), &resType);
2361 } else {
2362 // these are untyped and don't have an AaptGroupEntry
2363 }
2364 if (entries.indexOf(kind) < 0) {
2365 entries.add(kind);
2366 mGroupEntries.add(kind);
2367 }
2368
2369 // use the one from the zip file if they both exist.
2370 dir->removeFile(entryName.getPathLeaf());
2371
2372 sp<AaptFile> file = new AaptFile(entryName, kind, resType);
2373 status_t err = dir->addLeafFile(entryName.getPathLeaf(), file);
2374 if (err != NO_ERROR) {
2375 fprintf(stderr, "err=%s entryName=%s\n", strerror(err), entryName.string());
2376 count = err;
2377 goto bail;
2378 }
2379 file->setCompressionMethod(entry->getCompressionMethod());
2380
2381#if 0
2382 if (entryName == "AndroidManifest.xml") {
2383 printf("AndroidManifest.xml\n");
2384 }
2385 printf("\n\nfile: %s\n", entryName.string());
2386#endif
2387
2388 size_t len = entry->getUncompressedLen();
2389 void* data = zip->uncompress(entry);
2390 void* buf = file->editData(len);
2391 memcpy(buf, data, len);
2392
2393#if 0
2394 const int OFF = 0;
2395 const unsigned char* p = (unsigned char*)data;
2396 const unsigned char* end = p+len;
2397 p += OFF;
2398 for (int i=0; i<32 && p < end; i++) {
2399 printf("0x%03x ", i*0x10 + OFF);
2400 for (int j=0; j<0x10 && p < end; j++) {
2401 printf(" %02x", *p);
2402 p++;
2403 }
2404 printf("\n");
2405 }
2406#endif
2407
2408 free(data);
2409
2410 count++;
2411 }
2412
2413bail:
2414 delete zip;
2415 return count;
2416}
2417
2418status_t AaptAssets::filter(Bundle* bundle)
2419{
2420 ResourceFilter reqFilter;
2421 status_t err = reqFilter.parse(bundle->getConfigurations());
2422 if (err != NO_ERROR) {
2423 return err;
2424 }
2425
2426 ResourceFilter prefFilter;
2427 err = prefFilter.parse(bundle->getPreferredConfigurations());
2428 if (err != NO_ERROR) {
2429 return err;
2430 }
2431
2432 if (reqFilter.isEmpty() && prefFilter.isEmpty()) {
2433 return NO_ERROR;
2434 }
2435
2436 if (bundle->getVerbose()) {
2437 if (!reqFilter.isEmpty()) {
2438 printf("Applying required filter: %s\n",
2439 bundle->getConfigurations());
2440 }
2441 if (!prefFilter.isEmpty()) {
2442 printf("Applying preferred filter: %s\n",
2443 bundle->getPreferredConfigurations());
2444 }
2445 }
2446
2447 const Vector<sp<AaptDir> >& resdirs = mResDirs;
2448 const size_t ND = resdirs.size();
2449 for (size_t i=0; i<ND; i++) {
2450 const sp<AaptDir>& dir = resdirs.itemAt(i);
2451 if (dir->getLeaf() == kValuesDir) {
2452 // The "value" dir is special since a single file defines
2453 // multiple resources, so we can not do filtering on the
2454 // files themselves.
2455 continue;
2456 }
2457 if (dir->getLeaf() == kMipmapDir) {
2458 // We also skip the "mipmap" directory, since the point of this
2459 // is to include all densities without stripping. If you put
2460 // other configurations in here as well they won't be stripped
2461 // either... So don't do that. Seriously. What is wrong with you?
2462 continue;
2463 }
2464
2465 const size_t NG = dir->getFiles().size();
2466 for (size_t j=0; j<NG; j++) {
2467 sp<AaptGroup> grp = dir->getFiles().valueAt(j);
2468
2469 // First remove any configurations we know we don't need.
2470 for (size_t k=0; k<grp->getFiles().size(); k++) {
2471 sp<AaptFile> file = grp->getFiles().valueAt(k);
2472 if (k == 0 && grp->getFiles().size() == 1) {
2473 // If this is the only file left, we need to keep it.
2474 // Otherwise the resource IDs we are using will be inconsistent
2475 // with what we get when not stripping. Sucky, but at least
2476 // for now we can rely on the back-end doing another filtering
2477 // pass to take this out and leave us with this resource name
2478 // containing no entries.
2479 continue;
2480 }
2481 if (file->getPath().getPathExtension() == ".xml") {
2482 // We can't remove .xml files at this point, because when
2483 // we parse them they may add identifier resources, so
2484 // removing them can cause our resource identifiers to
2485 // become inconsistent.
2486 continue;
2487 }
2488 const ResTable_config& config(file->getGroupEntry().toParams());
2489 if (!reqFilter.match(config)) {
2490 if (bundle->getVerbose()) {
2491 printf("Pruning unneeded resource: %s\n",
2492 file->getPrintableSource().string());
2493 }
2494 grp->removeFile(k);
2495 k--;
2496 }
2497 }
2498
2499 // Quick check: no preferred filters, nothing more to do.
2500 if (prefFilter.isEmpty()) {
2501 continue;
2502 }
2503
Adam Lesinski8cf61842013-10-18 13:42:09 -0700[diff] [blame]2504 // Get the preferred density if there is one. We do not match exactly for density.
2505 // If our preferred density is hdpi but we only have mdpi and xhdpi resources, we
2506 // pick xhdpi.
2507 uint32_t preferredDensity = 0;
2508 const SortedVector<uint32_t>* preferredConfigs = prefFilter.configsForAxis(AXIS_DENSITY);
2509 if (preferredConfigs != NULL && preferredConfigs->size() > 0) {
2510 preferredDensity = (*preferredConfigs)[0];
2511 }
2512
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2513 // Now deal with preferred configurations.
2514 for (int axis=AXIS_START; axis<=AXIS_END; axis++) {
2515 for (size_t k=0; k<grp->getFiles().size(); k++) {
2516 sp<AaptFile> file = grp->getFiles().valueAt(k);
2517 if (k == 0 && grp->getFiles().size() == 1) {
2518 // If this is the only file left, we need to keep it.
2519 // Otherwise the resource IDs we are using will be inconsistent
2520 // with what we get when not stripping. Sucky, but at least
2521 // for now we can rely on the back-end doing another filtering
2522 // pass to take this out and leave us with this resource name
2523 // containing no entries.
2524 continue;
2525 }
2526 if (file->getPath().getPathExtension() == ".xml") {
2527 // We can't remove .xml files at this point, because when
2528 // we parse them they may add identifier resources, so
2529 // removing them can cause our resource identifiers to
2530 // become inconsistent.
2531 continue;
2532 }
2533 const ResTable_config& config(file->getGroupEntry().toParams());
2534 if (!prefFilter.match(axis, config)) {
2535 // This is a resource we would prefer not to have. Check
2536 // to see if have a similar variation that we would like
2537 // to have and, if so, we can drop it.
Adam Lesinski8cf61842013-10-18 13:42:09 -0700[diff] [blame]2538
2539 uint32_t bestDensity = config.density;
2540
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2541 for (size_t m=0; m<grp->getFiles().size(); m++) {
2542 if (m == k) continue;
2543 sp<AaptFile> mfile = grp->getFiles().valueAt(m);
2544 const ResTable_config& mconfig(mfile->getGroupEntry().toParams());
2545 if (AaptGroupEntry::configSameExcept(config, mconfig, axis)) {
Adam Lesinski8cf61842013-10-18 13:42:09 -0700[diff] [blame]2546 if (axis == AXIS_DENSITY && preferredDensity > 0) {
2547 // See if there is a better density resource
2548 if (mconfig.density < bestDensity &&
2549 mconfig.density > preferredDensity &&
2550 bestDensity > preferredDensity) {
2551 // This density is between our best density and
2552 // the preferred density, therefore it is better.
2553 bestDensity = mconfig.density;
2554 } else if (mconfig.density > bestDensity &&
2555 bestDensity < preferredDensity) {
2556 // This density is better than our best density and
2557 // our best density was smaller than our preferred
2558 // density, so it is better.
2559 bestDensity = mconfig.density;
2560 }
2561 } else if (prefFilter.match(axis, mconfig)) {
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2562 if (bundle->getVerbose()) {
2563 printf("Pruning unneeded resource: %s\n",
2564 file->getPrintableSource().string());
2565 }
2566 grp->removeFile(k);
2567 k--;
2568 break;
2569 }
2570 }
2571 }
Adam Lesinski8cf61842013-10-18 13:42:09 -0700[diff] [blame]2572
2573 if (axis == AXIS_DENSITY && preferredDensity > 0 &&
2574 bestDensity != config.density) {
2575 if (bundle->getVerbose()) {
2576 printf("Pruning unneeded resource: %s\n",
2577 file->getPrintableSource().string());
2578 }
2579 grp->removeFile(k);
2580 k--;
2581 }
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2582 }
2583 }
2584 }
2585 }
2586 }
2587
2588 return NO_ERROR;
2589}
2590
2591sp<AaptSymbols> AaptAssets::getSymbolsFor(const String8& name)
2592{
2593 sp<AaptSymbols> sym = mSymbols.valueFor(name);
2594 if (sym == NULL) {
2595 sym = new AaptSymbols();
2596 mSymbols.add(name, sym);
2597 }
2598 return sym;
2599}
2600
2601sp<AaptSymbols> AaptAssets::getJavaSymbolsFor(const String8& name)
2602{
2603 sp<AaptSymbols> sym = mJavaSymbols.valueFor(name);
2604 if (sym == NULL) {
2605 sym = new AaptSymbols();
2606 mJavaSymbols.add(name, sym);
2607 }
2608 return sym;
2609}
2610
2611status_t AaptAssets::applyJavaSymbols()
2612{
2613 size_t N = mJavaSymbols.size();
2614 for (size_t i=0; i<N; i++) {
2615 const String8& name = mJavaSymbols.keyAt(i);
2616 const sp<AaptSymbols>& symbols = mJavaSymbols.valueAt(i);
2617 ssize_t pos = mSymbols.indexOfKey(name);
2618 if (pos < 0) {
2619 SourcePos pos;
2620 pos.error("Java symbol dir %s not defined\n", name.string());
2621 return UNKNOWN_ERROR;
2622 }
2623 //printf("**** applying java symbols in dir %s\n", name.string());
2624 status_t err = mSymbols.valueAt(pos)->applyJavaSymbols(symbols);
2625 if (err != NO_ERROR) {
2626 return err;
2627 }
2628 }
2629
2630 return NO_ERROR;
2631}
2632
2633bool AaptAssets::isJavaSymbol(const AaptSymbolEntry& sym, bool includePrivate) const {
2634 //printf("isJavaSymbol %s: public=%d, includePrivate=%d, isJavaSymbol=%d\n",
2635 // sym.name.string(), sym.isPublic ? 1 : 0, includePrivate ? 1 : 0,
2636 // sym.isJavaSymbol ? 1 : 0);
2637 if (!mHavePrivateSymbols) return true;
2638 if (sym.isPublic) return true;
2639 if (includePrivate && sym.isJavaSymbol) return true;
2640 return false;
2641}
2642
2643status_t AaptAssets::buildIncludedResources(Bundle* bundle)
2644{
2645 if (!mHaveIncludedAssets) {
2646 // Add in all includes.
2647 const Vector<const char*>& incl = bundle->getPackageIncludes();
2648 const size_t N=incl.size();
2649 for (size_t i=0; i<N; i++) {
2650 if (bundle->getVerbose())
2651 printf("Including resources from package: %s\n", incl[i]);
2652 if (!mIncludedAssets.addAssetPath(String8(incl[i]), NULL)) {
2653 fprintf(stderr, "ERROR: Asset package include '%s' not found.\n",
2654 incl[i]);
2655 return UNKNOWN_ERROR;
2656 }
2657 }
2658 mHaveIncludedAssets = true;
2659 }
2660
2661 return NO_ERROR;
2662}
2663
2664status_t AaptAssets::addIncludedResources(const sp<AaptFile>& file)
2665{
2666 const ResTable& res = getIncludedResources();
2667 // XXX dirty!
Narayan Kamath00b31442014-01-27 17:32:37 +0000[diff] [blame]2668 return const_cast<ResTable&>(res).add(file->getData(), file->getSize());
Adam Lesinski282e1812014-01-23 18:17:42 -0800[diff] [blame]2669}
2670
2671const ResTable& AaptAssets::getIncludedResources() const
2672{
2673 return mIncludedAssets.getResources(false);
2674}
2675
2676void AaptAssets::print(const String8& prefix) const
2677{
2678 String8 innerPrefix(prefix);
2679 innerPrefix.append(" ");
2680 String8 innerInnerPrefix(innerPrefix);
2681 innerInnerPrefix.append(" ");
2682 printf("%sConfigurations:\n", prefix.string());
2683 const size_t N=mGroupEntries.size();
2684 for (size_t i=0; i<N; i++) {
2685 String8 cname = mGroupEntries.itemAt(i).toDirName(String8());
2686 printf("%s %s\n", prefix.string(),
2687 cname != "" ? cname.string() : "(default)");
2688 }
2689
2690 printf("\n%sFiles:\n", prefix.string());
2691 AaptDir::print(innerPrefix);
2692
2693 printf("\n%sResource Dirs:\n", prefix.string());
2694 const Vector<sp<AaptDir> >& resdirs = mResDirs;
2695 const size_t NR = resdirs.size();
2696 for (size_t i=0; i<NR; i++) {
2697 const sp<AaptDir>& d = resdirs.itemAt(i);
2698 printf("%s Type %s\n", prefix.string(), d->getLeaf().string());
2699 d->print(innerInnerPrefix);
2700 }
2701}
2702
2703sp<AaptDir> AaptAssets::resDir(const String8& name) const
2704{
2705 const Vector<sp<AaptDir> >& resdirs = mResDirs;
2706 const size_t N = resdirs.size();
2707 for (size_t i=0; i<N; i++) {
2708 const sp<AaptDir>& d = resdirs.itemAt(i);
2709 if (d->getLeaf() == name) {
2710 return d;
2711 }
2712 }
2713 return NULL;
2714}
2715
2716bool
2717valid_symbol_name(const String8& symbol)
2718{
2719 static char const * const KEYWORDS[] = {
2720 "abstract", "assert", "boolean", "break",
2721 "byte", "case", "catch", "char", "class", "const", "continue",
2722 "default", "do", "double", "else", "enum", "extends", "final",
2723 "finally", "float", "for", "goto", "if", "implements", "import",
2724 "instanceof", "int", "interface", "long", "native", "new", "package",
2725 "private", "protected", "public", "return", "short", "static",
2726 "strictfp", "super", "switch", "synchronized", "this", "throw",
2727 "throws", "transient", "try", "void", "volatile", "while",
2728 "true", "false", "null",
2729 NULL
2730 };
2731 const char*const* k = KEYWORDS;
2732 const char*const s = symbol.string();
2733 while (*k) {
2734 if (0 == strcmp(s, *k)) {
2735 return false;
2736 }
2737 k++;
2738 }
2739 return true;
2740}