]> git.saurik.com Git - android/aapt.git/blame_incremental - AaptAssets.cpp
projects / android / aapt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Find layout classes in all "layout-*" dirs.
[android/aapt.git] / AaptAssets.cpp
... / ...
CommitLineData
1//
2// Copyright 2006 The Android Open Source Project
3//
4
5#include "AaptAssets.h"
6#include "Main.h"
7
8#include <utils/misc.h>
9#include <utils/SortedVector.h>
10
11#include <ctype.h>
12#include <dirent.h>
13#include <errno.h>
14
15static const char* kDefaultLocale = "default";
16static const char* kWildcardName = "any";
17static const char* kAssetDir = "assets";
18static const char* kResourceDir = "res";
19static const char* kInvalidChars = "/\\:";
20static const size_t kMaxAssetFileName = 100;
21
22static const String8 kResString(kResourceDir);
23
24/*
25 * Names of asset files must meet the following criteria:
26 *
27 * - the filename length must be less than kMaxAssetFileName bytes long
28 * (and can't be empty)
29 * - all characters must be 7-bit printable ASCII
30 * - none of { '/' '\\' ':' }
31 *
32 * Pass in just the filename, not the full path.
33 */
34static bool validateFileName(const char* fileName)
35{
36 const char* cp = fileName;
37 size_t len = 0;
38
39 while (*cp != '\0') {
40 if ((*cp & 0x80) != 0)
41 return false; // reject high ASCII
42 if (*cp < 0x20 || *cp >= 0x7f)
43 return false; // reject control chars and 0x7f
44 if (strchr(kInvalidChars, *cp) != NULL)
45 return false; // reject path sep chars
46 cp++;
47 len++;
48 }
49
50 if (len < 1 || len > kMaxAssetFileName)
51 return false; // reject empty or too long
52
53 return true;
54}
55
56static bool isHidden(const char *root, const char *path)
57{
58 const char *ext = NULL;
59 const char *type = NULL;
60
61 // Skip all hidden files.
62 if (path[0] == '.') {
63 // Skip ., .. and .svn but don't chatter about it.
64 if (strcmp(path, ".") == 0
65 || strcmp(path, "..") == 0
66 || strcmp(path, ".svn") == 0) {
67 return true;
68 }
69 type = "hidden";
70 } else if (path[0] == '_') {
71 // skip directories starting with _ (don't chatter about it)
72 String8 subdirName(root);
73 subdirName.appendPath(path);
74 if (getFileType(subdirName.string()) == kFileTypeDirectory) {
75 return true;
76 }
77 } else if (strcmp(path, "CVS") == 0) {
78 // Skip CVS but don't chatter about it.
79 return true;
80 } else if (strcasecmp(path, "thumbs.db") == 0
81 || strcasecmp(path, "picasa.ini") == 0) {
82 // Skip suspected image indexes files.
83 type = "index";
84 } else if (path[strlen(path)-1] == '~') {
85 // Skip suspected emacs backup files.
86 type = "backup";
87 } else if ((ext = strrchr(path, '.')) != NULL && strcmp(ext, ".scc") == 0) {
88 // Skip VisualSourceSafe files and don't chatter about it
89 return true;
90 } else {
91 // Let everything else through.
92 return false;
93 }
94
95 /* If we get this far, "type" should be set and the file
96 * should be skipped.
97 */
98 String8 subdirName(root);
99 subdirName.appendPath(path);
100 fprintf(stderr, " (skipping %s %s '%s')\n", type,
101 getFileType(subdirName.string())==kFileTypeDirectory ? "dir":"file",
102 subdirName.string());
103
104 return true;
105}
106
107// =========================================================================
108// =========================================================================
109// =========================================================================
110
111status_t
112AaptGroupEntry::parseNamePart(const String8& part, int* axis, uint32_t* value)
113{
114 ResTable_config config;
115
116 // IMSI - MCC
117 if (getMccName(part.string(), &config)) {
118 *axis = AXIS_MCC;
119 *value = config.mcc;
120 return 0;
121 }
122
123 // IMSI - MNC
124 if (getMncName(part.string(), &config)) {
125 *axis = AXIS_MNC;
126 *value = config.mnc;
127 return 0;
128 }
129
130 // locale - language
131 if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
132 *axis = AXIS_LANGUAGE;
133 *value = part[1] << 8 | part[0];
134 return 0;
135 }
136
137 // locale - language_REGION
138 if (part.length() == 5 && isalpha(part[0]) && isalpha(part[1])
139 && part[2] == '_' && isalpha(part[3]) && isalpha(part[4])) {
140 *axis = AXIS_LANGUAGE;
141 *value = (part[4] << 24) | (part[3] << 16) | (part[1] << 8) | (part[0]);
142 return 0;
143 }
144
145 // screen layout size
146 if (getScreenLayoutSizeName(part.string(), &config)) {
147 *axis = AXIS_SCREENLAYOUTSIZE;
148 *value = (config.screenLayout&ResTable_config::MASK_SCREENSIZE);
149 return 0;
150 }
151
152 // screen layout long
153 if (getScreenLayoutLongName(part.string(), &config)) {
154 *axis = AXIS_SCREENLAYOUTLONG;
155 *value = (config.screenLayout&ResTable_config::MASK_SCREENLONG);
156 return 0;
157 }
158
159 // orientation
160 if (getOrientationName(part.string(), &config)) {
161 *axis = AXIS_ORIENTATION;
162 *value = config.orientation;
163 return 0;
164 }
165
166 // density
167 if (getDensityName(part.string(), &config)) {
168 *axis = AXIS_DENSITY;
169 *value = config.density;
170 return 0;
171 }
172
173 // touchscreen
174 if (getTouchscreenName(part.string(), &config)) {
175 *axis = AXIS_TOUCHSCREEN;
176 *value = config.touchscreen;
177 return 0;
178 }
179
180 // keyboard hidden
181 if (getKeysHiddenName(part.string(), &config)) {
182 *axis = AXIS_KEYSHIDDEN;
183 *value = config.inputFlags;
184 return 0;
185 }
186
187 // keyboard
188 if (getKeyboardName(part.string(), &config)) {
189 *axis = AXIS_KEYBOARD;
190 *value = config.keyboard;
191 return 0;
192 }
193
194 // navigation hidden
195 if (getNavHiddenName(part.string(), &config)) {
196 *axis = AXIS_NAVHIDDEN;
197 *value = config.inputFlags;
198 return 0;
199 }
200
201 // navigation
202 if (getNavigationName(part.string(), &config)) {
203 *axis = AXIS_NAVIGATION;
204 *value = config.navigation;
205 return 0;
206 }
207
208 // screen size
209 if (getScreenSizeName(part.string(), &config)) {
210 *axis = AXIS_SCREENSIZE;
211 *value = config.screenSize;
212 return 0;
213 }
214
215 // version
216 if (getVersionName(part.string(), &config)) {
217 *axis = AXIS_VERSION;
218 *value = config.version;
219 return 0;
220 }
221
222 return 1;
223}
224
225bool
226AaptGroupEntry::initFromDirName(const char* dir, String8* resType)
227{
228 Vector<String8> parts;
229
230 String8 mcc, mnc, loc, layoutsize, layoutlong, orient, den;
231 String8 touch, key, keysHidden, nav, navHidden, size, vers;
232
233 const char *p = dir;
234 const char *q;
235 while (NULL != (q = strchr(p, '-'))) {
236 String8 val(p, q-p);
237 val.toLower();
238 parts.add(val);
239 //printf("part: %s\n", parts[parts.size()-1].string());
240 p = q+1;
241 }
242 String8 val(p);
243 val.toLower();
244 parts.add(val);
245 //printf("part: %s\n", parts[parts.size()-1].string());
246
247 const int N = parts.size();
248 int index = 0;
249 String8 part = parts[index];
250
251 // resource type
252 if (!isValidResourceType(part)) {
253 return false;
254 }
255 *resType = part;
256
257 index++;
258 if (index == N) {
259 goto success;
260 }
261 part = parts[index];
262
263 // imsi - mcc
264 if (getMccName(part.string())) {
265 mcc = part;
266
267 index++;
268 if (index == N) {
269 goto success;
270 }
271 part = parts[index];
272 } else {
273 //printf("not mcc: %s\n", part.string());
274 }
275
276 // imsi - mnc
277 if (getMncName(part.string())) {
278 mnc = part;
279
280 index++;
281 if (index == N) {
282 goto success;
283 }
284 part = parts[index];
285 } else {
286 //printf("not mcc: %s\n", part.string());
287 }
288
289 // locale - language
290 if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
291 loc = part;
292
293 index++;
294 if (index == N) {
295 goto success;
296 }
297 part = parts[index];
298 } else {
299 //printf("not language: %s\n", part.string());
300 }
301
302 // locale - region
303 if (loc.length() > 0
304 && part.length() == 3 && part[0] == 'r' && part[0] && part[1]) {
305 loc += "-";
306 part.toUpper();
307 loc += part.string() + 1;
308
309 index++;
310 if (index == N) {
311 goto success;
312 }
313 part = parts[index];
314 } else {
315 //printf("not region: %s\n", part.string());
316 }
317
318 if (getScreenLayoutSizeName(part.string())) {
319 layoutsize = part;
320
321 index++;
322 if (index == N) {
323 goto success;
324 }
325 part = parts[index];
326 } else {
327 //printf("not screen layout size: %s\n", part.string());
328 }
329
330 if (getScreenLayoutLongName(part.string())) {
331 layoutlong = part;
332
333 index++;
334 if (index == N) {
335 goto success;
336 }
337 part = parts[index];
338 } else {
339 //printf("not screen layout long: %s\n", part.string());
340 }
341
342 // orientation
343 if (getOrientationName(part.string())) {
344 orient = part;
345
346 index++;
347 if (index == N) {
348 goto success;
349 }
350 part = parts[index];
351 } else {
352 //printf("not orientation: %s\n", part.string());
353 }
354
355 // density
356 if (getDensityName(part.string())) {
357 den = part;
358
359 index++;
360 if (index == N) {
361 goto success;
362 }
363 part = parts[index];
364 } else {
365 //printf("not density: %s\n", part.string());
366 }
367
368 // touchscreen
369 if (getTouchscreenName(part.string())) {
370 touch = part;
371
372 index++;
373 if (index == N) {
374 goto success;
375 }
376 part = parts[index];
377 } else {
378 //printf("not touchscreen: %s\n", part.string());
379 }
380
381 // keyboard hidden
382 if (getKeysHiddenName(part.string())) {
383 keysHidden = part;
384
385 index++;
386 if (index == N) {
387 goto success;
388 }
389 part = parts[index];
390 } else {
391 //printf("not keysHidden: %s\n", part.string());
392 }
393
394 // keyboard
395 if (getKeyboardName(part.string())) {
396 key = part;
397
398 index++;
399 if (index == N) {
400 goto success;
401 }
402 part = parts[index];
403 } else {
404 //printf("not keyboard: %s\n", part.string());
405 }
406
407 // navigation hidden
408 if (getNavHiddenName(part.string())) {
409 navHidden = part;
410
411 index++;
412 if (index == N) {
413 goto success;
414 }
415 part = parts[index];
416 } else {
417 //printf("not navHidden: %s\n", part.string());
418 }
419
420 if (getNavigationName(part.string())) {
421 nav = part;
422
423 index++;
424 if (index == N) {
425 goto success;
426 }
427 part = parts[index];
428 } else {
429 //printf("not navigation: %s\n", part.string());
430 }
431
432 if (getScreenSizeName(part.string())) {
433 size = part;
434
435 index++;
436 if (index == N) {
437 goto success;
438 }
439 part = parts[index];
440 } else {
441 //printf("not screen size: %s\n", part.string());
442 }
443
444 if (getVersionName(part.string())) {
445 vers = part;
446
447 index++;
448 if (index == N) {
449 goto success;
450 }
451 part = parts[index];
452 } else {
453 //printf("not version: %s\n", part.string());
454 }
455
456 // if there are extra parts, it doesn't match
457 return false;
458
459success:
460 this->mcc = mcc;
461 this->mnc = mnc;
462 this->locale = loc;
463 this->screenLayoutSize = layoutsize;
464 this->screenLayoutLong = layoutlong;
465 this->orientation = orient;
466 this->density = den;
467 this->touchscreen = touch;
468 this->keysHidden = keysHidden;
469 this->keyboard = key;
470 this->navHidden = navHidden;
471 this->navigation = nav;
472 this->screenSize = size;
473 this->version = vers;
474
475 // what is this anyway?
476 this->vendor = "";
477
478 return true;
479}
480
481String8
482AaptGroupEntry::toString() const
483{
484 String8 s = this->mcc;
485 s += ",";
486 s += this->mnc;
487 s += ",";
488 s += this->locale;
489 s += ",";
490 s += screenLayoutSize;
491 s += ",";
492 s += screenLayoutLong;
493 s += ",";
494 s += this->orientation;
495 s += ",";
496 s += density;
497 s += ",";
498 s += touchscreen;
499 s += ",";
500 s += keysHidden;
501 s += ",";
502 s += keyboard;
503 s += ",";
504 s += navHidden;
505 s += ",";
506 s += navigation;
507 s += ",";
508 s += screenSize;
509 s += ",";
510 s += version;
511 return s;
512}
513
514String8
515AaptGroupEntry::toDirName(const String8& resType) const
516{
517 String8 s = resType;
518 if (this->mcc != "") {
519 s += "-";
520 s += mcc;
521 }
522 if (this->mnc != "") {
523 s += "-";
524 s += mnc;
525 }
526 if (this->locale != "") {
527 s += "-";
528 s += locale;
529 }
530 if (this->screenLayoutSize != "") {
531 s += "-";
532 s += screenLayoutSize;
533 }
534 if (this->screenLayoutLong != "") {
535 s += "-";
536 s += screenLayoutLong;
537 }
538 if (this->orientation != "") {
539 s += "-";
540 s += orientation;
541 }
542 if (this->density != "") {
543 s += "-";
544 s += density;
545 }
546 if (this->touchscreen != "") {
547 s += "-";
548 s += touchscreen;
549 }
550 if (this->keysHidden != "") {
551 s += "-";
552 s += keysHidden;
553 }
554 if (this->keyboard != "") {
555 s += "-";
556 s += keyboard;
557 }
558 if (this->navHidden != "") {
559 s += "-";
560 s += navHidden;
561 }
562 if (this->navigation != "") {
563 s += "-";
564 s += navigation;
565 }
566 if (this->screenSize != "") {
567 s += "-";
568 s += screenSize;
569 }
570 if (this->version != "") {
571 s += "-";
572 s += version;
573 }
574
575 return s;
576}
577
578bool AaptGroupEntry::getMccName(const char* name,
579 ResTable_config* out)
580{
581 if (strcmp(name, kWildcardName) == 0) {
582 if (out) out->mcc = 0;
583 return true;
584 }
585 const char* c = name;
586 if (tolower(*c) != 'm') return false;
587 c++;
588 if (tolower(*c) != 'c') return false;
589 c++;
590 if (tolower(*c) != 'c') return false;
591 c++;
592
593 const char* val = c;
594
595 while (*c >= '0' && *c <= '9') {
596 c++;
597 }
598 if (*c != 0) return false;
599 if (c-val != 3) return false;
600
601 int d = atoi(val);
602 if (d != 0) {
603 if (out) out->mcc = d;
604 return true;
605 }
606
607 return false;
608}
609
610bool AaptGroupEntry::getMncName(const char* name,
611 ResTable_config* out)
612{
613 if (strcmp(name, kWildcardName) == 0) {
614 if (out) out->mcc = 0;
615 return true;
616 }
617 const char* c = name;
618 if (tolower(*c) != 'm') return false;
619 c++;
620 if (tolower(*c) != 'n') return false;
621 c++;
622 if (tolower(*c) != 'c') return false;
623 c++;
624
625 const char* val = c;
626
627 while (*c >= '0' && *c <= '9') {
628 c++;
629 }
630 if (*c != 0) return false;
631 if (c-val == 0 || c-val > 3) return false;
632
633 int d = atoi(val);
634 if (d != 0) {
635 if (out) out->mnc = d;
636 return true;
637 }
638
639 return false;
640}
641
642/*
643 * Does this directory name fit the pattern of a locale dir ("en-rUS" or
644 * "default")?
645 *
646 * TODO: Should insist that the first two letters are lower case, and the
647 * second two are upper.
648 */
649bool AaptGroupEntry::getLocaleName(const char* fileName,
650 ResTable_config* out)
651{
652 if (strcmp(fileName, kWildcardName) == 0
653 || strcmp(fileName, kDefaultLocale) == 0) {
654 if (out) {
655 out->language[0] = 0;
656 out->language[1] = 0;
657 out->country[0] = 0;
658 out->country[1] = 0;
659 }
660 return true;
661 }
662
663 if (strlen(fileName) == 2 && isalpha(fileName[0]) && isalpha(fileName[1])) {
664 if (out) {
665 out->language[0] = fileName[0];
666 out->language[1] = fileName[1];
667 out->country[0] = 0;
668 out->country[1] = 0;
669 }
670 return true;
671 }
672
673 if (strlen(fileName) == 5 &&
674 isalpha(fileName[0]) &&
675 isalpha(fileName[1]) &&
676 fileName[2] == '-' &&
677 isalpha(fileName[3]) &&
678 isalpha(fileName[4])) {
679 if (out) {
680 out->language[0] = fileName[0];
681 out->language[1] = fileName[1];
682 out->country[0] = fileName[3];
683 out->country[1] = fileName[4];
684 }
685 return true;
686 }
687
688 return false;
689}
690
691bool AaptGroupEntry::getScreenLayoutSizeName(const char* name,
692 ResTable_config* out)
693{
694 if (strcmp(name, kWildcardName) == 0) {
695 if (out) out->screenLayout =
696 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
697 | ResTable_config::SCREENSIZE_ANY;
698 return true;
699 } else if (strcmp(name, "small") == 0) {
700 if (out) out->screenLayout =
701 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
702 | ResTable_config::SCREENSIZE_SMALL;
703 return true;
704 } else if (strcmp(name, "normal") == 0) {
705 if (out) out->screenLayout =
706 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
707 | ResTable_config::SCREENSIZE_NORMAL;
708 return true;
709 } else if (strcmp(name, "large") == 0) {
710 if (out) out->screenLayout =
711 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
712 | ResTable_config::SCREENSIZE_LARGE;
713 return true;
714 }
715
716 return false;
717}
718
719bool AaptGroupEntry::getScreenLayoutLongName(const char* name,
720 ResTable_config* out)
721{
722 if (strcmp(name, kWildcardName) == 0) {
723 if (out) out->screenLayout =
724 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
725 | ResTable_config::SCREENLONG_ANY;
726 return true;
727 } else if (strcmp(name, "long") == 0) {
728 if (out) out->screenLayout =
729 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
730 | ResTable_config::SCREENLONG_YES;
731 return true;
732 } else if (strcmp(name, "notlong") == 0) {
733 if (out) out->screenLayout =
734 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
735 | ResTable_config::SCREENLONG_NO;
736 return true;
737 }
738
739 return false;
740}
741
742bool AaptGroupEntry::getOrientationName(const char* name,
743 ResTable_config* out)
744{
745 if (strcmp(name, kWildcardName) == 0) {
746 if (out) out->orientation = out->ORIENTATION_ANY;
747 return true;
748 } else if (strcmp(name, "port") == 0) {
749 if (out) out->orientation = out->ORIENTATION_PORT;
750 return true;
751 } else if (strcmp(name, "land") == 0) {
752 if (out) out->orientation = out->ORIENTATION_LAND;
753 return true;
754 } else if (strcmp(name, "square") == 0) {
755 if (out) out->orientation = out->ORIENTATION_SQUARE;
756 return true;
757 }
758
759 return false;
760}
761
762bool AaptGroupEntry::getDensityName(const char* name,
763 ResTable_config* out)
764{
765 if (strcmp(name, kWildcardName) == 0) {
766 if (out) out->density = ResTable_config::DENSITY_DEFAULT;
767 return true;
768 }
769
770 if (strcmp(name, "nodpi") == 0) {
771 if (out) out->density = ResTable_config::DENSITY_NONE;
772 return true;
773 }
774
775 if (strcmp(name, "ldpi") == 0) {
776 if (out) out->density = ResTable_config::DENSITY_LOW;
777 return true;
778 }
779
780 if (strcmp(name, "mdpi") == 0) {
781 if (out) out->density = ResTable_config::DENSITY_MEDIUM;
782 return true;
783 }
784
785 if (strcmp(name, "hdpi") == 0) {
786 if (out) out->density = ResTable_config::DENSITY_HIGH;
787 return true;
788 }
789
790 char* c = (char*)name;
791 while (*c >= '0' && *c <= '9') {
792 c++;
793 }
794
795 // check that we have 'dpi' after the last digit.
796 if (toupper(c[0]) != 'D' ||
797 toupper(c[1]) != 'P' ||
798 toupper(c[2]) != 'I' ||
799 c[3] != 0) {
800 return false;
801 }
802
803 // temporarily replace the first letter with \0 to
804 // use atoi.
805 char tmp = c[0];
806 c[0] = '\0';
807
808 int d = atoi(name);
809 c[0] = tmp;
810
811 if (d != 0) {
812 if (out) out->density = d;
813 return true;
814 }
815
816 return false;
817}
818
819bool AaptGroupEntry::getTouchscreenName(const char* name,
820 ResTable_config* out)
821{
822 if (strcmp(name, kWildcardName) == 0) {
823 if (out) out->touchscreen = out->TOUCHSCREEN_ANY;
824 return true;
825 } else if (strcmp(name, "notouch") == 0) {
826 if (out) out->touchscreen = out->TOUCHSCREEN_NOTOUCH;
827 return true;
828 } else if (strcmp(name, "stylus") == 0) {
829 if (out) out->touchscreen = out->TOUCHSCREEN_STYLUS;
830 return true;
831 } else if (strcmp(name, "finger") == 0) {
832 if (out) out->touchscreen = out->TOUCHSCREEN_FINGER;
833 return true;
834 }
835
836 return false;
837}
838
839bool AaptGroupEntry::getKeysHiddenName(const char* name,
840 ResTable_config* out)
841{
842 uint8_t mask = 0;
843 uint8_t value = 0;
844 if (strcmp(name, kWildcardName) == 0) {
845 mask = out->MASK_KEYSHIDDEN;
846 value = out->KEYSHIDDEN_ANY;
847 } else if (strcmp(name, "keysexposed") == 0) {
848 mask = out->MASK_KEYSHIDDEN;
849 value = out->KEYSHIDDEN_NO;
850 } else if (strcmp(name, "keyshidden") == 0) {
851 mask = out->MASK_KEYSHIDDEN;
852 value = out->KEYSHIDDEN_YES;
853 } else if (strcmp(name, "keyssoft") == 0) {
854 mask = out->MASK_KEYSHIDDEN;
855 value = out->KEYSHIDDEN_SOFT;
856 }
857
858 if (mask != 0) {
859 if (out) out->inputFlags = (out->inputFlags&~mask) | value;
860 return true;
861 }
862
863 return false;
864}
865
866bool AaptGroupEntry::getKeyboardName(const char* name,
867 ResTable_config* out)
868{
869 if (strcmp(name, kWildcardName) == 0) {
870 if (out) out->keyboard = out->KEYBOARD_ANY;
871 return true;
872 } else if (strcmp(name, "nokeys") == 0) {
873 if (out) out->keyboard = out->KEYBOARD_NOKEYS;
874 return true;
875 } else if (strcmp(name, "qwerty") == 0) {
876 if (out) out->keyboard = out->KEYBOARD_QWERTY;
877 return true;
878 } else if (strcmp(name, "12key") == 0) {
879 if (out) out->keyboard = out->KEYBOARD_12KEY;
880 return true;
881 }
882
883 return false;
884}
885
886bool AaptGroupEntry::getNavHiddenName(const char* name,
887 ResTable_config* out)
888{
889 uint8_t mask = 0;
890 uint8_t value = 0;
891 if (strcmp(name, kWildcardName) == 0) {
892 mask = out->MASK_NAVHIDDEN;
893 value = out->NAVHIDDEN_ANY;
894 } else if (strcmp(name, "navexposed") == 0) {
895 mask = out->MASK_NAVHIDDEN;
896 value = out->NAVHIDDEN_NO;
897 } else if (strcmp(name, "navhidden") == 0) {
898 mask = out->MASK_NAVHIDDEN;
899 value = out->NAVHIDDEN_YES;
900 }
901
902 if (mask != 0) {
903 if (out) out->inputFlags = (out->inputFlags&~mask) | value;
904 return true;
905 }
906
907 return false;
908}
909
910bool AaptGroupEntry::getNavigationName(const char* name,
911 ResTable_config* out)
912{
913 if (strcmp(name, kWildcardName) == 0) {
914 if (out) out->navigation = out->NAVIGATION_ANY;
915 return true;
916 } else if (strcmp(name, "nonav") == 0) {
917 if (out) out->navigation = out->NAVIGATION_NONAV;
918 return true;
919 } else if (strcmp(name, "dpad") == 0) {
920 if (out) out->navigation = out->NAVIGATION_DPAD;
921 return true;
922 } else if (strcmp(name, "trackball") == 0) {
923 if (out) out->navigation = out->NAVIGATION_TRACKBALL;
924 return true;
925 } else if (strcmp(name, "wheel") == 0) {
926 if (out) out->navigation = out->NAVIGATION_WHEEL;
927 return true;
928 }
929
930 return false;
931}
932
933bool AaptGroupEntry::getScreenSizeName(const char* name,
934 ResTable_config* out)
935{
936 if (strcmp(name, kWildcardName) == 0) {
937 if (out) {
938 out->screenWidth = out->SCREENWIDTH_ANY;
939 out->screenHeight = out->SCREENHEIGHT_ANY;
940 }
941 return true;
942 }
943
944 const char* x = name;
945 while (*x >= '0' && *x <= '9') x++;
946 if (x == name || *x != 'x') return false;
947 String8 xName(name, x-name);
948 x++;
949
950 const char* y = x;
951 while (*y >= '0' && *y <= '9') y++;
952 if (y == name || *y != 0) return false;
953 String8 yName(x, y-x);
954
955 uint16_t w = (uint16_t)atoi(xName.string());
956 uint16_t h = (uint16_t)atoi(yName.string());
957 if (w < h) {
958 return false;
959 }
960
961 if (out) {
962 out->screenWidth = w;
963 out->screenHeight = h;
964 }
965
966 return true;
967}
968
969bool AaptGroupEntry::getVersionName(const char* name,
970 ResTable_config* out)
971{
972 if (strcmp(name, kWildcardName) == 0) {
973 if (out) {
974 out->sdkVersion = out->SDKVERSION_ANY;
975 out->minorVersion = out->MINORVERSION_ANY;
976 }
977 return true;
978 }
979
980 if (*name != 'v') {
981 return false;
982 }
983
984 name++;
985 const char* s = name;
986 while (*s >= '0' && *s <= '9') s++;
987 if (s == name || *s != 0) return false;
988 String8 sdkName(name, s-name);
989
990 if (out) {
991 out->sdkVersion = (uint16_t)atoi(sdkName.string());
992 out->minorVersion = 0;
993 }
994
995 return true;
996}
997
998int AaptGroupEntry::compare(const AaptGroupEntry& o) const
999{
1000 int v = mcc.compare(o.mcc);
1001 if (v == 0) v = mnc.compare(o.mnc);
1002 if (v == 0) v = locale.compare(o.locale);
1003 if (v == 0) v = vendor.compare(o.vendor);
1004 if (v == 0) v = screenLayoutSize.compare(o.screenLayoutSize);
1005 if (v == 0) v = screenLayoutLong.compare(o.screenLayoutLong);
1006 if (v == 0) v = orientation.compare(o.orientation);
1007 if (v == 0) v = density.compare(o.density);
1008 if (v == 0) v = touchscreen.compare(o.touchscreen);
1009 if (v == 0) v = keysHidden.compare(o.keysHidden);
1010 if (v == 0) v = keyboard.compare(o.keyboard);
1011 if (v == 0) v = navHidden.compare(o.navHidden);
1012 if (v == 0) v = navigation.compare(o.navigation);
1013 if (v == 0) v = screenSize.compare(o.screenSize);
1014 if (v == 0) v = version.compare(o.version);
1015 return v;
1016}
1017
1018ResTable_config AaptGroupEntry::toParams() const
1019{
1020 ResTable_config params;
1021 memset(&params, 0, sizeof(params));
1022 getMccName(mcc.string(), &params);
1023 getMncName(mnc.string(), &params);
1024 getLocaleName(locale.string(), &params);
1025 getScreenLayoutSizeName(screenLayoutSize.string(), &params);
1026 getScreenLayoutLongName(screenLayoutLong.string(), &params);
1027 getOrientationName(orientation.string(), &params);
1028 getDensityName(density.string(), &params);
1029 getTouchscreenName(touchscreen.string(), &params);
1030 getKeysHiddenName(keysHidden.string(), &params);
1031 getKeyboardName(keyboard.string(), &params);
1032 getNavHiddenName(navHidden.string(), &params);
1033 getNavigationName(navigation.string(), &params);
1034 getScreenSizeName(screenSize.string(), &params);
1035 getVersionName(version.string(), &params);
1036 return params;
1037}
1038
1039// =========================================================================
1040// =========================================================================
1041// =========================================================================
1042
1043void* AaptFile::editData(size_t size)
1044{
1045 if (size <= mBufferSize) {
1046 mDataSize = size;
1047 return mData;
1048 }
1049 size_t allocSize = (size*3)/2;
1050 void* buf = realloc(mData, allocSize);
1051 if (buf == NULL) {
1052 return NULL;
1053 }
1054 mData = buf;
1055 mDataSize = size;
1056 mBufferSize = allocSize;
1057 return buf;
1058}
1059
1060void* AaptFile::editData(size_t* outSize)
1061{
1062 if (outSize) {
1063 *outSize = mDataSize;
1064 }
1065 return mData;
1066}
1067
1068void* AaptFile::padData(size_t wordSize)
1069{
1070 const size_t extra = mDataSize%wordSize;
1071 if (extra == 0) {
1072 return mData;
1073 }
1074
1075 size_t initial = mDataSize;
1076 void* data = editData(initial+(wordSize-extra));
1077 if (data != NULL) {
1078 memset(((uint8_t*)data) + initial, 0, wordSize-extra);
1079 }
1080 return data;
1081}
1082
1083status_t AaptFile::writeData(const void* data, size_t size)
1084{
1085 size_t end = mDataSize;
1086 size_t total = size + end;
1087 void* buf = editData(total);
1088 if (buf == NULL) {
1089 return UNKNOWN_ERROR;
1090 }
1091 memcpy(((char*)buf)+end, data, size);
1092 return NO_ERROR;
1093}
1094
1095void AaptFile::clearData()
1096{
1097 if (mData != NULL) free(mData);
1098 mData = NULL;
1099 mDataSize = 0;
1100 mBufferSize = 0;
1101}
1102
1103String8 AaptFile::getPrintableSource() const
1104{
1105 if (hasData()) {
1106 String8 name(mGroupEntry.locale.string());
1107 name.appendPath(mGroupEntry.vendor.string());
1108 name.appendPath(mPath);
1109 name.append(" #generated");
1110 return name;
1111 }
1112 return mSourceFile;
1113}
1114
1115// =========================================================================
1116// =========================================================================
1117// =========================================================================
1118
1119status_t AaptGroup::addFile(const sp<AaptFile>& file)
1120{
1121 if (mFiles.indexOfKey(file->getGroupEntry()) < 0) {
1122 file->mPath = mPath;
1123 mFiles.add(file->getGroupEntry(), file);
1124 return NO_ERROR;
1125 }
1126
1127 SourcePos(file->getSourceFile(), -1).error("Duplicate file.\n%s: Original is here.",
1128 getPrintableSource().string());
1129 return UNKNOWN_ERROR;
1130}
1131
1132void AaptGroup::removeFile(size_t index)
1133{
1134 mFiles.removeItemsAt(index);
1135}
1136
1137void AaptGroup::print() const
1138{
1139 printf(" %s\n", getPath().string());
1140 const size_t N=mFiles.size();
1141 size_t i;
1142 for (i=0; i<N; i++) {
1143 sp<AaptFile> file = mFiles.valueAt(i);
1144 const AaptGroupEntry& e = file->getGroupEntry();
1145 if (file->hasData()) {
1146 printf(" Gen: (%s) %d bytes\n", e.toString().string(),
1147 (int)file->getSize());
1148 } else {
1149 printf(" Src: %s\n", file->getPrintableSource().string());
1150 }
1151 }
1152}
1153
1154String8 AaptGroup::getPrintableSource() const
1155{
1156 if (mFiles.size() > 0) {
1157 // Arbitrarily pull the first source file out of the list.
1158 return mFiles.valueAt(0)->getPrintableSource();
1159 }
1160
1161 // Should never hit this case, but to be safe...
1162 return getPath();
1163
1164}
1165
1166// =========================================================================
1167// =========================================================================
1168// =========================================================================
1169
1170status_t AaptDir::addFile(const String8& name, const sp<AaptGroup>& file)
1171{
1172 if (mFiles.indexOfKey(name) >= 0) {
1173 return ALREADY_EXISTS;
1174 }
1175 mFiles.add(name, file);
1176 return NO_ERROR;
1177}
1178
1179status_t AaptDir::addDir(const String8& name, const sp<AaptDir>& dir)
1180{
1181 if (mDirs.indexOfKey(name) >= 0) {
1182 return ALREADY_EXISTS;
1183 }
1184 mDirs.add(name, dir);
1185 return NO_ERROR;
1186}
1187
1188sp<AaptDir> AaptDir::makeDir(const String8& path)
1189{
1190 String8 name;
1191 String8 remain = path;
1192
1193 sp<AaptDir> subdir = this;
1194 while (name = remain.walkPath(&remain), remain != "") {
1195 subdir = subdir->makeDir(name);
1196 }
1197
1198 ssize_t i = subdir->mDirs.indexOfKey(name);
1199 if (i >= 0) {
1200 return subdir->mDirs.valueAt(i);
1201 }
1202 sp<AaptDir> dir = new AaptDir(name, subdir->mPath.appendPathCopy(name));
1203 subdir->mDirs.add(name, dir);
1204 return dir;
1205}
1206
1207void AaptDir::removeFile(const String8& name)
1208{
1209 mFiles.removeItem(name);
1210}
1211
1212void AaptDir::removeDir(const String8& name)
1213{
1214 mDirs.removeItem(name);
1215}
1216
1217status_t AaptDir::renameFile(const sp<AaptFile>& file, const String8& newName)
1218{
1219 sp<AaptGroup> origGroup;
1220
1221 // Find and remove the given file with shear, brute force!
1222 const size_t NG = mFiles.size();
1223 size_t i;
1224 for (i=0; origGroup == NULL && i<NG; i++) {
1225 sp<AaptGroup> g = mFiles.valueAt(i);
1226 const size_t NF = g->getFiles().size();
1227 for (size_t j=0; j<NF; j++) {
1228 if (g->getFiles().valueAt(j) == file) {
1229 origGroup = g;
1230 g->removeFile(j);
1231 if (NF == 1) {
1232 mFiles.removeItemsAt(i);
1233 }
1234 break;
1235 }
1236 }
1237 }
1238
1239 //printf("Renaming %s to %s\n", file->getPath().getPathName(), newName.string());
1240
1241 // Place the file under its new name.
1242 if (origGroup != NULL) {
1243 return addLeafFile(newName, file);
1244 }
1245
1246 return NO_ERROR;
1247}
1248
1249status_t AaptDir::addLeafFile(const String8& leafName, const sp<AaptFile>& file)
1250{
1251 sp<AaptGroup> group;
1252 if (mFiles.indexOfKey(leafName) >= 0) {
1253 group = mFiles.valueFor(leafName);
1254 } else {
1255 group = new AaptGroup(leafName, mPath.appendPathCopy(leafName));
1256 mFiles.add(leafName, group);
1257 }
1258
1259 return group->addFile(file);
1260}
1261
1262ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
1263 const AaptGroupEntry& kind, const String8& resType)
1264{
1265 Vector<String8> fileNames;
1266
1267 {
1268 DIR* dir = NULL;
1269
1270 dir = opendir(srcDir.string());
1271 if (dir == NULL) {
1272 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
1273 return UNKNOWN_ERROR;
1274 }
1275
1276 /*
1277 * Slurp the filenames out of the directory.
1278 */
1279 while (1) {
1280 struct dirent* entry;
1281
1282 entry = readdir(dir);
1283 if (entry == NULL)
1284 break;
1285
1286 if (isHidden(srcDir.string(), entry->d_name))
1287 continue;
1288
1289 fileNames.add(String8(entry->d_name));
1290 }
1291
1292 closedir(dir);
1293 }
1294
1295 ssize_t count = 0;
1296
1297 /*
1298 * Stash away the files and recursively descend into subdirectories.
1299 */
1300 const size_t N = fileNames.size();
1301 size_t i;
1302 for (i = 0; i < N; i++) {
1303 String8 pathName(srcDir);
1304 FileType type;
1305
1306 pathName.appendPath(fileNames[i].string());
1307 type = getFileType(pathName.string());
1308 if (type == kFileTypeDirectory) {
1309 sp<AaptDir> subdir;
1310 bool notAdded = false;
1311 if (mDirs.indexOfKey(fileNames[i]) >= 0) {
1312 subdir = mDirs.valueFor(fileNames[i]);
1313 } else {
1314 subdir = new AaptDir(fileNames[i], mPath.appendPathCopy(fileNames[i]));
1315 notAdded = true;
1316 }
1317 ssize_t res = subdir->slurpFullTree(bundle, pathName, kind,
1318 resType);
1319 if (res < NO_ERROR) {
1320 return res;
1321 }
1322 if (res > 0 && notAdded) {
1323 mDirs.add(fileNames[i], subdir);
1324 }
1325 count += res;
1326 } else if (type == kFileTypeRegular) {
1327 sp<AaptFile> file = new AaptFile(pathName, kind, resType);
1328 status_t err = addLeafFile(fileNames[i], file);
1329 if (err != NO_ERROR) {
1330 return err;
1331 }
1332
1333 count++;
1334
1335 } else {
1336 if (bundle->getVerbose())
1337 printf(" (ignoring non-file/dir '%s')\n", pathName.string());
1338 }
1339 }
1340
1341 return count;
1342}
1343
1344status_t AaptDir::validate() const
1345{
1346 const size_t NF = mFiles.size();
1347 const size_t ND = mDirs.size();
1348 size_t i;
1349 for (i = 0; i < NF; i++) {
1350 if (!validateFileName(mFiles.valueAt(i)->getLeaf().string())) {
1351 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1352 "Invalid filename. Unable to add.");
1353 return UNKNOWN_ERROR;
1354 }
1355
1356 size_t j;
1357 for (j = i+1; j < NF; j++) {
1358 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1359 mFiles.valueAt(j)->getLeaf().string()) == 0) {
1360 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1361 "File is case-insensitive equivalent to: %s",
1362 mFiles.valueAt(j)->getPrintableSource().string());
1363 return UNKNOWN_ERROR;
1364 }
1365
1366 // TODO: if ".gz", check for non-.gz; if non-, check for ".gz"
1367 // (this is mostly caught by the "marked" stuff, below)
1368 }
1369
1370 for (j = 0; j < ND; j++) {
1371 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1372 mDirs.valueAt(j)->getLeaf().string()) == 0) {
1373 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1374 "File conflicts with dir from: %s",
1375 mDirs.valueAt(j)->getPrintableSource().string());
1376 return UNKNOWN_ERROR;
1377 }
1378 }
1379 }
1380
1381 for (i = 0; i < ND; i++) {
1382 if (!validateFileName(mDirs.valueAt(i)->getLeaf().string())) {
1383 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1384 "Invalid directory name, unable to add.");
1385 return UNKNOWN_ERROR;
1386 }
1387
1388 size_t j;
1389 for (j = i+1; j < ND; j++) {
1390 if (strcasecmp(mDirs.valueAt(i)->getLeaf().string(),
1391 mDirs.valueAt(j)->getLeaf().string()) == 0) {
1392 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1393 "Directory is case-insensitive equivalent to: %s",
1394 mDirs.valueAt(j)->getPrintableSource().string());
1395 return UNKNOWN_ERROR;
1396 }
1397 }
1398
1399 status_t err = mDirs.valueAt(i)->validate();
1400 if (err != NO_ERROR) {
1401 return err;
1402 }
1403 }
1404
1405 return NO_ERROR;
1406}
1407
1408void AaptDir::print() const
1409{
1410 const size_t ND=getDirs().size();
1411 size_t i;
1412 for (i=0; i<ND; i++) {
1413 getDirs().valueAt(i)->print();
1414 }
1415
1416 const size_t NF=getFiles().size();
1417 for (i=0; i<NF; i++) {
1418 getFiles().valueAt(i)->print();
1419 }
1420}
1421
1422String8 AaptDir::getPrintableSource() const
1423{
1424 if (mFiles.size() > 0) {
1425 // Arbitrarily pull the first file out of the list as the source dir.
1426 return mFiles.valueAt(0)->getPrintableSource().getPathDir();
1427 }
1428 if (mDirs.size() > 0) {
1429 // Or arbitrarily pull the first dir out of the list as the source dir.
1430 return mDirs.valueAt(0)->getPrintableSource().getPathDir();
1431 }
1432
1433 // Should never hit this case, but to be safe...
1434 return mPath;
1435
1436}
1437
1438// =========================================================================
1439// =========================================================================
1440// =========================================================================
1441
1442sp<AaptFile> AaptAssets::addFile(
1443 const String8& filePath, const AaptGroupEntry& entry,
1444 const String8& srcDir, sp<AaptGroup>* outGroup,
1445 const String8& resType)
1446{
1447 sp<AaptDir> dir = this;
1448 sp<AaptGroup> group;
1449 sp<AaptFile> file;
1450 String8 root, remain(filePath), partialPath;
1451 while (remain.length() > 0) {
1452 root = remain.walkPath(&remain);
1453 partialPath.appendPath(root);
1454
1455 const String8 rootStr(root);
1456
1457 if (remain.length() == 0) {
1458 ssize_t i = dir->getFiles().indexOfKey(rootStr);
1459 if (i >= 0) {
1460 group = dir->getFiles().valueAt(i);
1461 } else {
1462 group = new AaptGroup(rootStr, filePath);
1463 status_t res = dir->addFile(rootStr, group);
1464 if (res != NO_ERROR) {
1465 return NULL;
1466 }
1467 }
1468 file = new AaptFile(srcDir.appendPathCopy(filePath), entry, resType);
1469 status_t res = group->addFile(file);
1470 if (res != NO_ERROR) {
1471 return NULL;
1472 }
1473 break;
1474
1475 } else {
1476 ssize_t i = dir->getDirs().indexOfKey(rootStr);
1477 if (i >= 0) {
1478 dir = dir->getDirs().valueAt(i);
1479 } else {
1480 sp<AaptDir> subdir = new AaptDir(rootStr, partialPath);
1481 status_t res = dir->addDir(rootStr, subdir);
1482 if (res != NO_ERROR) {
1483 return NULL;
1484 }
1485 dir = subdir;
1486 }
1487 }
1488 }
1489
1490 mGroupEntries.add(entry);
1491 if (outGroup) *outGroup = group;
1492 return file;
1493}
1494
1495void AaptAssets::addResource(const String8& leafName, const String8& path,
1496 const sp<AaptFile>& file, const String8& resType)
1497{
1498 sp<AaptDir> res = AaptDir::makeDir(kResString);
1499 String8 dirname = file->getGroupEntry().toDirName(resType);
1500 sp<AaptDir> subdir = res->makeDir(dirname);
1501 sp<AaptGroup> grr = new AaptGroup(leafName, path);
1502 grr->addFile(file);
1503
1504 subdir->addFile(leafName, grr);
1505}
1506
1507
1508ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
1509{
1510 int count;
1511 int totalCount = 0;
1512 FileType type;
1513 const Vector<const char *>& resDirs = bundle->getResourceSourceDirs();
1514 const size_t dirCount =resDirs.size();
1515 sp<AaptAssets> current = this;
1516
1517 const int N = bundle->getFileSpecCount();
1518
1519 /*
1520 * If a package manifest was specified, include that first.
1521 */
1522 if (bundle->getAndroidManifestFile() != NULL) {
1523 // place at root of zip.
1524 String8 srcFile(bundle->getAndroidManifestFile());
1525 addFile(srcFile.getPathLeaf(), AaptGroupEntry(), srcFile.getPathDir(),
1526 NULL, String8());
1527 totalCount++;
1528 }
1529
1530 /*
1531 * If a directory of custom assets was supplied, slurp 'em up.
1532 */
1533 if (bundle->getAssetSourceDir()) {
1534 const char* assetDir = bundle->getAssetSourceDir();
1535
1536 FileType type = getFileType(assetDir);
1537 if (type == kFileTypeNonexistent) {
1538 fprintf(stderr, "ERROR: asset directory '%s' does not exist\n", assetDir);
1539 return UNKNOWN_ERROR;
1540 }
1541 if (type != kFileTypeDirectory) {
1542 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir);
1543 return UNKNOWN_ERROR;
1544 }
1545
1546 String8 assetRoot(assetDir);
1547 sp<AaptDir> assetAaptDir = makeDir(String8(kAssetDir));
1548 AaptGroupEntry group;
1549 count = assetAaptDir->slurpFullTree(bundle, assetRoot, group,
1550 String8());
1551 if (count < 0) {
1552 totalCount = count;
1553 goto bail;
1554 }
1555 if (count > 0) {
1556 mGroupEntries.add(group);
1557 }
1558 totalCount += count;
1559
1560 if (bundle->getVerbose())
1561 printf("Found %d custom asset file%s in %s\n",
1562 count, (count==1) ? "" : "s", assetDir);
1563 }
1564
1565 /*
1566 * If a directory of resource-specific assets was supplied, slurp 'em up.
1567 */
1568 for (size_t i=0; i<dirCount; i++) {
1569 const char *res = resDirs[i];
1570 if (res) {
1571 type = getFileType(res);
1572 if (type == kFileTypeNonexistent) {
1573 fprintf(stderr, "ERROR: resource directory '%s' does not exist\n", res);
1574 return UNKNOWN_ERROR;
1575 }
1576 if (type == kFileTypeDirectory) {
1577 if (i>0) {
1578 sp<AaptAssets> nextOverlay = new AaptAssets();
1579 current->setOverlay(nextOverlay);
1580 current = nextOverlay;
1581 }
1582 count = current->slurpResourceTree(bundle, String8(res));
1583
1584 if (count < 0) {
1585 totalCount = count;
1586 goto bail;
1587 }
1588 totalCount += count;
1589 }
1590 else {
1591 fprintf(stderr, "ERROR: '%s' is not a directory\n", res);
1592 return UNKNOWN_ERROR;
1593 }
1594 }
1595
1596 }
1597 /*
1598 * Now do any additional raw files.
1599 */
1600 for (int arg=0; arg<N; arg++) {
1601 const char* assetDir = bundle->getFileSpecEntry(arg);
1602
1603 FileType type = getFileType(assetDir);
1604 if (type == kFileTypeNonexistent) {
1605 fprintf(stderr, "ERROR: input directory '%s' does not exist\n", assetDir);
1606 return UNKNOWN_ERROR;
1607 }
1608 if (type != kFileTypeDirectory) {
1609 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir);
1610 return UNKNOWN_ERROR;
1611 }
1612
1613 String8 assetRoot(assetDir);
1614
1615 if (bundle->getVerbose())
1616 printf("Processing raw dir '%s'\n", (const char*) assetDir);
1617
1618 /*
1619 * Do a recursive traversal of subdir tree. We don't make any
1620 * guarantees about ordering, so we're okay with an inorder search
1621 * using whatever order the OS happens to hand back to us.
1622 */
1623 count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8());
1624 if (count < 0) {
1625 /* failure; report error and remove archive */
1626 totalCount = count;
1627 goto bail;
1628 }
1629 totalCount += count;
1630
1631 if (bundle->getVerbose())
1632 printf("Found %d asset file%s in %s\n",
1633 count, (count==1) ? "" : "s", assetDir);
1634 }
1635
1636 count = validate();
1637 if (count != NO_ERROR) {
1638 totalCount = count;
1639 goto bail;
1640 }
1641
1642
1643bail:
1644 return totalCount;
1645}
1646
1647ssize_t AaptAssets::slurpFullTree(Bundle* bundle, const String8& srcDir,
1648 const AaptGroupEntry& kind,
1649 const String8& resType)
1650{
1651 ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType);
1652 if (res > 0) {
1653 mGroupEntries.add(kind);
1654 }
1655
1656 return res;
1657}
1658
1659ssize_t AaptAssets::slurpResourceTree(Bundle* bundle, const String8& srcDir)
1660{
1661 ssize_t err = 0;
1662
1663 DIR* dir = opendir(srcDir.string());
1664 if (dir == NULL) {
1665 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
1666 return UNKNOWN_ERROR;
1667 }
1668
1669 status_t count = 0;
1670
1671 /*
1672 * Run through the directory, looking for dirs that match the
1673 * expected pattern.
1674 */
1675 while (1) {
1676 struct dirent* entry = readdir(dir);
1677 if (entry == NULL) {
1678 break;
1679 }
1680
1681 if (isHidden(srcDir.string(), entry->d_name)) {
1682 continue;
1683 }
1684
1685 String8 subdirName(srcDir);
1686 subdirName.appendPath(entry->d_name);
1687
1688 AaptGroupEntry group;
1689 String8 resType;
1690 bool b = group.initFromDirName(entry->d_name, &resType);
1691 if (!b) {
1692 fprintf(stderr, "invalid resource directory name: %s/%s\n", srcDir.string(),
1693 entry->d_name);
1694 err = -1;
1695 continue;
1696 }
1697
1698 FileType type = getFileType(subdirName.string());
1699
1700 if (type == kFileTypeDirectory) {
1701 sp<AaptDir> dir = makeDir(String8(entry->d_name));
1702 ssize_t res = dir->slurpFullTree(bundle, subdirName, group,
1703 resType);
1704 if (res < 0) {
1705 count = res;
1706 goto bail;
1707 }
1708 if (res > 0) {
1709 mGroupEntries.add(group);
1710 count += res;
1711 }
1712
1713 mDirs.add(dir);
1714 } else {
1715 if (bundle->getVerbose()) {
1716 fprintf(stderr, " (ignoring file '%s')\n", subdirName.string());
1717 }
1718 }
1719 }
1720
1721bail:
1722 closedir(dir);
1723 dir = NULL;
1724
1725 if (err != 0) {
1726 return err;
1727 }
1728 return count;
1729}
1730
1731ssize_t
1732AaptAssets::slurpResourceZip(Bundle* bundle, const char* filename)
1733{
1734 int count = 0;
1735 SortedVector<AaptGroupEntry> entries;
1736
1737 ZipFile* zip = new ZipFile;
1738 status_t err = zip->open(filename, ZipFile::kOpenReadOnly);
1739 if (err != NO_ERROR) {
1740 fprintf(stderr, "error opening zip file %s\n", filename);
1741 count = err;
1742 delete zip;
1743 return -1;
1744 }
1745
1746 const int N = zip->getNumEntries();
1747 for (int i=0; i<N; i++) {
1748 ZipEntry* entry = zip->getEntryByIndex(i);
1749 if (entry->getDeleted()) {
1750 continue;
1751 }
1752
1753 String8 entryName(entry->getFileName());
1754
1755 String8 dirName = entryName.getPathDir();
1756 sp<AaptDir> dir = dirName == "" ? this : makeDir(dirName);
1757
1758 String8 resType;
1759 AaptGroupEntry kind;
1760
1761 String8 remain;
1762 if (entryName.walkPath(&remain) == kResourceDir) {
1763 // these are the resources, pull their type out of the directory name
1764 kind.initFromDirName(remain.walkPath().string(), &resType);
1765 } else {
1766 // these are untyped and don't have an AaptGroupEntry
1767 }
1768 if (entries.indexOf(kind) < 0) {
1769 entries.add(kind);
1770 mGroupEntries.add(kind);
1771 }
1772
1773 // use the one from the zip file if they both exist.
1774 dir->removeFile(entryName.getPathLeaf());
1775
1776 sp<AaptFile> file = new AaptFile(entryName, kind, resType);
1777 status_t err = dir->addLeafFile(entryName.getPathLeaf(), file);
1778 if (err != NO_ERROR) {
1779 fprintf(stderr, "err=%s entryName=%s\n", strerror(err), entryName.string());
1780 count = err;
1781 goto bail;
1782 }
1783 file->setCompressionMethod(entry->getCompressionMethod());
1784
1785#if 0
1786 if (entryName == "AndroidManifest.xml") {
1787 printf("AndroidManifest.xml\n");
1788 }
1789 printf("\n\nfile: %s\n", entryName.string());
1790#endif
1791
1792 size_t len = entry->getUncompressedLen();
1793 void* data = zip->uncompress(entry);
1794 void* buf = file->editData(len);
1795 memcpy(buf, data, len);
1796
1797#if 0
1798 const int OFF = 0;
1799 const unsigned char* p = (unsigned char*)data;
1800 const unsigned char* end = p+len;
1801 p += OFF;
1802 for (int i=0; i<32 && p < end; i++) {
1803 printf("0x%03x ", i*0x10 + OFF);
1804 for (int j=0; j<0x10 && p < end; j++) {
1805 printf(" %02x", *p);
1806 p++;
1807 }
1808 printf("\n");
1809 }
1810#endif
1811
1812 free(data);
1813
1814 count++;
1815 }
1816
1817bail:
1818 delete zip;
1819 return count;
1820}
1821
1822sp<AaptSymbols> AaptAssets::getSymbolsFor(const String8& name)
1823{
1824 sp<AaptSymbols> sym = mSymbols.valueFor(name);
1825 if (sym == NULL) {
1826 sym = new AaptSymbols();
1827 mSymbols.add(name, sym);
1828 }
1829 return sym;
1830}
1831
1832status_t AaptAssets::buildIncludedResources(Bundle* bundle)
1833{
1834 if (!mHaveIncludedAssets) {
1835 // Add in all includes.
1836 const Vector<const char*>& incl = bundle->getPackageIncludes();
1837 const size_t N=incl.size();
1838 for (size_t i=0; i<N; i++) {
1839 if (bundle->getVerbose())
1840 printf("Including resources from package: %s\n", incl[i]);
1841 if (!mIncludedAssets.addAssetPath(String8(incl[i]), NULL)) {
1842 fprintf(stderr, "ERROR: Asset package include '%s' not found.\n",
1843 incl[i]);
1844 return UNKNOWN_ERROR;
1845 }
1846 }
1847 mHaveIncludedAssets = true;
1848 }
1849
1850 return NO_ERROR;
1851}
1852
1853status_t AaptAssets::addIncludedResources(const sp<AaptFile>& file)
1854{
1855 const ResTable& res = getIncludedResources();
1856 // XXX dirty!
1857 return const_cast<ResTable&>(res).add(file->getData(), file->getSize(), NULL);
1858}
1859
1860const ResTable& AaptAssets::getIncludedResources() const
1861{
1862 return mIncludedAssets.getResources(false);
1863}
1864
1865void AaptAssets::print() const
1866{
1867 printf("Locale/Vendor pairs:\n");
1868 const size_t N=mGroupEntries.size();
1869 for (size_t i=0; i<N; i++) {
1870 printf(" %s/%s\n",
1871 mGroupEntries.itemAt(i).locale.string(),
1872 mGroupEntries.itemAt(i).vendor.string());
1873 }
1874
1875 printf("\nFiles:\n");
1876 AaptDir::print();
1877}
1878
1879sp<AaptDir> AaptAssets::resDir(const String8& name)
1880{
1881 const Vector<sp<AaptDir> >& dirs = mDirs;
1882 const size_t N = dirs.size();
1883 for (size_t i=0; i<N; i++) {
1884 const sp<AaptDir>& d = dirs.itemAt(i);
1885 if (d->getLeaf() == name) {
1886 return d;
1887 }
1888 }
1889 return NULL;
1890}
1891
1892bool
1893valid_symbol_name(const String8& symbol)
1894{
1895 static char const * const KEYWORDS[] = {
1896 "abstract", "assert", "boolean", "break",
1897 "byte", "case", "catch", "char", "class", "const", "continue",
1898 "default", "do", "double", "else", "enum", "extends", "final",
1899 "finally", "float", "for", "goto", "if", "implements", "import",
1900 "instanceof", "int", "interface", "long", "native", "new", "package",
1901 "private", "protected", "public", "return", "short", "static",
1902 "strictfp", "super", "switch", "synchronized", "this", "throw",
1903 "throws", "transient", "try", "void", "volatile", "while",
1904 "true", "false", "null",
1905 NULL
1906 };
1907 const char*const* k = KEYWORDS;
1908 const char*const s = symbol.string();
1909 while (*k) {
1910 if (0 == strcmp(s, *k)) {
1911 return false;
1912 }
1913 k++;
1914 }
1915 return true;
1916}
mirror of aapt