AaptAssets.h

   1 //
   2 // Copyright 2006 The Android Open Source Project
   3 //
   4 // Information about assets being operated on.
   5 //
   6 #ifndef __AAPT_ASSETS_H
   7 #define __AAPT_ASSETS_H
   8
   9 #include <stdlib.h>
  10 #include <androidfw/AssetManager.h>
  11 #include <androidfw/ResourceTypes.h>
  12 #include <utils/KeyedVector.h>
  13 #include <utils/RefBase.h>
  14 #include <utils/SortedVector.h>
  15 #include <utils/String8.h>
  16 #include <utils/String8.h>
  17 #include <utils/Vector.h>
  18 #include "ZipFile.h"
  19
  20 #include "Bundle.h"
  21 #include "SourcePos.h"
  22
  23 using namespace android;
  24
  25
  26 extern const char * const gDefaultIgnoreAssets;
  27 extern const char * gUserIgnoreAssets;
  28
  29 bool valid_symbol_name(const String8& str);
  30
  31 class AaptAssets;
  32
  33 enum {
  34     AXIS_NONE = 0,
  35     AXIS_MCC = 1,
  36     AXIS_MNC,
  37     AXIS_LANGUAGE,
  38     AXIS_REGION,
  39     AXIS_SCREENLAYOUTSIZE,
  40     AXIS_SCREENLAYOUTLONG,
  41     AXIS_ORIENTATION,
  42     AXIS_UIMODETYPE,
  43     AXIS_UIMODENIGHT,
  44     AXIS_DENSITY,
  45     AXIS_TOUCHSCREEN,
  46     AXIS_KEYSHIDDEN,
  47     AXIS_KEYBOARD,
  48     AXIS_NAVHIDDEN,
  49     AXIS_NAVIGATION,
  50     AXIS_SCREENSIZE,
  51     AXIS_SMALLESTSCREENWIDTHDP,
  52     AXIS_SCREENWIDTHDP,
  53     AXIS_SCREENHEIGHTDP,
  54     AXIS_LAYOUTDIR,
  55     AXIS_VERSION,
  56
  57     AXIS_START = AXIS_MCC,
  58     AXIS_END = AXIS_VERSION,
  59 };
  60
  61 /**
  62  * This structure contains a specific variation of a single file out
  63  * of all the variations it can have that we can have.
  64  */
  65 struct AaptGroupEntry
  66 {
  67 public:
  68     AaptGroupEntry() : mParamsChanged(true) { }
  69     AaptGroupEntry(const String8& _locale, const String8& _vendor)
  70         : locale(_locale), vendor(_vendor), mParamsChanged(true) { }
  71
  72     bool initFromDirName(const char* dir, String8* resType);
  73
  74     static status_t parseNamePart(const String8& part, int* axis, uint32_t* value);
  75
  76     static uint32_t getConfigValueForAxis(const ResTable_config& config, int axis);
  77
  78     static bool configSameExcept(const ResTable_config& config,
  79             const ResTable_config& otherConfig, int axis);
  80
  81     static bool getMccName(const char* name, ResTable_config* out = NULL);
  82     static bool getMncName(const char* name, ResTable_config* out = NULL);
  83     static bool getLocaleName(const char* name, ResTable_config* out = NULL);
  84     static bool getScreenLayoutSizeName(const char* name, ResTable_config* out = NULL);
  85     static bool getScreenLayoutLongName(const char* name, ResTable_config* out = NULL);
  86     static bool getOrientationName(const char* name, ResTable_config* out = NULL);
  87     static bool getUiModeTypeName(const char* name, ResTable_config* out = NULL);
  88     static bool getUiModeNightName(const char* name, ResTable_config* out = NULL);
  89     static bool getDensityName(const char* name, ResTable_config* out = NULL);
  90     static bool getTouchscreenName(const char* name, ResTable_config* out = NULL);
  91     static bool getKeysHiddenName(const char* name, ResTable_config* out = NULL);
  92     static bool getKeyboardName(const char* name, ResTable_config* out = NULL);
  93     static bool getNavigationName(const char* name, ResTable_config* out = NULL);
  94     static bool getNavHiddenName(const char* name, ResTable_config* out = NULL);
  95     static bool getScreenSizeName(const char* name, ResTable_config* out = NULL);
  96     static bool getSmallestScreenWidthDpName(const char* name, ResTable_config* out = NULL);
  97     static bool getScreenWidthDpName(const char* name, ResTable_config* out = NULL);
  98     static bool getScreenHeightDpName(const char* name, ResTable_config* out = NULL);
  99     static bool getLayoutDirectionName(const char* name, ResTable_config* out = NULL);
 100     static bool getVersionName(const char* name, ResTable_config* out = NULL);
 101
 102     int compare(const AaptGroupEntry& o) const;
 103
 104     const ResTable_config& toParams() const;
 105
 106     inline bool operator<(const AaptGroupEntry& o) const { return compare(o) < 0; }
 107     inline bool operator<=(const AaptGroupEntry& o) const { return compare(o) <= 0; }
 108     inline bool operator==(const AaptGroupEntry& o) const { return compare(o) == 0; }
 109     inline bool operator!=(const AaptGroupEntry& o) const { return compare(o) != 0; }
 110     inline bool operator>=(const AaptGroupEntry& o) const { return compare(o) >= 0; }
 111     inline bool operator>(const AaptGroupEntry& o) const { return compare(o) > 0; }
 112
 113     String8 toString() const;
 114     String8 toDirName(const String8& resType) const;
 115
 116     const String8& getVersionString() const { return version; }
 117
 118 private:
 119     String8 mcc;
 120     String8 mnc;
 121     String8 locale;
 122     String8 vendor;
 123     String8 smallestScreenWidthDp;
 124     String8 screenWidthDp;
 125     String8 screenHeightDp;
 126     String8 screenLayoutSize;
 127     String8 screenLayoutLong;
 128     String8 orientation;
 129     String8 uiModeType;
 130     String8 uiModeNight;
 131     String8 density;
 132     String8 touchscreen;
 133     String8 keysHidden;
 134     String8 keyboard;
 135     String8 navHidden;
 136     String8 navigation;
 137     String8 screenSize;
 138     String8 layoutDirection;
 139     String8 version;
 140
 141     mutable bool mParamsChanged;
 142     mutable ResTable_config mParams;
 143 };
 144
 145 inline int compare_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs)
 146 {
 147     return lhs.compare(rhs);
 148 }
 149
 150 inline int strictly_order_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs)
 151 {
 152     return compare_type(lhs, rhs) < 0;
 153 }
 154
 155 class AaptGroup;
 156 class FilePathStore;
 157
 158 /**
 159  * A single asset file we know about.
 160  */
 161 class AaptFile : public RefBase
 162 {
 163 public:
 164     AaptFile(const String8& sourceFile, const AaptGroupEntry& groupEntry,
 165              const String8& resType)
 166         : mGroupEntry(groupEntry)
 167         , mResourceType(resType)
 168         , mSourceFile(sourceFile)
 169         , mData(NULL)
 170         , mDataSize(0)
 171         , mBufferSize(0)
 172         , mCompression(ZipEntry::kCompressStored)
 173         {
 174             //printf("new AaptFile created %s\n", (const char*)sourceFile);
 175         }
 176     virtual ~AaptFile() {
 177         free(mData);
 178     }
 179
 180     const String8& getPath() const { return mPath; }
 181     const AaptGroupEntry& getGroupEntry() const { return mGroupEntry; }
 182
 183     // Data API.  If there is data attached to the file,
 184     // getSourceFile() is not used.
 185     bool hasData() const { return mData != NULL; }
 186     const void* getData() const { return mData; }
 187     size_t getSize() const { return mDataSize; }
 188     void* editData(size_t size);
 189     void* editData(size_t* outSize = NULL);
 190     void* padData(size_t wordSize);
 191     status_t writeData(const void* data, size_t size);
 192     void clearData();
 193
 194     const String8& getResourceType() const { return mResourceType; }
 195
 196     // File API.  If the file does not hold raw data, this is
 197     // a full path to a file on the filesystem that holds its data.
 198     const String8& getSourceFile() const { return mSourceFile; }
 199
 200     String8 getPrintableSource() const;
 201
 202     // Desired compression method, as per utils/ZipEntry.h.  For example,
 203     // no compression is ZipEntry::kCompressStored.
 204     int getCompressionMethod() const { return mCompression; }
 205     void setCompressionMethod(int c) { mCompression = c; }
 206 private:
 207     friend class AaptGroup;
 208
 209     String8 mPath;
 210     AaptGroupEntry mGroupEntry;
 211     String8 mResourceType;
 212     String8 mSourceFile;
 213     void* mData;
 214     size_t mDataSize;
 215     size_t mBufferSize;
 216     int mCompression;
 217 };
 218
 219 /**
 220  * A group of related files (the same file, with different
 221  * vendor/locale variations).
 222  */
 223 class AaptGroup : public RefBase
 224 {
 225 public:
 226     AaptGroup(const String8& leaf, const String8& path)
 227         : mLeaf(leaf), mPath(path) { }
 228     virtual ~AaptGroup() { }
 229
 230     const String8& getLeaf() const { return mLeaf; }
 231
 232     // Returns the relative path after the AaptGroupEntry dirs.
 233     const String8& getPath() const { return mPath; }
 234
 235     const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& getFiles() const
 236         { return mFiles; }
 237
 238     status_t addFile(const sp<AaptFile>& file);
 239     void removeFile(size_t index);
 240
 241     void print(const String8& prefix) const;
 242
 243     String8 getPrintableSource() const;
 244
 245 private:
 246     String8 mLeaf;
 247     String8 mPath;
 248
 249     DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > mFiles;
 250 };
 251
 252 /**
 253  * A single directory of assets, which can contain files and other
 254  * sub-directories.
 255  */
 256 class AaptDir : public RefBase
 257 {
 258 public:
 259     AaptDir(const String8& leaf, const String8& path)
 260         : mLeaf(leaf), mPath(path) { }
 261     virtual ~AaptDir() { }
 262
 263     const String8& getLeaf() const { return mLeaf; }
 264
 265     const String8& getPath() const { return mPath; }
 266
 267     const DefaultKeyedVector<String8, sp<AaptGroup> >& getFiles() const { return mFiles; }
 268     const DefaultKeyedVector<String8, sp<AaptDir> >& getDirs() const { return mDirs; }
 269
 270     virtual status_t addFile(const String8& name, const sp<AaptGroup>& file);
 271
 272     void removeFile(const String8& name);
 273     void removeDir(const String8& name);
 274
 275     /*
 276      * Perform some sanity checks on the names of files and directories here.
 277      * In particular:
 278      *  - Check for illegal chars in filenames.
 279      *  - Check filename length.
 280      *  - Check for presence of ".gz" and non-".gz" copies of same file.
 281      *  - Check for multiple files whose names match in a case-insensitive
 282      *    fashion (problematic for some systems).
 283      *
 284      * Comparing names against all other names is O(n^2).  We could speed
 285      * it up some by sorting the entries and being smarter about what we
 286      * compare against, but I'm not expecting to have enough files in a
 287      * single directory to make a noticeable difference in speed.
 288      *
 289      * Note that sorting here is not enough to guarantee that the package
 290      * contents are sorted -- subsequent updates can rearrange things.
 291      */
 292     status_t validate() const;
 293
 294     void print(const String8& prefix) const;
 295
 296     String8 getPrintableSource() const;
 297
 298 private:
 299     friend class AaptAssets;
 300
 301     status_t addDir(const String8& name, const sp<AaptDir>& dir);
 302     sp<AaptDir> makeDir(const String8& name);
 303     status_t addLeafFile(const String8& leafName,
 304                          const sp<AaptFile>& file);
 305     virtual ssize_t slurpFullTree(Bundle* bundle,
 306                                   const String8& srcDir,
 307                                   const AaptGroupEntry& kind,
 308                                   const String8& resType,
 309                                   sp<FilePathStore>& fullResPaths);
 310
 311     String8 mLeaf;
 312     String8 mPath;
 313
 314     DefaultKeyedVector<String8, sp<AaptGroup> > mFiles;
 315     DefaultKeyedVector<String8, sp<AaptDir> > mDirs;
 316 };
 317
 318 /**
 319  * All information we know about a particular symbol.
 320  */
 321 class AaptSymbolEntry
 322 {
 323 public:
 324     AaptSymbolEntry()
 325         : isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN)
 326     {
 327     }
 328     AaptSymbolEntry(const String8& _name)
 329         : name(_name), isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN)
 330     {
 331     }
 332     AaptSymbolEntry(const AaptSymbolEntry& o)
 333         : name(o.name), sourcePos(o.sourcePos), isPublic(o.isPublic)
 334         , isJavaSymbol(o.isJavaSymbol), comment(o.comment), typeComment(o.typeComment)
 335         , typeCode(o.typeCode), int32Val(o.int32Val), stringVal(o.stringVal)
 336     {
 337     }
 338     AaptSymbolEntry operator=(const AaptSymbolEntry& o)
 339     {
 340         sourcePos = o.sourcePos;
 341         isPublic = o.isPublic;
 342         isJavaSymbol = o.isJavaSymbol;
 343         comment = o.comment;
 344         typeComment = o.typeComment;
 345         typeCode = o.typeCode;
 346         int32Val = o.int32Val;
 347         stringVal = o.stringVal;
 348         return *this;
 349     }
 350
 351     const String8 name;
 352
 353     SourcePos sourcePos;
 354     bool isPublic;
 355     bool isJavaSymbol;
 356
 357     String16 comment;
 358     String16 typeComment;
 359
 360     enum {
 361         TYPE_UNKNOWN = 0,
 362         TYPE_INT32,
 363         TYPE_STRING
 364     };
 365
 366     int typeCode;
 367
 368     // Value.  May be one of these.
 369     int32_t int32Val;
 370     String8 stringVal;
 371 };
 372
 373 /**
 374  * A group of related symbols (such as indices into a string block)
 375  * that have been generated from the assets.
 376  */
 377 class AaptSymbols : public RefBase
 378 {
 379 public:
 380     AaptSymbols() { }
 381     virtual ~AaptSymbols() { }
 382
 383     status_t addSymbol(const String8& name, int32_t value, const SourcePos& pos) {
 384         if (!check_valid_symbol_name(name, pos, "symbol")) {
 385             return BAD_VALUE;
 386         }
 387         AaptSymbolEntry& sym = edit_symbol(name, &pos);
 388         sym.typeCode = AaptSymbolEntry::TYPE_INT32;
 389         sym.int32Val = value;
 390         return NO_ERROR;
 391     }
 392
 393     status_t addStringSymbol(const String8& name, const String8& value,
 394             const SourcePos& pos) {
 395         if (!check_valid_symbol_name(name, pos, "symbol")) {
 396             return BAD_VALUE;
 397         }
 398         AaptSymbolEntry& sym = edit_symbol(name, &pos);
 399         sym.typeCode = AaptSymbolEntry::TYPE_STRING;
 400         sym.stringVal = value;
 401         return NO_ERROR;
 402     }
 403
 404     status_t makeSymbolPublic(const String8& name, const SourcePos& pos) {
 405         if (!check_valid_symbol_name(name, pos, "symbol")) {
 406             return BAD_VALUE;
 407         }
 408         AaptSymbolEntry& sym = edit_symbol(name, &pos);
 409         sym.isPublic = true;
 410         return NO_ERROR;
 411     }
 412
 413     status_t makeSymbolJavaSymbol(const String8& name, const SourcePos& pos) {
 414         if (!check_valid_symbol_name(name, pos, "symbol")) {
 415             return BAD_VALUE;
 416         }
 417         AaptSymbolEntry& sym = edit_symbol(name, &pos);
 418         sym.isJavaSymbol = true;
 419         return NO_ERROR;
 420     }
 421
 422     void appendComment(const String8& name, const String16& comment, const SourcePos& pos) {
 423         if (comment.size() <= 0) {
 424             return;
 425         }
 426         AaptSymbolEntry& sym = edit_symbol(name, &pos);
 427         if (sym.comment.size() == 0) {
 428             sym.comment = comment;
 429         } else {
 430             sym.comment.append(String16("\n"));
 431             sym.comment.append(comment);
 432         }
 433     }
 434
 435     void appendTypeComment(const String8& name, const String16& comment) {
 436         if (comment.size() <= 0) {
 437             return;
 438         }
 439         AaptSymbolEntry& sym = edit_symbol(name, NULL);
 440         if (sym.typeComment.size() == 0) {
 441             sym.typeComment = comment;
 442         } else {
 443             sym.typeComment.append(String16("\n"));
 444             sym.typeComment.append(comment);
 445         }
 446     }
 447
 448     sp<AaptSymbols> addNestedSymbol(const String8& name, const SourcePos& pos) {
 449         if (!check_valid_symbol_name(name, pos, "nested symbol")) {
 450             return NULL;
 451         }
 452
 453         sp<AaptSymbols> sym = mNestedSymbols.valueFor(name);
 454         if (sym == NULL) {
 455             sym = new AaptSymbols();
 456             mNestedSymbols.add(name, sym);
 457         }
 458
 459         return sym;
 460     }
 461
 462     status_t applyJavaSymbols(const sp<AaptSymbols>& javaSymbols);
 463
 464     const KeyedVector<String8, AaptSymbolEntry>& getSymbols() const
 465         { return mSymbols; }
 466     const DefaultKeyedVector<String8, sp<AaptSymbols> >& getNestedSymbols() const
 467         { return mNestedSymbols; }
 468
 469     const String16& getComment(const String8& name) const
 470         { return get_symbol(name).comment; }
 471     const String16& getTypeComment(const String8& name) const
 472         { return get_symbol(name).typeComment; }
 473
 474 private:
 475     bool check_valid_symbol_name(const String8& symbol, const SourcePos& pos, const char* label) {
 476         if (valid_symbol_name(symbol)) {
 477             return true;
 478         }
 479         pos.error("invalid %s: '%s'\n", label, symbol.string());
 480         return false;
 481     }
 482     AaptSymbolEntry& edit_symbol(const String8& symbol, const SourcePos* pos) {
 483         ssize_t i = mSymbols.indexOfKey(symbol);
 484         if (i < 0) {
 485             i = mSymbols.add(symbol, AaptSymbolEntry(symbol));
 486         }
 487         AaptSymbolEntry& sym = mSymbols.editValueAt(i);
 488         if (pos != NULL && sym.sourcePos.line < 0) {
 489             sym.sourcePos = *pos;
 490         }
 491         return sym;
 492     }
 493     const AaptSymbolEntry& get_symbol(const String8& symbol) const {
 494         ssize_t i = mSymbols.indexOfKey(symbol);
 495         if (i >= 0) {
 496             return mSymbols.valueAt(i);
 497         }
 498         return mDefSymbol;
 499     }
 500
 501     KeyedVector<String8, AaptSymbolEntry>           mSymbols;
 502     DefaultKeyedVector<String8, sp<AaptSymbols> >   mNestedSymbols;
 503     AaptSymbolEntry                                 mDefSymbol;
 504 };
 505
 506 class ResourceTypeSet : public RefBase,
 507                         public KeyedVector<String8,sp<AaptGroup> >
 508 {
 509 public:
 510     ResourceTypeSet();
 511 };
 512
 513 // Storage for lists of fully qualified paths for
 514 // resources encountered during slurping.
 515 class FilePathStore : public RefBase,
 516                       public Vector<String8>
 517 {
 518 public:
 519     FilePathStore();
 520 };
 521
 522 /**
 523  * Asset hierarchy being operated on.
 524  */
 525 class AaptAssets : public AaptDir
 526 {
 527 public:
 528     AaptAssets();
 529     virtual ~AaptAssets() { delete mRes; }
 530
 531     const String8& getPackage() const { return mPackage; }
 532     void setPackage(const String8& package) {
 533         mPackage = package;
 534         mSymbolsPrivatePackage = package;
 535         mHavePrivateSymbols = false;
 536     }
 537
 538     const SortedVector<AaptGroupEntry>& getGroupEntries() const;
 539
 540     virtual status_t addFile(const String8& name, const sp<AaptGroup>& file);
 541
 542     sp<AaptFile> addFile(const String8& filePath,
 543                          const AaptGroupEntry& entry,
 544                          const String8& srcDir,
 545                          sp<AaptGroup>* outGroup,
 546                          const String8& resType);
 547
 548     void addResource(const String8& leafName,
 549                      const String8& path,
 550                      const sp<AaptFile>& file,
 551                      const String8& resType);
 552
 553     void addGroupEntry(const AaptGroupEntry& entry) { mGroupEntries.add(entry); }
 554
 555     ssize_t slurpFromArgs(Bundle* bundle);
 556
 557     sp<AaptSymbols> getSymbolsFor(const String8& name);
 558
 559     sp<AaptSymbols> getJavaSymbolsFor(const String8& name);
 560
 561     status_t applyJavaSymbols();
 562
 563     const DefaultKeyedVector<String8, sp<AaptSymbols> >& getSymbols() const { return mSymbols; }
 564
 565     String8 getSymbolsPrivatePackage() const { return mSymbolsPrivatePackage; }
 566     void setSymbolsPrivatePackage(const String8& pkg) {
 567         mSymbolsPrivatePackage = pkg;
 568         mHavePrivateSymbols = mSymbolsPrivatePackage != mPackage;
 569     }
 570
 571     bool havePrivateSymbols() const { return mHavePrivateSymbols; }
 572
 573     bool isJavaSymbol(const AaptSymbolEntry& sym, bool includePrivate) const;
 574
 575     status_t buildIncludedResources(Bundle* bundle);
 576     status_t addIncludedResources(const sp<AaptFile>& file);
 577     const ResTable& getIncludedResources() const;
 578
 579     void print(const String8& prefix) const;
 580
 581     inline const Vector<sp<AaptDir> >& resDirs() const { return mResDirs; }
 582     sp<AaptDir> resDir(const String8& name) const;
 583
 584     inline sp<AaptAssets> getOverlay() { return mOverlay; }
 585     inline void setOverlay(sp<AaptAssets>& overlay) { mOverlay = overlay; }
 586
 587     inline KeyedVector<String8, sp<ResourceTypeSet> >* getResources() { return mRes; }
 588     inline void
 589         setResources(KeyedVector<String8, sp<ResourceTypeSet> >* res) { delete mRes; mRes = res; }
 590
 591     inline sp<FilePathStore>& getFullResPaths() { return mFullResPaths; }
 592     inline void
 593         setFullResPaths(sp<FilePathStore>& res) { mFullResPaths = res; }
 594
 595     inline sp<FilePathStore>& getFullAssetPaths() { return mFullAssetPaths; }
 596     inline void
 597         setFullAssetPaths(sp<FilePathStore>& res) { mFullAssetPaths = res; }
 598
 599 private:
 600     virtual ssize_t slurpFullTree(Bundle* bundle,
 601                                   const String8& srcDir,
 602                                   const AaptGroupEntry& kind,
 603                                   const String8& resType,
 604                                   sp<FilePathStore>& fullResPaths);
 605
 606     ssize_t slurpResourceTree(Bundle* bundle, const String8& srcDir);
 607     ssize_t slurpResourceZip(Bundle* bundle, const char* filename);
 608
 609     status_t filter(Bundle* bundle);
 610
 611     String8 mPackage;
 612     SortedVector<AaptGroupEntry> mGroupEntries;
 613     DefaultKeyedVector<String8, sp<AaptSymbols> > mSymbols;
 614     DefaultKeyedVector<String8, sp<AaptSymbols> > mJavaSymbols;
 615     String8 mSymbolsPrivatePackage;
 616     bool mHavePrivateSymbols;
 617
 618     Vector<sp<AaptDir> > mResDirs;
 619
 620     bool mChanged;
 621
 622     bool mHaveIncludedAssets;
 623     AssetManager mIncludedAssets;
 624
 625     sp<AaptAssets> mOverlay;
 626     KeyedVector<String8, sp<ResourceTypeSet> >* mRes;
 627
 628     sp<FilePathStore> mFullResPaths;
 629     sp<FilePathStore> mFullAssetPaths;
 630 };
 631
 632 #endif // __AAPT_ASSETS_H
 633