@aiot-toolkit/emulator 2.0.2-beta.1 → 2.0.2-beta.11

package/lib/instance/miwear.js

@@ -35,245 +35,272 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const JavascriptDefaultCompileOption_1 = __importDefault(require("@aiot-toolkit/aiotpack/lib/compiler/javascript/JavascriptDefaultCompileOption"));
-const ColorConsole_1 = __importDefault(require("@aiot-toolkit/shared-utils/lib/ColorConsole"));
+const shared_utils_1 = require("@aiot-toolkit/shared-utils");
 const adbMiwt = __importStar(require("@miwt/adb"));
 const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const portfinder_1 = __importDefault(require("portfinder"));
 const ws_1 = __importStar(require("ws"));
-const constants_1 = require("../static/constants");
 const utils_1 = require("../utils");
 const common_1 = __importDefault(require("./common"));
+const dayjs_1 = __importDefault(require("dayjs"));
 const MAX_RECONNECT_COUNT = 8;
 /**
  * MiwearInstance
- * 针对 vela4.0 的镜像
+ * 针对 Vela正式版（4.0）的镜像
  */
 class MiwearInstance extends common_1.default {
     constructor(params) {
         super(params);
+        this.params = params;
+        this.quickappStartedFlag = /quickapp_rpk_installer_init|rpk installer init done/;
         this.appPathInEmulator = '/data/quickapp/app';
         this.reconnectCount = 0;
+        this.emulatorStartedFlag = /quickapp_rpk_installer_init|rpk installer init done/;
     }
-    /** 在goldfish模拟器中运行快应用 */
+    /**
+     * 1. 启动模拟器
+     * 2. 启动成功后，adb连接模拟器
+     * 3. 连接成功后，在模拟器中启动快应用
+     */
     start(options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startOptions = options;
+            this.sn = `emulator-${this.startOptions.adbPort}`;
             // 启动模拟器
             yield this.startGoldfish(options);
             // adb连接模拟器
-            const connected = yield this.connectGoldfish();
+            const connected = yield this.isConnected();
             if (connected) {
-                ColorConsole_1.default.info('### Emulator ### Goldfish emulator connected successfully');
+                shared_utils_1.ColorConsole.info('### Emulator ### Goldfish emulator connected successfully');
+                // 如果是首次启动，创建server端监听事件
                 if (this.isFirstStart && this.startOptions.serverPort) {
                     yield this.createWebsockeServer();
                 }
+                // 在模拟器中启动快应用
                 this.startupQuickApp(options);
                 this.isFirstStart = false;
             }
             else {
-                ColorConsole_1.default.throw('### Emulator ### Failed to connect emulator, please check whether the adb is normal');
+                const msg = '### Emulator ### Failed to connect emulator, please check whether the adb is normal';
+                shared_utils_1.ColorConsole.throw(msg);
+                throw new Error(msg);
             }
         });
     }
-    /** 启动goldfish模拟器 */
+    /**
+     * 启动模拟器
+     * 1. 通过options生成模拟器的启动命令
+     * 2. 执行启动命令
+     * 3. 判断模拟器是否启动成功
+     *    3.1 若disableNSH=true，输出流中匹配到/quickapp_rpk_installer_init|rpk installer init done/，认为模拟器启动成功了
+     *    3.2 若disableNSH=false，认为8s过后模拟器启动成功了
+     * @param options
+     * @returns
+     */
     startGoldfish(options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { avdName, devtool } = options;
+            const { avdName, devtool, origin = 'terminal' } = options;
+            // 获取emulator bin的绝对路径
             const emulatorBin = this.getEmulatorBinPath();
-            ColorConsole_1.default.log(`### Emulator ### emulator path: ${emulatorBin}`);
+            shared_utils_1.ColorConsole.log(`### Emulator ### emulator path: ${emulatorBin}`);
+            // 获取vela镜像的绝对路径
             const avdInfo = this.velaAvdCls.getVelaAvdInfo(avdName);
             const { avdArch, avdImagePath } = avdInfo;
-            this.adbPort = yield portfinder_1.default.getPortPromise({ port: this.adbPort });
-            ColorConsole_1.default.log(`### Emulator ### adb port: ${this.adbPort}`);
+            shared_utils_1.ColorConsole.log(`### Emulator ### adb port: ${options.adbPort}`);
             if (!avdImagePath) {
-                return ColorConsole_1.default.throw(`### Emulator ### Unable to find vela image via avd`);
+                return shared_utils_1.ColorConsole.throw(`### Emulator ### Unable to find vela image via avd`);
             }
             const nuttxBinPath = path_1.default.resolve(avdImagePath, 'nuttx');
-            ColorConsole_1.default.log(`### Emulator ### nuttx path: ${nuttxBinPath}`);
+            shared_utils_1.ColorConsole.log(`### Emulator ### nuttx path: ${nuttxBinPath}`);
             // 端口映射
-            let portMappingStr = `-network-user-mode-options hostfwd=tcp:127.0.0.1:${this.adbPort}-10.0.2.15:5555`;
+            let portMappingStr = ``;
             if (devtool) {
-                this.debugPort = yield portfinder_1.default.getPortPromise({ port: this.debugPort });
-                portMappingStr += `,hostfwd=tcp:127.0.0.1:${this.debugPort}-10.0.2.15:101`;
+                portMappingStr += `-network-user-mode-options hostfwd=tcp:127.0.0.1:${options.debugPort}-10.0.2.15:101`;
             }
-            // 文件系统配置，第一次使用fatfs镜像挂载，后续使用adb push更新应用
-            const systemImageBin = path_1.default.resolve(avdImagePath, 'vela_resource.img');
-            const dataImageBin = path_1.default.resolve(avdImagePath, 'data.img');
-            const imageMountStr = `-drive index=0,id=system,if=none,format=raw,file=${systemImageBin} \
+            // 设备挂载节点
+            const systemImageBin = path_1.default.resolve(avdImagePath, 'vela_resource.bin'); // 只读
+            const dataImageBin = path_1.default.resolve(avdImagePath, 'vela_data.bin'); // 可读可写
+            const coreBin = path_1.default.resolve(avdImagePath, 'coredump.core'); // 只读
+            // 复制可写文件到AVD目录下（多模拟器实例时需要）
+            const dataImageBinInAvd = path_1.default.join(this.avdHome, `${avdName}.avd`, 'vela_data.bin');
+            if (!fs_extra_1.default.existsSync(dataImageBinInAvd)) {
+                // vela_data.bin不存在时直接copy
+                fs_extra_1.default.copyFileSync(dataImageBin, dataImageBinInAvd);
+            }
+            else {
+                // vela_data.bin存在时，如果.export里的时间晚于avd里的时候，说明更新了镜像，需要重新copy
+                const statsInAvd = fs_extra_1.default.statSync(dataImageBinInAvd);
+                const stats = fs_extra_1.default.statSync(dataImageBin);
+                if ((0, dayjs_1.default)(stats.mtime).isAfter(statsInAvd.mtime)) {
+                    fs_extra_1.default.copyFileSync(dataImageBin, dataImageBinInAvd);
+                }
+            }
+            // 挂载节点配置，只读文件加入read-only标识
+            const imageMountStr = `-drive index=0,id=system,if=none,format=raw,file=${systemImageBin},read-only \
 -device virtio-blk-device,bus=virtio-mmio-bus.0,drive=system \
--drive index=1,id=userdata,if=none,format=raw,file=${dataImageBin} \
+-drive index=1,id=userdata,if=none,format=raw,file=${dataImageBinInAvd} \
 -device virtio-blk-device,bus=virtio-mmio-bus.1,drive=userdata \
+-drive index=2,id=vendor,if=none,format=raw,file=${coreBin},read-only \
+-device virtio-blk-device,bus=virtio-mmio-bus.4,drive=vendor \
 -device virtio-snd,bus=virtio-mmio-bus.2 -allow-host-audio -semihosting`;
-            // vnc配置
+            // grpc配置
             let windowStr = '';
-            let vncStr = '';
-            if ((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.vncPort) {
-                windowStr = '-no-window';
-                const portSuffix = this.startOptions.vncPort - constants_1.defaultVncPort;
-                vncStr = `-vnc :${portSuffix}`;
+            let grpcStr = '';
+            if ((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.grpcPort) {
+                windowStr = '-qt-hide-window';
+                grpcStr = ` -idle-grpc-timeout 300 -grpc ${this.startOptions.grpcPort}`;
             }
-            const stdioType = options.disableNSH ? 'pipe' : 'inherit';
-            // 启动goldfish的命令和参数
-            const cmd = `${emulatorBin} -nuttx -avd ${avdName} -avd-arch ${avdArch} -show-kernel -kernel ${nuttxBinPath} ${portMappingStr} ${windowStr} -qemu ${vncStr} ${imageMountStr}`;
+            // 启动模拟器的命令和参数
+            const cmd = `${emulatorBin} -nuttx -avd ${avdName} -port ${options.adbPort} -avd-arch ${avdArch} -show-kernel -kernel ${nuttxBinPath} ${portMappingStr} ${windowStr} ${grpcStr} -qemu ${imageMountStr}`;
             const spawnArgs = cmd.split(' ');
             const spawnBin = spawnArgs.shift();
-            ColorConsole_1.default.log(`### Emulator ### Start CMD: ${cmd}`);
+            shared_utils_1.ColorConsole.log(`### Emulator ### Start CMD: ${cmd}`);
             return new Promise((resolve) => {
                 var _a, _b, _c;
-                this.goldfishProcess = (0, child_process_1.spawn)(spawnBin, spawnArgs, { stdio: stdioType, shell: true });
-                (_a = this.goldfishProcess.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                    const stderrCb = options.stderrCallback || console.log;
-                    stderrCb(data.toString());
+                this.goldfishProcess = (0, child_process_1.spawn)(spawnBin, spawnArgs, {
+                    stdio: 'pipe',
+                    shell: true,
+                    cwd: this.sdkHome
                 });
+                // 监听模拟器的退出事件
                 this.goldfishProcess.on('exit', (code) => {
-                    ColorConsole_1.default.error(`### Emulator ### Goldfish emulator exited with code ${code}`);
+                    shared_utils_1.ColorConsole.error(`### Emulator ### Goldfish emulator exited with code ${code}`);
                     if (options.exitCallback) {
                         options.exitCallback(code);
                     }
                 });
-                if (options.disableNSH) {
-                    (_c = (_b = this.goldfishProcess) === null || _b === void 0 ? void 0 : _b.stdout) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
-                        const msg = data.toString();
-                        const stdoutCb = options.stdoutCallback || console.log;
-                        stdoutCb(msg);
-                        if (msg.match(/quickapp_rpk_installer_init|rpk installer init done/)) {
-                            ColorConsole_1.default.info(`### Emulator ### Goldfish emulator starts successfully`);
-                            resolve();
-                        }
-                    });
-                }
-                else {
-                    setTimeout(() => {
-                        ColorConsole_1.default.info(`### Emulator ### Goldfish emulator starts successfully`);
+                // 监听错误流
+                (_a = this.goldfishProcess.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                    const stderrCb = options.stderrCallback || console.log;
+                    stderrCb(data.toString());
+                });
+                // 监听输出流
+                (_c = (_b = this.goldfishProcess) === null || _b === void 0 ? void 0 : _b.stdout) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
+                    const msg = data.toString();
+                    const stdoutCb = options.stdoutCallback || console.log;
+                    stdoutCb(msg);
+                    // 应用安装成功，则启动它
+                    if (msg.match(/InstallState_Finished|install finished/)) {
+                        shared_utils_1.ColorConsole.info(`### Emulator ### Install quickapp successfully`);
+                        this.launchQuickapp();
+                    }
+                    // 匹配到，则认为模拟器启动成功
+                    if (msg.match(this.emulatorStartedFlag)) {
+                        shared_utils_1.ColorConsole.info(`### Emulator ### Goldfish emulator starts successfully`);
                         resolve();
-                    }, 8000);
-                    ColorConsole_1.default.info(`### Emulator ### Goldfish emulator starts successfully`);
-                    resolve();
-                }
-            });
-        });
-    }
-    /** 通过adb连接模拟器 */
-    connectGoldfish() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let adbConnected = false;
-            const connectFn = () => __awaiter(this, void 0, void 0, function* () {
-                const sn = `127.0.0.1:${this.adbPort}`;
-                while (!adbConnected) {
-                    const adbKillCmd = `adb kill-server`;
-                    ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbKillCmd}`);
-                    yield adbMiwt.execAdbCmdAsync(adbKillCmd);
-                    const adbConnectCmd = `adb connect ${sn}`;
-                    ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbConnectCmd}`);
-                    const str = yield adbMiwt.execAdbCmdAsync(adbConnectCmd);
-                    ColorConsole_1.default.log(`### Emulator ### ${str}`);
-                    const devices = yield adbMiwt.getAdbDevices();
-                    ColorConsole_1.default.log(`### Emulator ### adb devices: ${JSON.stringify(devices)}`);
-                    adbConnected =
-                        devices.filter((item) => item.sn === sn && item.status === 'device').length > 0;
-                }
-                Promise.resolve(adbConnected);
+                    }
+                });
             });
-            yield Promise.race([
-                connectFn(),
-                new Promise((resolve) => {
-                    setTimeout(() => resolve(false), 600 * 1000);
-                })
-            ]);
-            return adbConnected;
         });
     }
-    /** 在goldfish中启动快应用 */
+    /**
+     * 在模拟器中启动快应用
+     * 1. 检查release目录是否有打包好的rpk
+     * 2. 检查当前是否为调试模式.
+     *    若是，将debugger_ip.cfg推到模拟器的/data/目录下
+     *    若否，则要删除模拟器中已有的data/debugger_ip.cfg
+     * 3. 调用installRpkToAppList将当前快应用安装到模拟器的应用列表中
+     * @param options
+     */
     startupQuickApp(options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { package: appPackageName } = this.projectInfo;
-            const releaseDir = path_1.default.resolve(this.projectPath, JavascriptDefaultCompileOption_1.default.releasePath || 'dist');
+            const releaseDir = this.isRpk
+                ? path_1.default.resolve(this.projectPath, '../')
+                : path_1.default.resolve(this.projectPath, ((_a = this.params.compilerOption) === null || _a === void 0 ? void 0 : _a.releasePath) || 'dist');
             const files = fs_extra_1.default
                 .readdirSync(releaseDir)
-                .filter(item => item.includes(appPackageName) && item.endsWith('.rpk'));
-            if (files.length < 0) {
-                ColorConsole_1.default.error(`### Emulator the rpk does not exist`);
+                .filter((item) => item.includes(appPackageName) && item.endsWith('.rpk'));
+            if (files.length === 0) {
+                shared_utils_1.ColorConsole.error(`### Emulator the rpk does not exist`);
             }
             const rpkPath = path_1.default.resolve(releaseDir, files[0]);
             // 调试模式需要push一个文件至miwear中
-            const sn = `127.0.0.1:${this.adbPort}`;
             if (options.devtool) {
                 const debuggerCfgFile = path_1.default.join(__dirname, '../static/debugger_ip.cfg');
-                yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} push ${debuggerCfgFile} /data/debugger_ip.cfg`);
+                yield adbMiwt.execAdbCmdAsync(`adb -s ${this.sn} push ${debuggerCfgFile} /data/debugger_ip.cfg`);
             }
             else {
-                adbMiwt.execAdbCmdAsync(`adb -s ${sn} shell rm /data/debugger_ip.cfg`);
+                yield adbMiwt.execAdbCmdAsync(`adb -s ${this.sn} shell rm /data/debugger_ip.cfg`);
             }
             this.installRpkToAppList(rpkPath, this.appPathInEmulator);
         });
     }
-    /** 将快应用安装到应用列表 */
+    /**
+     * 将快应用安装到模拟器的应用列表
+     * 1. 使用adb push将打包好的rpk推到模拟器的/data/quickapp/app/
+     * 2. nsh中调用pm install命令安装应用
+     * @param rpkPath rpk的绝对目录
+     * @param targetDir 要将rpk放到模拟器的哪个目录下
+     */
     installRpkToAppList(rpkPath, targetDir) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const sn = `127.0.0.1:${this.adbPort}`;
-                const { package: packageName } = this.projectInfo;
-                const rpkName = path_1.default.basename(rpkPath);
-                // 1. 查询应用是否已经安装，如果安装了，则先卸载
-                const lsCmd = `adb -s ${sn} shell ls ${this.appPathInEmulator}`;
-                const res = yield adbMiwt.execAdbCmdAsync(lsCmd);
-                if (res.includes(packageName)) {
-                    const uninstallCmd = `adb -s ${sn} shell pm uninstall ${packageName}`;
-                    ColorConsole_1.default.info(`### Emulator ### Excuting cmd: ${uninstallCmd}`);
-                    adbMiwt.execAdbCmdAsync(uninstallCmd);
-                    // 这里等待2s的作用是等qemu执行完uninstall操作的一系列工作
-                    yield (0, utils_1.sleep)(2000);
-                }
-                // 2. adb push应用的rpk
-                const targetPath = `${targetDir}/${packageName}.rpk`;
-                const pushCmd = `adb -s ${sn} push ${rpkPath} ${targetPath}`;
-                ColorConsole_1.default.info(`### Emulator ### Excuting cmd: ${pushCmd}`);
-                yield adbMiwt.execAdbCmdAsync(pushCmd);
-                yield (0, utils_1.sleep)(100);
-                // 3. 安装应用
-                const installCmd = `adb -s ${sn} shell pm install ${targetPath}`;
-                ColorConsole_1.default.info(`### Emulator ### Excuting cmd: ${installCmd}`);
-                adbMiwt.execAdbCmdAsync(installCmd);
-            }
-            catch (e) { }
+            const { package: packageName } = this.projectInfo;
+            // 1. adb push应用的rpk
+            const targetPath = `${targetDir}/${packageName}.rpk`;
+            const pushCmd = `adb -s ${this.sn} push "${rpkPath}" ${targetPath}`;
+            shared_utils_1.ColorConsole.info(`### Emulator ### Excuting cmd: ${pushCmd}`);
+            yield adbMiwt.execAdbCmdAsync(pushCmd);
+            const installCmd = `adb -s ${this.sn} shell pm install ${targetPath}`;
+            shared_utils_1.ColorConsole.info(`### Emulator ### Excuting cmd: ${installCmd}`);
+            yield adbMiwt.execAdbCmdAsync(installCmd);
+        });
+    }
+    /** 使用am start启动快应用 */
+    launchQuickapp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { package: packageName } = this.projectInfo;
+            const startCmd = `adb -s ${this.sn} shell am start ${packageName}`;
+            shared_utils_1.ColorConsole.info(`### Emulator ### Excuting cmd: ${startCmd}`);
+            adbMiwt.execAdbCmdAsync(startCmd);
         });
     }
+    /** 连接模拟器中的调试服务，创建debugSocket
+     * 主要用于热更新时，通过debugSocket通知调试服务更新页面
+     * 设置了重连机制，会重复连接8次
+     */
     initDebugSocket() {
-        if (this.debugSocket && this.debugSocket.OPEN) {
-            return Promise.resolve();
-        }
-        this.debugSocket = new ws_1.default(`ws://localhost:${this.debugPort}`);
-        this.debugSocket.onopen = () => {
-            ColorConsole_1.default.info(`### Emulator debugSocket connect success`);
-            return Promise.resolve();
-        };
-        this.debugSocket.onerror = (e) => {
+        return new Promise((resolve, reject) => {
             var _a;
-            // 重连机制
-            (_a = this.debugSocket) === null || _a === void 0 ? void 0 : _a.terminate();
-            if (this.reconnectCount < MAX_RECONNECT_COUNT) {
-                ColorConsole_1.default.info(`### Emulator the ${this.reconnectCount + 1}th time to reconnect debug server`);
-                this.reconnectCount++;
-                setTimeout(() => this.initDebugSocket(), 2000);
+            if (this.debugSocket && this.debugSocket.OPEN) {
+                return resolve();
             }
-            else {
+            this.debugSocket = new ws_1.default(`ws://localhost:${(_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.debugPort}`);
+            this.debugSocket.onopen = () => {
+                shared_utils_1.ColorConsole.info(`### Emulator debugSocket connect success`);
+                return resolve();
+            };
+            this.debugSocket.onerror = (errorEvent) => {
+                var _a;
+                // 重连机制
+                (_a = this.debugSocket) === null || _a === void 0 ? void 0 : _a.terminate();
+                if (this.reconnectCount < MAX_RECONNECT_COUNT) {
+                    shared_utils_1.ColorConsole.info(`### Emulator the ${this.reconnectCount + 1}th time to reconnect debug server`);
+                    this.reconnectCount++;
+                    setTimeout(() => this.initDebugSocket(), 2000);
+                }
+                else {
+                    this.debugSocket = undefined;
+                    this.reconnectCount = 0;
+                    return reject(`### Emulator debugSocket connect failed, ${errorEvent.message}`);
+                }
+            };
+            this.debugSocket.onclose = (closeEvent) => {
                 this.debugSocket = undefined;
                 this.reconnectCount = 0;
-                return Promise.reject(`### Emulator debugSocket connect failed`);
-            }
-        };
-        this.debugSocket.onclose = (e) => {
-            this.debugSocket = undefined;
-            this.reconnectCount = 0;
-            ColorConsole_1.default.log(`### Emulator debugSocket connect close: ${e.data}`);
-        };
+                shared_utils_1.ColorConsole.log(`### Emulator debugSocket connect close: ${closeEvent.reason}`);
+            };
+        });
     }
-    /** 通知模拟器更新 */
+    /** 通知模拟器更新
+     * 1. 确保已经成功连接模拟器中的调试服务
+     * 2. 使用adb push将build文件下的内容推到/data/quickapp/app/${packageName}
+     * 3. 发送Page.reload命令给调试服务，通知更新
+     */
     handleUpdate() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -281,47 +308,87 @@ class MiwearInstance extends common_1.default {
                 this.reconnectCount = 0;
                 yield this.initDebugSocket();
                 // 1. 将整包重新推到miwear中（TODO：增量更新）
-                const sn = `127.0.0.1:${this.adbPort}`;
-                const { package: appPackageName } = this.projectInfo;
-                // windows平台adb push时无法使用通配符，需另外处理
-                if (os_1.default.platform() === 'win32') {
-                    const rmCmd = `adb -s ${sn} shell rm -r ${this.appPathInEmulator}/${appPackageName}`;
-                    yield adbMiwt.execAdbCmdAsync(rmCmd);
-                    const sourcePath = path_1.default.resolve(this.projectPath, './build');
-                    const pushCmd = `adb -s ${sn} push ${sourcePath} ${this.appPathInEmulator}/${appPackageName}`;
-                    yield adbMiwt.execAdbCmdAsync(pushCmd);
-                }
-                else {
-                    const sourcePath = path_1.default.resolve(this.projectPath, './build/*');
-                    yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} push ${sourcePath} ${this.appPathInEmulator}/${appPackageName}`);
-                }
-                ColorConsole_1.default.info(`### Emulator push to ${this.appPathInEmulator}/${appPackageName} successfully`);
+                yield this.pushBuild();
                 // 2. 下发CDP命令给调试服务告知刷新
                 if (((_a = this.debugSocket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
                     (_b = this.debugSocket) === null || _b === void 0 ? void 0 : _b.send(JSON.stringify({ id: 10000, method: 'Page.reload', params: {} }));
                 }
             }
             catch (e) {
-                ColorConsole_1.default.error(`${e}`);
+                shared_utils_1.ColorConsole.error(`${e}`);
+            }
+        });
+    }
+    /** 热更新时push目录 */
+    pushBuild() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { package: appPackageName } = this.projectInfo;
+            // windows平台adb push时无法使用通配符，需另外处理;
+            // 项目路径包含空格时，无法通过加引号来使用 * 通配符
+            if (os_1.default.platform() === 'win32' || this.projectPath.indexOf(' ') > 0) {
+                const rmCmd = `adb -s ${this.sn} shell rm -r ${this.appPathInEmulator}/${appPackageName}`;
+                yield adbMiwt.execAdbCmdAsync(rmCmd);
+                const sourcePath = path_1.default.resolve(this.projectPath, './build');
+                const pushCmd = `adb -s ${this.sn} push "${sourcePath}" ${this.appPathInEmulator}/${appPackageName}`;
+                yield adbMiwt.execAdbCmdAsync(pushCmd);
+            }
+            else {
+                const sourcePath = path_1.default.resolve(this.projectPath, './build/*');
+                yield adbMiwt.execAdbCmdAsync(`adb -s ${this.sn} push ${sourcePath} ${this.appPathInEmulator}/${appPackageName}`);
+            }
+            shared_utils_1.ColorConsole.info(`### Emulator push to ${this.appPathInEmulator}/${appPackageName} successfully`);
+        });
+    }
+    /** 在模拟器中重启快应用（基于am命令，需要保证镜像中已经有am功能）
+     * 1. 使用adb push将build文件下的内容推到/data/quickapp/app/${packageName}
+     * 2. nsh中执行am stop命令退出快应用
+     * 3. nsh中执行am start命令启动快应用
+     */
+    pushAndReloadApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. 将整包重新推到miwear中（TODO：增量更新）
+            yield this.pushBuild();
+            yield this.reloadApp();
+        });
+    }
+    reloadApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { package: appPackageName } = this.projectInfo;
+                // 2. 执行am stop和am start命令
+                const stopCmd = `adb -s ${this.sn} shell am stop ${appPackageName}`;
+                yield adbMiwt.execAdbCmdAsync(stopCmd);
+                shared_utils_1.ColorConsole.info(`### Emulator stop ${appPackageName} successfully`);
+                // 这里是为了等am stop命令清除资源等
+                yield (0, utils_1.sleep)(500);
+                const startCmd = `adb -s ${this.sn} shell am start ${appPackageName}`;
+                yield adbMiwt.execAdbCmdAsync(startCmd);
+                shared_utils_1.ColorConsole.info(`### Emulator start ${appPackageName} successfully`);
+            }
+            catch (e) {
+                shared_utils_1.ColorConsole.error(`${e}`);
             }
         });
     }
-    /** 创建server */
+    /**
+     * 创建server端，监听打包过程中client端发来的消息
+     */
     createWebsockeServer() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const wsServer = new ws_1.WebSocketServer({
-                port: (_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.serverPort,
+                port: (_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.serverPort
             });
-            wsServer.on('connection', socket => {
-                ColorConsole_1.default.success(`### App Socket server ### Websocket connects to websocket server`);
-                socket.on('error', err => {
-                    ColorConsole_1.default.error(`### App Socket server ### Websocket server error: ${err.message}`);
+            wsServer.on('connection', (socket) => {
+                shared_utils_1.ColorConsole.success(`### App Socket server ### Websocket connects to websocket server`);
+                socket.on('error', (err) => {
+                    shared_utils_1.ColorConsole.error(`### App Socket server ### Websocket server error: ${err.message}`);
                 });
+                // data的格式：{ type: string, data: any }
                 socket.on('message', (data) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
                     const message = JSON.parse(data.toString());
-                    ColorConsole_1.default.log(`### App Socket server ### Websocket server get data: ${data}`);
+                    shared_utils_1.ColorConsole.log(`### App Socket server ### Websocket server get data: ${data}`);
                     if (message.type === 'restart') {
                         // 非调试模式下无法热更新
                         if (!((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.devtool)) {

package/lib/instance/pre.d.ts

@@ -0,0 +1,8 @@
+import GoldfishInstance from './dev';
+/**
+ * 不带 miwear 的 4.0 镜像
+ */
+declare class PreInstance extends GoldfishInstance {
+    appRunDir: string;
+}
+export default PreInstance;

package/lib/instance/pre.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dev_1 = __importDefault(require("./dev"));
+const miwear_1 = __importDefault(require("./miwear"));
+/**
+ * 不带 miwear 的 4.0 镜像
+ */
+class PreInstance extends dev_1.default {
+    constructor() {
+        super(...arguments);
+        this.appRunDir = '/data/quickapp/app';
+    }
+}
+//  pre 镜像的 启动 方式与 MiwearInstance 一致
+PreInstance.prototype.startGoldfish = miwear_1.default.prototype.startGoldfish;
+exports.default = PreInstance;

package/lib/instance/preDev.d.ts

@@ -2,20 +2,48 @@
 import { ChildProcess } from 'child_process';
 import { INewGoldfishInstanceParams, IStartOptions } from '../typing/Instance';
 import CommonInstance from './common';
+/**
+ * OldGoldfishInstance
+ * 针对 Vela开发版（dev, 0.0.2）的镜像
+ */
 declare class OldGoldfishInstance extends CommonInstance {
     private host9pPort;
     v9fsProcess: ChildProcess | undefined;
     constructor(params: INewGoldfishInstanceParams);
-    /** 在goldfish模拟器中运行快应用 */
+    /**
+     * 1. 启动9p server
+     * 2. 将打包好的rpk推到host的挂载目录
+     * 3. 启动模拟器
+     * 4. 模拟器启动成功后，adb连接模拟器
+     * 5. 连接成功后，在模拟器中启动快应用
+     */
     start(options: IStartOptions): Promise<void>;
-    /** 在goldfish中启动快应用 */
+    /**
+     * 在模拟器中启动快应用（快应用都在模拟器的/data/app目录下）
+     * 1. 是否为调试模式
+     *    若是，在模拟器终端执行vapp app/${packageName} &
+     *    若否，在模拟器终端执行vapp --jsdebugger=10.0.2.15:101 app/${packageName} &
+     */
     startupQuickApp(options: IStartOptions): void;
-    /** host启动9pServer */
+    /** host启动9pServer
+     * 作用是将本地的quickappMountDir目录挂载到模拟器的/data目录
+     */
     ensure9pServerRunnning(): Promise<void>;
-    /** 启动goldfish模拟器 */
+    /**
+     * 启动模拟器
+     * 1. 通过options生成模拟器的启动命令
+     * 2. 执行启动命令
+     * 3. 判断模拟器是否启动成功
+     *    3.1 若disableNSH=true，输出流中匹配到/quickapp_rpk_installer_init|rpk installer init done/，认为模拟器启动成功了
+     *    3.2 若disableNSH=false，认为8s过后模拟器启动成功了
+     * @param options
+     * @returns
+     */
     startGoldfish(options: IStartOptions): Promise<void>;
-    /** 通过adb连接模拟器 */
-    connectGoldfish(): Promise<boolean>;
+    /**
+     * 推送文件到本地的${sdkHome}/qa/app/${packageName}目录
+     * @param sourceRoot 源目录
+     */
     pushRpk(sourceRoot: string): Promise<void>;
     /** 停止模拟器并释放相关资源 */
     stop(): Promise<void>;