@atomicservice/ascf-toolkit-hvigor-plugin 1.0.0 → 1.0.1-beta.0

package/index.ts

@@ -1,3 +1,7 @@
+import { default as ascfPlugin } from './src/plugin/ascf-toolkit-hvigor-plugin';
 
-import ascfPlugin from './src/plugin/ascf-toolkit-hvigor-plugin';
+export { default as signByBuildModePlugin } from './src/plugin/sign-by-build-mode-plugin';
+export { default as modifyShareInfoPlugin } from './src/plugin/modifyShareInfoPlugin';
+export { default as installAscfHspPlugin } from './src/plugin/installAscfHspPlugin';
+export { ascfPlugin };
 export default ascfPlugin;

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@atomicservice/ascf-toolkit-hvigor-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1-beta.0",
   "title": "ASCF toolkit hvigor plugin for atomicservice",
   "description": "ASCF toolkit hvigor plugin for atomicservice",
-  "main": "index.js",
+  "main": "index.ts",
   "author": "atomicservice",
+  "type": "module",
   "devDependencies": {
     "@ohos/hvigor": "5.8.9",
-    "@ohos/hvigor-ohos-plugin": "5.8.9"
+    "@ohos/hvigor-ohos-plugin": "5.8.9",
+    "@atomicservice/ascf-toolkit": "*"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/config.json

@@ -0,0 +1,3 @@
+{
+  "ascfHspUrl": "https://h5hosting-drcn.dbankcdn.cn/cch5/wallet/ascf-cn/ascfHsp.html?auto=1"
+}

package/src/plugin/ascf-toolkit-hvigor-plugin.ts

@@ -1,64 +1,106 @@
-import { OhosPluginId, OhosAppContext } from '@ohos/hvigor-ohos-plugin';
-import { hvigor, HvigorNode, HvigorPlugin } from '@ohos/hvigor';
-import { exec, execSync } from 'child_process';
+import { OhosAppContext, OhosPluginId } from '@ohos/hvigor-ohos-plugin';
+import { Property } from '@ohos/hvigor-ohos-plugin/src/sdk/lib/property-get';
+import { PropertyConst } from '@ohos/hvigor-ohos-plugin/src/const/property-const';
+import { hvigor, HvigorLogger, HvigorNode, HvigorPlugin } from '@ohos/hvigor';
+import ascf from '@atomicservice/ascf-toolkit';
+import { exec } from 'child_process';
+import path from 'path';
 import os from 'os';
 
-export default function ascfToolkitHvigorPlugin(): HvigorPlugin {
-    return {
-        pluginId: 'ascfToolkitHvigorPlugin',
-        apply(node: HvigorNode) {
-            hvigor.nodesEvaluated(async () => {
-                const existCmdStr = getExistCmdStr();
-                if (!await existCmd(existCmdStr)) {
-                    const installAscfCmd = `npm install -g @atomicservice/ascf-toolkit`;
-                    console.log(`start exec [${installAscfCmd}]`);
-                    try {
-                        const output = execSync(installAscfCmd, { stdio: 'inherit' });
-                        console.log(output);
-                    } catch (error) {
-                        console.error('ERROR: failed to install the ascf dependency');
-                        console.info(`INFO: run the [${installAscfCmd}] command to install the dependency`)
-                        return;
-                    }
-                }
-                const appContext = node.getContext(OhosPluginId.OHOS_APP_PLUGIN) as OhosAppContext;
-                const cmd = `ascf compile -c ${appContext.getProjectPath()}`;
-                console.log(`INFO: start exec [${cmd}]`);
-                const output = execSync(cmd, { stdio: 'inherit' });
-                console.log(output);
+import { doModifyShareInfoPlugin } from './modifyShareInfoPlugin';
+import { doInstallAscfHspPlugin } from './installAscfHspPlugin';
+
+const logger = HvigorLogger.getLogger('ascfPlugin');
+
+export interface AscfPluginOptions {
+  fixSharedHsp: true,
+  installAscfHsp: true,
+  debug: true,
+}
+
+const DEFAULT_OPTIONS: AscfPluginOptions = {
+  fixSharedHsp: true,
+  installAscfHsp: true,
+  debug: true,
+};
+
+export default function ascfToolkitHvigorPlugin(options: AscfPluginOptions): HvigorPlugin {
+  return {
+    pluginId: 'ascfToolkitHvigorPlugin',
+    apply(node: HvigorNode) {
+      const opts = Object.assign({}, DEFAULT_OPTIONS, options);
+
+      hvigor.nodesEvaluated(async () => {
+        await execPlugin(opts, node);
+
+        try {
+          if (hvigor.isCommandEntryTask('GetHvigorDepsCachesDir')) {
+            node.registerTask({
+              name: 'GetHvigorDepsCachesDir',
+              run() {
+                console.log('ASCF_GET_HVIGOR_DEPS_CACHES_DIR=' + ascf.getAscfToolkitDirname());
+              },
             });
+          } else {
+            logger.debug('start exec ascf compile');
+            const appContext = node.getContext(OhosPluginId.OHOS_APP_PLUGIN) as OhosAppContext;
+            const buildMode = appContext.getBuildMode();
+            const nodeExe = getNodeExe();
+            const ascfScript = getAscfScript();
+            let cmd = `\"${nodeExe}\" \"${ascfScript}\" compile -c ${buildMode === 'debug' ? '-m' : ''} ${appContext.getProjectPath()}`;
+
+            if (opts.debug && logger.getLevel().levelStr === 'DEBUG') {
+              cmd += ' --debug';
+            }
+
+            await executeCommand(cmd);
+            logger.debug('ascf compile completed');
+          }
+        } catch (err: any) {
+          logger.errorExit(new Error(err));
         }
+      });
     }
+  };
 }
 
-function executeCommand(command: string) {
-    return new Promise((resolve, reject) => {
-        exec(command, (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(stdout);
-            }
-        });
-    });
+async function execPlugin(opts: AscfPluginOptions, node: HvigorNode) {
+  const entryNode = hvigor.getNodeByName('entry');
+  if (entryNode && opts.fixSharedHsp) {
+    await doModifyShareInfoPlugin(entryNode).catch(err => logger.error(err));
+  }
+  if (entryNode && opts.installAscfHsp) {
+    await doInstallAscfHspPlugin(node).catch(err => logger.error(err));
+  }
 }
 
-async function existCmd(command: string){
-    let res;
-    await executeCommand(command)
-        .then((result) => {
-            res = true;
-        })
-        .catch((error) => {
-            res = false;
-        })
-    return res;
+function executeCommand(command: string) {
+  return new Promise((resolve, reject) => {
+    exec(command, (error: any, stdout: any, stderr: string) => {
+      if (error) {
+        reject(error);
+      } else {
+        logger.debug(stderr);
+        logger.debug(stdout);
+        resolve(stderr);
+      }
+    });
+  });
 }
 
-function getExistCmdStr() {
-    if (os.platform() === 'win32') {
-        return 'where ascf';
-    }
-    return 'which ascf';
+function getNodeExe() {
+  const property: Property = new Property();
+  const nodeDir = property.getProperty(PropertyConst.NPM_DIR);
+  const platform = os.platform();
+  if (platform === 'win32') {
+    return path.join(nodeDir, 'node.exe');
+  } else if (platform === 'darwin' || platform === 'linux') {
+    return path.join(nodeDir, 'node');
+  } else {
+    return 'node';
+  }
 }
 
+function getAscfScript() {
+  return path.join(ascf.getAscfToolkitDirname(), 'bin', 'ascf.js');
+}

package/src/plugin/installAscfHspPlugin.ts

@@ -0,0 +1,94 @@
+import type { HvigorNode, HvigorPlugin } from '@ohos/hvigor';
+import { hvigor, HvigorLogger } from '@ohos/hvigor';
+import { OhosAppContext, OhosHapContext, OhosPluginId, Target } from '@ohos/hvigor-ohos-plugin';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+const logger = HvigorLogger.getLogger('modifyShareInfoPlugin');
+
+function execSafe(cmd: string) {
+  try {
+    return execSync(cmd)?.toString('utf8');
+  } catch (e) {
+    logger.warn('exec cmd error', e);
+  }
+}
+
+const BUNDLE_NAME_ASCF = 'com.huawei.hms.ascf';
+const ERR_MSG = `${BUNDLE_NAME_ASCF} install failed, please open helloUniapp manually.`;
+
+function checkAscfHsp() {
+  logger.debug(`Check and install ${BUNDLE_NAME_ASCF} for local development`);
+  const sharedInfo = execSafe(`hdc shell bm dump-shared -a`);
+  if (sharedInfo?.includes(BUNDLE_NAME_ASCF)) {
+    const verInfo = execSafe(`hdc shell "bm dump-shared -n ${BUNDLE_NAME_ASCF} | grep versionName"`);
+    logger.debug(`found ${BUNDLE_NAME_ASCF} ${verInfo}`);
+    return true;
+  }
+  return false;
+}
+
+function doInstallAscfHsp(resolve: any, reject: any) {
+  if (checkAscfHsp()) {
+    resolve();
+    return;
+  }
+
+  logger.debug(`trying to install ${BUNDLE_NAME_ASCF}`);
+  const configJsonPath = path.resolve(__dirname, '../config.json');
+  const configJson = JSON.parse(fs.readFileSync(configJsonPath).toString());
+  const startInfo = execSafe(`hdc shell aa start -b com.huawei.hmos.browser -a MainAbility -A ohos.want.action.viewData -U "${configJson.ascfHspUrl}"`);
+  if (!startInfo?.includes('successfully')) {
+    logger.warn(`${ERR_MSG} errorInfo=${startInfo}`);
+    reject(ERR_MSG);
+    return;
+  }
+
+  logger.debug(`begin to wait install hsp`);
+  let needWait = 0;
+  let timer = setInterval(() => {
+    const found = checkAscfHsp();
+    needWait++;
+
+    if (found || needWait > 5) {
+      clearInterval(timer);
+      if (found) {
+        resolve();
+      } else {
+        logger.warn(ERR_MSG);
+        reject(ERR_MSG);
+      }
+      return;
+    }
+  }, 1000);
+}
+
+export async function doInstallAscfHspPlugin(rootNode: HvigorNode): Promise<void> {
+  logger.debug('start exec install ascf hsp plugin');
+  const appContext = rootNode.getContext(OhosPluginId.OHOS_APP_PLUGIN) as OhosAppContext;
+  const currentNode = hvigor.getNodeByName('entry')!;
+  const hapContext = currentNode.getContext(OhosPluginId.OHOS_HAP_PLUGIN) as OhosHapContext;
+  if (appContext?.getBuildMode() !== 'debug') {
+    return;
+  }
+
+  hapContext?.targets((target: Target) => {
+    const targetName = target.getTargetName();
+    logger.debug(`installAscfHspPlugin targetName:${targetName}`);
+    currentNode.registerTask({
+      name: 'installAscfHspTask',
+      run: () => new Promise<void>(doInstallAscfHsp).catch((err) => logger.error(err)),
+      dependencies: [`${targetName}@CompileArkTS`],
+      postDependencies: [`${targetName}@PackageHap`]
+    });
+  });
+  logger.debug('exec install ascf hsp plugin completed');
+}
+
+export default function installAscfHspPlugin(): HvigorPlugin {
+  return {
+    pluginId: 'installAscfHspPlugin',
+    apply: doInstallAscfHspPlugin,
+  };
+}

package/src/plugin/modifyShareInfoPlugin.ts

@@ -0,0 +1,138 @@
+import type { HvigorNode, HvigorPlugin, HvigorTaskContext } from '@ohos/hvigor';
+import { HvigorLogger } from '@ohos/hvigor';
+import { OhosHapContext, OhosPluginId, Target } from '@ohos/hvigor-ohos-plugin';
+import path from 'path';
+import fs from 'fs';
+
+const logger = HvigorLogger.getLogger('modifyShareInfoPlugin');
+
+const readJson = (filepath: string) => JSON.parse(fs.readFileSync(filepath, 'utf-8'));
+const writeJson = (filepath: string, str: any) => fs.writeFileSync(filepath, JSON.stringify(str), 'utf-8');
+
+function addShareInfo(sharedInfos: any, srcPath: string) {
+  logger.debug(`addShareInfo srcPath ${srcPath}`);
+  let modulePath = path.resolve(srcPath, 'src/main/module.json');
+  if (!fs.existsSync(modulePath)) {
+    modulePath += '5'; // trying module.json5
+    if (!fs.existsSync(modulePath)) {
+      return;
+    }
+  }
+  logger.debug(`addShareInfo modulePath ${modulePath}`);
+  const srcModuleJson = readJson(modulePath);
+  logger.debug(`addShareInfo srcModuleJson ${JSON.stringify(srcModuleJson, null, '  ')}`);
+  const srcBundleName = srcModuleJson?.app?.bundleName ?? '';
+  const srcVersionCode = srcModuleJson?.app?.versionCode ?? 0;
+  const srcModuleName = srcModuleJson?.module?.name ?? '';
+  const srcModuleType = srcModuleJson?.module?.type ?? '';
+  if (srcModuleType === 'shared' && srcBundleName && srcVersionCode !== 0 && srcModuleName) {
+    const shareInfo = {
+      'bundleName': srcBundleName,
+      'moduleName': srcModuleName,
+      'versionCode': srcVersionCode
+    };
+    sharedInfos.push(shareInfo);
+  } else if (srcModuleType === 'shared' && !srcBundleName && srcVersionCode === 0 && srcModuleName) {
+    const shareInfo = {
+      'moduleName': srcModuleName,
+    };
+    sharedInfos.push(shareInfo);
+  }
+};
+
+function getSharedInfos(modulePath: string): Array<object> {
+  const sharedInfos: any = [];
+  const moduleFilePath = path.resolve(modulePath, `oh_modules`);
+  const moduleFileNames = fs.readdirSync(moduleFilePath);
+  logger.debug(`moduleFileNames=${moduleFileNames}`);
+
+  moduleFileNames.filter(v => v && !v.startsWith('.')).forEach((moduleFileName) => {
+    logger.debug(`moduleFileName=${moduleFileName}`);
+
+    if (moduleFileName.startsWith('@')) {
+      const cloudModuleFilePath = path.resolve(modulePath, `oh_modules/${moduleFileName}`);
+      const cloudModuleFileNames = fs.readdirSync(cloudModuleFilePath);
+      logger.debug(`cloudModuleFileNames=${cloudModuleFileNames}`);
+
+      cloudModuleFileNames.forEach((cloudModuleFileName) => {
+        logger.debug(`cloudModuleFileName=${cloudModuleFileName}`);
+        addShareInfo(sharedInfos, path.resolve(cloudModuleFilePath, `${cloudModuleFileName}`));
+      });
+    } else {
+      addShareInfo(sharedInfos, path.resolve(moduleFilePath, `${moduleFileName}`));
+    }
+  });
+  return sharedInfos;
+}
+
+function updateSharedInfo(modulePath: string): void {
+  const buildFilePath = path.resolve(modulePath, `build`);
+  if (!fs.existsSync(buildFilePath)) {
+    logger.debug('buildFilePath:' + buildFilePath);
+    return;
+  }
+
+  const dependencies = getSharedInfos(modulePath);
+  if (!dependencies?.length) {
+    logger.debug('dependencies is empty');
+    return;
+  }
+
+  const buildFileNames = fs.readdirSync(buildFilePath);
+  logger.debug('buildFileNames:' + buildFileNames);
+  buildFileNames.filter(v => v).forEach((productName) => {
+    logger.debug('productName: ' + productName);
+    const filePath = path.resolve(buildFilePath, `${productName}/intermediates/res/${productName}/module.json`);
+    logger.debug('module.json filePath: ' + filePath);
+    if (fs.existsSync(filePath)) {
+      const moduleJson = readJson(filePath);
+      moduleJson.module.dependencies = dependencies;
+      writeJson(filePath, moduleJson);
+      logger.debug(`final moduleJson ${JSON.stringify(moduleJson, null, '  ')}`);
+    } else {
+      logger.debug('module.json filePath: ' + filePath + ' is not Exists');
+    }
+
+    const metadataPath = path.resolve(buildFilePath,
+      `${productName}/intermediates/hap_metadata/${productName}/output_metadata.json`);
+    logger.debug('output_metadata.json filePath: ' + metadataPath);
+    if (fs.existsSync(metadataPath)) {
+      const metadataJson = readJson(metadataPath);
+      metadataJson?.forEach((v: any) => {
+        const found = v.dependRemoteHsps?.findIndex((x: any) => x.hspName?.includes('ascf'));
+        if (v.dependRemoteHsps && found !== -1) {
+          v.dependRemoteHsps.splice(found, 1);
+        }
+      });
+      writeJson(metadataPath, metadataJson);
+      logger.debug(`final metadataJson ${JSON.stringify(metadataJson, null, '  ')}`);
+    }
+  });
+}
+
+export async function doModifyShareInfoPlugin(currentNode: HvigorNode): Promise<void> {
+  logger.debug('start exec modify share info plugin');
+  const hapContext = currentNode.getContext(OhosPluginId.OHOS_HAP_PLUGIN) as OhosHapContext;
+
+  hapContext?.targets((target: Target) => {
+    const targetName = target.getTargetName();
+    logger.debug(`targetName:${targetName}`);
+    currentNode.registerTask({
+      name: 'modifyShareInfoTask',
+      run: (taskContext: HvigorTaskContext) => {
+        logger.debug('moduleName=' + taskContext.moduleName + ' modulePath=' + taskContext.modulePath);
+        updateSharedInfo(taskContext.modulePath);
+      },
+      dependencies: [`${targetName}@CompileArkTS`],
+      postDependencies: [`${targetName}@PackageHap`]
+    });
+  });
+  logger.debug('exec modify share info plugin completed');
+}
+
+export default function modifyShareInfoPlugin(): HvigorPlugin {
+  return {
+    pluginId: 'modifyShareInfoPlugin',
+    apply: doModifyShareInfoPlugin,
+  };
+}

package/src/plugin/sign-by-build-mode-plugin.ts

@@ -0,0 +1,27 @@
+import { HvigorLogger, HvigorNode, HvigorPlugin } from '@ohos/hvigor';
+import { OhosAppContext, OhosPluginId } from '@ohos/hvigor-ohos-plugin';
+
+const logger = HvigorLogger.getLogger('signByBuildModePlugin');
+
+function signByBuildMode(debugSignName: string, releaseSignName: string): HvigorPlugin {
+  return {
+    pluginId: 'signByBuildMode',
+    apply(node: HvigorNode) {
+      try {
+        logger.debug('start exec sign by build mode');
+        const appContext = node.getContext(OhosPluginId.OHOS_APP_PLUGIN) as OhosAppContext;
+        const signingConfig = appContext.getBuildMode() === 'debug' ? debugSignName : releaseSignName;
+        logger.debug('signByBuildMode change signingConfig=' + signingConfig);
+
+        const bpOpt = appContext.getBuildProfileOpt();
+        bpOpt.app.products![0].signingConfig = signingConfig;
+        appContext.setBuildProfileOpt(bpOpt);
+        logger.debug('sign by build mode completed');
+      } catch (err: any) {
+        logger.errorExit(new Error(err));
+      }
+    },
+  };
+}
+
+export default signByBuildMode;