@aiot-toolkit/emulator 2.0.2-dev.7 → 2.0.2

package/lib/instance/common.js

@@ -39,25 +39,31 @@ const UxFileUtils_1 = __importDefault(require("@aiot-toolkit/aiotpack/lib/utils/
 const ColorConsole_1 = __importDefault(require("@aiot-toolkit/shared-utils/lib/ColorConsole"));
 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 = require("ws");
 const avd_1 = __importDefault(require("../avd"));
-const constants_1 = require("../static/constants");
+const constants_1 = require("../emulatorutil/constants");
 const utils_1 = require("../utils");
 /**
  * CommonInstance
  */
 class CommonInstance {
     constructor(params) {
-        this.adbPort = 5555;
-        this.debugPort = 10055;
+        this.quickappStartedFlag = /Start App loop/;
         this.isFirstStart = true;
+        this.isDistributedApp = false;
         this.projectPath = params.projectPath;
         this.sdkHome = params.sdkHome || constants_1.defaultSDKHome;
         this.avdHome = params.avdHome || constants_1.defaultAvdHome;
         this.isRpk = params.sourceRoot === './';
+        const projectJsonFile = path_1.default.resolve(this.projectPath, '.project.json');
+        const projectJsonExist = fs_extra_1.default.existsSync(projectJsonFile);
+        if (projectJsonExist) {
+            const projectJsonInfo = fs_extra_1.default.readJSONSync(projectJsonFile);
+            this.isDistributedApp = projectJsonInfo.projectType === 'distributed';
+        }
         this.velaAvdCls = new avd_1.default({
             sdkHome: this.sdkHome,
             avdHome: this.avdHome
@@ -75,153 +81,64 @@ class CommonInstance {
     /** 在goldfish模拟器中运行快应用 */
     start(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.startOptions = options;
-            // 启动模拟器
-            yield this.startGoldfish(options);
-            const connected = yield this.connectGoldfish();
-            if (connected) {
-                ColorConsole_1.default.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');
-                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');
-            }
+            throw new Error(`start method not implemented, ${options}`);
         });
     }
-    /** 在goldfish中启动快应用 */
-    startupQuickApp(options) {
-        try {
-            let vappCmd = `adb -s 127.0.0.1:${this.adbPort} shell vapp app/${this.projectInfo.package} &`;
-            if (options.devtool) {
-                vappCmd = `adb -s 127.0.0.1:${this.adbPort} shell vapp --jsdebugger=10.0.2.15:101 app/${this.projectInfo.package} &`;
-            }
-            ColorConsole_1.default.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}`);
-        }
-    }
-    /** 启动goldfish模拟器 */
-    startGoldfish(options) {
-        var _a;
+    /**
+     * 判断模拟器是否 ready
+     */
+    isConnected() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { avdName, devtool } = options;
-            const emulatorBin = this.getEmulatorBinPath();
-            ColorConsole_1.default.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}`);
-            if (!avdImagePath) {
-                return ColorConsole_1.default.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}`);
-            // 端口映射
-            const adbPortMappingStr = `-network-user-mode-options hostfwd=tcp:127.0.0.1:${this.adbPort}-10.0.2.15:5555`;
-            let debugPortMappingStr = '';
-            if (devtool) {
-                debugPortMappingStr = `-network-user-mode-options hostfwd=tcp:127.0.0.1:${this.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} \
--device virtio-blk-device,bus=virtio-mmio-bus.0,drive=system \
--drive index=1,id=userdata,if=none,format=raw,file=${dataImageBin} \
--device virtio-blk-device,bus=virtio-mmio-bus.1,drive=userdata \
--device virtio-snd,bus=virtio-mmio-bus.2 -allow-host-audio -semihosting`;
-            // vnc配置
-            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}`;
-            }
-            const stdioType = options.disableNSH ? 'pipe' : 'inherit';
-            // 启动goldfish的命令和参数
-            const cmd = `${emulatorBin} -nuttx -avd ${avdName} -avd-arch ${avdArch} -show-kernel -kernel ${nuttxBinPath} ${adbPortMappingStr} ${debugPortMappingStr} -qemu ${windowStr} ${vncStr} ${imageMountStr}`;
-            const spawnArgs = cmd.split(' ');
-            const spawnBin = spawnArgs.shift();
-            ColorConsole_1.default.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) => {
-                        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) => {
-                        console.log(data.toString());
-                    });
-                }
-                else {
-                    setTimeout(() => {
-                        ColorConsole_1.default.log(`### Emulator ### Goldfish emulator starts successfully`);
-                        resolve();
-                    }, 2000);
-                }
-                this.goldfishProcess.on('exit', (code) => {
-                    ColorConsole_1.default.error(`### Emulator ### Goldfish emulator exited with code ${code}`);
-                });
-            });
+            return (0, utils_1.tryRun)(() => __awaiter(this, void 0, void 0, function* () {
+                const devices = yield adbMiwt.getAdbDevices();
+                ColorConsole_1.default.log(`### Emulator ### adb devices: ${JSON.stringify(devices)}`);
+                const curDev = devices.find((t) => t.sn === this.sn);
+                return (curDev === null || curDev === void 0 ? void 0 : curDev.status) === 'device';
+            }), 10, 500);
         });
     }
-    /** 通过adb连接模拟器 */
+    /**
+     * 通过adb连接模拟器。
+     * 时间限制为 @param timeout 秒，超时则表示连接失败
+     * @returns
+     */
     connectGoldfish() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let adbConnected = false;
+        return __awaiter(this, arguments, void 0, function* (timeout = 10) {
+            let adbConnected = false; // adb是否连接成功
+            let enableLoop = true; // 是否允许循环，用于终止adb的连接
+            let needKill = 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}`);
-                    adbMiwt.execAdbCmdSync(adbKillCmd);
-                    const adbConnectCmd = `adb connect ${sn}`;
-                    ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbConnectCmd}`);
-                    const str = adbMiwt.execAdbCmdSync(adbConnectCmd);
+                while (enableLoop && !adbConnected) {
+                    if (needKill) {
+                        const adbKillCmd = `adb kill-server`;
+                        ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbKillCmd}`);
+                        yield adbMiwt.execAdbCmdAsync(adbKillCmd);
+                    }
+                    const str = yield this.connectDevice();
                     ColorConsole_1.default.log(`### Emulator ### ${str}`);
+                    // 查询模拟器的状态是否为“device”
                     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;
+                    const curDev = devices.find((t) => t.sn === this.sn);
+                    if ((curDev === null || curDev === void 0 ? void 0 : curDev.status) === 'offline')
+                        needKill = true;
+                    adbConnected = devices.some((item) => item.sn === this.sn && item.status === 'device');
                 }
-                Promise.resolve(adbConnected);
+                return Promise.resolve(adbConnected);
             });
-            yield Promise.race([
+            const res = yield Promise.race([
                 connectFn(),
                 new Promise((resolve) => {
-                    setTimeout(() => resolve(false), 600 * 1000);
+                    setTimeout(() => {
+                        if (!adbConnected) {
+                            enableLoop = false;
+                        }
+                        // 超时则认为adb没有连接成功
+                        resolve(false);
+                    }, timeout * 1000);
                 })
             ]);
-            return adbConnected;
-        });
-    }
-    /** 将打包后的文件推到挂载的快应用目录 */
-    pushRpk(sourceRoot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sn = `127.0.0.1:${this.adbPort}`;
-            const { package: appPackageName } = UxFileUtils_1.default.getMainfestInfo(this.projectPath);
-            const appRunDir = '/data/app';
-            ColorConsole_1.default.log(`### Emulator ### Pushing ${appPackageName} to ${appRunDir}`);
-            (0, child_process_1.execSync)(`adb -s ${sn} shell mkdir ${appRunDir}/${appPackageName}`, { stdio: 'ignore' });
-            yield adbMiwt.execAdbCmdAsync(`adb -s ${sn} push ${sourceRoot}/* ${appRunDir}/${appPackageName}`);
-            ColorConsole_1.default.log(`### Emulator ### Push ${appPackageName} to ${appRunDir} successfully`);
+            return res;
         });
     }
     /** 杀死进程 */
@@ -246,8 +163,8 @@ class CommonInstance {
     }
     /** 停止模拟器并释放相关资源 */
     stop() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             if (this.goldfishProcess) {
                 // Linux删除goldfishProcess后，子进程仍存在，导致模拟器窗口未关闭
                 // 这里的作用是手动删除创建出来的子进程
@@ -255,29 +172,34 @@ class CommonInstance {
                 //   process.kill(this.goldfishProcess.pid + 1)
                 // }
                 this.killProcess(this.goldfishProcess);
-                yield (0, utils_1.killProcessByCmd)((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.avdName);
+                if ((_a = this.startOptions) === null || _a === void 0 ? void 0 : _a.avdName) {
+                    const emulatorProcessFlag = `-avd ${(_b = this.startOptions) === null || _b === void 0 ? void 0 : _b.avdName} -avd-arch`;
+                    yield (0, utils_1.killProcessByCmd)(emulatorProcessFlag);
+                }
                 this.goldfishProcess = undefined;
             }
         });
     }
     /** 重启模拟器 */
     restart() {
-        this.stop();
-        this.start(this.startOptions);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stop();
+            this.start(this.startOptions);
+        });
     }
     /** 创建server */
     createWebsockeServer() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             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 => {
+            wsServer.on('connection', (socket) => {
                 ColorConsole_1.default.success(`### App Socket server ### Websocket connects to websocket server`);
-                socket.on('error', err => {
+                socket.on('error', (err) => {
                     ColorConsole_1.default.error(`### App Socket server ### Websocket server error: ${err.message}`);
                 });
-                socket.on('message', data => {
+                socket.on('message', (data) => {
                     const message = JSON.parse(data.toString());
                     ColorConsole_1.default.log(`### App Socket server ### Websocket server get data: ${data}`);
                     if (message.type === 'restart') {
@@ -290,5 +212,32 @@ class CommonInstance {
             });
         });
     }
+    connectDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adbConnectCmd = `adb connect ${this.sn}`;
+            ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbConnectCmd}`);
+            let pending = true;
+            const p1 = adbMiwt.execAdbCmdAsync(adbConnectCmd);
+            let timer;
+            // 超过一定时间还没有连接成功，则 kill-server 后再试
+            // 用于处理 adb connect 一直 pending 的情况
+            const p2 = new Promise((resolve) => {
+                timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    if (pending) {
+                        const adbKillCmd = `adb kill-server`;
+                        ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${adbKillCmd}`);
+                        yield adbMiwt.execAdbCmdAsync(adbKillCmd);
+                    }
+                    resolve();
+                }), 10 * 1000);
+            });
+            p1.then((r) => {
+                pending = false;
+                clearTimeout(timer);
+                console.log(r);
+            });
+            return Promise.race([p1, p2]);
+        });
+    }
 }
 exports.default = CommonInstance;

package/lib/instance/dev.d.ts

@@ -1,15 +1,51 @@
+import readline from 'readline';
 import { INewGoldfishInstanceParams, IStartOptions } from '../typing/Instance';
 import CommonInstance from './common';
 declare class GoldfishInstance extends CommonInstance {
-    private appRunDir;
+    appDir: string;
+    emulatorStartedFlag: string;
+    stdoutReadline: readline.Interface;
+    stderrReadline: readline.Interface;
     constructor(params: INewGoldfishInstanceParams);
-    /** 在goldfish模拟器中运行快应用 */
+    /**
+     * 1. 启动模拟器
+     * 2. 启动成功后，adb连接模拟器
+     * 3. 连接成功后，在模拟器中启动快应用
+     */
     start(options: IStartOptions): Promise<void>;
-    /** 在goldfish中启动快应用 */
+    /**
+     * 在模拟器中启动快应用
+     * 通过vapp命令启动，调试时需额外配置--jsdebugger参数
+     * @param options
+     */
     startupQuickApp(options: IStartOptions): Promise<void>;
-    /** 启动goldfish模拟器 */
+    /**
+     * 启动模拟器
+     * 1. 通过options生成模拟器的启动命令
+     * 2. 执行启动命令
+     * 3. 判断模拟器是否启动成功
+     *    3.1 若disableNSH=true，输出流中匹配到(NSH)，认为模拟器启动成功了
+     *    3.2 若disableNSH=false，认为2s过后模拟器启动成功了
+     * @param options
+     * @returns
+     */
     startGoldfish(options: IStartOptions): Promise<void>;
-    /** 将打包后的文件推到挂载的快应用目录 */
-    pushRpk(sourceRoot: string): Promise<void>;
+    /**
+     * 将目录通过adb push到模拟器中
+     */
+    pushAndInstall(rpkPath?: string): Promise<void>;
+    /** 通过命令行启动时，在watich模式下监听websocket消息，
+     * 在文件发生变动时，重新启动应用
+     */
+    restart(): Promise<void>;
+    /**
+     * 重新推送，然后重启应用
+     */
+    pushAndReloadApp(): Promise<void>;
+    /**
+     * 重启应用
+     */
+    reloadApp(): Promise<void>;
+    reboot(): Promise<boolean>;
 }
 export default GoldfishInstance;

package/lib/instance/dev.js

@@ -38,47 +38,59 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ColorConsole_1 = __importDefault(require("@aiot-toolkit/shared-utils/lib/ColorConsole"));
 const adbMiwt = __importStar(require("@miwt/adb"));
 const child_process_1 = require("child_process");
+const readline_1 = __importDefault(require("readline"));
+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 Instance_1 = require("../typing/Instance");
 const common_1 = __importDefault(require("./common"));
+const emulatorutil_1 = require("../emulatorutil");
 class GoldfishInstance extends common_1.default {
     constructor(params) {
         super(params);
-        this.appRunDir = '/data/app';
+        this.appDir = '/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');
                 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');
-                yield this.pushRpk(buildedFilesPath);
+                yield this.pushAndInstall();
                 // 在模拟器中启动快应用
                 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';
+                ColorConsole_1.default.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}`);
                 // vapp进程会一直pending，不会退出。这里必须加stdio: 'ignore'，否则快应用无法运行成功
@@ -89,75 +101,42 @@ class GoldfishInstance extends common_1.default {
             }
         });
     }
-    /** 启动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 emulatorBin = this.getEmulatorBinPath();
-            ColorConsole_1.default.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}`);
-            if (!avdImagePath) {
-                return ColorConsole_1.default.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}`);
-            // 端口映射
-            let portMappingStr = `-network-user-mode-options hostfwd=tcp:127.0.0.1:${this.adbPort}-10.0.2.15:5555`;
-            if (devtool) {
-                portMappingStr += `,hostfwd=tcp:127.0.0.1:${this.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} \
--device virtio-blk-device,bus=virtio-mmio-bus.0,drive=system \
--drive index=1,id=userdata,if=none,format=raw,file=${dataImageBin} \
--device virtio-blk-device,bus=virtio-mmio-bus.1,drive=userdata \
--device virtio-snd,bus=virtio-mmio-bus.2 -allow-host-audio -semihosting`;
-            // vnc配置
-            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}`;
-            }
-            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 { origin = Instance_1.IStartOrigin.Terminal } = options;
+            // 启动模拟器的命令和参数
+            const cmd = emulatorutil_1.EmulatorCmd.createDevCmd(options, this.sdkHome, this.avdHome);
+            if (!cmd)
+                return;
             const spawnArgs = cmd.split(' ');
             const spawnBin = spawnArgs.shift();
-            ColorConsole_1.default.log(`### Emulator ### Start CMD: ${cmd}`);
+            ColorConsole_1.default.log(`### Emulator ### Start CMD dev: ${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);
+                this.goldfishProcess = (0, child_process_1.spawn)(spawnBin, spawnArgs, { stdio: 'pipe', shell: true });
+                // 利用 readline 接口可解决子进程日志换行的问题
+                this.stdoutReadline = readline_1.default.createInterface({
+                    input: this.goldfishProcess.stdout
+                });
+                this.stderrReadline = readline_1.default.createInterface({
+                    input: this.goldfishProcess.stderr
+                });
+                (_a = this.stderrReadline) === null || _a === void 0 ? void 0 : _a.on('line', (data) => {
+                    const stderrCb = options.stderrCallback || console.log;
+                    stderrCb(data.toString());
+                });
+                if (origin === Instance_1.IStartOrigin.Terminal) {
+                    process.stdin.pipe(this.goldfishProcess.stdin);
                 }
                 this.goldfishProcess.on('exit', (code) => {
                     ColorConsole_1.default.error(`### Emulator ### Goldfish emulator exited with code ${code}`);
@@ -165,19 +144,94 @@ class GoldfishInstance extends common_1.default {
                         options.exitCallback(code);
                     }
                 });
+                (_b = this.stdoutReadline) === null || _b === void 0 ? void 0 : _b.on('line', (data) => {
+                    const msg = data.toString();
+                    const stdoutCb = options.stdoutCallback || console.log;
+                    stdoutCb(msg);
+                    if (emulatorutil_1.EmulatorLog.devIsStart(msg)) {
+                        ColorConsole_1.default.log(`### Emulator ### Goldfish emulator starts successfully`);
+                        resolve();
+                    }
+                });
             });
         });
     }
-    /** 将打包后的文件推到挂载的快应用目录 */
-    pushRpk(sourceRoot) {
+    /**
+     * 将目录通过adb push到模拟器中
+     */
+    pushAndInstall(rpkPath) {
         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`);
+            const sourceRoot = rpkPath || this.isRpk ? this.projectPath : path_1.default.join(this.projectPath, './build');
+            // 获取最后一层目录，比如build
+            const basename = path_1.default.basename(sourceRoot);
+            if (os_1.default.platform() === 'win32' || this.projectPath.indexOf(' ') > 0) {
+                // windows系统或者项目路径有空格：1. adb push目录；2. 在模拟器中使用mv命令重命名
+                // 注意 sourceRoot 中可能会有空格
+                const pushCmd = `adb -s ${sn} push "${sourceRoot}" ${this.appDir}`;
+                ColorConsole_1.default.info(`### Emulator ### push CMD: ${pushCmd}`);
+                yield adbMiwt.execAdbCmdAsync(pushCmd);
+                // 在 windows 上 mv 命令不能更新原有的文件,需要先删除
+                const rmCmd = `adb -s ${sn} shell rm -r ${this.appDir}/${appPackageName}`;
+                ColorConsole_1.default.info(`### Emulator ### mv CMD: ${rmCmd}`);
+                yield adbMiwt.execAdbCmdAsync(rmCmd);
+                const mvCmd = `adb -s ${sn} shell  mv ${this.appDir}/${basename} ${this.appDir}/${appPackageName}`;
+                ColorConsole_1.default.info(`### Emulator ### mv CMD: ${mvCmd}`);
+                yield adbMiwt.execAdbCmdAsync(mvCmd);
+            }
+            else {
+                // 支持通配符处理: 1. 模拟器中mkdir创建目录 2. adb push ./XXXXX/* /XXX
+                const sourcePath = path_1.default.join(sourceRoot, './*');
+                const mkdirCmd = `adb -s ${sn} shell mkdir ${this.appDir}/${appPackageName}`;
+                ColorConsole_1.default.log(`### Emulator ### mkdir CMD: ${mkdirCmd}`);
+                yield adbMiwt.execAdbCmdAsync(mkdirCmd);
+                const pushCmd = `adb -s ${sn} push ${sourcePath} ${this.appDir}/${appPackageName}`;
+                ColorConsole_1.default.log(`### Emulator ### pushCmd CMD: ${pushCmd}`);
+                yield adbMiwt.execAdbCmdAsync(pushCmd);
+            }
+            ColorConsole_1.default.info(`### Emulator push to ${this.appDir}/${appPackageName} successfully`);
+        });
+    }
+    /** 通过命令行启动时，在watich模式下监听websocket消息，
+     * 在文件发生变动时，重新启动应用
+     */
+    restart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pushAndReloadApp();
+        });
+    }
+    /**
+     * 重新推送，然后重启应用
+     */
+    pushAndReloadApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.pushAndInstall();
+                yield this.reboot();
+                this.reloadApp();
+            }
+            catch (e) {
+                ColorConsole_1.default.error(`${e}`);
+            }
+        });
+    }
+    /**
+     * 重启应用
+     */
+    reloadApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { package: appPackageName } = this.projectInfo;
+            this.startupQuickApp(this.startOptions);
+            ColorConsole_1.default.info(`### Emulator start ${appPackageName} successfully`);
+        });
+    }
+    reboot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rebootCmd = `adb -s ${this.sn} shell reboot`;
+            ColorConsole_1.default.log(`### Emulator ### Excuting adb cmd: ${rebootCmd}`);
+            yield adbMiwt.execAdbCmdAsync(rebootCmd);
+            return this.isConnected();
         });
     }
 }