encodeImageToBase64,

ensureReportsDirExists,

checkImageLogType,

adbShellCommand

adbShellCommand,

logWarn

} from "./utils";

import { INsCapabilities } from "./interfaces/ns-capabilities";

}

public async navBack() {

if (this.isAndroid) {

logInfo("=== Navigate back with hardware button!");

} else {

logInfo("=== Navigate back.");

}

return await this._driver.back();

}

prepareApp(args);

if (!args.device) {

if (args.isAndroid) {

args.device = DeviceManager.getDefaultDevice(args, sessionInfo.capabilities.desired.deviceName, sessionInfo.capabilities.deviceUDID.replace("emulator-", ""), sessionInfo.capabilities.deviceUDID.includes("emulator") ? DeviceType.EMULATOR : DeviceType.SIMULATOR, sessionInfo.capabilities.desired.platformVersion || sessionInfo.capabilities.platformVersion);

args.device = DeviceManager.getDefaultDevice(args, sessionInfo.capabilities.desired.deviceName, sessionInfo.capabilities.deviceUDID.replace("emulator-", ""), sessionInfo.capabilities.deviceUDID.includes("emulator") ? DeviceType.EMULATOR : DeviceType.SIMULATOR, sessionInfo.capabilities.deviceApiLevel || sessionInfo.capabilities.platformVersion);

} else {

args.device = DeviceManager.getDefaultDevice(args);

}

}

} catch (error) {

args.verbose = true;

console.log("===============================");

console.log("", error)

if (!args.ignoreDeviceController && error && error.message && error.message.includes("Failure [INSTALL_FAILED_INSUFFICIENT_STORAGE]")) {

await DeviceManager.kill(args.device);

await DeviceController.startDevice(args.device);

console.log("Retry launching appium driver!");

hasStarted = false;

if (error && error.message && error.message.includes("WebDriverAgent")) {

const freePort = await findFreePort(100, args.wdaLocalPort);

console.log("args.appiumCaps['wdaLocalPort']", freePort);

args.appiumCaps["wdaLocalPort"] = freePort;

}

// if (error && error.message && error.message.includes("WebDriverAgent")) {

// const freePort = await findFreePort(100, args.wdaLocalPort);

// console.log("args.appiumCaps['wdaLocalPort']", freePort);

// args.appiumCaps["wdaLocalPort"] = freePort;

// }

}

if (hasStarted) {

public async scroll(direction: Direction, y: number, x: number, yOffset: number, xOffset: number = 0) {

await scroll(this._wd, this._driver, direction, this._webio.isIOS, y, x, yOffset, xOffset,this._args.verbose);

await scroll(this._wd, this._driver, direction, this._webio.isIOS, y, x, yOffset, xOffset);

}

/**

while ((el === null || !isDisplayed) && retryCount > 0) {

try {

el = await element();

isDisplayed = await el.isDisplayed();

isDisplayed = el&&await el.isDisplayed();

if (!isDisplayed) {

await scroll(this._wd, this._driver, direction, this._webio.isIOS, startPoint.y, startPoint.x, offsetPoint.x, offsetPoint.y,this._args.verbose);

await scroll(this._wd, this._driver, direction, this._webio.isIOS, startPoint.y, startPoint.x, offsetPoint.y, offsetPoint.x);

el = null;

}

} catch (error) {

console.log("scrollTo Error: " + error);

await scroll(this._wd, this._driver, direction, this._webio.isIOS, startPoint.y, startPoint.x, offsetPoint.y, offsetPoint.x);

el = null;

}

retryCount--;

}

}

private static async applyAdditionalSettings(args) {

private static async applyAdditionalSettings(args: INsCapabilities) {

if (args.isSauceLab) return;

args.appiumCaps['udid'] = args.appiumCaps['udid'] || args.device.token;

args.appiumCaps["wdaStartupRetries"] = 5;

args.appiumCaps["shouldUseSingletonTestManager"] = args.appiumCaps.shouldUseSingletonTestManager;

if (args.derivedDataPath) {

args.appiumCaps["derivedDataPath"] = `${args.derivedDataPath}/${args.device.token}`;

logWarn('Changed derivedDataPath to: ', args.appiumCaps["derivedDataPath"]);

}

// It looks we need it for XCTest (iOS 10+ automation)

if (args.appiumCaps.platformVersion >= 10 && args.wdaLocalPort) {

console.log(`args.appiumCaps['wdaLocalPort']: ${args.wdaLocalPort}`);

private startAppiumServer(logLevel: string, isSauceLab: boolean) {

const startingServerArgs: Array<string> = isSauceLab ? ["--log-level", logLevel] : ["-p", this.port.toString(), "--log-level", logLevel];

if (this._args.isAndroid&&this._args.ignoreDeviceController&&!this._args.isSauceLab) {

if (this._args.isAndroid) {

this._args.relaxedSecurity ? startingServerArgs.push("--relaxed-security") : console.log("'relaxedSecurity' is not enabled!\nTo enabled it use '--relaxedSecurity'!");

}

type: type,

platform: args.appiumCaps.platformName.toLowerCase(),

token: token,

apiLevel: platformVersion || args.appiumCaps.platformVersion,

apiLevel: platformVersion || args.appiumCaps.deviceApiLevel||args.appiumCaps.platformVersion,

config: { "density": args.appiumCaps.density, "offsetPixels": args.appiumCaps.offsetPixels }

}

const sizeArr = sessionInfoDetails.deviceScreenSize.split("x");

args.device.deviceScreenSize = { width: sizeArr[0], height: sizeArr[1] };

args.device.apiLevel = sessionInfoDetails.deviceApiLevel;

args.device.apiLevel = sessionInfoDetails.deviceApiLevel||args.device.apiLevel;

args.device.deviceScreenDensity = sessionInfoDetails.deviceScreenDensity / 100;

args.device.config = { "density": args.device.deviceScreenDensity || args.device.config.density, "offsetPixels": +sessionInfoDetails.statBarHeight || args.device.config.offsetPixels };

} else {

args.device.statBarHeight = sessionInfoDetails.statBarHeight;

args.device.viewportRect = DeviceManager.convertViewportRectToIRectangle(sessionInfoDetails.viewportRect);

args.device.token = args.device.token || sessionInfoDetails.udid;

return args.device;

}

const status = value ? 1 : 0;

try {

if (args.isAndroid) {

if (!args.ignoreDeviceController) {

AndroidController.setDontKeepActivities(value, args.device);

} else if (args.relaxedSecurity) {

if (args.relaxedSecurity) {

const output = await DeviceManager.executeShellCommand(driver, { command: "settings", args: ['put', 'global', 'always_finish_activities', status] });

console.log(`Output from setting always_finish_activities to ${status}: ${output}`);

//check if set

const check = await DeviceManager.executeShellCommand(driver, { command: "settings", args: ['get', 'global', 'always_finish_activities'] });

console.info(`Check if always_finish_activities is set correctly: ${check}`);

} else if (!args.ignoreDeviceController) {

AndroidController.setDontKeepActivities(value, args.device);

}

} else {

// Do nothing for iOS ...

export declare constenum Direction {

export declare enum Direction {

down = 0,

up = 1,

left = 2,

export constenum Direction {

export enum Direction {

down,

up,

left,

import { ITestReporter } from "./test-reporter";

import { LogImageType } from "../enums/log-image-type";

export interface INsCapabilitiesArgs {

derivedDataPath?: string;

port?: number;

wdaLocalPort?: number;

projectDir?: string;

import { LogImageType } from "../enums/log-image-type";

export interface INsCapabilitiesArgs {

derivedDataPath?: string;

port?: number;

wdaLocalPort?: number;

projectDir?: string;

deviceTypeOrPlatform: string;

driverConfig: any;

logImageTypes: Array<LogImageType>;

derivedDataPath: string;

constructor(_parser: INsCapabilitiesArgs);

readonly isAndroid: any;

readonly isIOS: boolean;

public deviceTypeOrPlatform: string;

public driverConfig: any;

public logImageTypes: Array<LogImageType>;

public derivedDataPath: string;

constructor(private _parser: INsCapabilitiesArgs) {

this.projectDir = this._parser.projectDir;

this.isSauceLab = this._parser.isSauceLab;

this.ignoreDeviceController = this._parser.ignoreDeviceController;

this.wdaLocalPort = this._parser.wdaLocalPort;

this.derivedDataPath = this._parser.derivedDataPath;

this.path = this._parser.path;

this.capabilitiesName = this._parser.capabilitiesName;

this.imagesPath = this._parser.imagesPath;

import { LogImageType } from "./enums/log-image-type";

export declare const projectDir: string, projectBinary: string, pluginRoot: string, pluginBinary: string, port: number, verbose: boolean, appiumCapsLocation: string, testFolder: string, runType: string, isSauceLab: boolean, appPath: string, storage: string, testReports: string, devMode: boolean, ignoreDeviceController: boolean, wdaLocalPort: number, path: string, relaxedSecurity: boolean, cleanApp: boolean, attachToDebug: boolean, sessionId: string, startSession: boolean, capabilitiesName: string, imagesPath: string, startDeviceOptions: string, deviceTypeOrPlatform: string, device: any, driverConfig: any, logImageTypes: LogImageType[], appiumCaps: any;

export declare const projectDir: string, projectBinary: string, pluginRoot: string, pluginBinary: string, port: number, verbose: boolean, appiumCapsLocation: string, testFolder: string, runType: string, isSauceLab: boolean, appPath: string, storage: string, testReports: string, devMode: boolean, ignoreDeviceController: boolean, wdaLocalPort: number, derivedDataPath: string,path: string, relaxedSecurity: boolean, cleanApp: boolean, attachToDebug: boolean, sessionId: string, startSession: boolean, capabilitiesName: string, imagesPath: string, startDeviceOptions: string, deviceTypeOrPlatform: string, device: any, driverConfig: any, logImageTypes: LogImageType[], appiumCaps: any;