我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

【鸿蒙南向开发】OpenHarmony应用构建工具Hvigor的构建流程_hvigor 生成tgz文件

作者：我家小花儿 | 2024-07-25 01:38:13

踩

hvigor 生成tgz文件

前言

OpenHarmony 应用和服务使用 Hvigor 作为工程的构建工具。本篇文章将介绍 Hvigor 的构建流程，通过修改脚本配置使 Hvigor 执行自定义任务。

Hvigor 的构建流程

1.加载命令行参数和环境变量；
2.初始化项目结构，创建 Project 和 Module 实例；
3.配置项目插件和任务流；
4.执行任务流；

// hvigor/index.js
// LiftOff 命令行辅助工具
const cli = new LiftOff({
    name: 'hvigor',
    processTitle: make_title.makeTitle('hvigor', process.argv.slice(2)),
    moduleName: exports.hvigorPath,// @ohos/hvigor-base
    configName: "hvigorFile",
    v8flags: v8flags,
    extensions: interpret.jsVariants
});
// cli options定义所有的可支持的命令行
const parser = yargs.usage("Usage", cli_options.cliOptions);
// 解析命令行
const opts = parser.argv;
function run() {
    cli.prepare({
        cwd: opts.cwd,
        require: opts.require,
        completion: opts.completion,
    }, function (env) {
        // help 指令
        if (opts.help) {
            yargs.usage('Usage: hvigor [options]')
                .example('hvigor assembleApp', 'Do assembleApp task')
                .help('h')
                .alias('h', 'help')
                .epilog('copyright 2021')
                .argv;
            exit.exit(0);
        }
        // version 指令
        if (opts.version) {
            _log.info('CLI version:', cliVersion);
            _log.info('Local version:', env.modulePackage.version || 'Unknown');
            exit.exit(0);
        }
        // 设置日志等级
        evaluateLogLevel();

        // 判断当前 nodejs工具版本信息
        const LOWEST_VERSION = "v14.18.3";
        if (process.version < LOWEST_VERSION) {
            _log.warn(`node version: ${process.version}`);
            _log.warn(`node version cannot be lower than ${LOWEST_VERSION}`);
            process.exit(-1);
        }
        // 1. 加载命令行参数和环境变量
        init_env_config_props.initEnvConfigProps(env, opts);
        cli.execute(env, env.nodeFlags, function () {
            return __awaiter(this, void 0, void 0, function* () {
                const taskBeginTime = process.hrtime();
                // 执行具体的 Hvigor 任务
                yield process_utils.processUtils(opts, env);
                const taskEndTime = process.hrtime(taskBeginTime);
                const realTime = pretty_hrtime.default)(taskEndTime);
                if (0 == profile_js.profile.executed) {
                    _log.error(`No task found to execute in project!`);
                }
                _log.info(`BUILD SUCCESSFUL in ${realTime}`);
            });
        });
    });
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

执行具体的 Hvigor 的任务

// hvigor/src/process-utils.js
function processUtils(opts, env) {
    ···
    // 2. 初始化项目结构，创建 Project 和 Module 实例；
    init.init(env);
    // 3. 配置项目插件和任务流；
    const project = configuration.configuration(env);
    // 4. 执行任务流；
    const executeMode = env.configProps.get(modeAlias);
    switch (executeMode) {
       ···
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

1. 加载命令行参数和环境变量

读取命令行参数，并把参数和配置文件的路径放入全局配置项中。

// hvigor/src/init-env-config-props.js
function initEnvConfigProps(env, opts) {
    ···
    // 获取项目级别 build-profile.json5 文件路径，[项目路径]/build-profile.json5
    const configFilePath = path.resolve(process.cwd(), hvigor_base.HvigorCommonConst.PROJECT_CONFIG_FILE);
    ···
    const properties = new Map();
    // 获取命令行 prop(p) 参数，放入 Map 中
    if (opts.prop !== undefined) {
        [].concat(opts.prop).forEach((value) => {
            const arr = value.split('=');
            properties.set(arr[0], arr[1]);
        });
    }
    // 把"项目级别 build-profile.json5 文件路径"、"命令行 prop(p) 参数集合"和"命令行 mode(m) 模式参数"配置进环境变量中
    env.configProps = new Map([
        [configFileName, configFilePath],
        [propertiesAlias, properties],
        [modeAlias, opts.mode]
    ]);
    return configFilePath;
}

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

2. 初始化项目结构，创建 Project 和 Module 实例

工程结构实例化。

// hvigor/src/lifecycle/init.js
function init(env) {
    // env.modulePath 是在命令行辅助工具 LiftOff 中加载的模块函数，"modulePath": "[项目路径]/node_modules/@ohos/hvigor-base/index.js",
    const vigorConfigInst = require(env.modulePath).vigorConfigInst;
    // 把从命令行加载来的 prop(p) 参数放入 vigorConfigInst 实体的 ExtraConfig 中
    vigorConfigInst.setExtraConfig(env.configProps.get(propertiesAlias));
    // 初始化项目，参数：[项目路径]/build-profile.json5，[项目路径]
    vigorConfigInst.initRootProject(path.resolve(env.cwd, hvigor_base.HvigorCommonConst.PROJECT_CONFIG_FILE), env.cwd);
}

// hvigor-base/index.js
exports.vigorConfigInst = new VigorConfig();
class VigorConfig {
    constructor() {
        this._log = hvigor_log_js.HvigorLogger.getLogger(VigorConfig.name);
        this._project = undefined;
        this._projectDir = "";
        this._projectConfigFile = "";
        this._extraConfig = new Map();
    }
    ···
    // 初始化项目，参数：[项目路径]/build-profile.json5，[项目路径]
    initRootProject(projectConfigFile, projectRootDir) {
        // 配置项目级别 build-profile.json5 文件路径
        this._projectConfigFile = projectConfigFile;
        // 配置项目根路径
        this._projectDir = projectRootDir;
        // 创建项目实例，参数：[项目名称]，[项目路径]
        const projectImpl = new project_impl_js.ProjectImpl(path.basename(projectRootDir), projectRootDir);
        // 读取 [项目路径]/build-profile.json5 配置数据
        const projectStructureOpt = json5_reader_js.Json5Reader.getJson5Obj(this._projectConfigFile);
        ···
        // 从配置文件中读取项目下的全部 Modules 
        projectStructureOpt.modules?.forEach(module => {
            // 校验 Module 配置参数
            validate_util_js.ValidateUtil.validateModule(module);
            // 添加子项目，根据配置文件中 Modules 循环创建 Module 实例，参数：项目实例，Module 名称，Module 的路径
            projectImpl.addSubProject(new module_impl_js.ModuleImpl(projectImpl, module.name, module.srcPath));
        });
        this._project = projectImpl;
        return projectImpl;
    }
}
class ValidateUtil {
    static validateModule(module) {
        if (module.name === undefined) {
            this.logger.errorMessageExit(`Project level build-profile.json5 lose required property: module-name`);
        }
        if (module.srcPath === undefined) {
            this.logger.errorMessageExit(`Project level build-profile.json5 lose required property: module-srcPath`);
        }
    }
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

Project 实现类

// hvigor-base/src/impl/project-impl.js
class ProjectImpl extends default_module_impl.DefaultModuleImpl {
    constructor(moduleName, moduleDir) {
        super(moduleName, moduleDir);
        // 配置项目级别 build-profile.json5 文件路径
        this._projectStructureFile = path.resolve(moduleDir, common_const.HvigorCommonConst.PROJECT_CONFIG_FILE);
        this._subProjects = new Map();
    }
    ···
}

1
2
3
4
5
6
7
8
9
10
11

Module 实现类

// hvigor-base/src/impl/module-impl.js
class ModuleImpl extends default_module_impl.DefaultModuleImpl {
    constructor(project, moduleName, moduleDir) {
        super(moduleName, moduleDir);
        this._project = project;
    }
    ···
}

1
2
3
4
5
6
7
8
9

默认 Module 实现类

// hvigor-base/src/impl/default-module-impl.js
class DefaultModuleImpl {
    constructor(moduleName, modulePath) {
        this._moduleName = moduleName;
        this._modulePath = modulePath;
        // 获取项目和模块的 package.json 文件路径
        this._packageJsonPath = path.resolve(modulePath, "package.json");
        // 获取项目和模块的 hvigorfile.js 文件路径
        this._buildFilePath = path.resolve(modulePath, common_const.HvigorCommonConst.BUILD_FILE_NAME);
    }
    ···
}

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

3. 配置项目插件和任务流

加载 hvigorfile.js 文件中配置的任务脚本。

// hvigor/src/lifecycle/configuration.js
function configuration(env) {
    // 整个项目的结构在 init 中初始化完成，读取 vigorConfigInst
    const vigorConfigInst = require(env.modulePath).vigorConfigInst;
    // 通过 vigorConfigInst 获取项目实例
    const project = vigorConfigInst.getProject();
    // 获取项目全部的 Module 实例，遍历加载任务脚本
    for (const subModule of project.getAllSubProjects()) {
        // 获取 Module 的 hvigorfile.js 文件路径
        const subModuleVigorFileJs = subModule.getBuildFilePath();
        // 加载任务脚本
        configModule(subModule, subModuleVigorFileJs);
    }
    // 获取 Project 的 hvigorfile.js 文件路径
    const projectVigorFileJs = path.resolve(env.cwd, hvigor_base.HvigorCommonConst.BUILD_FILE_NAME);
    // 加载任务脚本
    configModule(project, projectVigorFileJs);
    return project;
}

function configModule(module, hvigorFilePath) {
    // FA 模型
    // 工程级别
    // module.exports = require('@ohos/hvigor-ohos-plugin').legacyAppTasks
    // 模块级别
    // module.exports = require('@ohos/hvigor-ohos-plugin').legacyHapTasks
    // module.exports = require('@ohos/hvigor-ohos-plugin').legacyHarTasks

    // Stage 模型
    // 工程级别
    // module.exports = require('@ohos/hvigor-ohos-plugin').appTasks
    // 模块级别
    // module.exports = require('@ohos/hvigor-ohos-plugin').hapTasks
    // module.exports = require('@ohos/hvigor-ohos-plugin').harTasks

    // 加载 hvigorFile 任务脚本
    const moduleExported = require(hvigorFilePath);

    // 配置 Project 和 Module 的任务流
    const pluginNTasks = moduleExported(module);
    module.exported = pluginNTasks;

    // 绑定创建的 Plugin 对象到 Project 实例和 Module 实例上
    module.bindPlugin(pluginNTasks.plugin);
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

4. 执行任务流

根据命令行 mode 参数判断要执行任务流的级别。

// hvigor/src/process-utils.js
// 从环境变量中获取 mode(m) 参数
const executeMode = env.configProps.get(modeAlias);

// 根据 mode 判断要执行任务流的级别
switch (executeMode) {
    case hvigor_base.HvigorBuildConst.PROJECT_MODE: // project
        execute_task.execute(project, true, opts).then(outputInfo);
        break;
    case hvigor_base.HvigorBuildConst.MODULE_MODE: // module
        execute_task.executeModuleTask(project, opts).then(outputInfo);
        break;
    case undefined: // 未配置
        execute_task.execute(project, false, opts); 
        execute_task.executeModuleTask(project, opts).then(outputInfo);
        break;
    default:
        _log.error(`Unknown mode '${executeMode}' specified in command line,Please check!`);
}

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

执行任务

//hvigor/src/lifecycle/execute-task.js
function executeModuleTask(project, opts) {
    // 获取 prop(p) 参数中 module 的取值
    const modules = hvigor_base.vigorConfigInst.getExtraConfig().get("module");
    // 如果不指定 module 则默认执行所有 Module 任务
    if (modules === undefined) {
        // 从项目实例中获取全部 Module 并执行任务
        yield Promise.all(project.getAllSubProjects().map((module) => {
            execute(module, false, opts);
        })).catch(error => {
            _log.error(error);
        });
    }
    else {
        // 如果指定 module 则从项目级别 build-profile.json5 配置文件中查找匹配的 Module ，如果存在则执行任务
        yield Promise.all(modules.split(",").map((value) => {
            const values = value.split("@");
            const module = project.findModuleByName(values[0]);
            if (module === undefined) {
                _log.errorMessageExit(`Unknown module '${values[0]}' in command lines,Please check!`);
            }
            execute(module, true, opts);
        })).catch(error => {
            _log.error(error);
        });
    }
}
// 执行任务流
function execute(model, shouldCheckTask, opts) {
    return __awaiter(this, void 0, void 0, function* () {
        // 从命令行获取需要执行的任务列表
        const tasks = opts._;
        // 如果没配置则执行 default 任务
        const toRun = tasks.length ? tasks : ['default'];
        ···
        const moduleName = model.getName();
        // [项目路径]/node_modules/@ohos/hvigor-base/index.js.Hvigor
        const HvigorClass = require(index.hvigorPath).Hvigor;
        // 项目打包工具的主入口
        const vigorInst = new HvigorClass();
        // 注册任务
        const registryTasks = register_exports.registerExports(vigorInst, model.exported);
        if (needSync) {
            profile_js.profile.executed += 1;
            yield sync.sync(model, registryTasks, vigorInst);
            return;
        }
        // 筛选最终要执行的操作
        const finallyToRun = toRun.filter((taskName) => {
            return registryTasks.has(taskName);
        });
        // 指定具体要执行的模块,但是找不到对应的任务
        if (!needSync && shouldCheckTask && finallyToRun.length === 0) {
            _log.errorMessageExit(`Task ${toRun} not found in module:${moduleName}.`);
        }
        // 未指定具体要执行的模块,没有可执行任务时直接返回
        if (finallyToRun.length === 0) {
            _log.debug(`No task found to execute in ${moduleName}!`);
            return;
        }
        profile_js.profile.executed += finallyToRun.length;
        // series:串行 parallel:并行
        const runMethod = opts.series ? 'series' : 'parallel';
        // 执行任务流
        vigorInst[runMethod](finallyToRun)(function (err) {
            if (err) {
                _log.errorExit(err.message);
            }
        });
    });
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

注册任务

// hvigor/src/register-exports.js
function registerExports(vigorInst, hvigorFileObj) {
    const registryTasks = new Map();
    const taskNames = Object.keys(hvigorFileObj);
    if (taskNames.length) {
        taskNames.forEach((taskName) => {
            const exportObj = hvigorFileObj[taskName];
            // plugin 不会被注册
            if (exportObj instanceof Task) {
                const task = exportObj.registry();
                vigorInst.task(taskName, task);
                registryTasks.set(taskName, exportObj instanceof DefaultSyncTask);
            }
        });
    }
    return registryTasks;
}

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

Hvigor 的插件和任务流

Build 任务脚本

// hvigor-ohos-plugin/index.js
// Stage 模型的 hap 任务流
const hapTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getHapPlugin(module);
    return {
        plugin,
        assembleHap: plugin.assembleHap,
        clean: plugin.clean,
        compileNative: plugin.compileNative,
        sync: plugin.sync,
        buildPreviewerResource: plugin.buildPreviewerRes
    };
};
// FA 模型的 hap 任务流
const legacyHapTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getHapPlugin(module, true);
    return {
        plugin,
        assembleHap: plugin.assembleHap,
        clean: plugin.clean,
        compileNative: plugin.compileNative,
        buildPreviewerResource: plugin.buildPreviewerRes,
        sync: plugin.sync
    };
};
// Stage 模型的 app 任务流
const appTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getAppPlugin(module);
    return {
        plugin,
        assembleApp: plugin.assembleApp,
        clean: plugin.clean,
        sync: plugin.sync
    };
};
// FA 模型的 app 任务流
const legacyAppTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getAppPlugin(module, true);
    return {
        plugin,
        assembleApp: plugin.assembleApp,
        clean: plugin.clean,
        sync: plugin.sync
    };
};
// Stage 模型的 Har 插件
const harTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getHarPlugin(module);
    return {
        plugin,
        clean: plugin.clean,
        assembleHar: plugin.assembleHar,
        assembleSubHar: plugin.assembleSubHar,
        buildPreviewerResource: plugin.buildHarPreviewerRes
    };
};
// FA 模型的 Har 插件
const legacyHarTasks = (module) => {
    const plugin = plugin_factory_js.PluginFactory.getHarPlugin(module, true);
    return {
        plugin,
        clean: plugin.clean,
        assembleHar: plugin.assembleHar,
        assembleSubHar: plugin.assembleSubHar,
        buildPreviewerResource: plugin.buildHarPreviewerRes
    };
};

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

Plugin 工厂类

// hvigor-ohos-plugin/src/plugin/factory/plugin-factory.js
class PluginFactory {
    static getAppPlugin(project, isFaMode = false) {
        // 创建 AppPlugin 实例
        return new app_plugin_js.AppPlugin(project, isFaMode);
    }
    static getHapPlugin(module, isFaMode = false) {
        // 创建 HppPlugin 实例
        return new hap_plugin_js.HapPlugin(module, isFaMode);
    }
    static getHarPlugin(module, isFaMode = false) {
        // 创建 HarPlugin 实例
        return new har_plugin_js.HarPlugin(module, isFaMode);
    }
}

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

HapPlugin & HarPlugin

// hvigor-ohos-plugin/src/plugin/hap-plugin.js
class HapPlugin extends abstract_module_plugin_js.AbstractModulePlugin {
    constructor(module, isFaMode) {
        super(module, isFaMode);
    }
    initTasks() {
        // Hap 打包的任务流
        this.assembleHap = new assemble_hap_js.AssembleHap(this._taskService, this.isFaMode);
        // Clean 任务
        this.clean = new clean_js.Clean(this._taskService);
        // Native 代码编译任务
        this.compileNative = new compile_native_js.CompileNative(this._taskService);
        // Module 级别的 Sync 任务
        this.sync = new sync_module_js.SyncModule(this._module);
        // Hap 在 Priviewer 模式构建的任务流
        this.buildPreviewerRes = new build_previewer_res_js.BuildPreviewerRes(this._taskService, this.isFaMode);
    }
}

// hvigor-ohos-plugin/src/plugin/har-plugin.js
class HarPlugin extends abstract_module_plugin_js.AbstractModulePlugin {
    constructor(module, isFaMode) {
        super(module, isFaMode);
    }
    initTasks() {
        // Har 打包的任务流
        this.assembleHar = new assemble_har_js.AssembleHar(this._taskService, this.isFaMode);
        // 子 Har 打包的任务流
        this.assembleSubHar = new assemble_sub_har_js.AssembleSubHar(this._taskService, this.isFaMode);
        // Clean 任务
        this.clean = new clean_js.Clean(this._taskService);
        // Har 在 Priviewer 模式构建的任务流
        this.buildHarPreviewerRes = new build_har_previewer_res_js.BuildHarPreviewerRes(this._taskService, this.isFaMode);
    }
}

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
26
27
28
29
30
31
32
33
34
35
36

初始化 ModulePlugin 结构实例

// hvigor-ohos-plugin/src/plugin/common/abstract-module-plugin.js
class AbstractModulePlugin {
    constructor(module, isFaMode) {
        this._log = ohos_logger_js.OhosLogger.getLogger(AbstractModulePlugin.name);
        this._module = module;
        const project = module.getProject();
        this.isFaMode = isFaMode;
        // FA 模型
        if (this.isFaMode) {
            // 创建 LegacyProjectModelImpl 实例,LegacyProjectModelImpl 为单例，同一个项目只会创建一次
            this._projectModel = legacy_project_model_impl_js.LegacyProjectModelImpl.getInstance(project.getModuleDir(), project.getName());

            // 创建 LegacyModuleModelImpl 实例
            this._moduleModel = new legacy_module_model_impl_js.LegacyModuleModelImpl(module.getModuleDir(), module.getName(), this._projectModel);

            // 检查任务脚本和模块级别 build-profile.json5 中 apiType 是否匹配
            this.checkModuleStatus(hap_extra_info_js.ApiType.FA);
        }
        // Stage 模型
        else {
             // 创建 ProjectModelImpl 实例,ProjectModelImpl 为单例，同一个项目只会创建一次
            this._projectModel = project_model_impl_js.ProjectModelImpl.getInstance(project.getModuleDir(), project.getName());

            // 创建 ModuleModelImpl 实例
            this._moduleModel = new module_model_impl_js.ModuleModelImpl(module.getModuleDir(), module.getName(), this._projectModel);

            // 检查任务脚本和模块级别 build-profile.json5 中 apiType 是否匹配
            this.checkModuleStatus(hap_extra_info_js.ApiType.STAGE);
        }
      
        // 创建 Module 任务服务实例
        this._taskService = new module_task_service_js.ModuleTaskService(this._projectModel, this._moduleModel);

        // 初始化任务
        this.initTasks();
    }
    checkModuleStatus(apiType) {
        // 获取模块级别 build-profile.json5 中 apiType 配置信息
        const curApiType = this._moduleModel.getProfileOpt().apiType === undefined ?
            hap_extra_info_js.ApiType.STAGE :
            this._moduleModel.getProfileOpt().apiType;
        if (curApiType !== apiType) {
            this._log._buildError("The 'hvigorfile.js' import is not match the apiType!")
                ._solution(`Change the apiType to '${apiType}'.`)
                ._file(this._moduleModel.getProfilePath())
                ._printErrorAndExit(this._moduleModel.getName());
        }
    }
    ···
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

创建 FA 模型 LegacyModuleModelImpl 实例

FA 模型的模块持久化数据模型,包含模块源码数据,配置数据等

// hvigor-ohos-plugin/src/model/module/legacy-module-model-impl.js
class LegacyModuleModelImpl extends core_module_model_impl_js.CoreModuleModelImpl {
    constructor(modulePath, moduleName, parentProject) {
        super(modulePath, moduleName, parentProject);
        this._legacyAbilitiesMap = new Map();
        this.initDefaultTargetSourceSet();
    }
    ···
    initDefaultTargetSourceSet() {
        // 配置 [模块路径]/src/main 文件夹下配置文件 config.json 路径和 resources 路径实例
        const defaultTargetSourceSet = new legacy_target_source_set_impl_js.LegacyTargetSourceSetImpl(path.default.resolve(this._sourceRootDir, "main"));
        // defaultTargetName = 'default'
        this.targetSourceSetMap.set(defaultTargetName, defaultTargetSourceSet);
        this.initAbilityInfo(defaultTargetName, defaultTargetSourceSet);
        // 创建 [模块路径]/src/ohosTest 文件夹下配置文件 config.json 路径和 resources 路径
        const ohosTestTargetSourceSet = new legacy_target_source_set_impl_js.LegacyTargetSourceSetImpl(path.default.resolve(this._sourceRootDir, "ohosTest"));
        // ohosTestTargetName = 'ohosTest'
        this.targetSourceSetMap.set(ohosTestTargetName, ohosTestTargetSourceSet);
        // 初始化 Ability 信息
        this.initAbilityInfo(ohosTestTargetName, ohosTestTargetSourceSet);
    }
    ···
    // 初始化 Module 中的 Ability 信息
    initAbilityInfo(targetName, targetSourceSet) {
        ···
        // 读取 config.json 配置项
        const configJsonObj = project_file_reader_js.ProjectFileReader.getJson5Obj(configJsonPath);
        // 获取配置中 module.abilities 配置项
        const abilityObjs = configJsonObj.module.abilities ?
            configJsonObj.module.abilities : [];
        const legacyAbilities = [];
        for (let i = 0; i < abilityObjs.length; i++) {
            // 创建 FA模型 Ability 实例
            legacyAbilities.push(new legacy_ability_model_impl_js.LegacyAbilityModelImpl(configJsonPath, abilityObjs[i].name));
        }
        // 验证是否有重名的 Ability，如果重名则会报错并退出
        LegacyModuleModelImpl.validateSameNameAbility(legacyAbilities);
        // 读取 module.js 配置信息
        const jsObjs = configJsonObj.module.js ? configJsonObj.module.js : [];
        // 查找 js 配置项中 type 为 form 的配置项
        for (let i = 0; i < jsObjs.length; i++) {
            if ('form' !== jsObjs[i].type) {
                continue;
            }
            // 创建 FA模型 Form 实例
            legacyAbilities.push(new legacy_form_model_impl_js.LegacyFormModelImpl(configJsonPath, jsObjs[i]));
        }
        this._legacyAbilitiesMap.set(targetName, legacyAbilities);
    }
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

创建 Stage 模型 ModuleModelImpl 实例

Stage 模型的模块数据管理类

// hvigor-ohos-plugin/src/model/module/module-model-impl.js
class ModuleModelImpl extends core_module_model_impl_js.CoreModuleModelImpl {
    constructor(modulePath, moduleName, parentProject) {
        super(modulePath, moduleName, parentProject);
        this.initDefaultTargetSourceSet();
    }
    initDefaultTargetSourceSet() {
        // 创建 [模块路径]/src/main 文件夹下配置文件 module.json5 路径和 resources 路径实例
        const defaultTargetSourceSet = new target_source_set_impl_js.TargetSourceSetImpl(path.default.resolve(this._sourceRootDir, "main"));
        // defaultTargetName = 'default'
        this.targetSourceSetMap.set(defaultTargetName, defaultTargetSourceSet);
        // 创建 [模块路径]/src/ohosTest 文件夹下配置文件 module.json5 路径和 resources 路径实例
        const ohosTestTargetSourceSet = new target_source_set_impl_js.TargetSourceSetImpl(path.default.resolve(this._sourceRootDir, "ohosTest"));
        // OHOS_TEST_TARGET = 'ohosTest'
        this.targetSourceSetMap.set(common_const_js.DefaultTargetConst.OHOS_TEST_TARGET, ohosTestTargetSourceSet);
    }
    ···
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Module 模块的核心数据管理类

Hvigor 工程的 module 模块的核心数据管理类

// hvigor-ohos-plugin/src/model/module/core-module-model-impl.js
class CoreModuleModelImpl {
    constructor(modulePath, moduleName, parentProject) {
        this._log = ohos_logger_js.OhosLogger.getLogger(CoreModuleModelImpl.name);
        this.targetSourceSetMap = new Map();
        // 模块名称
        this.name = moduleName;
        // 模块路径
        this.modulePath = path.default.resolve(modulePath);
        // 项目 LegacyProjectModelImpl 实例
        this.parentProject = parentProject;
        // Module 的 hvigorfile.js 文件路径
        this.buildProfilePath = path.default.resolve(this.modulePath, this.getBuildProfileName());
        // Module 的 build-profile.json5 文件路径
        const moduleBuildProfilePath = path.default.resolve(this.modulePath, common_const_js.CommonConst.PROFILE_JSON5);
        // 使用 Schema 验证配置文件是否正确，错误则退出
        this.moduleBuildProfileCheck(moduleBuildProfilePath);
        // Module 的 src 路径
        this._sourceRootDir = path.default.resolve(modulePath, "src");
    }
}

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

创建 Module 任务服务实例

基于持久化 Module 的模型层提供的数据，经过处理后,提供给打包 hap 任务流需要使用的服务和数据

// hvigor-ohos-plugin/src/tasks/service/module-task-service.js
class ModuleTaskService extends task_service.TaskService {
    constructor(projectModel, moduleModel) {
        super(projectModel);
        this._log = ohos_logger_js.OhosLogger.getLogger(ModuleTaskService.name);
        this.computeTargets = () => {
            // 默认不配置target时,执行所有的target
            const targets = ["all"];
            // 从命令行 prop(p) 参数中获取 module 配置 
            const configModules = hvigor_base.vigorConfigInst.getExtraConfig().get("module");
            if (configModules === undefined) {
                return targets;
            }
            // 例：entry@phone@free 则 targets为 ['phone','free']
            const modules = configModules.split(",");
            for (let i = 0; i < modules.length; i++) {
                const module = modules[i];
                const values = module.split("@");
                if (this._moduleModel.getName() !== values[0]) {
                    continue;
                }
                for (let j = 1; j < values.length; j++) {
                    targets[j - 1] = values[j];
                }
            }
            return targets;
        };
        this.checkNeedPack = (targetProduct, targetName, curModuleConfigTargets) => {
            let needPack = false;
            // 如果在 prop(p) module 中配置则需要打包
            if (curModuleConfigTargets.indexOf(targetName) > -1) {
                needPack = true;
            }
            if ((curModuleConfigTargets.indexOf("all") > -1)) {
                // 默认不配置target时,不打包ohosTest的包
                needPack = targetName !== "ohosTest";
            }
            const checkApplyProduct = (targetProduct) => {
                // 获取模块级别 build-profile.json5 配置文件中对应的 target 的 applyToProducts
                let products = this._projectModel?.getTargetApplyProducts(this._moduleModel.getName(), targetName);
                // 如果没有配置applyToProducts则默认是default
                if (products === undefined) {
                    products = ["default"];
                }
                // 如果存在则需要打包
                return products.includes(targetProduct);
            };
            return checkApplyProduct(targetProduct.name) && needPack;
        };
        // 初始化 Hap 模块打包流的 target 数据集合
        this.initTargetData = () => {
            // 根据命令行参数计算需要的 target 项
            const curModuleConfigTargets = this.computeTargets();
            // 获取命令行 prop(p) 中 buildRoot 参数
            let buildRoot = hvigor_base.vigorConfigInst.getExtraConfig().get("buildRoot");
            if (!buildRoot) {
                // 默认打包路径 build
                buildRoot = build_directory_const_js.BuildDirConst.BUILD_ROOT;
            }
            // 读取模块级别 build-profile.json5 的 targets
            let targets = this._moduleModel.getProfileOpt().targets;
            if (targets === undefined) {
                targets = [{
                        name: "default",
                    }, {
                        name: "ohosTest"
                    }];
            }
            else {
                const targetNames = targets.map(target => {
                    return target.name;
                });
                if (!targetNames.includes("default")) {
                    targets.push({
                        name: "default",
                    });
                }
                if (!targetNames.includes("ohosTest")) {
                    targets.push({
                        name: "ohosTest"
                    });
                }
            }
            // 获取命令行中配置的需要打包的 product 如果未配置则默认为 default
            const targetProduct = find_target_product.findTargetProduct(this._projectModel);
            let hasTargetNeedPack = false;
            targets.forEach((target) => {
                const targetName = target.name;
                // 验证可打包的 target
                const needPack = this.checkNeedPack(targetProduct, targetName, curModuleConfigTargets);
                if (needPack) {
                    hasTargetNeedPack = true;
                }
                // 创建路径信息实例
                const pathInfo = new module_path_info_iml.ModulePathInfoIml(this._moduleModel, targetName, targetProduct.name, buildRoot);
                this._targetDataMap.set(targetName, [new hap_task_target_data.ModuleTargetData(this._moduleModel, targetName, pathInfo, targetProduct), needPack]);
            });
            if (!hasTargetNeedPack) {
                this._log._buildError(`Current product is ${targetProduct.name},There is no executable target!`)
                    ._solution(`Please check the module targets ${util.format(targets)} applyToProducts field`)
                    ._file(this._projectModel.getProfilePath())
                    ._printErrorAndExit(this._moduleModel.getName());
            }
        };
        this._moduleModel = moduleModel;
        this._targetDataMap = new Map();
        // 获取额外信息, isSupportHos 和 isStageMode
        this._hapExtraInfo = project_extra_info_service_js.ProjectExtraInfoService.getProjectExtraInfoByPath(this._moduleModel);
        // 获取编译 SDK 版本信息
        this._compileSdkVersion = this._projectModel.getProfileOpt().app.compileSdkVersion;
        // 实例化 SDK 工具信息实例
        this._sdkInfo = new sdk_info.SdkInfo(this._compileSdkVersion, this.getModuleRequiredSDKs());
        // 初始化 Target 数据
        this.initTargetData();
    }
    getModuleRequiredSDKs() {
        // 默认加载 Toolchains
        const sdkComponents = [sdkmanager_common.ComponentPath.TOOLCHAINS];
        for (const key of this._moduleModel.getSourceSetByTargetName(common_const_js.DefaultTargetConst.DEFAULT_TARGET).getCodeMap().keys()) {
            // 按照目录存在就加载的逻辑，例如main目录下存在 ets目录则加载 ets SDK 实例
            // CodeType["JS"] = "js";
            // CodeType["ETS"] = "ets";
            // CodeType["CPP"] = "cpp";
            if (code_type_enum.CodeType.CPP === key) {
                if (this._moduleModel.getProfileOpt().buildOption.externalNativeOptions) {
                    sdkComponents.push(code_type_enum.CodeType.getSDKComponentName(key));
                }
            }
            else {
                sdkComponents.push(code_type_enum.CodeType.getSDKComponentName(key));
            }
        }
        this._log.debug(`${this._moduleModel.getName()} require SDK: ${sdkComponents.join(" ").toLowerCase()}`);
        return sdkComponents;
    }
    ···
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

根据命令行中的配置找到项目级别 build-profile.json5 中的 Product

// hvigor-ohos-plugin/src/common/find-target-product.js
function findTargetProduct(projectModuleModel) {
    // 从命令行 prop(p) 参数中获取 Product 配置 
    const configProduct = hvigor_base.vigorConfigInst.getExtraConfig().get("product");
    // 没有配置时默认是default
    const targetProduct = configProduct ? configProduct : "default";
    _log.debug(`Find product from build-profile.json: %s`, targetProduct);
    // 检查项目级别 build-profile.json5 配置 app.products 项中是否有该 product
    const mProduct = array_util_js.getElementFromArr(projectModuleModel.getProfileOpt().app.products, targetProduct);
    if (!mProduct) {
        _log._buildError(`Can not find product ${targetProduct}, please check!`)
            ._solution('Please check attribute products from build-profile.json5.')
            ._file(projectModuleModel.getProfilePath())
            ._printErrorAndExit(projectModuleModel.getName());
    }
    return mProduct;
}

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

AppPlugin

// hvigor-ohos-plugin/src/plugin/app-plugin.js
class AppPlugin {
    constructor(project, isFaMode) {
        this._module = project;
        this._moduleName = project.getName();
        // 判断是否为 FA 模型,创建不同的 ProjectModel 实例,参数：项目路径，项目名称
        this._projectModel = isFaMode ?
            legacy_project_model_impl_js.LegacyProjectModelImpl.getInstance(project.getModuleDir(), project.getName()) :
            project_model_impl_js.ProjectModelImpl.getInstance(project.getModuleDir(), project.getName());

        // 创建项目任务服务实例
        this._taskService = new project_task_service_js.ProjectTaskService(project, this._projectModel);

        // 创建具体任务实例
        this.assembleApp = new assemble_app_js.AssembleApp(this._taskService, isFaMode);
        this.clean = new clean_js.Clean(this._taskService);
        this.sync = new sync_project_js.SyncProject(project); 
    }
    getTaskService() {
        return this._taskService;
    }
}

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

创建 FA 模型 LegacyProjectModelImpl 实例

FA 模型的工程持久化数据模型，包含工程源码数据，配置数据等

// hvigor-ohos-plugin/src/model/project/legacy-project-model-impl.js
class LegacyProjectModelImpl extends core_project_model_impl_js.CoreProjectModelImpl {
    constructor(projectPath, name) {
        super(projectPath, name);
    }
    static getInstance(projectPath, name) {
        if (!LegacyProjectModelImpl.instance) {
            if (projectPath === null || projectPath === undefined) {
                throw new Error("工程模型还未初始化，请正确传递工程路径");
            }
            if (name === null || name === undefined) {
                throw new Error("工程模型还未初始化，请正确传递工程名称");
            }
            LegacyProjectModelImpl.instance = new LegacyProjectModelImpl(projectPath, name);
        }
        return LegacyProjectModelImpl.instance;
    }
    ···
}

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

创建 Stage 模型 ProjectModelImpl 实例

Stage 模型的工程持久化数据模型，包含工程源码数据，配置数据等

// hvigor-ohos-plugin/src/model/project/project-model-impl.js
class ProjectModelImpl extends core_project_model_impl_js.CoreProjectModelImpl {
    constructor(projectPath, name) {
        super(projectPath, name);
        // 创建 App 级资源实例
        this.appRes = new app_res_model_impl_js.AppResModelImpl(path.default.resolve(projectPath, "AppScope"));
    }
    static getInstance(projectPath, name) {
        if (!ProjectModelImpl.instance) {
            if (projectPath === null || projectPath === undefined) {
                throw new Error("工程模型还未初始化，请正确传递工程路径");
            }
            if (name === null || name === undefined) {
                throw new Error("工程模型还未初始化，请正确传递工程名称");
            }
            ProjectModelImpl.instance = new ProjectModelImpl(projectPath, name);
        }
        return ProjectModelImpl.instance;
    }
    ···
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Project 模块的核心数据管理类

// hvigor-ohos-plugin/src/model/project/project-model-impl.js
class CoreProjectModelImpl {
    constructor(projectPath, name) {
        this._log = ohos_logger_js.OhosLogger.getLogger(CoreProjectModelImpl.name);
        this.subModels = new Map();
        // 项目路径
        this.projectPath = projectPath;
        // 项目名称
        this.name = name;
        // 设置 [项目路径]/build-profile.json5 文件路径
        this._profilePath = path.default.resolve(this.projectPath, common_const_js.CommonConst.PROFILE_JSON5);
        // 验证文件是否存在，是否符合规范
        this.projectBuildProfileCheck(this._profilePath);
        // 读取 [项目路径]/build-profile.json5 文件数据
        this._profileOptions = project_file_reader_js.ProjectFileReader.getJson5Obj(this.getProfilePath());
        // 检查配置文件中 SDK 版本信息，compileApiVersion 大于 8，compatibleApiVersion 小于等于 compileApiVersion
        this.projectStatusCheck();
        // 加载 [项目路径]/build-profile.json5 文件中 Modules 配置信息，创建 ModuleModelImpl 实例并设置进 subModels 中
        this.initSubProject();
    }
    ···
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

创建 Project 任务服务实例

基于持久化 project 的模型层提供的数据，经过处理后,提供给打包 app 任务流需要使用的服务和数据

// hvigor-ohos-plugin/src/tasks/service/project-task-service.js
class ProjectTaskService extends task_service.TaskService {
    constructor(project, projectModel) {
        super(projectModel);
        // 初始化 Project 中 Module 需要打包的目标项集合
        this.initProductData = () => {
            // 遍历所有模块
            this._project?.getSubProjects().forEach((value) => {
                const moduleName = value.getName();
                const plugin = value.getPlugin();
                if (plugin === undefined) {
                    throw new Error(`Cannot find build file 'hvigorfile.js' in module ${moduleName}`);
                }
                const moduleTargetDataArr = [];
                if (plugin instanceof hap_plugin.HapPlugin) {
                    // 获取项目级别 build-profile.json5 中 modules 里配置的 name 匹配的配置项
                    const appModuleOpt = this._projectModel?.getModuleProfileOpt(moduleName);
                    // 获取 module 配置中 targets 配置项
                    const appModuleConfigTargets = appModuleOpt?.targets;
                    // 获取 module 的 taskService 中 targetData 信息
                    const targetDataMap = plugin.getTaskService().getTargetDataMap();
                    // 遍历 Module 中需要打包的目标项
                    targetDataMap.forEach((targetData, targetName, targetMap) => {
                        // 该target需要打包，并且在项目级别 build-profile.json5 的 targets 中配置
                        if (targetData[1] && array_util.getElementFromArr(appModuleConfigTargets, targetName) !== undefined) {
                            moduleTargetDataArr.push(targetData[0]);
                        }
                    });
                    this._productDataMap.set(moduleName, moduleTargetDataArr);
                }
            });
        };
        this._project = project;
        // 获取命令行中配置的需要打包的 product 如果未配置则默认为 default
        this._targetProduct = find_target_product.findTargetProduct(projectModel);
        // 创建 SDK 工具实例,传入编译版本和 toolchains 工具名称
        this._sdkInfo = new sdk_info_js.SdkInfo(projectModel.getCompileApiVersion(), [sdkmanager_common.ComponentPath.TOOLCHAINS]);
        // 创建路径信息实例
        this._pathInfo = new project_path_info_iml.ProjectPathInfoIml(projectModel, this._targetProduct.name);
        this._productDataMap = new Map();
        this.initProductData();
    }
    ···
}
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Hvigor 自定义任务

创建任务

继承 Task 类实现自定义任务。创建自定义任务 command.js 文件,输出工程名称。

// command.js
const hvigor_base = require("@ohos/hvigor-base");

class Command extends hvigor_base.Task {
    _taskService = null
    _logger = hvigor_base.HvigorLogger.getLogger(Command.name);

    constructor(taskService) {
        super();
        this._taskService = taskService;
    }
    registry = () => {
        return this.doTaskAction;
    }
    doTaskAction = (cb) => {
        this._logger.info(`CustomCommand`);
        this._logger.info(`ProjectName : ${this._taskService.getProjectModel().getName()}`);
        cb();
    }
}
exports.Command = Command;

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

修改任务脚本

修改任务脚本把自定义任务加入到任务流中。

// hvigorfile
const command_js = require('./command');
const hapTasks = require('@ohos/hvigor-ohos-plugin').hapTasks;

module.exports = (module) => {
    const tasks = hapTasks(module);
    const taskService = tasks['plugin'].getTaskService();
    tasks.command = new command_js.Command(taskService);
    return tasks;
}
1
2
3
4
5
6
7
8
9
10

执行任务

**执行命令 **node node_modules@ohos\hvigor\bin\hvigor.js command

效果如下：

在这里插入图片描述

写在最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）文档用来跟着学习是非常有必要的。

这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。