refactor: change emulator and simulator managers with mobile-devices-controller

* Implement devices controller

* Update to new mobile-device-controller

* Include mobile-devices-controller in device-controller

Author: SvetoslavTsenov

index.d.ts

@@ -5,7 +5,7 @@ export { Point } from "./lib/point";
 export { SearchOptions } from "./lib/search-options";
 export { Locator } from "./lib/locators";
 export { Direction } from "./lib/direction";
-export { EmulatorManager } from "./lib/emulator-manager";
+export { DeviceController } from "./lib/device-controller";
 export declare function startServer(port?: number): Promise<void>;
 export declare function stopServer(): Promise<void>;
 export declare function createDriver(): Promise<any>;

index.ts

@@ -12,7 +12,7 @@ export { Point } from "./lib/point";
 export { SearchOptions } from "./lib/search-options";
 export { Locator } from "./lib/locators";
 export { Direction } from "./lib/direction";
-export { EmulatorManager } from "./lib/emulator-manager";
+export { DeviceController } from "./lib/device-controller";
 
 const nsCapabilities = new NsCapabilities();
 const appiumServer = new AppiumServer(nsCapabilities);

lib/appium-driver.ts

@@ -365,7 +365,7 @@ export class AppiumDriver {
             }
 
             driverConfig = "https://" + sauceUser + ":" + sauceKey + "@ondemand.saucelabs.com:443/wd/hub";
-            
+
 
             args.appiumCaps.app = "sauce-storage:" + args.appPath;
             console.log("Using Sauce Labs. The application path is changed to: " + args.appPath);
@@ -400,7 +400,10 @@ export class AppiumDriver {
         console.log("Killing driver");
         try {
             await this._driver.quit();
+            await this._driver.quit();
+            await this._webio.quit();
         } catch (error) {
+            console.log("", error);
         }
         this._isAlive = false;
         console.log("Driver is dead");

lib/appium-server.ts

@@ -1,8 +1,7 @@
 import * as child_process from "child_process";
 import { log, resolve, waitForOutput, shutdown, fileExists, isWin, executeCommand } from "./utils";
 import { INsCapabilities } from "./ins-capabilities";
-import { SimulatorManager } from "./simulator-manager";
-import { EmulatorManager } from "./emulator-manager";
+import { DeviceController } from "./device-controller";
 
 export class AppiumServer {
     private _server: child_process.ChildProcess;
@@ -46,16 +45,9 @@ export class AppiumServer {
     }
 
     public async start() {
-
-        if (this._args.appiumCaps.platformName.toLowerCase() === "android") {
-            await EmulatorManager.startEmulator(this._args);
-        }
-
-        if (!this._args.isSauceLab && this._args.appiumCaps.platformName.toLowerCase().includes("ios")) {
-            await SimulatorManager.startDevice(this._args);
-        }
-
+        const device = await DeviceController.startDevice(this._args)
         log("Starting server...", this._args.verbose);
+        this._args.appiumCaps["udid"] = device.token;
         const logLevel = this._args.verbose === true ? "debug" : "info";
         this._server = child_process.spawn(this._appium, ["-p", this.port.toString(), "--log-level", logLevel], {
             shell: true,
@@ -68,15 +60,7 @@ export class AppiumServer {
     }
 
     public async stop() {
-
-        if (this._args.appiumCaps.platformName.toLowerCase() === "android") {
-            await EmulatorManager.stop(this._args);
-        }
-
-        if (!this._args.isSauceLab && !this._args.reuseDevice && this._args.appiumCaps.platformName.toLowerCase().includes("ios")) {
-            await SimulatorManager.stop(this._args);
-        }
-
+        await DeviceController.stop(this._args);
         return new Promise((resolve, reject) => {
             this._server.on("close", (code, signal) => {
                 log(`Appium terminated due signal: ${signal} and code: ${code}`, this._args.verbose);
@@ -102,10 +86,12 @@ export class AppiumServer {
             try {
                 if (isWin) {
                     shutdown(this._server, this._args.verbose);
-                    this._server.kill("SIGINT");                    
+                    this._server.kill("SIGINT");
+                    this._server.kill("SIGINT");
                 } else {
                     this._server.kill("SIGINT");
                     this._server.kill("SIGINT");
+                    this._server.kill("SIGKILL");
                     shutdown(this._server, this._args.verbose);
                 }
             } catch (error) {

lib/device-controller.d.ts

@@ -0,0 +1,10 @@
+import { INsCapabilities } from "./ins-capabilities";
+import { IDevice } from "mobile-devices-controller";
+export declare class DeviceController {
+    private static _emulators;
+    static startDevice(args: INsCapabilities): Promise<IDevice>;
+    static stop(args: INsCapabilities): Promise<void>;
+    static kill(device: IDevice): Promise<void>;
+    private static device(runType);
+    private static getDevicesByStatus(devices, status);
+}

lib/device-controller.ts

@@ -0,0 +1,89 @@
+import { waitForOutput, resolve, log, isWin, shutdown, executeCommand } from "./utils";
+import * as child_process from "child_process";
+import { INsCapabilities } from "./ins-capabilities";
+
+import {
+    DeviceManager,
+    AndroidManager,
+    IOSManager,
+    IDevice,
+    Platform,
+    Status
+} from "mobile-devices-controller";
+
+
+export class DeviceController {
+    private static _emulators: Map<string, IDevice> = new Map();
+
+    public static async startDevice(args: INsCapabilities) {
+        const devices = (await DeviceManager.getAllDevices(args.appiumCaps.platformName.toLowerCase(), args.appiumCaps.deviceName));
+        if (!devices || devices === null || devices.size) {
+            console.log("Available devices:\n", devices);
+            throw new Error(`No such device ${args.appiumCaps.deviceName}!!!\n Check availabe emulators!!!`);
+        }
+
+        let device: IDevice;
+        // Should find new device
+        if (!args.reuseDevice) {
+            device = DeviceController.getDevicesByStatus(devices, Status.SHUTDOWN);
+        }
+
+        // If there is no  shutdown device
+        if (!device || device === null) {
+            device = DeviceController.getDevicesByStatus(devices, Status.BOOTED);
+        }
+
+        // If there is no booted device
+        if (!device || device === null) {
+            device = DeviceController.getDevicesByStatus(devices, Status.FREE);
+        }
+
+        // In case reuse device is true but there weren't any booted devices. We need to fall back and boot new one.
+        if (!device || device === null && args.reuseDevice) {
+            device = DeviceController.getDevicesByStatus(devices, Status.SHUTDOWN);
+        }
+        
+        if (device.status === Status.SHUTDOWN) {
+            await DeviceManager.startDevice(device);
+            console.log("Started device: ", device);
+        } else {
+            console.log("Device is alredy started", device);
+            if (!args.reuseDevice) {
+                DeviceController.kill(device);
+                await DeviceManager.startDevice(device);
+            }
+        }
+
+        DeviceController._emulators.set(args.runType, device);
+
+        return device;
+    }
+
+    public static async stop(args: INsCapabilities) {
+        if (DeviceController._emulators.has(args.runType) && !args.reuseDevice) {
+            const device = DeviceController._emulators.get(args.runType);
+            await DeviceManager.kill(device);
+        }
+    }
+
+    public static async kill(device: IDevice) {
+        await DeviceManager.kill(device);
+    }
+
+    private static device(runType) {
+        return DeviceController._emulators.get(runType);
+    }
+
+    private static getDevicesByStatus(devices: Array<IDevice>, status) {
+        let device: IDevice;
+        const shutdownDeivces = devices.filter(dev => {
+            return dev.status === status;
+        });
+
+        if (shutdownDeivces && shutdownDeivces !== null && shutdownDeivces.length > 0) {
+            device = shutdownDeivces[0];
+        }
+
+        return device;
+    }
+}