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