1
2
3
4
5

String16 mAssetsPackage;
PackageType mPackageType;
sp<AaptAssets> mAssets;
DefaultKeyedVector<String16, sp<Package> > mPackages;
Vector<sp<Package> > mOrderedPackages;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

struct ResChunk_header
{
        // Type identifier for this chunk.  The meaning of this value depends
        // on the containing chunk.
        uint16_t type;
        // Size of the chunk header (in bytes).  Adding this value to
        // the address of the chunk allows you to find its associated data
        // (if any).
        uint16_t headerSize;
        // Total size of this chunk (in bytes).  This is the chunkSize plus
        // the size of any data associated with the chunk.  Adding this value
        // to the chunk allows you to completely skip its contents (including
        // any child chunks).  If this value is the same as chunkSize, there is
        // no data associated with the chunk.
        uint32_t size;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct ResTable_package
{
        struct ResChunk_header header;
        // If this is a base package, its ID.  Package IDs start
        // at 1 (corresponding to the value of the package bits in a
        // resource identifier).  0 means this is not a base package.
        uint32_t id;
        // Actual name of this package, \0-terminated.
        uint16_t name[128];
        // Offset to a ResStringPool_header defining the resource
        // type symbol table.  If zero, this package is inheriting from
        // another base package (overriding specific values in it).
        uint32_t typeStrings;
        // Last index into typeStrings that is for public use by others.
        uint32_t lastPublicType;
        // Offset to a ResStringPool_header defining the resource
        // key symbol table.  If zero, this package is inheriting from
        // another base package (overriding specific values in it).
        uint32_t keyStrings;
        // Last index into keyStrings that is for public use by others.
        uint32_t lastPublicKey;
        uint32_t typeIdOffset;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

struct ResTable_typeSpec
{
        struct ResChunk_header header;
        // The type identifier this chunk is holding.  Type IDs start
        // at 1 (corresponding to the value of the type bits in a
        // resource identifier).  0 is invalid.
        uint8_t id;

        // Must be 0.
        uint8_t res0;
        // Must be 0.
        uint16_t res1;

        // Number of uint32_t entry configuration masks that follow.
        uint32_t entryCount;
        enum {
        // Additional flag indicating an entry is public.
            SPEC_PUBLIC = 0x40000000
        };
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct ResTable_type
{
        struct ResChunk_header header;
        enum {
            NO_ENTRY = 0xFFFFFFFF
        };

        // The type identifier this chunk is holding.  Type IDs start
        // at 1 (corresponding to the value of the type bits in a
        // resource identifier).  0 is invalid.
        uint8_t id;

        // Must be 0.
        uint8_t res0;
        // Must be 0.
        uint16_t res1;

        // Number of uint32_t entry indices that follow.
        uint32_t entryCount;
        // Offset from header where ResTable_entry data starts.
        uint32_t entriesStart;

        // Configuration this collection of entries is designed for.
        ResTable_config config;
};

1
2

else if (argv[1][0] == 'p')
        bundle.setCommand(kCommandPackage);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int handleCommand(Bundle* bundle)
{
    switch (bundle->getCommand()) {
        case kCommandVersion:      return doVersion(bundle);
        case kCommandList:         return doList(bundle);
        case kCommandDump:         return doDump(bundle);
        case kCommandAdd:          return doAdd(bundle);
        case kCommandRemove:       return doRemove(bundle);
        case kCommandPackage:      return doPackage(bundle);
        case kCommandCrunch:       return doCrunch(bundle);
        case kCommandSingleCrunch: return doSingleCrunch(bundle);
        case kCommandDaemon:       return runInDaemonMode(bundle);
        default:
            fprintf(stderr, "%s: requested command not yet supported\n", gProgName);
            return 1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

sp<AaptGroup> androidManifestFile =
            assets->getFiles().valueFor(String8("AndroidManifest.xml"));
if (androidManifestFile == NULL) {
        fprintf(stderr, "ERROR: No AndroidManifest.xml file found.\n");
        return UNKNOWN_ERROR;
}

status_t err = parsePackage(bundle, assets, androidManifestFile);
if (err != NO_ERROR) {
        return err;
}

ResourceTable::PackageType packageType = ResourceTable::App;
    if (bundle->getBuildSharedLibrary()) {
        packageType = ResourceTable::SharedLibrary;
    } else if (bundle->getExtending()) {
        packageType = ResourceTable::System;
    } else if (!bundle->getFeatureOfPackage().isEmpty()) {
        packageType = ResourceTable::AppFeature;
    }

ResourceTable table(bundle, String16(assets->getPackage()), packageType);

1
2
3
4
5
6
7
8
9
10
11

if (code == ResXMLTree::START_TAG) {
        if (strcmp16(block.getElementName(&len), uses_sdk16.string()) == 0) {
        ssize_t minSdkIndex = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE,
        "minSdkVersion");
        if (minSdkIndex >= 0) {
        const char16_t* minSdk16 = block.getAttributeStringValue(minSdkIndex,&len);
        const char* minSdk8 = strdup(String8(minSdk16).string());
        bundle->setManifestMinSdkVersion(minSdk8);
      }
   }
}

1
2
3
4

err = table.addIncludedResources(bundle, assets);
if (err != NO_ERROR) {
    return err;
}

1
2

eyedVector<String8, sp<ResourceTypeSet>> *resources = new KeyedVector<String8, sp<ResourceTypeSet>>;
collect_files(assets, resources);

1
2
3
4
5
6
7
8
9
10

class AaptAssets : public AaptDir
{
	public:
		AaptAssets();
		virtual ~AaptAssets() { delete mRes; }

    ........

    private:
    	KeyedVector<String8, sp<ResourceTypeSet>>* mRes;

1
2
3
4
5
6
7
8
9
10
11
12
13

if (!applyFileOverlay(bundle, assets, &drawables, "drawable") ||
        !applyFileOverlay(bundle, assets, &layouts, "layout") ||
        !applyFileOverlay(bundle, assets, &anims, "anim") ||
        !applyFileOverlay(bundle, assets, &animators, "animator") ||
        !applyFileOverlay(bundle, assets, &interpolators, "interpolator") ||
        !applyFileOverlay(bundle, assets, &transitions, "transition") ||
        !applyFileOverlay(bundle, assets, &xmls, "xml") ||
        !applyFileOverlay(bundle, assets, &raws, "raw") ||
        !applyFileOverlay(bundle, assets, &colors, "color") ||
        !applyFileOverlay(bundle, assets, &menus, "menu") ||
        !applyFileOverlay(bundle, assets, &mipmaps, "mipmap")) {
        return UNKNOWN_ERROR;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

sp<ResourceTypeSet> drawables;
sp<ResourceTypeSet> layouts;
sp<ResourceTypeSet> anims;
sp<ResourceTypeSet> animators;
sp<ResourceTypeSet> interpolators;
sp<ResourceTypeSet> transitions;
sp<ResourceTypeSet> xmls;
sp<ResourceTypeSet> raws;
sp<ResourceTypeSet> colors;
sp<ResourceTypeSet> menus;
sp<ResourceTypeSet> mipmaps;

........

if (layouts != NULL) {
        err = makeFileResources(bundle, assets, &table, layouts, "layout");
        if (err != NO_ERROR) {
            hasErrors = true;
        }
}

.........

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

current = assets;
while(current.get()) {
        KeyedVector<String8, sp<ResourceTypeSet> > *resources = current->getResources();
        ssize_t index = resources->indexOfKey(String8("values"));
        if (index >= 0) {
            ResourceDirIterator it(resources->valueAt(index), String8("values"));
            ssize_t res;
            while ((res=it.next()) == NO_ERROR) {
                sp<AaptFile> file = it.getFile();
                res = compileResourceFile(bundle, assets, file, it.getParams(),(current!=assets), &table);
                if (res != NO_ERROR) {
                    hasErrors = true;
                }
            }
        }
        current = current->getOverlay();
}

1
2
3
4
5
6
7
8
9
10

// --------------------------------------------------------------------
// Assignment of resource IDs and initial generation of resource table.
// --------------------------------------------------------------------

if (table.hasResources()) {
        err = table.assignResourceIds();
        if (err < NO_ERROR) {
            return err;
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

if (layouts != NULL) {
        ResourceDirIterator it(layouts, String8("layout"));
        while ((err=it.next()) == NO_ERROR) {
            String8 src = it.getFile()->getPrintableSource();
            err = compileXmlFile(bundle, assets, String16(it.getBaseName()),
            it.getFile(), &table, xmlFlags);
            if (err == NO_ERROR) {
                ResXMLTree block;
                block.setTo(it.getFile()->getData(), it.getFile()->getSize(), true);
                checkForIds(src, block);
            } else {
                hasErrors = true;
            }
        }
        if (err < NO_ERROR) {
            hasErrors = true;
        }
        err = NO_ERROR;
}

1
2
3
4
5

sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));
err = table.addSymbols(symbols, bundle>getSkipSymbolsWithoutDefaultLocalization());
if (err < NO_ERROR) {
    return err;
}

1
2
3
4
5
6

android {
    ......
    aaptOptions {
        additionalParameters "--split","xhdpi"
    }
}

1
2
3
4
5
6

android {
    ......
    aaptOptions {
        additionalParameters "--split","patch"
    }
}