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

package/lib/instance/dev.js

@@ -35,149 +35,268 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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 dayjs_1 = __importDefault(require("dayjs"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const portfinder_1 = __importDefault(require("portfinder"));
-const constants_1 = require("../static/constants");
 const common_1 = __importDefault(require("./common"));
 class GoldfishInstance extends common_1.default {
     constructor(params) {
         super(params);
         this.appRunDir = '/data/app';
+        this.emulatorStartedFlag = '(NSH)';
     }
-    /** 在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);
-            const connected = yield this.connectGoldfish();
+            const connected = yield this.isConnected();
             if (connected) {
-                ColorConsole_1.default.log('### Emulator ### Goldfish emulator connected successfully');
+                shared_utils_1.ColorConsole.log('### Emulator ### Goldfish emulator connected successfully');
                 if (this.isFirstStart && this.startOptions.serverPort) {
                     yield this.createWebsockeServer();
                 }
                 // adb push快应用到模拟器的/data/app目录
-                const buildedFilesPath = this.isRpk ? this.projectPath : path_1.default.resolve(this.projectPath, './build');
+                // aspect应用后续要考虑各种形状表盘的推包
+                const buildedFilesPath = this.isRpk
+                    ? this.projectPath
+                    : this.isDistributedApp
+                        ? options.dist ||
+                            path_1.default.join(this.projectPath, './build', `${this.projectInfo.package}.watch`)
+                        : path_1.default.join(this.projectPath, './build');
                 yield this.pushRpk(buildedFilesPath);
                 // 在模拟器中启动快应用
                 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中启动快应用 */
+    /**
+     * 在模拟器中启动快应用
+     * 通过vapp命令启动，调试时需额外配置--jsdebugger参数
+     * @param options
+     */
     startupQuickApp(options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const { package: packageName } = this.projectInfo;
-                let vappCmd = `adb -s 127.0.0.1:${this.adbPort} shell vapp app/${packageName} &`;
+                let vappCmd = `adb -s ${this.sn} shell vapp app/${packageName} &`;
                 if (options.devtool) {
-                    vappCmd = `adb -s 127.0.0.1:${this.adbPort} shell vapp --jsdebugger=10.0.2.15:101 app/${packageName} &`;
+                    vappCmd = `adb -s ${this.sn} shell vapp --jsdebugger=10.0.2.15:101 app/${packageName} &`;
                 }
-                ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${vappCmd}`);
+                shared_utils_1.ColorConsole.log(`### Emulator ### Excuting adb cmd: ${vappCmd}`);
                 // vapp进程会一直pending，不会退出。这里必须加stdio: 'ignore'，否则快应用无法运行成功
                 adbMiwt.execAdbCmdAsync(vappCmd, { stdio: 'ignore', encoding: 'utf-8' });
             }
             catch (e) {
-                ColorConsole_1.default.error(`### Emulator ### Failed to startup quickapp: ${e.message}`);
+                shared_utils_1.ColorConsole.error(`### Emulator ### Failed to startup quickapp: ${e.message}`);
             }
         });
     }
-    /** 启动goldfish模拟器 */
+    /**
+     * 启动模拟器
+     * 1. 通过options生成模拟器的启动命令
+     * 2. 执行启动命令
+     * 3. 判断模拟器是否启动成功
+     *    3.1 若disableNSH=true，输出流中匹配到(NSH)，认为模拟器启动成功了
+     *    3.2 若disableNSH=false，认为2s过后模拟器启动成功了
+     * @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;
             const emulatorBin = this.getEmulatorBinPath();
-            ColorConsole_1.default.log(`### Emulator ### emulator path: ${emulatorBin}`);
+            shared_utils_1.ColorConsole.log(`### Emulator ### emulator path: ${emulatorBin}`);
             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) {
-                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(this.sdkHome, 'tools/image/system.img');
-            const dataImageBin = path_1.default.resolve(this.sdkHome, 'tools/image/data.img');
-            const imageMountStr = `-drive index=0,id=system,if=none,format=raw,file=${systemImageBin} \
+            const systemImageBin = path_1.default.join(avdImagePath, 'system.img');
+            const dataImageBin = path_1.default.join(avdImagePath, 'data.img');
+            // 复制可写文件到AVD目录下（多模拟器实例时需要）
+            const dataImageBinInAvd = path_1.default.join(this.avdHome, `${avdName}.avd`, 'data.img');
+            if (!fs_1.default.existsSync(dataImageBinInAvd)) {
+                // data.img不存在时直接copy
+                fs_1.default.copyFileSync(dataImageBin, dataImageBinInAvd);
+            }
+            else {
+                // data.img存在时，如果.export里的时间晚于avd里的时候，说明更新了镜像，需要重新copy
+                const statsInAvd = fs_1.default.statSync(dataImageBinInAvd);
+                const stats = fs_1.default.statSync(dataImageBin);
+                if ((0, dayjs_1.default)(stats.mtime).isAfter(statsInAvd.mtime)) {
+                    fs_1.default.copyFileSync(dataImageBin, dataImageBinInAvd);
+                }
+            }
+            // 复制可写文件到AVD目录下（多模拟器实例时需要）
+            const systemImageBinInAvd = path_1.default.join(this.avdHome, `${avdName}.avd`, 'system.img');
+            if (!fs_1.default.existsSync(systemImageBinInAvd)) {
+                // data.img不存在时直接copy
+                fs_1.default.copyFileSync(systemImageBin, systemImageBinInAvd);
+            }
+            else {
+                // data.img存在时，如果.export里的时间晚于avd里的时候，说明更新了镜像，需要重新copy
+                const statsInAvd = fs_1.default.statSync(systemImageBinInAvd);
+                const stats = fs_1.default.statSync(systemImageBin);
+                if ((0, dayjs_1.default)(stats.mtime).isAfter(statsInAvd.mtime)) {
+                    fs_1.default.copyFileSync(systemImageBin, systemImageBinInAvd);
+                }
+            }
+            // 复制可写文件到AVD目录下（多模拟器实例时需要）
+            // const nuttxBinInAvd = path.join(this.avdHome, `${avdName}.avd`, 'nuttx')
+            // if (!fs.existsSync(nuttxBinInAvd)) {
+            //   // data.img不存在时直接copy
+            //   fs.copyFileSync(nuttxBinPath, nuttxBinInAvd)
+            // } else {
+            //   // data.img存在时，如果.export里的时间晚于avd里的时候，说明更新了镜像，需要重新copy
+            //   const statsInAvd = fs.statSync(nuttxBinInAvd)
+            //   const stats = fs.statSync(nuttxBinPath)
+            //   if (dayjs(stats.mtime).isAfter(statsInAvd.mtime)) {
+            //     fs.copyFileSync(nuttxBinPath, nuttxBinInAvd)
+            //   }
+            // }
+            const imageMountStr = `-drive index=0,id=system,if=none,format=raw,file=${systemImageBinInAvd} \
 -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 \
 -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;
-                this.goldfishProcess = (0, child_process_1.spawn)(spawnBin, spawnArgs, { stdio: stdioType, shell: true });
-                if (options.disableNSH) {
-                    (_a = this.goldfishProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                        if (options.stdoutCallback) {
-                            options.stdoutCallback(data);
-                        }
-                        else {
-                            console.log(data.toString());
-                        }
-                        if (data.toString().includes('(NSH)')) {
-                            ColorConsole_1.default.log(`### Emulator ### Goldfish emulator starts successfully`);
-                            resolve();
-                        }
-                    });
-                    (_b = this.goldfishProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                        const stderrCb = options.stderrCallback || console.log;
-                        stderrCb(data.toString());
-                    });
-                }
-                else {
-                    setTimeout(() => {
-                        ColorConsole_1.default.log(`### Emulator ### Goldfish emulator starts successfully`);
-                        resolve();
-                    }, 2000);
+                var _a, _b, _c;
+                this.goldfishProcess = (0, child_process_1.spawn)(spawnBin, spawnArgs, { stdio: 'pipe', 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());
+                });
+                if (origin === 'terminal') {
+                    process.stdout.pipe(this.goldfishProcess.stdin);
+                    (_b = this.goldfishProcess.stdout) === null || _b === void 0 ? void 0 : _b.pipe(process.stdout);
                 }
                 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);
                     }
                 });
+                (_c = this.goldfishProcess.stdout) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
+                    const msg = data.toString();
+                    if (origin === 'ide') {
+                        const stdoutCb = options.stdoutCallback || console.log;
+                        stdoutCb(msg);
+                    }
+                    if (msg.includes(this.emulatorStartedFlag)) {
+                        shared_utils_1.ColorConsole.log(`### Emulator ### Goldfish emulator starts successfully`);
+                        resolve();
+                    }
+                });
             });
         });
     }
-    /** 将打包后的文件推到挂载的快应用目录 */
+    /**
+     * 将目录通过adb push到模拟器中
+     * @param sourceRoot
+     */
     pushRpk(sourceRoot) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sn = `127.0.0.1:${this.adbPort}`;
+            const sn = this.sn;
             const { package: appPackageName } = this.projectInfo;
-            const sourcePath = path_1.default.resolve(sourceRoot, './*');
-            ColorConsole_1.default.log(`### Emulator ### Pushing ${appPackageName} to ${this.appRunDir}`);
-            yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} shell mkdir ${this.appRunDir}/${appPackageName}`);
-            yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} push ${sourcePath} ${this.appRunDir}/${appPackageName}`);
-            ColorConsole_1.default.log(`### Emulator ### Push ${appPackageName} to ${this.appRunDir} successfully`);
+            // 获取最后一层目录，比如build
+            const basename = path_1.default.basename(sourceRoot);
+            if (os_1.default.platform() === 'win32' || this.projectPath.indexOf(' ') > 0) {
+                // windows系统或者项目路径有空格：1. adb push目录；2. 在模拟器中使用mv命令重命名
+                yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} push ${sourceRoot} ${this.appRunDir}`);
+                yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} shell  mv ${this.appRunDir}/${basename} ${this.appRunDir}/${appPackageName}`);
+            }
+            else {
+                // 支持通配符处理: 1. 模拟器中mkdir创建目录 2. adb push ./XXXXX/* /XXX
+                const sourcePath = path_1.default.join(sourceRoot, './*');
+                const mkdirCmd = `adb -s ${sn} shell mkdir ${this.appRunDir}/${appPackageName}`;
+                shared_utils_1.ColorConsole.log(`### Emulator ### mkdir CMD: ${mkdirCmd}`);
+                yield adbMiwt.execAdbCmdAsync(mkdirCmd);
+                const pushCmd = `adb -s ${sn} push ${sourcePath} ${this.appRunDir}/${appPackageName}`;
+                shared_utils_1.ColorConsole.log(`### Emulator ### pushCmd CMD: ${pushCmd}`);
+                yield adbMiwt.execAdbCmdAsync(pushCmd);
+            }
+            shared_utils_1.ColorConsole.info(`### Emulator push to ${this.appRunDir}/${appPackageName} successfully`);
+        });
+    }
+    /**
+     * 重新推送，然后重启应用
+     */
+    pushAndReloadApp() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 1. 将整包重新推到miwear中（TODO：增量更新）
+                // adb push快应用到模拟器的/data/app目录
+                // aspect应用后续要考虑各种形状表盘的推包
+                const buildedFilesPath = this.isRpk
+                    ? this.projectPath
+                    : this.isDistributedApp
+                        ? ((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.dist) ||
+                            path_1.default.join(this.projectPath, './build', `${this.projectInfo.package}.watch`)
+                        : path_1.default.join(this.projectPath, './build');
+                yield this.pushRpk(buildedFilesPath);
+                this.reloadApp();
+            }
+            catch (e) {
+                shared_utils_1.ColorConsole.error(`${e}`);
+            }
+        });
+    }
+    /**
+     * 重启应用
+     */
+    reloadApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { package: appPackageName } = this.projectInfo;
+            this.startupQuickApp(this.startOptions);
+            shared_utils_1.ColorConsole.info(`### Emulator start ${appPackageName} successfully`);
+        });
+    }
+    reboot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rebootCmd = `adb -s ${this.sn} shell reboot`;
+            shared_utils_1.ColorConsole.log(`### Emulator ### Excuting adb cmd: ${rebootCmd}`);
+            yield adbMiwt.execAdbCmdAsync(rebootCmd);
+            return this.isConnected();
         });
     }
 }

package/lib/instance/index.d.ts

@@ -1,7 +1,15 @@
 import { INewGoldfishInstanceParams } from '../typing/Instance';
 import CommonInstance from './common';
 import GoldfishInstance from './dev';
-import MiwearInstance from "./miwear";
+import MiwearInstance from './miwear';
 import OldGoldfishInstance from './preDev';
+import PreInstance from './pre';
+/**
+ * 根据镜像决定使用哪个instance
+ * Vela正式版(4.0) -> MiwearInstance
+ * Vela正式版(不带 miwear 版本) -> PreInstance
+ * Vela开发版（dev, 0.0.2) -> OldGoldfishInstance
+ * Vela开发版（dev)，除0.0.2的其他版本 -> GoldfishInstance
+ */
 declare function findInstance(avdName: string, params: INewGoldfishInstanceParams): GoldfishInstance | MiwearInstance | OldGoldfishInstance | undefined;
-export { CommonInstance, GoldfishInstance, MiwearInstance, OldGoldfishInstance, findInstance };
+export { CommonInstance, GoldfishInstance, MiwearInstance, OldGoldfishInstance, PreInstance, findInstance };

package/lib/instance/index.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findInstance = exports.OldGoldfishInstance = exports.MiwearInstance = exports.GoldfishInstance = exports.CommonInstance = void 0;
-const ColorConsole_1 = __importDefault(require("@aiot-toolkit/shared-utils/lib/ColorConsole"));
+exports.findInstance = exports.PreInstance = exports.OldGoldfishInstance = exports.MiwearInstance = exports.GoldfishInstance = exports.CommonInstance = void 0;
+const shared_utils_1 = require("@aiot-toolkit/shared-utils");
 const avd_1 = __importDefault(require("../avd"));
 const common_1 = __importDefault(require("./common"));
 exports.CommonInstance = common_1.default;
@@ -14,13 +14,25 @@ const miwear_1 = __importDefault(require("./miwear"));
 exports.MiwearInstance = miwear_1.default;
 const preDev_1 = __importDefault(require("./preDev"));
 exports.OldGoldfishInstance = preDev_1.default;
+const pre_1 = __importDefault(require("./pre"));
+exports.PreInstance = pre_1.default;
+/**
+ * 根据镜像决定使用哪个instance
+ * Vela正式版(4.0) -> MiwearInstance
+ * Vela正式版(不带 miwear 版本) -> PreInstance
+ * Vela开发版（dev, 0.0.2) -> OldGoldfishInstance
+ * Vela开发版（dev)，除0.0.2的其他版本 -> GoldfishInstance
+ */
 function findInstance(avdName, params) {
     const { sdkHome, avdHome } = params;
     const { avdImagePath } = new avd_1.default({ sdkHome, avdHome }).getVelaAvdInfo(avdName);
     if (!avdImagePath) {
-        ColorConsole_1.default.throw(`### Emulator ### Unable to find vela image via avd`);
+        shared_utils_1.ColorConsole.throw(`### Emulator ### Unable to find vela image via avd`);
         return;
     }
+    if (avdImagePath.includes('vela-pre-4.0')) {
+        return new pre_1.default(params);
+    }
     if (avdImagePath.includes('release')) {
         return new miwear_1.default(params);
     }

package/lib/instance/miwear.d.ts

@@ -2,27 +2,76 @@ import { INewGoldfishInstanceParams, IStartOptions } from '../typing/Instance';
 import CommonInstance from './common';
 /**
  * MiwearInstance
- * 针对 vela4.0 的镜像
+ * 针对 Vela正式版（4.0）的镜像
  */
 declare class MiwearInstance extends CommonInstance {
+    private params;
+    quickappStartedFlag: RegExp;
     private appPathInEmulator;
     private debugSocket?;
     private reconnectCount;
+    emulatorStartedFlag: RegExp;
     constructor(params: INewGoldfishInstanceParams);
-    /** 在goldfish模拟器中运行快应用 */
+    /**
+     * 1. 启动模拟器
+     * 2. 启动成功后，adb连接模拟器
+     * 3. 连接成功后，在模拟器中启动快应用
+     */
     start(options: IStartOptions): 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>;
-    /** 在goldfish中启动快应用 */
+    /**
+     * 在模拟器中启动快应用
+     * 1. 检查release目录是否有打包好的rpk
+     * 2. 检查当前是否为调试模式.
+     *    若是，将debugger_ip.cfg推到模拟器的/data/目录下
+     *    若否，则要删除模拟器中已有的data/debugger_ip.cfg
+     * 3. 调用installRpkToAppList将当前快应用安装到模拟器的应用列表中
+     * @param options
+     */
     startupQuickApp(options: IStartOptions): Promise<void>;
-    /** 将快应用安装到应用列表 */
+    /**
+     * 将快应用安装到模拟器的应用列表
+     * 1. 使用adb push将打包好的rpk推到模拟器的/data/quickapp/app/
+     * 2. nsh中调用pm install命令安装应用
+     * @param rpkPath rpk的绝对目录
+     * @param targetDir 要将rpk放到模拟器的哪个目录下
+     */
     installRpkToAppList(rpkPath: string, targetDir: string): Promise<void>;
-    initDebugSocket(): Promise<void> | undefined;
-    /** 通知模拟器更新 */
+    /** 使用am start启动快应用 */
+    launchQuickapp(): Promise<void>;
+    /** 连接模拟器中的调试服务，创建debugSocket
+     * 主要用于热更新时，通过debugSocket通知调试服务更新页面
+     * 设置了重连机制，会重复连接8次
+     */
+    initDebugSocket(): Promise<void>;
+    /** 通知模拟器更新
+     * 1. 确保已经成功连接模拟器中的调试服务
+     * 2. 使用adb push将build文件下的内容推到/data/quickapp/app/${packageName}
+     * 3. 发送Page.reload命令给调试服务，通知更新
+     */
     handleUpdate(): Promise<void>;
-    /** 创建server */
+    /** 热更新时push目录 */
+    pushBuild(): Promise<void>;
+    /** 在模拟器中重启快应用（基于am命令，需要保证镜像中已经有am功能）
+     * 1. 使用adb push将build文件下的内容推到/data/quickapp/app/${packageName}
+     * 2. nsh中执行am stop命令退出快应用
+     * 3. nsh中执行am start命令启动快应用
+     */
+    pushAndReloadApp(): Promise<void>;
+    reloadApp(): Promise<void>;
+    /**
+     * 创建server端，监听打包过程中client端发来的消息
+     */
     createWebsockeServer(): Promise<void>;
 }
 export default MiwearInstance;