game-adb/lib/device.js

"use strict";
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 __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Device = exports.DeviceEmitter = void 0;
var events_1 = require("events");
var utils_1 = require("./utils");
var DeviceEmitter = /** @class */ (function () {
    function DeviceEmitter() {
        this.emitter = new events_1.EventEmitter();
    }
    DeviceEmitter.prototype.on = function (eventName, listener) {
        this.emitter.on(eventName, listener);
    };
    DeviceEmitter.prototype.off = function (eventName, listener) {
        this.emitter.off(eventName, listener);
    };
    DeviceEmitter.prototype.emit = function (eventName, arg) {
        this.emitter.emit(eventName, arg);
    };
    return DeviceEmitter;
}());
exports.DeviceEmitter = DeviceEmitter;
/**
 * The Device instance is binding with specific serial number of adb device.
 *
 */
var Device = /** @class */ (function () {
    function Device(adbPath, serialNumber, connectStatus) {
        /**
         * Check whether device is connected before issue a command
         */
        this.autoCheckConnected = true;
        this.deviceResolution = { x: 0, y: 0 };
        this.commandResolution = { x: 1280, y: 720 };
        this._running = false;
        this._eventEmmiter = new DeviceEmitter();
        this.adbPath = adbPath;
        this.serialNumber = serialNumber;
        this._connected = connectStatus;
    }
    Object.defineProperty(Device.prototype, "resolutionRatio", {
        get: function () {
            return {
                x: this.deviceResolution.x / this.commandResolution.x,
                y: this.deviceResolution.y / this.commandResolution.y,
            };
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Device.prototype, "connected", {
        /**
         * Determines whether the device is connected
         */
        get: function () {
            return this._connected;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Device.prototype, "running", {
        /**
         * Determines whether the command is running
         */
        get: function () {
            return this._running;
        },
        enumerable: false,
        configurable: true
    });
    Device.prototype.checkConnected = function () {
        return __awaiter(this, arguments, void 0, function (retry) {
            var i, devicesStdout, deviceInfoArray, devicesAttached, _i, deviceInfoArray_1, info, _a, serialNumber, connectStatus;
            if (retry === void 0) { retry = 3; }
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        i = 0;
                        _b.label = 1;
                    case 1:
                        if (!(i < retry)) return [3 /*break*/, 6];
                        return [4 /*yield*/, (0, utils_1.issueCommand)({ adbPath: this.adbPath, args: ["devices"] })];
                    case 2:
                        devicesStdout = _b.sent();
                        deviceInfoArray = devicesStdout.trim().split("\r\n");
                        devicesAttached = false;
                        for (_i = 0, deviceInfoArray_1 = deviceInfoArray; _i < deviceInfoArray_1.length; _i++) {
                            info = deviceInfoArray_1[_i];
                            if (devicesAttached) {
                                _a = info.split("\t"), serialNumber = _a[0], connectStatus = _a[1];
                                if (serialNumber === this.serialNumber) {
                                    return [2 /*return*/, connectStatus === "device"];
                                }
                            }
                            else if (info === "List of devices attached") {
                                devicesAttached = true;
                            }
                        }
                        if (!(i < retry - 1)) return [3 /*break*/, 4];
                        return [4 /*yield*/, (0, utils_1.delay)(3000)];
                    case 3:
                        _b.sent();
                        return [3 /*break*/, 5];
                    case 4:
                        console.log("Adb get devices failed");
                        _b.label = 5;
                    case 5:
                        i++;
                        return [3 /*break*/, 1];
                    case 6: return [2 /*return*/, false];
                }
            });
        });
    };
    /**
     * Issue command by text
     * @param commandText
     */
    Device.prototype.issueShellCommandText = function (commandText) {
        return __awaiter(this, void 0, void 0, function () {
            var _a, result;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.autoCheckConnected) return [3 /*break*/, 2];
                        _a = this;
                        return [4 /*yield*/, this.checkConnected()];
                    case 1:
                        _a._connected = _b.sent();
                        _b.label = 2;
                    case 2:
                        if (!this._connected)
                            return [2 /*return*/, ""];
                        this._running = true;
                        return [4 /*yield*/, (0, utils_1.issueCommand)({
                                adbPath: this.adbPath,
                                serialNumber: this.serialNumber,
                                isShellCommand: true,
                                args: commandText.split(" "),
                            })];
                    case 3:
                        result = _b.sent();
                        this._running = false;
                        return [2 /*return*/, result];
                }
            });
        });
    };
    /**
     * Issue specified command
     * @param command
     */
    Device.prototype.issueShellCommand = function (command) {
        return __awaiter(this, void 0, void 0, function () {
            var _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.autoCheckConnected) return [3 /*break*/, 2];
                        _a = this;
                        return [4 /*yield*/, this.checkConnected()];
                    case 1:
                        _a._connected = _b.sent();
                        _b.label = 2;
                    case 2:
                        if (!this._connected)
                            return [2 /*return*/, false];
                        this._running = true;
                        this._eventEmmiter.emit("command_start", command);
                        return [4 /*yield*/, (0, utils_1.delay)(command.preDelay)];
                    case 3:
                        _b.sent();
                        return [4 /*yield*/, (0, utils_1.issueCommand)({
                                adbPath: this.adbPath,
                                serialNumber: this.serialNumber,
                                isShellCommand: true,
                                args: command.getCommandArgs(this.resolutionRatio),
                            })];
                    case 4:
                        _b.sent();
                        return [4 /*yield*/, (0, utils_1.delay)(command.postDelay)];
                    case 5:
                        _b.sent();
                        this._eventEmmiter.emit("command_finish", command);
                        this._running = false;
                        return [2 /*return*/, true];
                }
            });
        });
    };
    /**
     * Issue specified commands
     * @param commands
     */
    Device.prototype.issueShellCommands = function (commands) {
        return __awaiter(this, void 0, void 0, function () {
            var _i, commands_1, command, status;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        _i = 0, commands_1 = commands;
                        _a.label = 1;
                    case 1:
                        if (!(_i < commands_1.length)) return [3 /*break*/, 4];
                        command = commands_1[_i];
                        return [4 /*yield*/, this.issueShellCommand(command)];
                    case 2:
                        status = _a.sent();
                        if (!status)
                            return [2 /*return*/, false];
                        _a.label = 3;
                    case 3:
                        _i++;
                        return [3 /*break*/, 1];
                    case 4: return [2 /*return*/, true];
                }
            });
        });
    };
    /**
     * Add listener to command life cycle event
     * @param eventName
     * @param listener
     */
    Device.prototype.on = function (eventName, listener) {
        this._eventEmmiter.on(eventName, listener);
    };
    /**
     * Remove Listener to command life cycle event
     * @param eventName
     * @param listener
     */
    Device.prototype.off = function (eventName, listener) {
        this._eventEmmiter.off(eventName, listener);
    };
    /**
     * Get resolution of this device
     * @returns
     */
    Device.prototype.getResolution = function () {
        return __awaiter(this, void 0, void 0, function () {
            var result, _a, width, height;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("wm size")];
                    case 1:
                        result = _b.sent();
                        _a = result.split(":")[1].split("x"), width = _a[0], height = _a[1];
                        return [2 /*return*/, { x: Number(width.trim()), y: Number(height.trim()) }];
                }
            });
        });
    };
    Device.prototype.getAllPackages = function () {
        return __awaiter(this, void 0, void 0, function () {
            var result, packages;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("pm list packages")];
                    case 1:
                        result = _a.sent();
                        packages = this.parsePackages(result);
                        return [2 /*return*/, packages];
                }
            });
        });
    };
    Device.prototype.getSystemPackages = function () {
        return __awaiter(this, void 0, void 0, function () {
            var result, packages;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("pm list packages -s")];
                    case 1:
                        result = _a.sent();
                        packages = this.parsePackages(result);
                        return [2 /*return*/, packages];
                }
            });
        });
    };
    Device.prototype.getThirdPartyPackages = function () {
        return __awaiter(this, void 0, void 0, function () {
            var result, packages;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("pm list packages -3")];
                    case 1:
                        result = _a.sent();
                        packages = this.parsePackages(result);
                        return [2 /*return*/, packages];
                }
            });
        });
    };
    Device.prototype.parsePackages = function (content) {
        var lines = content.split("\r\n");
        var packages = [];
        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
            var l = lines_1[_i];
            if (l === "")
                continue;
            packages.push(l.split(":")[1]);
        }
        return packages;
    };
    Device.prototype.existPackage = function (packageName) {
        return __awaiter(this, void 0, void 0, function () {
            var packages;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getAllPackages()];
                    case 1:
                        packages = _a.sent();
                        return [2 /*return*/, packages.includes(packageName)];
                }
            });
        });
    };
    /**
     * Check if activity is running top
     * @param activityName
     * @returns
     */
    Device.prototype.isCurrentActivity = function (packageName, activityName) {
        return __awaiter(this, void 0, void 0, function () {
            var result, resultLines, _i, resultLines_1, line;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("dumpsys window")];
                    case 1:
                        result = _a.sent();
                        resultLines = result.split("\r\n");
                        for (_i = 0, resultLines_1 = resultLines; _i < resultLines_1.length; _i++) {
                            line = resultLines_1[_i];
                            if (!line.includes("mCurrentFocus"))
                                continue;
                            if (activityName) {
                                if (line.includes("".concat(packageName, "/").concat(activityName)))
                                    return [2 /*return*/, true];
                            }
                            else {
                                if (line.includes(packageName))
                                    return [2 /*return*/, true];
                            }
                        }
                        return [2 /*return*/, false];
                }
            });
        });
    };
    /**
     * Start an app if not at the current focus
     * @param packageName
     * @param activityName
     */
    Device.prototype.startApp = function (packageName_1, activityName_1) {
        return __awaiter(this, arguments, void 0, function (packageName, activityName, timeout) {
            var _this = this;
            if (timeout === void 0) { timeout = 10000; }
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("am start -n ".concat(packageName, "/").concat(activityName))];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
                                var retry, interval;
                                var _this = this;
                                return __generator(this, function (_a) {
                                    retry = 0;
                                    interval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
                                        var status;
                                        return __generator(this, function (_a) {
                                            switch (_a.label) {
                                                case 0:
                                                    if (!(retry * 1000 >= timeout)) return [3 /*break*/, 1];
                                                    clearInterval(interval);
                                                    resolve(false);
                                                    return [3 /*break*/, 3];
                                                case 1: return [4 /*yield*/, this.isCurrentActivity("".concat(packageName, "/").concat(activityName))];
                                                case 2:
                                                    status = _a.sent();
                                                    if (status) {
                                                        clearInterval(interval);
                                                        resolve(true);
                                                    }
                                                    else {
                                                        retry++;
                                                    }
                                                    _a.label = 3;
                                                case 3: return [2 /*return*/];
                                            }
                                        });
                                    }); });
                                    return [2 /*return*/];
                                });
                            }); })];
                }
            });
        });
    };
    /**
     * Close an app
     * @param packageName
     */
    Device.prototype.closeApp = function (packageName_1) {
        return __awaiter(this, arguments, void 0, function (packageName, timeout) {
            var _this = this;
            if (timeout === void 0) { timeout = 10000; }
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("am force-stop ".concat(packageName))];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
                                var retry, interval;
                                var _this = this;
                                return __generator(this, function (_a) {
                                    retry = 0;
                                    interval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
                                        var status;
                                        return __generator(this, function (_a) {
                                            switch (_a.label) {
                                                case 0:
                                                    if (!(retry * 1000 >= timeout)) return [3 /*break*/, 1];
                                                    clearInterval(interval);
                                                    resolve(false);
                                                    return [3 /*break*/, 3];
                                                case 1: return [4 /*yield*/, this.isCurrentActivity(packageName)];
                                                case 2:
                                                    status = _a.sent();
                                                    if (status) {
                                                        retry++;
                                                    }
                                                    else {
                                                        clearInterval(interval);
                                                        resolve(true);
                                                    }
                                                    _a.label = 3;
                                                case 3: return [2 /*return*/];
                                            }
                                        });
                                    }); });
                                    return [2 /*return*/];
                                });
                            }); })];
                }
            });
        });
    };
    /**
     * Take a screencap and pull it out
     * @param options
     */
    Device.prototype.getScreencap = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.issueShellCommandText("screencap ".concat((options === null || options === void 0 ? void 0 : options.fileName) || "/sdcard/screen.png"))];
                    case 1:
                        _a.sent();
                        return [4 /*yield*/, this.issueShellCommandText("pull ".concat((options === null || options === void 0 ? void 0 : options.fileName) || "/sdcard/screen.png", " ").concat((options === null || options === void 0 ? void 0 : options.pullPath) || "./"))];
                    case 2:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    return Device;
}());
exports.Device = Device;