@xenon-device-management/xenon 1.1.0

package/lib/src/device-managers/AndroidDeviceManager.js

@@ -0,0 +1,1155 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 helpers_1 = require("../helpers");
+const appium_adb_1 = require("appium-adb");
+const logger_1 = __importDefault(require("../logger"));
+const lodash_1 = __importDefault(require("lodash"));
+const support_1 = require("@appium/support");
+const ChromeDriverManager_1 = __importDefault(require("./ChromeDriverManager"));
+const typedi_1 = require("typedi");
+const device_utils_1 = require("../device-utils");
+const adbkit_1 = __importDefault(require("@devicefarmer/adbkit"));
+const node_abort_controller_1 = require("node-abort-controller");
+const async_wait_until_1 = __importDefault(require("async-wait-until"));
+const NodeDevices_1 = __importDefault(require("./NodeDevices"));
+const device_service_1 = require("../data-service/device-service");
+const device_store_1 = require("../data-service/device-store");
+const Devices_1 = __importDefault(require("./cloud/Devices"));
+const DeviceLockManager_1 = require("./android/DeviceLockManager");
+const PluginContext_1 = require("../PluginContext");
+const typedi_2 = require("typedi");
+let AndroidDeviceManager = class AndroidDeviceManager {
+    constructor(context) {
+        this.context = context;
+        this.log = logger_1.default.scope('AndroidManager');
+        this.adbAvailable = true;
+        this.abortControl = new Map();
+        this.tracker = undefined;
+        this.remoteTrackers = [];
+        this.getDeviceName = (adbInstance, udid) => __awaiter(this, void 0, void 0, function* () {
+            let deviceName = yield this.getDeviceProperty(yield adbInstance, udid, 'ro.product.name');
+            if (!deviceName || (deviceName && deviceName.trim() === '')) {
+                // If the device name is null or empty, try to get it from the Bluetooth manager.
+                deviceName = yield (yield adbInstance).adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'dumpsys',
+                    'bluetooth_manager',
+                    '|',
+                    'grep',
+                    'name:',
+                    '|',
+                    'cut',
+                    '-c9-',
+                ]);
+            }
+            return deviceName;
+        });
+    }
+    get pluginArgs() {
+        return this.context.pluginArgs;
+    }
+    get hostPort() {
+        return this.context.port;
+    }
+    get nodeId() {
+        return this.context.nodeId;
+    }
+    initiateAbortControl(deviceUdid) {
+        const control = new node_abort_controller_1.AbortController();
+        this.abortControl.set(deviceUdid, control);
+        return control;
+    }
+    abort(deviceUdid) {
+        var _a;
+        (_a = this.abortControl.get(deviceUdid)) === null || _a === void 0 ? void 0 : _a.abort();
+    }
+    cancelAbort(deviceUdid) {
+        if (this.abortControl.has(deviceUdid)) {
+            this.abortControl.delete(deviceUdid);
+        }
+    }
+    getDevices(deviceTypes, existingDeviceDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.adbAvailable) {
+                logger_1.default.info('adb is not available. So, returning empty list');
+                return [];
+            }
+            let devices = [];
+            try {
+                if ((_a = this.pluginArgs.cloud) === null || _a === void 0 ? void 0 : _a.cloudName) {
+                    const cloud = new Devices_1.default(this.pluginArgs.cloud, devices, 'android');
+                    return yield cloud.getDevices();
+                }
+                else {
+                    devices = yield this.fetchAndroidDevices(existingDeviceDetails, this.pluginArgs);
+                    logger_1.default.info(`Found ${devices.length} android devices`);
+                }
+                if (deviceTypes.androidDeviceType === 'real') {
+                    return devices.filter((device) => {
+                        console.log(`Filtering device ${device.udid}, type: ${device.deviceType}, expected real`);
+                        return device.deviceType === 'real';
+                    });
+                }
+                else if (deviceTypes.androidDeviceType === 'simulated') {
+                    return devices.filter((device) => {
+                        return device.deviceType === 'emulator';
+                    });
+                    // return both real and simulated (emulated) devices
+                }
+                else {
+                    return devices;
+                }
+            }
+            catch (e) {
+                logger_1.default.error(`Error while getting android devices. Error: ${e instanceof Error ? e.message : e}`);
+            }
+            return [];
+        });
+    }
+    fetchAndroidDevices(existingDeviceDetails, pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requireSdkRoot();
+            const connectedDevices = yield this.getConnectedDevices(pluginArgs);
+            const deviceProcessingPromises = [];
+            for (const [adbInstance, devices] of connectedDevices) {
+                logger_1.default.debug(`fetchAndroidDevices from host: ${adbInstance.adbRemoteHost || 'Local'}. Found ${devices.length} android devices`);
+                const devicesArray = devices;
+                for (const device of devicesArray) {
+                    deviceProcessingPromises.push((() => __awaiter(this, void 0, void 0, function* () {
+                        device.adbRemoteHost =
+                            adbInstance.adbRemoteHost === null
+                                ? this.pluginArgs.bindHostOrIp
+                                : adbInstance.adbRemoteHost;
+                        const existingDevice = existingDeviceDetails.find((dev) => dev.udid === device.udid && dev.host.includes(this.pluginArgs.bindHostOrIp));
+                        if (existingDevice) {
+                            logger_1.default.info(`Android Device details for ${device.udid} already available`);
+                            return Object.assign(Object.assign({}, existingDevice), { busy: false });
+                        }
+                        else {
+                            logger_1.default.info(`Android Device details for ${device.udid} not available. So querying now.`);
+                            if (device.state === 'device') {
+                                try {
+                                    return yield this.deviceInfo(device, adbInstance, this.pluginArgs, this.hostPort);
+                                }
+                                catch (e) {
+                                    logger_1.default.error(`Error while getting device info for ${device.udid}. Error: ${e}`);
+                                    return undefined;
+                                }
+                            }
+                            else {
+                                logger_1.default.info(`Device ${device.udid} is not in "device" state. So, ignoring.`);
+                                return undefined;
+                            }
+                        }
+                    }))());
+                }
+            }
+            const processedDevices = yield Promise.all(deviceProcessingPromises);
+            const availableDevices = [];
+            const seenUdids = new Set();
+            for (const dev of processedDevices) {
+                if (dev && !seenUdids.has(`${dev.udid}-${dev.adbRemoteHost}`)) {
+                    availableDevices.push(dev);
+                    seenUdids.add(`${dev.udid}-${dev.adbRemoteHost}`);
+                }
+            }
+            return availableDevices;
+        });
+    }
+    deviceInfo(device, adbInstance, pluginArgs, hostPort) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const systemPort = yield (0, helpers_1.getFreePort)();
+            const totalUtilizationTimeMilliSec = yield (0, device_utils_1.getUtilizationTime)(device.udid);
+            let deviceInfo;
+            try {
+                deviceInfo = yield Promise.all([
+                    this.getDeviceVersion(adbInstance, device.udid),
+                    this.isRealDevice(adbInstance, device.udid),
+                    this.getDeviceName(adbInstance, device.udid),
+                ]);
+            }
+            catch (error) {
+                logger_1.default.info(`Error while getting base device info for ${device.udid}. Error: ${error}`);
+                return undefined;
+            }
+            const [sdk, realDevice, name] = deviceInfo;
+            // Base info is mandatory
+            if (lodash_1.default.isNil(sdk) || lodash_1.default.isNil(realDevice) || lodash_1.default.isNil(name)) {
+                logger_1.default.info(`Cannot get base device info for ${device.udid}. Skipping`);
+                return undefined;
+            }
+            let host;
+            if (adbInstance.adbHost != null) {
+                host = `http://${adbInstance.adbHost}:${adbInstance.adbPort}`;
+            }
+            else if (pluginArgs.remoteMachineProxyIP !== undefined) {
+                host = `http://${pluginArgs.remoteMachineProxyIP}:${hostPort}`;
+            }
+            else {
+                host = `http://${pluginArgs.bindHostOrIp}:${hostPort}`;
+            }
+            return {
+                adbRemoteHost: (_a = adbInstance.adbRemoteHost) !== null && _a !== void 0 ? _a : undefined,
+                adbPort: adbInstance.adbPort,
+                systemPort,
+                sdk: sdk !== null && sdk !== void 0 ? sdk : 'unknown',
+                realDevice,
+                name: name !== null && name !== void 0 ? name : 'unknown',
+                busy: false,
+                state: device.state,
+                udid: device.udid,
+                platform: 'android',
+                deviceType: realDevice ? 'real' : 'emulator',
+                host,
+                totalUtilizationTimeMilliSec: totalUtilizationTimeMilliSec,
+                sessionStartTime: 0,
+                userBlocked: false,
+            };
+        });
+    }
+    getAdditionalDeviceInfo(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Fetching additional device info for ${device.udid} (Lazy Loading)`);
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return {};
+            const adb = device.adbRemoteHost
+                ? adbInstance.clone({
+                    remoteAdbHost: device.adbRemoteHost,
+                    adbPort: device.adbPort,
+                })
+                : adbInstance;
+            try {
+                const [chromeDriverPath, screenSize] = yield Promise.all([
+                    this.getChromeVersion(adb, device.udid, this.pluginArgs),
+                    this.getScreenSize(adb, device.udid),
+                ]);
+                return {
+                    chromeDriverPath,
+                    screenWidth: screenSize === null || screenSize === void 0 ? void 0 : screenSize.width,
+                    screenHeight: screenSize === null || screenSize === void 0 ? void 0 : screenSize.height,
+                };
+            }
+            catch (err) {
+                logger_1.default.warn(`Failed to fetch additional info for ${device.udid}: ${err}`);
+                return {};
+            }
+        });
+    }
+    getScreenSize(adbInstance, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const adb = yield adbInstance;
+                let stdout = yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                    return yield adb.adbExec(['-s', udid, 'shell', 'wm', 'size'], { timeout: 10000 });
+                }));
+                const physicalMatch = /Physical size: (\d+)x(\d+)/.exec(stdout);
+                const overrideMatch = /Override size: (\d+)x(\d+)/.exec(stdout);
+                if (overrideMatch) {
+                    logger_1.default.info(`Detected Override size for ${udid}: ${overrideMatch[1]}x${overrideMatch[2]}`);
+                    return { width: overrideMatch[1], height: overrideMatch[2] };
+                }
+                if (physicalMatch) {
+                    logger_1.default.info(`Detected Physical size for ${udid}: ${physicalMatch[1]}x${physicalMatch[2]}`);
+                    return { width: physicalMatch[1], height: physicalMatch[2] };
+                }
+                // Fallback: dumpsys display
+                logger_1.default.debug(`wm size failed for ${udid}, trying dumpsys display`);
+                stdout = yield adb.adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'dumpsys',
+                    'display',
+                    '|',
+                    'grep',
+                    'mBaseDisplayInfo',
+                ]);
+                const sizeMatch = /width=(\d+), height=(\d+)/.exec(stdout);
+                if (sizeMatch) {
+                    return { width: sizeMatch[1], height: sizeMatch[2] };
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`Error while getting screen size for ${udid}. Error: ${error}`);
+            }
+            return undefined;
+        });
+    }
+    getAdb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.adb) {
+                    try {
+                        this.adb = yield appium_adb_1.ADB.createADB({});
+                    }
+                    catch (e) {
+                        this.adbAvailable = false;
+                        this.log.error('Could not find ADB');
+                    }
+                    if (process.env.NODE_ENV !== 'test') {
+                        const client = adbkit_1.default.createClient();
+                        this.tracker = yield client.trackDevices();
+                        if (this.tracker && this.adb) {
+                            const originalADBTracking = this.createLocalAdbTracker(this.tracker, this.adb);
+                            yield originalADBTracking();
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                logger_1.default.error(`Failed to initialize ADB: ${e}`);
+                this.adbAvailable = false;
+            }
+            return { adbInstance: this.adb, adbTracker: this.tracker };
+        });
+    }
+    getAdbForDevice(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                throw new Error('ADB is not available');
+            const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+            if (device && device.adbRemoteHost) {
+                logger_1.default.debug(`Using remote ADB instance for ${udid} at ${device.adbRemoteHost}:${device.adbPort}`);
+                return adbInstance.clone({
+                    remoteAdbHost: device.adbRemoteHost,
+                    adbPort: device.adbPort,
+                });
+            }
+            return adbInstance;
+        });
+    }
+    waitBootComplete(originalADB, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, async_wait_until_1.default)(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const bootStatus = (yield this.getDeviceProperty(originalADB, udid, 'init.svc.bootanim'));
+                    if (!lodash_1.default.isNil(bootStatus) && !lodash_1.default.isEmpty(bootStatus) && bootStatus == 'stopped') {
+                        this.log.info('Boot Completed!', udid);
+                        return true;
+                    }
+                }
+                catch (err) {
+                    return false;
+                }
+            }), {
+                intervalBetweenAttempts: 2000,
+                timeout: 60 * 1000,
+            });
+        });
+    }
+    getConnectedDevices(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceList = new Map();
+            const { adbInstance: originalADB } = yield this.getAdb();
+            if (!originalADB)
+                return deviceList;
+            deviceList.set(originalADB, yield originalADB.getConnectedDevices());
+            const adbRemote = pluginArgs.adbRemote;
+            if (adbRemote !== undefined && adbRemote.length > 0) {
+                const promises = adbRemote.map((value) => __awaiter(this, void 0, void 0, function* () {
+                    const adbRemoteValue = value.split(':');
+                    const adbHost = adbRemoteValue[0];
+                    const adbPort = parseInt(adbRemoteValue[1]) || 5037;
+                    const cloneAdb = originalADB.clone({
+                        remoteAdbHost: adbHost,
+                        adbPort,
+                    });
+                    const devices = yield cloneAdb.getConnectedDevices();
+                    deviceList.set(cloneAdb, devices);
+                    const remoteAdb = adbkit_1.default.createClient({
+                        host: adbHost,
+                        port: adbPort,
+                    });
+                    const remoteAdbTracking = yield this.createRemoteAdbTracker(remoteAdb, originalADB, value);
+                    yield remoteAdbTracking();
+                }));
+                yield Promise.all(promises);
+            }
+            return deviceList;
+        });
+    }
+    onDeviceAdded(originalADB, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!device || !device.id)
+                return;
+            const newDevice = { udid: device.id, state: device.type };
+            logger_1.default.info(`Device ${newDevice.udid} was plugged. Detail: ${JSON.stringify(newDevice)}`);
+            if (newDevice.state != 'offline') {
+                logger_1.default.info(`Device ${newDevice.udid} was plugged`);
+                this.initiateAbortControl(newDevice.udid);
+                let bootCompleted = false;
+                try {
+                    yield this.waitBootComplete(originalADB, newDevice.udid);
+                    bootCompleted = true;
+                }
+                catch (error) {
+                    logger_1.default.info(`Device ${newDevice.udid} boot did not complete. Error: ${error}`);
+                }
+                if (!bootCompleted) {
+                    logger_1.default.info(`Device ${newDevice.udid} boot did not complete in time. Ignoring`);
+                    return;
+                }
+                this.cancelAbort(newDevice.udid);
+                const trackedDevice = yield this.deviceInfo(newDevice, originalADB, this.pluginArgs, this.hostPort);
+                if (!trackedDevice) {
+                    logger_1.default.info(`Cannot get device info for ${newDevice.udid}. Skipping`);
+                    return;
+                }
+                logger_1.default.info(`Adding device ${newDevice.udid} to list!`);
+                const deviceTracked = Object.assign(Object.assign({}, trackedDevice), { nodeId: this.nodeId });
+                if (this.pluginArgs.hub != undefined) {
+                    logger_1.default.info(`Updating Hub with device ${newDevice.udid}`);
+                    const nodeDevices = new NodeDevices_1.default(this.pluginArgs.hub, this.pluginArgs.tlsRejectUnauthorized);
+                    yield nodeDevices.postDevicesToHub([deviceTracked], 'add');
+                }
+                // node also need a copy of devices, otherwise it cannot serve requests
+                yield (0, device_service_1.addNewDevice)([deviceTracked], this.pluginArgs.bindHostOrIp);
+            }
+        });
+    }
+    createLocalAdbTracker(tracker, originalADB) {
+        const pluginArgs = this.pluginArgs;
+        const adbTracker = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                tracker.on('add', (device) => __awaiter(this, void 0, void 0, function* () {
+                    if (!device || !device.id)
+                        return;
+                    yield this.onDeviceAdded(originalADB, device);
+                }));
+                tracker.on('remove', (device) => __awaiter(this, void 0, void 0, function* () {
+                    if (!device || !device.id)
+                        return;
+                    yield this.onDeviceRemoved(device, pluginArgs);
+                }));
+                tracker.on('change', (device) => __awaiter(this, void 0, void 0, function* () {
+                    if (!device || !device.id)
+                        return;
+                    if (device.type === 'offline' || device.type === 'unauthorized') {
+                        yield this.onDeviceRemoved(device, pluginArgs);
+                    }
+                    else {
+                        yield this.onDeviceAdded(originalADB, device);
+                    }
+                }));
+                tracker.on('end', () => {
+                    logger_1.default.info('Tracking stopped');
+                });
+            }
+            catch (err) {
+                logger_1.default.error('Something went wrong:', err instanceof Error ? err.stack : err);
+            }
+        });
+        return adbTracker;
+    }
+    onDeviceRemoved(device, pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clonedDevice = {
+                udid: device['id'],
+                host: pluginArgs.bindHostOrIp,
+                state: device.type,
+            };
+            if (pluginArgs.hub != undefined) {
+                const nodeDevices = new NodeDevices_1.default(pluginArgs.hub, pluginArgs.tlsRejectUnauthorized);
+                yield nodeDevices.postDevicesToHub([clonedDevice], 'remove');
+            }
+            // node also need a copy of devices, otherwise it cannot serve requests
+            yield (0, device_service_1.removeDevice)([clonedDevice]);
+            this.abort(clonedDevice.udid);
+        });
+    }
+    /**
+     * Return and cache a tracker for remote adb. If tracker already exists for the given id, return the existing one.
+     * @param adbClient
+     * @param originalADB
+     * @param id
+     * @returns
+     */
+    createRemoteAdbTracker(adbClient, originalADB, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let remoteTracker;
+            // get tracker from remoteTracker list if already exists
+            const existingTracker = this.remoteTrackers.find((tracker) => tracker.id === id);
+            if (!existingTracker) {
+                const newTracker = yield adbClient.trackDevices();
+                this.remoteTrackers.push({ id, tracker: newTracker });
+                remoteTracker = newTracker;
+            }
+            else {
+                remoteTracker = existingTracker.tracker;
+            }
+            const pluginArgs = this.pluginArgs;
+            const adbTracking = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    remoteTracker.on('add', (device) => __awaiter(this, void 0, void 0, function* () {
+                        yield this.onDeviceAdded(originalADB, device);
+                    }));
+                    remoteTracker.on('remove', (device) => __awaiter(this, void 0, void 0, function* () {
+                        yield this.onDeviceRemoved(device, pluginArgs);
+                    }));
+                    remoteTracker.on('change', (device) => __awaiter(this, void 0, void 0, function* () {
+                        if (device.type === 'offline' || device.type === 'unauthorized') {
+                            logger_1.default.info(`Device ${device.id} is ${device.type}. Removing from list`);
+                            yield this.onDeviceRemoved(device, pluginArgs);
+                        }
+                        else {
+                            yield this.onDeviceAdded(originalADB, device);
+                        }
+                    }));
+                    remoteTracker.on('end', () => this.log.info('Tracking stopped'));
+                }
+                catch (err) {
+                    this.log.error('Something went wrong:', err instanceof Error ? err.stack : err);
+                }
+            });
+            return adbTracking;
+        });
+    }
+    getChromeVersion(adbInstance, udid, pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (pluginArgs.skipChromeDownload) {
+                logger_1.default.warn('skipChromeDownload server arg is set; skipping Chromedriver installation.');
+                logger_1.default.warn('Android web/hybrid testing will not be possible without Chromedriver.');
+                return;
+            }
+            logger_1.default.debug('Getting package info for chrome');
+            const chromeDriverManager = typedi_1.Container.get(ChromeDriverManager_1.default);
+            let versionName = '';
+            try {
+                const stdout = yield (yield adbInstance).adbExec(['-s', udid, 'shell', 'dumpsys', 'package', 'com.android.chrome']);
+                const versionNameMatch = new RegExp(/versionName=([\d+.]+)/).exec(stdout);
+                if (versionNameMatch) {
+                    versionName = versionNameMatch[1];
+                    versionName = versionName.split('.')[0];
+                    return yield chromeDriverManager.downloadChromeDriver(versionName);
+                }
+            }
+            catch (err) {
+                logger_1.default.warn(`Error '${err instanceof Error ? err.message : err}' while dumping package info`);
+            }
+        });
+    }
+    downloadChromeDriver(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = typedi_1.Container.get(ChromeDriverManager_1.default);
+            return yield instance.downloadChromeDriver(version);
+        });
+    }
+    getDeviceVersion(adbInstance, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getDeviceProperty(adbInstance, udid, 'ro.build.version.release');
+        });
+    }
+    getDeviceProperty(adbInstance, udid, prop) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (yield adbInstance).adbExec(['-s', udid, 'shell', 'getprop', prop]);
+            }
+            catch (error) {
+                logger_1.default.error(`Error while getting device property "${prop}" for ${udid}. Error: ${error}`);
+            }
+        });
+    }
+    isRealDevice(adbInstance, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const character = yield this.getDeviceProperty(adbInstance, udid, 'ro.build.characteristics');
+            return character !== 'emulator';
+        });
+    }
+    requireSdkRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sdkRoot = (0, appium_adb_1.getSdkRootFromEnv)();
+            const docMsg = 'Read https://developer.android.com/studio/command-line/variables for more details';
+            if (lodash_1.default.isEmpty(sdkRoot)) {
+                throw new Error(`Neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable was exported. ${docMsg}`);
+            }
+            if (sdkRoot === undefined || !(yield support_1.fs.exists(sdkRoot))) {
+                throw new Error(`The Android SDK root folder '${sdkRoot}' does not exist on the local file system. ${docMsg}`);
+            }
+            const stats = yield support_1.fs.stat(sdkRoot);
+            if (!stats.isDirectory()) {
+                throw new Error(`The Android SDK root '${sdkRoot}' must be a folder. ${docMsg}`);
+            }
+            return sdkRoot;
+        });
+    }
+    tap(udid, x, y) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android Tap on ${udid} at ${x},${y}`);
+            const adb = yield this.getAdbForDevice(udid);
+            yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                yield adb.adbExec(['-s', udid, 'shell', 'input', 'tap', Math.round(x).toString(), Math.round(y).toString()], { timeout: 10000 });
+            }));
+        });
+    }
+    swipe(udid, x, y, endX, endY, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android Swipe on ${udid}: (${x},${y}) -> (${endX},${endY}) duration: ${duration}`);
+            const adb = yield this.getAdbForDevice(udid);
+            yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                yield adb.adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'input',
+                    'swipe',
+                    Math.round(x).toString(),
+                    Math.round(y).toString(),
+                    Math.round(endX).toString(),
+                    Math.round(endY).toString(),
+                    duration.toString(),
+                ], { timeout: 15000 });
+            }));
+        });
+    }
+    typeText(udid, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android TypeText on ${udid}: ${text}`);
+            const adb = yield this.getAdbForDevice(udid);
+            // Escape whitespace for shell input
+            const escapedText = text.replace(/ /g, '%s');
+            yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                yield adb.adbExec(['-s', udid, 'shell', 'input', 'text', escapedText], { timeout: 10000 });
+            }));
+        });
+    }
+    pressKey(udid, keyCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android PressKey on ${udid}: ${keyCode}`);
+            const adb = yield this.getAdbForDevice(udid);
+            yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                yield adb.adbExec(['-s', udid, 'shell', 'input', 'keyevent', keyCode.toString()], {
+                    timeout: 10000,
+                });
+            }));
+        });
+    }
+    getPageSource(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android getPageSource on ${udid}`);
+            const adb = yield this.getAdbForDevice(udid);
+            return yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const dumpPath = '/data/local/tmp/dump.xml';
+                    yield adb.adbExec(['-s', udid, 'shell', 'uiautomator', 'dump', dumpPath], {
+                        timeout: 15000,
+                    });
+                    const xml = yield adb.adbExec(['-s', udid, 'shell', 'cat', dumpPath], { timeout: 10000 });
+                    return xml || '';
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to get Android page source for ${udid}: ${err.message}`);
+                    return '';
+                }
+            }));
+        });
+    }
+    installApp(udid, appPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                throw new Error('ADB is not available');
+            yield adbInstance.adbExec(['-s', udid, 'install', '-r', appPath]);
+        });
+    }
+    uninstallApp(udid, bundleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                throw new Error('ADB is not available');
+            yield adbInstance.adbExec(['-s', udid, 'uninstall', bundleId]);
+        });
+    }
+    /**
+     * Helper function to temporarily set the Android device's IME to Appium Settings.
+     * This is required on Android 10+ to bypass OS background clipboard restrictions.
+     */
+    withAppiumIME(adbInstance, udid, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let originalIME = '';
+            const appiumIME = 'io.appium.settings/.AppiumIME';
+            try {
+                // 1. Get current IME
+                originalIME = (yield adbInstance.adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'settings',
+                    'get',
+                    'secure',
+                    'default_input_method',
+                ])).trim();
+                // 2. Enable and Set Appium IME
+                if (originalIME !== appiumIME) {
+                    yield adbInstance.adbExec(['-s', udid, 'shell', 'ime', 'enable', appiumIME]);
+                    yield adbInstance.adbExec(['-s', udid, 'shell', 'ime', 'set', appiumIME]);
+                    // Give the OS a tiny moment to process the IME swap
+                    yield new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                // 3. Execute the clipboard action with the Appium IME active
+                return yield action();
+            }
+            finally {
+                // 4. Always restore the original IME if we swapped it
+                if (originalIME && originalIME !== appiumIME) {
+                    try {
+                        yield adbInstance.adbExec(['-s', udid, 'shell', 'ime', 'set', originalIME]);
+                    }
+                    catch (e) {
+                        logger_1.default.warn(`[${udid}] Failed to restore original IME (${originalIME}): ${e}`);
+                    }
+                }
+            }
+        });
+    }
+    getClipboard(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return '';
+            try {
+                // Wrap the targeted broadcast in the Appium IME context
+                return yield this.withAppiumIME(adbInstance, udid, () => __awaiter(this, void 0, void 0, function* () {
+                    // 1. Try Targeted Broadcast method (Reliable for modern Android)
+                    const result = yield adbInstance.adbExec([
+                        '-s',
+                        udid,
+                        'shell',
+                        'am',
+                        'broadcast',
+                        '-a',
+                        'com.appium.settings.clipboard.get',
+                        '-n',
+                        'io.appium.settings/.receivers.ClipboardReceiver',
+                    ]);
+                    // Parse result like: Broadcast completed: result=-1, data="BASE64_DATA"
+                    const dataMatch = /data="([^"]*)"/.exec(result);
+                    if (dataMatch) {
+                        const rawData = dataMatch[1];
+                        if (!rawData)
+                            return '';
+                        // Appium Settings returns Base64 for robustness
+                        try {
+                            const decoded = Buffer.from(rawData, 'base64').toString('utf8');
+                            // If it looks like printable text after decoding, use it
+                            if (/^[\x20-\x7E\s\u00A0-\uFFFF]*$/.test(decoded))
+                                return decoded;
+                            return rawData;
+                        }
+                        catch (e) {
+                            return rawData;
+                        }
+                    }
+                    // 2. Fallback: Query the content provider (Legacy/Alternative)
+                    const queryResult = yield adbInstance.adbExec([
+                        '-s',
+                        udid,
+                        'shell',
+                        'content',
+                        'query',
+                        '--uri',
+                        'content://io.appium.settings.clipboard/clipboard',
+                    ]);
+                    // Extract value using a more flexible regex that handles different formats
+                    const valMatch = /value=([^\s,]*)/i.exec(queryResult);
+                    if (valMatch) {
+                        const val = valMatch[1];
+                        // Most content providers return base64 for safety
+                        try {
+                            const decoded = Buffer.from(val, 'base64').toString('utf8');
+                            // Basic sanity check: if it contains non-printable characters, it might not have been base64
+                            if (/^[\x20-\x7E\s]*$/.test(decoded))
+                                return decoded;
+                            return val;
+                        }
+                        catch (e) {
+                            return val;
+                        }
+                    }
+                    return '';
+                }));
+            }
+            catch (err) {
+                logger_1.default.warn(`Failed to fetch Android clipboard for ${udid}: ${err instanceof Error ? err.message : err}`);
+            }
+            return '';
+        });
+    }
+    setClipboard(udid, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return;
+            try {
+                yield this.withAppiumIME(adbInstance, udid, () => __awaiter(this, void 0, void 0, function* () {
+                    yield adbInstance.adbExec([
+                        '-s',
+                        udid,
+                        'shell',
+                        'am',
+                        'broadcast',
+                        '-a',
+                        'com.appium.settings.clipboard.set',
+                        '-n',
+                        'io.appium.settings/.receivers.ClipboardReceiver',
+                        '--es',
+                        'label',
+                        'clipboard',
+                        '--es',
+                        'content',
+                        Buffer.from(content).toString('base64'), // Send as Base64 for safety
+                    ]);
+                }));
+            }
+            catch (err) {
+                logger_1.default.warn(`Failed to set Android clipboard for ${udid}: ${err instanceof Error ? err.message : err}`);
+            }
+        });
+    }
+    touchAndHold(udid, x, y, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return;
+            yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                yield adbInstance.adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'input',
+                    'swipe',
+                    x.toString(),
+                    y.toString(),
+                    x.toString(),
+                    y.toString(),
+                    duration.toString(),
+                ], { timeout: 15000 });
+            }));
+        });
+    }
+    lock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return;
+            // 26 is POWER button, usually locks if screen is on
+            yield adbInstance.adbExec(['-s', udid, 'shell', 'input', 'keyevent', '26']);
+        });
+    }
+    unlock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return;
+            // Wake up the device and potentially unlock
+            yield adbInstance.adbExec(['-s', udid, 'shell', 'input', 'keyevent', '224']); // WAKEUP
+            yield adbInstance.adbExec(['-s', udid, 'shell', 'input', 'keyevent', '82']); // MENU (locks/unlocks some devices)
+        });
+    }
+    listApps(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return [];
+            // List all third-party apps
+            const stdout = yield adbInstance.adbExec(['-s', udid, 'shell', 'pm', 'list', 'packages', '-3']);
+            return stdout
+                .split(/\r?\n/)
+                .map((line) => line.replace(/^package:/i, '').trim())
+                .filter((line) => line.length > 0)
+                .sort();
+        });
+    }
+    getScreenshot(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Android Get Screenshot on ${udid}`);
+            // Principal Optimization: Try to use the latest frame from the active stream if available
+            try {
+                const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./android/AndroidStreamService')));
+                const streamSession = typedi_1.Container.get(AndroidStreamService).getStreamStatus(udid);
+                if ((streamSession === null || streamSession === void 0 ? void 0 : streamSession.status) === 'running' && streamSession.latestFrame) {
+                    // Sanity Check: A full screenshot should be at least ~10KB as JPEG.
+                    // Staleness Check: If the frame is older than 5 seconds, it's considered poor quality for interactive use.
+                    const isFresh = streamSession.latestFrameTimestamp &&
+                        Date.now() - streamSession.latestFrameTimestamp < 5000;
+                    if (streamSession.latestFrame.length > 10000 && isFresh) {
+                        logger_1.default.info(`[AndroidDeviceManager] Using fresh cached stream frame for ${udid} screenshot.`);
+                        return streamSession.latestFrame.toString('base64');
+                    }
+                    else if (!isFresh) {
+                        logger_1.default.warn(`[AndroidDeviceManager] Cached frame for ${udid} is STALE (${Math.round((Date.now() - (streamSession.latestFrameTimestamp || 0)) / 1000)}s old). Falling back to direct screencap.`);
+                    }
+                    else {
+                        logger_1.default.warn(`[AndroidDeviceManager] Cached frame for ${udid} is too small (${streamSession.latestFrame.length}b). Falling back to direct screencap.`);
+                    }
+                }
+            }
+            catch (e) {
+                logger_1.default.debug(`Failed to check stream status for ${udid}: ${e}`);
+            }
+            const { spawn } = yield Promise.resolve().then(() => __importStar(require('child_process')));
+            const adb = yield this.getAdbForDevice(udid);
+            try {
+                // 1. Try targeted exec-out screencap -p for maximum speed/reliability
+                // This is binary-safe and avoids saving to device disk
+                const screenshot = yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                    return yield new Promise((resolve, reject) => {
+                        const adbArgs = ['-s', udid];
+                        // remote ADB support
+                        if (adb.adbHost && adb.adbPort) {
+                            adbArgs.unshift('-H', adb.adbHost, '-P', adb.adbPort.toString());
+                        }
+                        const adbPath = adb.executable.path || 'adb';
+                        const proc = spawn(adbPath, [...adbArgs, 'exec-out', 'screencap', '-p']);
+                        const chunks = [];
+                        proc.stdout.on('data', (c) => chunks.push(c));
+                        proc.on('close', (code) => {
+                            if (code === 0) {
+                                const base64 = Buffer.concat(chunks).toString('base64');
+                                logger_1.default.info(`ADB screencap successful for ${udid} (${base64.length} chars)`);
+                                resolve(base64);
+                            }
+                            else {
+                                reject(new Error(`ADB screencap failed with code ${code}`));
+                            }
+                        });
+                        proc.on('error', (err) => {
+                            logger_1.default.error(`ADB spawn error: ${err.message}`);
+                            reject(err);
+                        });
+                        // Safety timeout
+                        setTimeout(() => {
+                            proc.kill();
+                            reject(new Error('ADB Screenshot timeout after 15s'));
+                        }, 15000);
+                    });
+                }));
+                return screenshot;
+            }
+            catch (err) {
+                logger_1.default.error(`Failed to take screenshot for ${udid}: ${err instanceof Error ? err.message : err}`);
+                // Fallback: Try shell method with base64 conversion on device
+                try {
+                    logger_1.default.info(`Attempting fallback screenshot for ${udid}...`);
+                    const base64 = yield adb.adbExec(['-s', udid, 'shell', 'screencap', '-p', '|', 'base64']);
+                    return base64.replace(/\r?\n/g, '');
+                }
+                catch (fallbackErr) {
+                    logger_1.default.error(`Fallback screenshot also failed for ${udid}: ${fallbackErr instanceof Error ? fallbackErr.message : fallbackErr}`);
+                }
+                return '';
+            }
+        });
+    }
+    getLogs(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                return 'ADB is not available';
+            try {
+                // Get last 500 lines of logcat
+                return yield adbInstance.adbExec([
+                    '-s',
+                    udid,
+                    'shell',
+                    'logcat',
+                    '-d',
+                    '-t',
+                    '500',
+                    '-v',
+                    'threadtime',
+                ]);
+            }
+            catch (err) {
+                logger_1.default.warn(`Failed to fetch Android logs for ${udid}: ${err instanceof Error ? err.message : err}`);
+                return `Failed to fetch logs: ${err instanceof Error ? err.message : err}`;
+            }
+        });
+    }
+    checkHealth(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (device.cloud)
+                return { healthStatus: 'Healthy' };
+            try {
+                const adb = yield this.getAdbForDevice(device.udid);
+                const [bootCompleted, batteryInfo, storageInfo] = yield Promise.all([
+                    adb.adbExec(['-s', device.udid, 'shell', 'getprop', 'sys.boot_completed']),
+                    adb.adbExec(['-s', device.udid, 'shell', 'dumpsys', 'battery']),
+                    adb.adbExec(['-s', device.udid, 'shell', 'df', '-h', '/data']),
+                ]);
+                const isBooted = bootCompleted && bootCompleted.trim() === '1';
+                // Parse battery
+                const batteryLevelMatch = /level: (\d+)/.exec(batteryInfo);
+                const batteryLevel = batteryLevelMatch ? parseInt(batteryLevelMatch[1]) : undefined;
+                const batteryTempMatch = /temperature: (\d+)/.exec(batteryInfo);
+                const batteryTemp = batteryTempMatch ? parseInt(batteryTempMatch[1]) / 10 : undefined;
+                let thermalStatus = 'Normal';
+                if (batteryTemp && batteryTemp > 45)
+                    thermalStatus = 'Hot';
+                if (batteryTemp && batteryTemp > 55)
+                    thermalStatus = 'Critical';
+                // Parse storage
+                const storageLines = storageInfo.split(/\r?\n/);
+                let storageFree = 'Unknown';
+                if (storageLines.length > 1) {
+                    const fields = storageLines[1].trim().split(/\s+/);
+                    if (fields.length >= 4)
+                        storageFree = fields[3];
+                }
+                const healthData = {
+                    batteryLevel,
+                    thermalStatus,
+                    storageFree,
+                };
+                if (!isBooted) {
+                    return Object.assign(Object.assign({}, healthData), { healthStatus: 'Unhealthy', healthCheckError: `Device boot not completed. sys.boot_completed: ${bootCompleted}` });
+                }
+                if (batteryLevel !== undefined && batteryLevel < 10) {
+                    return Object.assign(Object.assign({}, healthData), { healthStatus: 'Unhealthy', healthCheckError: `Low battery: ${batteryLevel}%` });
+                }
+                if (thermalStatus === 'Critical') {
+                    return Object.assign(Object.assign({}, healthData), { healthStatus: 'Unhealthy', healthCheckError: `Critical thermal state: ${batteryTemp}°C` });
+                }
+                return Object.assign(Object.assign({}, healthData), { healthStatus: 'Healthy' });
+            }
+            catch (err) {
+                return {
+                    healthStatus: 'Unhealthy',
+                    healthCheckError: err instanceof Error ? err.message : String(err),
+                };
+            }
+        });
+    }
+    recoverHealth(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (device.cloud)
+                return true;
+            try {
+                logger_1.default.info(`🛡️ Attempting auto-recovery for Android device ${device.udid}...`);
+                const adb = yield this.getAdbForDevice(device.udid);
+                // Tier 1: Just log and hope it clears (for now)
+                // Tier 2: If low battery and not charging, or critical thermal, we can't do much but alert.
+                // Tier 3: If stuck booting or unresponsive, reboot.
+                if (device.healthStatus === 'Unhealthy') {
+                    if ((_a = device.healthCheckError) === null || _a === void 0 ? void 0 : _a.includes('boot not completed')) {
+                        logger_1.default.info(`Device ${device.udid} is stuck booting. Attempting hard reboot...`);
+                        yield adb.adbExec(['-s', device.udid, 'reboot']);
+                        return true;
+                    }
+                }
+                return true;
+            }
+            catch (err) {
+                logger_1.default.error(`Auto-recovery failed for ${device.udid}: ${err instanceof Error ? err.message : err}`);
+                return false;
+            }
+        });
+    }
+    executeShell(udid, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ALLOWED_COMMANDS = [
+                'ls',
+                'ps',
+                'top',
+                'dumpsys battery',
+                'dumpsys wifi',
+                'dumpsys power',
+                'whoami',
+                'getprop',
+                'pm list packages',
+                'ip addr',
+                'cat /proc/meminfo',
+                'cat /proc/cpuinfo',
+                'date',
+                'uptime',
+                'netstat',
+            ];
+            // Basic sanitation
+            const safeCommand = command.trim();
+            // Check if the command starts with any allowed prefix
+            const isAllowed = ALLOWED_COMMANDS.some((prefix) => safeCommand.startsWith(prefix));
+            if (!isAllowed) {
+                logger_1.default.warn(`Blocked potentially unsafe shell command on ${udid}: ${safeCommand}`);
+                throw new Error(`Command '${safeCommand}' is not allowed for security reasons.`);
+            }
+            // Split command into args for adbExec
+            // This is a naive split, but safe enough for the allowed commands which don't use complex quoting
+            const args = safeCommand.split(/\s+/);
+            logger_1.default.info(`Executing shell command on ${udid}: ${safeCommand}`);
+            const { adbInstance } = yield this.getAdb();
+            if (!adbInstance)
+                throw new Error('ADB is not available');
+            // Use device lock to ensure thread safety
+            return yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                // Direct raw shell execution might be better for piping, but adbExec is safer as it escapes args
+                // except we passed them as array, so standard child_process rules apply.
+                return yield adbInstance.adbExec(['-s', udid, 'shell', ...args], { timeout: 10000 });
+            }));
+        });
+    }
+};
+AndroidDeviceManager = __decorate([
+    (0, typedi_2.Service)(),
+    __metadata("design:paramtypes", [PluginContext_1.PluginContext])
+], AndroidDeviceManager);
+exports.default = AndroidDeviceManager;