@aiot-toolkit/emulator 2.0.1-alpha.8 → 2.0.2-batchmanifest-beta.1

package/README.md

@@ -1,2 +1,15 @@
+## emulator
 
-emulator tool
+QEMU模拟器
+
+模拟器的介绍可参考[开发帮助文档](https://xiaomi.f.mioffice.cn/docx/doxk4Rk6x67GanHlzQ8bEOrxtEe)里的「模拟器」章节
+
+## 目录结构
+
+| 目录     | 描述                                                                            |
+| -------- | ------------------------------------------------------------------------------- |
+| avd   |   模拟器的AVD，配置统一放置$HOME/.android/avd目录下         |
+| instance | 模拟器实例，不同的Vela镜像版本会使用不同的instance，通过findInstance确定                 |
+| static   | 创建AVD时需要用到的静态资源，常量配置文件                                           |
+| typing    | 接口定义                                                       |
+| utils   | 工具函数                                                       |

package/lib/avd/index.d.ts

@@ -3,10 +3,22 @@ declare class VelaAvdCls {
     private avdHome;
     private sdkHome;
     constructor(avdResourcePaths: IAvdResourcePaths);
+    /**
+     * 创建Vela端的AVD，统一保存在.android目录下
+     * 1. 创建.android/advancedFeatures.ini文件
+     * 2. 创建.android/${avdName}.ini文件
+     * 3. 创建.android/${avdName}.avd/config.ini文件
+     * @param avdParams AVD参数，宽高、绑定的镜像路径等
+     * @returns
+     */
     createVelaAvd(avdParams: IAvdParams): boolean;
+    /** 根据AVD名字获取模拟器的详细信息 */
     getVelaAvdInfo(avdName: string): IAvdParams;
+    /** 根据名字删除AVD */
     deleteVelaAvd(avdName: string): boolean;
+    /** 获取已经创建的模拟器列表 */
     getVelaAvdList(): IAvdParams[];
+    /** 获取模拟器皮肤列表 */
     getVelaSkinList(): string[];
 }
 export default VelaAvdCls;

package/lib/avd/index.js

@@ -3,10 +3,12 @@ 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 fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("../static/constants");
 const Avd_1 = require("../typing/Avd");
+const os_1 = __importDefault(require("os"));
 const EAvdParamsToIni = {
     'arm': {
         abiType: 'armeabi-v7a',
@@ -20,8 +22,25 @@ class VelaAvdCls {
         const { avdHome, sdkHome } = avdResourcePaths;
         this.avdHome = avdHome || constants_1.defaultAvdHome;
         this.sdkHome = sdkHome || constants_1.defaultSDKHome;
+        if (!fs_1.default.existsSync(this.avdHome)) {
+            fs_1.default.mkdirSync(this.avdHome, { recursive: true });
+        }
     }
+    /**
+     * 创建Vela端的AVD，统一保存在.android目录下
+     * 1. 创建.android/advancedFeatures.ini文件
+     * 2. 创建.android/${avdName}.ini文件
+     * 3. 创建.android/${avdName}.avd/config.ini文件
+     * @param avdParams AVD参数，宽高、绑定的镜像路径等
+     * @returns
+     */
     createVelaAvd(avdParams) {
+        // 在.android下创建advancedFeatures.ini文件
+        const advancedFeaturesIni = path_1.default.resolve(os_1.default.homedir(), '.android/advancedFeatures.ini');
+        if (!fs_1.default.existsSync(advancedFeaturesIni)) {
+            const iniSourcePath = path_1.default.join(__dirname, '../static/advancedFeatures.ini');
+            fs_1.default.copyFileSync(iniSourcePath, advancedFeaturesIni);
+        }
         const { avdName, avdArch, avdWidth, avdHeight, avdSkin, avdImagePath = constants_1.defaultImageHome } = avdParams;
         const avdDir = path_1.default.resolve(this.avdHome, `${avdName}.avd`);
         const avdIni = path_1.default.resolve(this.avdHome, `${avdName}.ini`);
@@ -62,9 +81,10 @@ class VelaAvdCls {
             return true;
         }
         catch (e) {
-            return false;
+            throw (`createVelaAvd: ${e.message}`);
         }
     }
+    /** 根据AVD名字获取模拟器的详细信息 */
     getVelaAvdInfo(avdName) {
         const avdInfo = {
             avdName,
@@ -76,25 +96,32 @@ class VelaAvdCls {
         };
         const currAvdDir = path_1.default.resolve(this.avdHome, `${avdName}.avd`);
         const configIni = path_1.default.resolve(currAvdDir, 'config.ini');
-        const contents = fs_1.default.readFileSync(configIni, 'utf-8');
-        // 这里需要使用惰性匹配
-        const archRegex = /hw.cpu.arch = ([\d\D]+?)\n/;
-        const archMatcher = contents.match(archRegex);
-        const heightRegex = /hw.lcd.height = ([\d\D]+?)\n/;
-        const heightMatcher = contents.match(heightRegex);
-        const widthRegex = /hw.lcd.width = ([\d\D]+?)\n/;
-        const widthMatcher = contents.match(widthRegex);
-        const skinRegex = /skin.name = ([\d\D]+?)\n/;
-        const skinMatcher = contents.match(skinRegex);
-        const imagePathRegex = /image.sysdir.1 = ([\d\D]+?)\n/;
-        const imagePathMather = contents.match(imagePathRegex);
-        archMatcher && (avdInfo.avdArch = archMatcher[1]);
-        heightMatcher && (avdInfo.avdHeight = heightMatcher[1]);
-        widthMatcher && (avdInfo.avdWidth = widthMatcher[1]);
-        skinMatcher && (avdInfo.avdSkin = skinMatcher[1]);
-        imagePathMather && (avdInfo.avdImagePath = imagePathMather[1]);
-        return avdInfo;
+        try {
+            const contents = fs_1.default.readFileSync(configIni, 'utf-8');
+            // 这里需要使用惰性匹配
+            const archRegex = /hw.cpu.arch = ([\d\D]+?)\n/;
+            const archMatcher = contents.match(archRegex);
+            const heightRegex = /hw.lcd.height = ([\d\D]+?)\n/;
+            const heightMatcher = contents.match(heightRegex);
+            const widthRegex = /hw.lcd.width = ([\d\D]+?)\n/;
+            const widthMatcher = contents.match(widthRegex);
+            const skinRegex = /skin.name = ([\d\D]+?)\n/;
+            const skinMatcher = contents.match(skinRegex);
+            const imagePathRegex = /image.sysdir.1 = ([\d\D]+?)\n/;
+            const imagePathMather = contents.match(imagePathRegex);
+            archMatcher && (avdInfo.avdArch = archMatcher[1]);
+            heightMatcher && (avdInfo.avdHeight = heightMatcher[1]);
+            widthMatcher && (avdInfo.avdWidth = widthMatcher[1]);
+            skinMatcher && (avdInfo.avdSkin = skinMatcher[1]);
+            imagePathMather && (avdInfo.avdImagePath = imagePathMather[1]);
+            return avdInfo;
+        }
+        catch (err) {
+            ColorConsole_1.default.log(`getVelaAvdInfo: ${err.message}`);
+            return avdInfo;
+        }
     }
+    /** 根据名字删除AVD */
     deleteVelaAvd(avdName) {
         const avdDir = path_1.default.resolve(this.avdHome, `${avdName}.avd`);
         const avdIni = path_1.default.resolve(this.avdHome, `${avdName}.ini`);
@@ -107,25 +134,22 @@ class VelaAvdCls {
             return false;
         }
     }
+    /** 获取已经创建的模拟器列表 */
     getVelaAvdList() {
-        try {
-            const avdList = [];
-            const files = fs_1.default.readdirSync(constants_1.defaultAvdHome);
-            const regex = /^(Vela[\d\D]*)\.avd$/;
-            for (const fileName of files) {
-                const matcher = fileName.match(regex);
-                if (matcher) {
-                    const avdName = matcher[1];
-                    const avdInfo = this.getVelaAvdInfo(avdName);
-                    avdList.push(avdInfo);
-                }
+        const avdList = [];
+        const files = fs_1.default.readdirSync(this.avdHome);
+        const regex = /^(Vela[\d\D]*)\.avd$/;
+        for (const fileName of files) {
+            const matcher = fileName.match(regex);
+            if (matcher) {
+                const avdName = matcher[1];
+                const avdInfo = this.getVelaAvdInfo(avdName);
+                avdList.push(avdInfo);
             }
-            return avdList;
-        }
-        catch (err) {
-            return [];
         }
+        return avdList;
     }
+    /** 获取模拟器皮肤列表 */
     getVelaSkinList() {
         try {
             const skinList = [];
@@ -142,5 +166,3 @@ class VelaAvdCls {
     }
 }
 exports.default = VelaAvdCls;
-
-//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import { default as VelaAvdCls } from './avd';
-import { default as GoldfishInstance } from './instance/goldfish';
+export * from './instance';
 export * from './typing/Avd';
 export * from './typing/Instance';
-export { GoldfishInstance, VelaAvdCls };
+export { VelaAvdCls };

package/lib/index.js

@@ -17,12 +17,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VelaAvdCls = exports.GoldfishInstance = void 0;
+exports.VelaAvdCls = void 0;
 const avd_1 = __importDefault(require("./avd"));
 Object.defineProperty(exports, "VelaAvdCls", { enumerable: true, get: function () { return avd_1.default; } });
-const goldfish_1 = __importDefault(require("./instance/goldfish"));
-Object.defineProperty(exports, "GoldfishInstance", { enumerable: true, get: function () { return goldfish_1.default; } });
+__exportStar(require("./instance"), exports);
 __exportStar(require("./typing/Avd"), exports);
 __exportStar(require("./typing/Instance"), exports);
-
-//# sourceMappingURL=index.js.map

package/lib/instance/common.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import IManifest from '@aiot-toolkit/aiotpack/lib/compiler/javascript/vela/interface/IManifest';
+import { ChildProcess } from 'child_process';
+import VelaAvdCls from '../avd';
+import { INewGoldfishInstanceParams, IStartOptions } from '../typing/Instance';
+/**
+ * CommonInstance
+ */
+declare class CommonInstance {
+    projectPath: string;
+    sdkHome: string;
+    avdHome: string;
+    velaAvdCls: VelaAvdCls;
+    goldfishProcess: ChildProcess | undefined;
+    isFirstStart: boolean;
+    startOptions: IStartOptions | undefined;
+    projectInfo: IManifest;
+    isRpk: boolean;
+    isDistributedApp: boolean;
+    sn?: string;
+    constructor(params: INewGoldfishInstanceParams);
+    /** 获取模拟器二进制文件所在位置 */
+    getEmulatorBinPath(): string;
+    /** 在goldfish模拟器中运行快应用 */
+    start(options: IStartOptions): Promise<void>;
+    /**
+     * 通过adb连接模拟器。
+     * 时间限制为 @param timeout 秒，超时则表示连接失败
+     * @returns
+     */
+    connectGoldfish(timeout?: number): Promise<unknown>;
+    /** 杀死进程 */
+    killProcess(currProcess?: ChildProcess): void;
+    /** 停止模拟器并释放相关资源 */
+    stop(): Promise<void>;
+    /** 重启模拟器 */
+    restart(): Promise<void>;
+    /** 创建server */
+    createWebsockeServer(): Promise<void>;
+    connectDevice(): Promise<string | void>;
+}
+export default CommonInstance;

package/lib/instance/common.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const UxFileUtils_1 = __importDefault(require("@aiot-toolkit/aiotpack/lib/utils/ux/UxFileUtils"));
+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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const ws_1 = require("ws");
+const avd_1 = __importDefault(require("../avd"));
+const constants_1 = require("../static/constants");
+const utils_1 = require("../utils");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * CommonInstance
+ */
+class CommonInstance {
+    constructor(params) {
+        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
+        });
+        this.projectInfo = UxFileUtils_1.default.getMainfestInfo(this.projectPath, params.sourceRoot);
+    }
+    /** 获取模拟器二进制文件所在位置 */
+    getEmulatorBinPath() {
+        const osPlatform = os_1.default.platform();
+        const arch = (0, utils_1.getSystemArch)();
+        const platform = osPlatform === 'win32' ? 'windows' : osPlatform;
+        const emulatorHome = path_1.default.resolve(this.sdkHome, 'emulator');
+        return path_1.default.resolve(emulatorHome, `${platform}-${arch}`, 'emulator');
+    }
+    /** 在goldfish模拟器中运行快应用 */
+    start(options) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    /**
+     * 通过adb连接模拟器。
+     * 时间限制为 @param timeout 秒，超时则表示连接失败
+     * @returns
+     */
+    connectGoldfish(timeout = 10) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let adbConnected = false; // adb是否连接成功
+            let enableLoop = true; // 是否允许循环，用于终止adb的连接
+            let needKill = false;
+            const connectFn = () => __awaiter(this, void 0, void 0, function* () {
+                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)}`);
+                    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');
+                }
+                return Promise.resolve(adbConnected);
+            });
+            const res = yield Promise.race([
+                connectFn(),
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        if (!adbConnected) {
+                            enableLoop = false;
+                        }
+                        // 超时则认为adb没有连接成功
+                        resolve(false);
+                    }, timeout * 1000);
+                })
+            ]);
+            return res;
+        });
+    }
+    /** 杀死进程 */
+    killProcess(currProcess) {
+        if (currProcess && currProcess.pid && currProcess.exitCode === null) {
+            console.log('process pid:', currProcess.pid);
+            try {
+                if (os_1.default.platform() === 'win32') {
+                    (0, child_process_1.execSync)(`taskkill /pid ${currProcess.pid} /T /F`);
+                }
+                else if (os_1.default.platform() === 'darwin') {
+                    process.kill(currProcess.pid);
+                }
+                else {
+                    currProcess.kill();
+                }
+            }
+            catch (err) {
+                ColorConsole_1.default.log(`### Emulator ### kill process get error :\n${err.stack}`);
+            }
+        }
+    }
+    /** 停止模拟器并释放相关资源 */
+    stop() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.goldfishProcess) {
+                // Linux删除goldfishProcess后，子进程仍存在，导致模拟器窗口未关闭
+                // 这里的作用是手动删除创建出来的子进程
+                // if (os.platform() === 'linux' && this.goldfishProcess.pid) {
+                //   process.kill(this.goldfishProcess.pid + 1)
+                // }
+                this.killProcess(this.goldfishProcess);
+                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() {
+        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* () {
+            const wsServer = new ws_1.WebSocketServer({
+                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}`);
+                });
+                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') {
+                        this.restart();
+                    }
+                    else if (message.type === 'stop') {
+                        this.stop();
+                    }
+                });
+            });
+        });
+    }
+    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, reject) => {
+                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

@@ -0,0 +1,35 @@
+import { INewGoldfishInstanceParams, IStartOptions } from '../typing/Instance';
+import CommonInstance from './common';
+declare class GoldfishInstance extends CommonInstance {
+    private appRunDir;
+    constructor(params: INewGoldfishInstanceParams);
+    /**
+     * 1. 启动模拟器
+     * 2. 启动成功后，adb连接模拟器
+     * 3. 连接成功后，在模拟器中启动快应用
+     */
+    start(options: IStartOptions): Promise<void>;
+    /**
+     * 在模拟器中启动快应用
+     * 通过vapp命令启动，调试时需额外配置--jsdebugger参数
+     * @param options
+     */
+    startupQuickApp(options: IStartOptions): Promise<void>;
+    /**
+     * 启动模拟器
+     * 1. 通过options生成模拟器的启动命令
+     * 2. 执行启动命令
+     * 3. 判断模拟器是否启动成功
+     *    3.1 若disableNSH=true，输出流中匹配到(NSH)，认为模拟器启动成功了
+     *    3.2 若disableNSH=false，认为2s过后模拟器启动成功了
+     * @param options
+     * @returns
+     */
+    startGoldfish(options: IStartOptions): Promise<void>;
+    /**
+     * 将目录通过adb push到模拟器中
+     * @param sourceRoot
+     */
+    pushRpk(sourceRoot: string): Promise<void>;
+}
+export default GoldfishInstance;