feature: implement mobile-devices-controller-server

* feature: expose server

* feat: implement interaction with mobile-devices-controller-server

* fix(appium-server): should not trying to subscribe for device if alredy has

* fix(service-context): url encoding

* fix: stopDevice

* chore: merge

* fix: kill on process exit appium server and driver

* refactor(device-controlelr) : update subscribe.

* fix: retry for starting server and driver

Author: SvetoslavTsenov

index.d.ts

@@ -1,4 +1,6 @@
+import { IDeviceManager } from "./lib/interfaces/device-manager";
 export { AppiumDriver } from "./lib/appium-driver";
+export { AppiumServer } from "./lib/appium-server";
 export { ElementHelper } from "./lib/element-helper";
 export { UIElement } from "./lib/ui-element";
 export { Point } from "./lib/point";
@@ -7,6 +9,7 @@ export { Locator } from "./lib/locators";
 export { Direction } from "./lib/direction";
 export { DeviceManger } from "./lib/device-controller";
 export { IRectangle } from "./lib/interfaces/rectangle";
-export declare function startServer(port?: number): Promise<void>;
+export { IDeviceManager } from "./lib/interfaces/device-manager";
+export declare function startServer(port?: number, deviceManager?: IDeviceManager): Promise<void>;
 export declare function stopServer(): Promise<void>;
 export declare function createDriver(): Promise<any>;

index.ts

@@ -1,11 +1,12 @@
-import * as portastic from "portastic";
 import { AppiumServer } from "./lib/appium-server";
 import { AppiumDriver } from "./lib/appium-driver";
 import { ElementHelper } from "./lib/element-helper";
 import { NsCapabilities } from "./lib/ns-capabilities";
-import { shutdown } from "./lib/utils";
+import { IDeviceManager } from "./lib/interfaces/device-manager";
+import { shutdown, findFreePort } from "./lib/utils";
 
 export { AppiumDriver } from "./lib/appium-driver";
+export { AppiumServer } from "./lib/appium-server";
 export { ElementHelper } from "./lib/element-helper";
 export { UIElement } from "./lib/ui-element";
 export { Point } from "./lib/point";
@@ -14,52 +15,27 @@ export { Locator } from "./lib/locators";
 export { Direction } from "./lib/direction";
 export { DeviceManger } from "./lib/device-controller";
 export { IRectangle } from "./lib/interfaces/rectangle";
+export { IDeviceManager } from "./lib/interfaces/device-manager";
 
 const nsCapabilities = new NsCapabilities();
 const appiumServer = new AppiumServer(nsCapabilities);
 
 let appiumDriver = null;
-export async function startServer(port?: number) {
-    appiumServer.port = port || nsCapabilities.port;
-    let retry = false;
-    if (!appiumServer.port) {
-        appiumServer.port = (await portastic.find({ min: 8600, max: 9080 }))[0];
-        retry = true;
-    }
-
-    let hasStarted = await appiumServer.start();
-    let retryCount = 0;
-    while (retry && !hasStarted && retryCount < 10) {
-        let tempPort = appiumServer.port + 10;
-        tempPort = (await portastic.find({ min: tempPort, max: 9180 }))[0];
-        console.log("Trying to use port: ", tempPort);
-        appiumServer.port = tempPort;
-        hasStarted = await appiumServer.start();
-        retryCount++;
-    }
-
-    if (!hasStarted) {
-        throw new Error("Appium driver failed to start!!! Run with --verbose option for more info!");
-    }
-
-    appiumServer.hasStarted = hasStarted;
-
-    process.on("uncaughtException", () => shutdown(appiumServer.server, nsCapabilities.verbose));
-    process.on("exit", () => shutdown(appiumServer.server, nsCapabilities.verbose));
-    process.on("SIGINT", () => shutdown(appiumServer.server, nsCapabilities.verbose));
+export async function startServer(port?: number, deviceManager?: IDeviceManager) {
+    await appiumServer.start(port || 8300, deviceManager);
 };
 
 export async function stopServer() {
     if (appiumDriver !== null && appiumDriver.isAlive) {
         await appiumDriver.quit();
     }
-    if (appiumServer !== null && appiumServer.hasStarted) {
+    if (appiumServer !== null && appiumServer.server && !appiumServer.server.killed) {
         await appiumServer.stop();
     }
 };
 
 export async function createDriver() {
-    if (!appiumServer.hasStarted) {
+    if (!appiumServer.server) {
         throw new Error("Server is not available!");
     }
     if (!nsCapabilities.appiumCapsLocation) {
@@ -79,3 +55,15 @@ export async function createDriver() {
 
     return appiumDriver;
 }
+
+const killProcesses = async (code) => {
+    if (appiumServer) {
+        return await stopServer();
+    }
+}
+
+process.on("exit", async (code) => await killProcesses(code));
+process.on("close", async (code) => await killProcesses(code));
+process.on("SIGINT", async (code) => await killProcesses(code));
+process.on("error", async (code) => await killProcesses(code));
+process.on("uncaughtException", () => async (code) => await killProcesses(code));

lib/appium-driver.d.ts

@@ -131,6 +131,7 @@ export declare class AppiumDriver {
     logScreenshot(fileName: string): Promise<string>;
     logPageSource(fileName: string): Promise<void>;
     static createAppiumDriver(port: number, args: INsCapabilities): Promise<AppiumDriver>;
+    private static applyAdditionalSettings(args);
     resetApp(): Promise<void>;
     init(): Promise<void>;
     quit(): Promise<void>;

lib/appium-driver.ts

@@ -10,6 +10,8 @@ import { SearchOptions } from "./search-options";
 import { UIElement } from "./ui-element";
 import { Direction } from "./direction";
 import { Locator } from "./locators";
+import { Platform } from "mobile-devices-controller";
+import { ServiceContext } from "./service/service-context";
 import {
     addExt,
     log,
@@ -21,6 +23,7 @@ import {
     getReportPath,
     calculateOffset,
     scroll,
+    findFreePort
 } from "./utils";
 import { INsCapabilities } from "./interfaces/ns-capabilities";
 import { IRectangle } from "./interfaces/rectangle";
@@ -410,6 +413,8 @@ export class AppiumDriver {
 
         log("Creating driver!", args.verbose);
 
+        args.appiumCaps['udid'] = args.appiumCaps['udid'] || args.device.token;
+        await AppiumDriver.applyAdditionalSettings(args);
         const _webio = webdriverio.remote({
             baseUrl: driverConfig.host,
             port: driverConfig.port,
@@ -419,10 +424,41 @@ export class AppiumDriver {
 
         const driver = await wd.promiseChainRemote(driverConfig);
         AppiumDriver.configureLogging(driver, args.verbose);
-        await driver.init(args.appiumCaps);
+        let hasStarted = false;
+        let retries = 10;
+        while (retries > 0 && !hasStarted) {
+            try {
+                const test = await driver.init(args.appiumCaps);
+                hasStarted = true;
+            } catch (error) {
+                if (error && error.message && error.message.includes("WebDriverAgent")) {
+                    let freePort = await findFreePort(10, args.appiumCaps.port, args);
+                    console.log(" args.appiumCaps['wdaLocalPort']", freePort)
+                    args.appiumCaps["wdaLocalPort"] = freePort;
+                }
+                console.log(error);
+            }
+            retries--;
+        }
+
         return new AppiumDriver(driver, wd, _webio, driverConfig, args);
     }
 
+    private static async applyAdditionalSettings(args) {
+        if (args.appiumCaps.platformName.toLowerCase() === Platform.IOS) {
+            args.appiumCaps["useNewWDA"] = false;
+            args.appiumCaps["wdaStartupRetries"] = 5;
+            args.appiumCaps["shouldUseSingletonTestManager"] = false;
+
+            // It looks we need it for XCTest (iOS 10+ automation)
+            if (args.appiumCaps.platformVersion >= 10) {
+                let freePort = await findFreePort(10, (parseInt(args.appiumCaps["wdaLocalPort"])) || 8400, args);
+                console.log(" args.appiumCaps['wdaLocalPort']", freePort)
+                args.appiumCaps["wdaLocalPort"] = freePort;
+            }
+        }
+    }
+
     public async resetApp() {
         await this._driver.resetApp();
     }

lib/appium-server.d.ts

@@ -1,19 +1,21 @@
 /// <reference types="node" />
 import * as child_process from "child_process";
 import { INsCapabilities } from "./interfaces/ns-capabilities";
+import { IDeviceManager } from "./interfaces/device-manager";
 export declare class AppiumServer {
     private _args;
     private _server;
     private _appium;
     private _port;
     private _runType;
     private _hasStarted;
+    private _deviceManager;
     constructor(_args: INsCapabilities);
     port: number;
     runType: string;
     readonly server: child_process.ChildProcess;
     hasStarted: boolean;
-    start(): Promise<boolean>;
+    start(port: any, deviceManager?: IDeviceManager): Promise<boolean>;
     stop(): Promise<{}>;
     private resolveAppiumDependency();
 }

lib/appium-server.ts

@@ -1,14 +1,26 @@
 import * as child_process from "child_process";
-import { log, resolve, waitForOutput, shutdown, fileExists, isWin, executeCommand } from "./utils";
+import {
+    log,
+    resolve,
+    waitForOutput,
+    shutdown,
+    fileExists,
+    isWin,
+    executeCommand,
+    findFreePort
+} from "./utils";
 import { INsCapabilities } from "./interfaces/ns-capabilities";
+import { IDeviceManager } from "./interfaces/device-manager";
 import { DeviceManger } from "./device-controller";
+import { ServiceContext } from "../lib/service/service-context";
 
 export class AppiumServer {
     private _server: child_process.ChildProcess;
     private _appium;
     private _port: number;
     private _runType: string;
     private _hasStarted: boolean;
+    private _deviceManager: IDeviceManager;
 
     constructor(private _args: INsCapabilities) {
         this._runType = this._args.runType;
@@ -44,23 +56,38 @@ export class AppiumServer {
         this._hasStarted = hasStarted;
     }
 
-    public async start() {
-        const device = await DeviceManger.startDevice(this._args);
+    public async start(port, deviceManager: IDeviceManager = new DeviceManger(port)) {
+        this._deviceManager = deviceManager;
+        if (!this._args.device) {
+            const device = await this._deviceManager.startDevice(this._args);
+            this._args.device = device;
+        }
         log("Starting server...", this._args.verbose);
-        this._args.device = device;
         const logLevel = this._args.verbose === true ? "debug" : "info";
-        this._server = child_process.spawn(this._appium, ["-p", this.port.toString(), "--log-level", logLevel], {
-            shell: true,
-            detached: false
-        });
-
-        const response: boolean = await waitForOutput(this._server, /listener started/, /Error: listen/, 60000, this._args.verbose);
+        this.port = port || this._args.port;
+        let retry = false;
+
+        let response: boolean = false;
+        let retries = 11;
+        while (retries > 0 && !response) {
+            retries--;
+            this.port = (await findFreePort(100, this.port, this._args));
+
+            this._server = child_process.spawn(this._appium, ["-p", this.port.toString(), "--log-level", logLevel], {
+                shell: true,
+                detached: false
+            });
+            response = await waitForOutput(this._server, /listener started/, /Error: listen/, 60000, this._args.verbose);
+            if (!response) {
+                this.port += 10;
+            }
+        }
 
         return response;
     }
 
     public async stop() {
-        await DeviceManger.stop(this._args);
+        await this._deviceManager.stopDevice(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);

lib/device-controller.d.ts

@@ -1,10 +1,13 @@
 import { INsCapabilities } from "./interfaces/ns-capabilities";
+import { IDeviceManager } from "./interfaces/device-manager";
+import { ServiceContext } from "./service/service-context";
 import { IDevice } from "mobile-devices-controller";
-export declare class DeviceManger {
+export declare class DeviceManger implements IDeviceManager {
+    private _serveiceContext;
     private static _emulators;
-    static startDevice(args: INsCapabilities): Promise<IDevice>;
-    static stop(args: INsCapabilities): Promise<void>;
+    constructor(port: any, _serveiceContext?: ServiceContext);
+    startDevice(args: INsCapabilities): Promise<IDevice>;
+    stopDevice(args: INsCapabilities): Promise<void>;
     static kill(device: IDevice): Promise<void>;
     private static getDefaultDevice(args);
-    private static device(runType);
 }