static void collect_files(const sp<AaptDir>& dir,
        KeyedVector<String8, sp<ResourceTypeSet> >* resources);

// apply the overlay files to the base set
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;
}

static status_t makeFileResources(Bundle* bundle, const sp<AaptAssets>& assets,
                                  ResourceTable* table,
                                  const sp<ResourceTypeSet>& set,
                                  const char* resType);

status_t compileResourceFile(Bundle* bundle,
                             const sp<AaptAssets>& assets,
                             const sp<AaptFile>& in,
                             const ResTable_config& defParams,
                             const bool overwrite,
                             ResourceTable* outTable);

status_t ResourceTable::assignResourceIds();

status_t compileXmlFile(const sp<AaptAssets>& assets,
                        const sp<AaptFile>& target,
                        ResourceTable* table,
                        int options);

if (table.hasResources()) {
    // 生成资源符号表
    sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R"));
    err = table.addSymbols(symbols);
    if (err < NO_ERROR) {
        return err;
    }
    // 生成资源索引表resources.arsc
    resFile = getResourceFile(assets);
    if (resFile == NULL) {
        fprintf(stderr, "Error: unable to generate entry for resource data\n");
        return UNKNOWN_ERROR;
    }

    err = table.flatten(bundle, resFile);
    if (err < NO_ERROR) {
        return err;
    }

    // 可能有一些同学用到过，这就是public.xml里定义的固定资源id
    if (bundle->getPublicOutputFile()) {
        FILE* fp = fopen(bundle->getPublicOutputFile(), "w+");
        if (fp == NULL) {
            fprintf(stderr, "ERROR: Unable to open public definitions output file %s: %s\n",
                    (const char*)bundle->getPublicOutputFile(), strerror(errno));
            return UNKNOWN_ERROR;
        }
        if (bundle->getVerbose()) {
            printf("  Writing public definitions to %s.\n", bundle->getPublicOutputFile());
        }
        table.writePublicDefinitions(String16(assets->getPackage()), fp);
        fclose(fp);
    }

    // 把资源读回来到最终资源表
    finalResTable.add(resFile->getData(), resFile->getSize(), NULL);
    // 生成完毕
}

// 一个400行的函数，具体的生成实现在这里
status_t ResourceTable::flatten(Bundle* bundle, const sp<AaptFile>& dest);

if (resFile != NULL) {
    // These resources are now considered to be a part of the included resources, for others to reference.
    err = assets->addIncludedResources(resFile);
    if (err < NO_ERROR) {
        fprintf(stderr, "ERROR: Unable to parse generated resources, aborting.\n");
        return err;
    }
}

err = writeProguardFile(bundle, assets);
if (err < 0) {
    goto bail;
}

status_t writeAPK(Bundle* bundle, const sp<AaptAssets>& assets, const String8& outputFile)
{
    ... 计时，初始化状态变量
    // so，apk就是作为一个zip包创建的
    ZipFile* zip = NULL;
    int count;

    /*
     * 准备Zip文件，如果文件存在，则根据bundle设置的"update"或者"force"进行对应处理
     */
    FileType fileType = getFileType(outputFile.string());
    ...

    // 准备完毕，new ZipFile并打开准备开始写
    status_t status;
    zip = new ZipFile;
    status = zip->open(outputFile.string(), ZipFile::kOpenReadWrite | ZipFile::kOpenCreate);
    if (status != NO_ERROR) {
        fprintf(stderr, "ERROR: unable to open '%s' as Zip file for writing\n",
                outputFile.string());
        goto bail;
    }

    // 先把assets丢进去（即第10步我们准备好的东西，包括了assets目录, res目录下values以外的子目录 - 因为values已经被编译到资源索引表了, resources.arsc）
    count = processAssets(bundle, zip, assets);
    if (count < 0) {
        fprintf(stderr, "ERROR: unable to process assets while packaging '%s'\n",
                outputFile.string());
        result = count;
        goto bail;
    }

    // 再把用-j指定的包含classes的jar或者zip包给丢进去
    count = processJarFiles(bundle, zip);
    if (count < 0) {
        fprintf(stderr, "ERROR: unable to process jar files while packaging '%s'\n",
                outputFile.string());
        result = count;
        goto bail;
    }

    // 走到这儿算是处理成功了
    result = NO_ERROR;

    /*
     * 各种标记删除，然后flush zip
     */
    ...

    /* 没东西要你何用，删 */
    if (zip->getNumEntries() == 0) {
        ...
    }

    // 如果被要求生成依赖文件，则在这里进行，最后写到指定apk输出目录下，如bin/resources.ap_.d
    ...

    assert(result == NO_ERROR);

// 上面任何一部出错则goto跑来这儿，删除文件
bail:
    delete zip;        // must close before remove in Win32
    if (result != NO_ERROR) {
        ...删除并unlink
    }

    if (result == NO_ERROR && bundle->getVerbose())
        printf("Done!\n");

    return result;
}

std::string get_trace_setting() {
#if ADB_HOST
    return get_trace_setting_from_env();
#else
    return get_trace_setting_from_prop();
#endif
}

static int install_app(transport_type t, const char* serial, int argc, const char** argv);
static int install_multiple_app(transport_type t, const char* serial, int argc, const char** argv);
static int uninstall_app(transport_type t, const char* serial, int argc, const char** argv);

static int install_app(transport_type transport, const char* serial, int argc,
                       const char** argv)
{
    static const char *const DATA_DEST = "/data/local/tmp/%s";
    static const char *const SD_DEST = "/sdcard/tmp/%s";
    const char* where = DATA_DEST;

    // 解析-s参数，有则把where改成SD_DEST
    ...

    // 找到最后的APK参数，检查是否是APK，不是则提示"Invalid APK file"，然后直接退出
    ...

    const char* apk_file = argv[last_apk];
    char apk_dest[PATH_MAX];
    // apk_dest这样就是最终要拷贝过去的完整路径了，比如"/data/local/tmp/app.apk"
    snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file));
    // 把文件push上去
    int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */);
    if (err) {
        goto cleanup_apk;
    } else {
        argv[last_apk] = apk_dest; /* destination name, not source location */
    }
    // 通过pm安装
    err = pm_command(transport, serial, argc, argv);

// push出错了就删了文件
cleanup_apk:
    delete_file(transport, serial, apk_dest);
    return err;
}

// pm命令
static int pm_command(transport_type transport, const char* serial,
                      int argc, const char** argv)
{
    std::string cmd = "shell:pm";

    while (argc-- > 0) {
        cmd += " " + escape_arg(*argv++);
    }

    return send_shell_command(transport, serial, cmd);
}

private int runInstall() {
    ....
    try {
        VerificationParams verificationParams = new VerificationParams(verificationURI,
                originatingURI, referrerURI, VerificationParams.NO_UID, null);
        // 通过IPackageManager
        mPm.installPackageAsUser(apkFilePath, obs.getBinder(), installFlags,
                installerPackageName, verificationParams, abi, userId);

        synchronized (obs) {
            while (!obs.finished) {
                try {
                    obs.wait();
                } catch (InterruptedException e) {
                }
            }
            // 我们看到的成功失败返回信息
            if (obs.result == PackageManager.INSTALL_SUCCEEDED) {
                System.out.println("Success");
                return 0;
            } else {
                System.err.println("Failure ["
                        + installFailureToString(obs)
                        + "]");
                return 1;
            }
        }
    } catch (RemoteException e) {
        ...
    }
}

int install(const char *uuid, const char *pkgname, uid_t uid, gid_t gid, const char *seinfo)
{
    if ((uid < AID_SYSTEM) || (gid < AID_SYSTEM)) {
        ALOGE("invalid uid/gid: %d %d\n", uid, gid);
        return -1;
    }

    std::string _pkgdir(create_data_user_package_path(uuid, 0, pkgname));
    const char* pkgdir = _pkgdir.c_str();

    if (mkdir(pkgdir, 0751) < 0) {
        ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
        return -1;
    }
    if (chmod(pkgdir, 0751) < 0) {
        ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -1;
    }

    if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
        ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -errno;
    }

    if (chown(pkgdir, uid, gid) < 0) {
        ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -1;
    }

    return 0;
}

// 5.0支持多用户后把用户数据和app数据的创建分开了，完成install后，
// java层会调用这儿依次为所有用户创建用户数据，而过去这两个函数是合并的一个函数
int make_user_data(const char *uuid, const char *pkgname, uid_t uid, userid_t userid, const char* seinfo)
{
    std::string _pkgdir(create_data_user_package_path(uuid, userid, pkgname));
    const char* pkgdir = _pkgdir.c_str();

    if (mkdir(pkgdir, 0751) < 0) {
        ALOGE("cannot create dir '%s': %s\n", pkgdir, strerror(errno));
        return -errno;
    }
    if (chmod(pkgdir, 0751) < 0) {
        ALOGE("cannot chmod dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -errno;
    }

    if (selinux_android_setfilecon(pkgdir, pkgname, seinfo, uid) < 0) {
        ALOGE("cannot setfilecon dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -errno;
    }

    if (chown(pkgdir, uid, uid) < 0) {
        ALOGE("cannot chown dir '%s': %s\n", pkgdir, strerror(errno));
        unlink(pkgdir);
        return -errno;
    }

    return 0;
}