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