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