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