appium-espresso-driver 1.46.0

package/build/lib/driver.js

@@ -0,0 +1,475 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.EspressoDriver = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _appiumBaseDriver = require("appium-base-driver");
+
+var _espressoRunner = require("./espresso-runner");
+
+var _appiumSupport = require("appium-support");
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+var _commands = _interopRequireDefault(require("./commands"));
+
+var _appiumAdb = require("appium-adb");
+
+var _appiumAndroidDriver = require("appium-android-driver");
+
+var _desiredCaps = _interopRequireDefault(require("./desired-caps"));
+
+var _package = require("../../package.json");
+
+var _portscanner = require("portscanner");
+
+var _asyncbox = require("asyncbox");
+
+var _utils = require("./utils");
+
+const helpers = _appiumAndroidDriver.androidHelpers;
+const SYSTEM_PORT_RANGE = [8300, 8399];
+const DEVICE_PORT = 6791;
+const NO_PROXY = [['GET', new RegExp('^/session/(?!.*/)')], ['GET', new RegExp('^/session/[^/]+/appium/device/current_activity')], ['GET', new RegExp('^/session/[^/]+/appium/device/current_package')], ['GET', new RegExp('^/session/[^/]+/appium/device/display_density')], ['GET', new RegExp('^/session/[^/]+/appium/device/is_keyboard_shown')], ['GET', new RegExp('^/session/[^/]+/appium/device/system_bars')], ['GET', new RegExp('^/session/[^/]+/appium/device/system_time')], ['GET', new RegExp('^/session/[^/]+/appium/settings')], ['GET', new RegExp('^/session/[^/]+/context')], ['GET', new RegExp('^/session/[^/]+/contexts')], ['GET', new RegExp('^/session/[^/]+/ime/[^/]+')], ['GET', new RegExp('^/session/[^/]+/log/types')], ['GET', new RegExp('^/session/[^/]+/network_connection')], ['GET', new RegExp('^/session/[^/]+/timeouts')], ['GET', new RegExp('^/session/[^/]+/url')], ['POST', new RegExp('^/session/[^/]+/appium/app/background')], ['POST', new RegExp('^/session/[^/]+/appium/app/close')], ['POST', new RegExp('^/session/[^/]+/appium/app/launch')], ['POST', new RegExp('^/session/[^/]+/appium/app/reset')], ['POST', new RegExp('^/session/[^/]+/appium/app/strings')], ['POST', new RegExp('^/session/[^/]+/appium/compare_images')], ['POST', new RegExp('^/session/[^/]+/appium/device/activate_app')], ['POST', new RegExp('^/session/[^/]+/appium/device/app_installed')], ['POST', new RegExp('^/session/[^/]+/appium/device/app_state')], ['POST', new RegExp('^/session/[^/]+/appium/device/get_clipboard')], ['POST', new RegExp('^/session/[^/]+/appium/device/install_app')], ['POST', new RegExp('^/session/[^/]+/appium/device/is_locked')], ['POST', new RegExp('^/session/[^/]+/appium/device/lock')], ['POST', new RegExp('^/session/[^/]+/appium/device/pull_file')], ['POST', new RegExp('^/session/[^/]+/appium/device/pull_folder')], ['POST', new RegExp('^/session/[^/]+/appium/device/push_file')], ['POST', new RegExp('^/session/[^/]+/appium/device/remove_app')], ['POST', new RegExp('^/session/[^/]+/appium/device/start_activity')], ['POST', new RegExp('^/session/[^/]+/appium/device/terminate_app')], ['POST', new RegExp('^/session/[^/]+/appium/device/unlock')], ['POST', new RegExp('^/session/[^/]+/appium/getPerformanceData')], ['POST', new RegExp('^/session/[^/]+/appium/performanceData/types')], ['POST', new RegExp('^/session/[^/]+/appium/settings')], ['POST', new RegExp('^/session/[^/]+/appium/execute_driver')], ['POST', new RegExp('^/session/[^/]+/appium/start_recording_screen')], ['POST', new RegExp('^/session/[^/]+/appium/stop_recording_screen')], ['POST', new RegExp('^/session/[^/]+/context')], ['POST', new RegExp('^/session/[^/]+/execute')], ['POST', new RegExp('^/session/[^/]+/execute/async')], ['POST', new RegExp('^/session/[^/]+/execute/sync')], ['POST', new RegExp('^/session/[^/]+/execute_async')], ['POST', new RegExp('^/session/[^/]+/ime/[^/]+')], ['POST', new RegExp('^/session/[^/]+/location')], ['POST', new RegExp('^/session/[^/]+/log')], ['POST', new RegExp('^/session/[^/]+/network_connection')], ['POST', new RegExp('^/session/[^/]+/timeouts')], ['POST', new RegExp('^/session/[^/]+/url')]];
+const CHROME_NO_PROXY = [['GET', new RegExp('^/session/[^/]+/appium')], ['GET', new RegExp('^/session/[^/]+/context')], ['GET', new RegExp('^/session/[^/]+/element/[^/]+/rect')], ['GET', new RegExp('^/session/[^/]+/orientation')], ['POST', new RegExp('^/session/[^/]+/appium')], ['POST', new RegExp('^/session/[^/]+/context')], ['POST', new RegExp('^/session/[^/]+/orientation')], ['POST', new RegExp('^/session/[^/]+/touch/multi/perform')], ['POST', new RegExp('^/session/[^/]+/touch/perform')], ['POST', new RegExp('^/session/[^/]+/execute$')], ['POST', new RegExp('^/session/[^/]+/execute/sync')]];
+const APP_EXTENSION = '.apk';
+
+class EspressoDriver extends _appiumBaseDriver.BaseDriver {
+  constructor(opts = {}, shouldValidateCaps = true) {
+    delete opts.shell;
+    super(opts, shouldValidateCaps);
+    this.locatorStrategies = ['id', 'class name', 'accessibility id'];
+    this.desiredCapConstraints = _desiredCaps.default;
+    this.espresso = null;
+    this.jwpProxyActive = false;
+    this.defaultIME = null;
+    this.jwpProxyAvoid = NO_PROXY;
+    this.apkStrings = {};
+    this.settings = new _appiumBaseDriver.DeviceSettings({}, this.onSettingsUpdate.bind(this));
+    this.chromedriver = null;
+    this.sessionChromedrivers = {};
+  }
+
+  async createSession(...args) {
+    try {
+      let [sessionId, caps] = await super.createSession(...args);
+      let serverDetails = {
+        platform: 'LINUX',
+        webStorageEnabled: false,
+        takesScreenshot: true,
+        javascriptEnabled: true,
+        databaseEnabled: false,
+        networkConnectionEnabled: true,
+        locationContextEnabled: false,
+        warnings: {},
+        desired: Object.assign({}, this.caps)
+      };
+      this.caps = Object.assign(serverDetails, this.caps);
+      this.curContext = this.defaultContextName();
+      let defaultOpts = {
+        fullReset: false,
+        autoLaunch: true,
+        adbPort: _appiumAdb.DEFAULT_ADB_PORT,
+        androidInstallTimeout: 90000
+      };
+
+      _lodash.default.defaults(this.opts, defaultOpts);
+
+      if (this.isChromeSession) {
+        if (this.opts.app) {
+          _logger.default.warn(`
+            'browserName' capability will be ignored.
+            Chrome browser cannot be run in Espresso sessions because Espresso automation doesn't have permission to access Chrome.
+          `);
+        } else {
+          _logger.default.errorAndThrow(`Chrome browser sessions cannot be run in Espresso because Espresso automation doesn't have permission to access Chrome`);
+        }
+      }
+
+      if (this.opts.reboot) {
+        this.setAvdFromCapabilities(caps);
+        this.addWipeDataToAvdArgs();
+      }
+
+      if (this.opts.app) {
+        this.opts.app = await this.helpers.configureApp(this.opts.app, APP_EXTENSION);
+        await this.checkAppPresent();
+      } else if (this.appOnDevice) {
+        _logger.default.info(`App file was not listed, instead we're going to run ` + `${this.opts.appPackage} directly on the device`);
+
+        await this.checkPackagePresent();
+      }
+
+      this.opts.systemPort = this.opts.systemPort || (await (0, _portscanner.findAPortNotInUse)(SYSTEM_PORT_RANGE[0], SYSTEM_PORT_RANGE[1]));
+      this.opts.adbPort = this.opts.adbPort || _appiumAdb.DEFAULT_ADB_PORT;
+      await this.startEspressoSession();
+      return [sessionId, caps];
+    } catch (e) {
+      await this.deleteSession();
+      e.message += '. Check https://github.com/appium/appium-espresso-driver#troubleshooting regarding advanced session startup troubleshooting.';
+
+      if ((0, _appiumBaseDriver.isErrorType)(e, _appiumBaseDriver.errors.SessionNotCreatedError)) {
+        throw e;
+      }
+
+      const err = new _appiumBaseDriver.errors.SessionNotCreatedError(e.message);
+      err.stack = e.stack;
+      throw err;
+    }
+  }
+
+  get driverData() {
+    return {};
+  }
+
+  isEmulator() {
+    return helpers.isEmulator(this.adb, this.opts);
+  }
+
+  setAvdFromCapabilities(caps) {
+    if (this.opts.avd) {
+      _logger.default.info('avd name defined, ignoring device name and platform version');
+    } else {
+      if (!caps.deviceName) {
+        _logger.default.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
+      }
+
+      if (!caps.platformVersion) {
+        _logger.default.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
+      }
+
+      let avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');
+      this.opts.avd = `${avdDevice}__${caps.platformVersion}`;
+    }
+  }
+
+  addWipeDataToAvdArgs() {
+    if (!this.opts.avdArgs) {
+      this.opts.avdArgs = '-wipe-data';
+    } else if (!this.opts.avdArgs.toLowerCase().includes('-wipe-data')) {
+      this.opts.avdArgs += ' -wipe-data';
+    }
+  }
+
+  async startEspressoSession() {
+    _logger.default.info(`EspressoDriver version: ${_package.version}`);
+
+    let {
+      udid,
+      emPort
+    } = await helpers.getDeviceInfoFromCaps(this.opts);
+    this.opts.udid = udid;
+    this.opts.emPort = emPort;
+    this.adb = await _appiumAndroidDriver.androidHelpers.createADB(this.opts);
+
+    if ((await this.adb.getApiLevel()) >= 28) {
+      _logger.default.warn('Relaxing hidden api policy');
+
+      await this.adb.setHiddenApiPolicy('1', !!this.opts.ignoreHiddenApiPolicyError);
+    }
+
+    let appInfo = await helpers.getLaunchInfo(this.adb, this.opts);
+
+    if (appInfo) {
+      Object.assign(this.opts, appInfo);
+    } else {
+      appInfo = this.opts;
+    }
+
+    await helpers.initDevice(this.adb, this.opts);
+
+    if (await this.adb.isAnimationOn()) {
+      try {
+        await this.adb.setAnimationState(false);
+        this.wasAnimationEnabled = true;
+      } catch (err) {
+        _logger.default.warn(`Unable to turn off animations: ${err.message}`);
+      }
+    }
+
+    this.caps.deviceName = this.adb.curDeviceId;
+    this.caps.deviceUDID = this.opts.udid;
+    this.initEspressoServer();
+
+    _logger.default.debug(`Forwarding Espresso Server port ${DEVICE_PORT} to ${this.opts.systemPort}`);
+
+    await this.adb.forwardPort(this.opts.systemPort, DEVICE_PORT);
+
+    if (!this.opts.skipUnlock) {
+      await helpers.unlock(this, this.adb, this.caps);
+    } else {
+      _logger.default.debug(`'skipUnlock' capability set, so skipping device unlock`);
+    }
+
+    await this.initAUT();
+
+    if (!this.caps.appPackage) {
+      this.caps.appPackage = appInfo.appPackage;
+    }
+
+    if (!this.caps.appWaitPackage) {
+      this.caps.appWaitPackage = appInfo.appWaitPackage || appInfo.appPackage || this.caps.appPackage;
+    }
+
+    if (this.caps.appActivity) {
+      this.caps.appActivity = (0, _utils.qualifyActivityName)(this.caps.appActivity, this.caps.appPackage);
+    } else {
+      this.caps.appActivity = (0, _utils.qualifyActivityName)(appInfo.appActivity, this.caps.appPackage);
+    }
+
+    if (this.caps.appWaitActivity) {
+      this.caps.appWaitActivity = (0, _utils.qualifyActivityName)(this.caps.appWaitActivity, this.caps.appWaitPackage);
+    } else {
+      this.caps.appWaitActivity = (0, _utils.qualifyActivityName)(appInfo.appWaitActivity || appInfo.appActivity || this.caps.appActivity, this.caps.appWaitPackage);
+    }
+
+    await this.espresso.startSession(this.caps);
+
+    if (this.caps.autoLaunch === false) {
+      _logger.default.info(`Not waiting for the application activity to start because 'autoLaunch' is disabled`);
+    } else {
+      await this.adb.waitForActivity(this.caps.appWaitPackage, this.caps.appWaitActivity, this.opts.appWaitDuration);
+    }
+
+    if (this.opts.autoWebview) {
+      await this.initWebview();
+    }
+
+    this.jwpProxyActive = true;
+    await this.addDeviceInfoToCaps();
+  }
+
+  async initWebview() {
+    const viewName = _appiumAndroidDriver.androidCommands.defaultWebviewName.call(this);
+
+    const timeout = this.opts.autoWebviewTimeout || 2000;
+
+    _logger.default.info(`Setting webview to context '${viewName}' with timeout ${timeout}ms`);
+
+    await (0, _asyncbox.retryInterval)(timeout / 500, 500, this.setContext.bind(this), viewName);
+  }
+
+  async addDeviceInfoToCaps() {
+    const {
+      apiVersion,
+      platformVersion,
+      manufacturer,
+      model,
+      realDisplaySize,
+      displayDensity
+    } = await this.mobileGetDeviceInfo();
+    this.caps.deviceApiLevel = parseInt(apiVersion, 10);
+    this.caps.platformVersion = platformVersion;
+    this.caps.deviceScreenSize = realDisplaySize;
+    this.caps.deviceScreenDensity = displayDensity;
+    this.caps.deviceModel = model;
+    this.caps.deviceManufacturer = manufacturer;
+  }
+
+  initEspressoServer() {
+    this.espresso = new _espressoRunner.EspressoRunner({
+      host: this.opts.remoteAdbHost || this.opts.host || 'localhost',
+      systemPort: this.opts.systemPort,
+      devicePort: DEVICE_PORT,
+      adb: this.adb,
+      apk: this.opts.app,
+      tmpDir: this.opts.tmpDir,
+      appPackage: this.opts.appPackage,
+      appActivity: this.opts.appActivity,
+      forceEspressoRebuild: !!this.opts.forceEspressoRebuild,
+      espressoBuildConfig: this.opts.espressoBuildConfig,
+      showGradleLog: !!this.opts.showGradleLog,
+      serverLaunchTimeout: this.opts.espressoServerLaunchTimeout,
+      androidInstallTimeout: this.opts.androidInstallTimeout,
+      skipServerInstallation: this.opts.skipServerInstallation,
+      useKeystore: this.opts.useKeystore,
+      keystorePath: this.opts.keystorePath,
+      keystorePassword: this.opts.keystorePassword,
+      keyAlias: this.opts.keyAlias,
+      keyPassword: this.opts.keyPassword,
+      disableSuppressAccessibilityService: this.opts.disableSuppressAccessibilityService
+    });
+    this.proxyReqRes = this.espresso.proxyReqRes.bind(this.espresso);
+  }
+
+  async initAUT() {
+    if (this.opts.uninstallOtherPackages) {
+      await helpers.uninstallOtherPackages(this.adb, helpers.parseArray(this.opts.uninstallOtherPackages), [_appiumAndroidDriver.SETTINGS_HELPER_PKG_ID, _espressoRunner.TEST_APK_PKG]);
+    }
+
+    if (!this.opts.app) {
+      if (this.opts.fullReset) {
+        _logger.default.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');
+      }
+
+      _logger.default.debug('No app capability. Assuming it is already on the device');
+
+      if (this.opts.fastReset) {
+        await helpers.resetApp(this.adb, this.opts);
+      }
+    }
+
+    if (!this.opts.skipUninstall) {
+      await this.adb.uninstallApk(this.opts.appPackage);
+    }
+
+    if (this.opts.app) {
+      if (this.opts.noSign) {
+        _logger.default.info('Skipping application signing because noSign capability is set to true. ' + 'Having the application under test with improper signature/non-signed will cause ' + 'Espresso automation startup failure.');
+      } else if (!(await this.adb.checkApkCert(this.opts.app, this.opts.appPackage))) {
+        await this.adb.sign(this.opts.app, this.opts.appPackage);
+      }
+
+      await helpers.installApk(this.adb, this.opts);
+    }
+
+    if (this.opts.skipServerInstallation) {
+      _logger.default.debug('skipServerInstallation capability is set. Not installig espresso-server ');
+    } else {
+      await this.espresso.installTestApk();
+
+      try {
+        await this.adb.addToDeviceIdleWhitelist(_appiumAndroidDriver.SETTINGS_HELPER_PKG_ID, _espressoRunner.TEST_APK_PKG);
+      } catch (e) {
+        _logger.default.warn(`Cannot add server packages to the Doze whitelist. Original error: ` + (e.stderr || e.message));
+      }
+    }
+  }
+
+  async deleteSession() {
+    _logger.default.debug('Deleting espresso session');
+
+    try {
+      if (!_lodash.default.isEmpty(this._screenRecordingProperties)) {
+        await this.stopRecordingScreen();
+      }
+    } catch (ign) {}
+
+    await _appiumAndroidDriver.androidHelpers.removeAllSessionWebSocketHandlers(this.server, this.sessionId);
+    await this.mobileStopScreenStreaming();
+
+    if (this.espresso) {
+      if (this.jwpProxyActive) {
+        await this.espresso.deleteSession();
+      }
+
+      this.espresso = null;
+    }
+
+    this.jwpProxyActive = false;
+
+    if (this.adb) {
+      if (this.wasAnimationEnabled) {
+        try {
+          await this.adb.setAnimationState(true);
+        } catch (err) {
+          _logger.default.warn(`Unable to reset animation: ${err.message}`);
+        }
+      }
+
+      if (this.opts.unicodeKeyboard && this.opts.resetKeyboard && this.defaultIME) {
+        _logger.default.debug(`Resetting IME to '${this.defaultIME}'`);
+
+        await this.adb.setIME(this.defaultIME);
+      }
+
+      if (!this.isChromeSession && this.opts.appPackage && !this.opts.dontStopAppOnReset) {
+        await this.adb.forceStop(this.opts.appPackage);
+      }
+
+      if (this.opts.fullReset && !this.opts.skipUninstall && !this.appOnDevice) {
+        _logger.default.debug(`FULL_RESET set to 'true', Uninstalling '${this.opts.appPackage}'`);
+
+        await this.adb.uninstallApk(this.opts.appPackage);
+      }
+
+      await this.adb.stopLogcat();
+
+      if (this.opts.reboot) {
+        let avdName = this.opts.avd.replace('@', '');
+
+        _logger.default.debug(`closing emulator '${avdName}'`);
+
+        await this.adb.killEmulator(avdName);
+      }
+
+      if ((await this.adb.getApiLevel()) >= 28) {
+        _logger.default.info('Restoring hidden api policy to the device default configuration');
+
+        await this.adb.setDefaultHiddenApiPolicy(!!this.opts.ignoreHiddenApiPolicyError);
+      }
+    }
+
+    await super.deleteSession();
+
+    if (this.opts.systemPort !== undefined) {
+      try {
+        await this.adb.removePortForward(this.opts.systemPort);
+      } catch (error) {
+        _logger.default.warn(`Unable to remove port forward '${error.message}'`);
+      }
+    }
+  }
+
+  async checkAppPresent() {
+    _logger.default.debug('Checking whether app is actually present');
+
+    if (!(await _appiumSupport.fs.exists(this.opts.app))) {
+      _logger.default.errorAndThrow(`Could not find app apk at '${this.opts.app}'`);
+    }
+  }
+
+  async onSettingsUpdate() {}
+
+  proxyActive(sessionId) {
+    super.proxyActive(sessionId);
+    return true;
+  }
+
+  canProxy(sessionId) {
+    super.canProxy(sessionId);
+    return true;
+  }
+
+  getProxyAvoidList(sessionId) {
+    super.getProxyAvoidList(sessionId);
+    this.jwpProxyAvoid = _lodash.default.isNil(this.chromedriver) ? NO_PROXY : CHROME_NO_PROXY;
+
+    if (this.opts.nativeWebScreenshot) {
+      this.jwpProxyAvoid = [...this.jwpProxyAvoid, ['GET', new RegExp('^/session/[^/]+/screenshot')]];
+    }
+
+    return this.jwpProxyAvoid;
+  }
+
+  get isChromeSession() {
+    return helpers.isChromeBrowser(this.opts.browserName);
+  }
+
+}
+
+exports.EspressoDriver = EspressoDriver;
+
+for (let [cmd, fn] of _lodash.default.toPairs(_appiumAndroidDriver.androidCommands)) {
+  if (!_lodash.default.includes(['defaultWebviewName'], cmd)) {
+    EspressoDriver.prototype[cmd] = fn;
+  }
+}
+
+for (let [cmd, fn] of _lodash.default.toPairs(_commands.default)) {
+  EspressoDriver.prototype[cmd] = fn;
+}
+
+var _default = EspressoDriver;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/driver.js"],"names":["helpers","androidHelpers","SYSTEM_PORT_RANGE","DEVICE_PORT","NO_PROXY","RegExp","CHROME_NO_PROXY","APP_EXTENSION","EspressoDriver","BaseDriver","constructor","opts","shouldValidateCaps","shell","locatorStrategies","desiredCapConstraints","espresso","jwpProxyActive","defaultIME","jwpProxyAvoid","apkStrings","settings","DeviceSettings","onSettingsUpdate","bind","chromedriver","sessionChromedrivers","createSession","args","sessionId","caps","serverDetails","platform","webStorageEnabled","takesScreenshot","javascriptEnabled","databaseEnabled","networkConnectionEnabled","locationContextEnabled","warnings","desired","Object","assign","curContext","defaultContextName","defaultOpts","fullReset","autoLaunch","adbPort","DEFAULT_ADB_PORT","androidInstallTimeout","_","defaults","isChromeSession","app","logger","warn","errorAndThrow","reboot","setAvdFromCapabilities","addWipeDataToAvdArgs","configureApp","checkAppPresent","appOnDevice","info","appPackage","checkPackagePresent","systemPort","startEspressoSession","e","deleteSession","message","errors","SessionNotCreatedError","err","stack","driverData","isEmulator","adb","avd","deviceName","platformVersion","avdDevice","replace","avdArgs","toLowerCase","includes","version","udid","emPort","getDeviceInfoFromCaps","createADB","getApiLevel","setHiddenApiPolicy","ignoreHiddenApiPolicyError","appInfo","getLaunchInfo","initDevice","isAnimationOn","setAnimationState","wasAnimationEnabled","curDeviceId","deviceUDID","initEspressoServer","debug","forwardPort","skipUnlock","unlock","initAUT","appWaitPackage","appActivity","appWaitActivity","startSession","waitForActivity","appWaitDuration","autoWebview","initWebview","addDeviceInfoToCaps","viewName","androidCommands","defaultWebviewName","call","timeout","autoWebviewTimeout","setContext","apiVersion","manufacturer","model","realDisplaySize","displayDensity","mobileGetDeviceInfo","deviceApiLevel","parseInt","deviceScreenSize","deviceScreenDensity","deviceModel","deviceManufacturer","EspressoRunner","host","remoteAdbHost","devicePort","apk","tmpDir","forceEspressoRebuild","espressoBuildConfig","showGradleLog","serverLaunchTimeout","espressoServerLaunchTimeout","skipServerInstallation","useKeystore","keystorePath","keystorePassword","keyAlias","keyPassword","disableSuppressAccessibilityService","proxyReqRes","uninstallOtherPackages","parseArray","SETTINGS_HELPER_PKG_ID","TEST_APK_PKG","fastReset","resetApp","skipUninstall","uninstallApk","noSign","checkApkCert","sign","installApk","installTestApk","addToDeviceIdleWhitelist","stderr","isEmpty","_screenRecordingProperties","stopRecordingScreen","ign","removeAllSessionWebSocketHandlers","server","mobileStopScreenStreaming","unicodeKeyboard","resetKeyboard","setIME","dontStopAppOnReset","forceStop","stopLogcat","avdName","killEmulator","setDefaultHiddenApiPolicy","undefined","removePortForward","error","fs","exists","proxyActive","canProxy","getProxyAvoidList","isNil","nativeWebScreenshot","isChromeBrowser","browserName","cmd","fn","toPairs","prototype","commands"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAIA,MAAMA,OAAO,GAAGC,mCAAhB;AAIA,MAAMC,iBAAiB,GAAG,CAAC,IAAD,EAAO,IAAP,CAA1B;AAIA,MAAMC,WAAW,GAAG,IAApB;AAMA,MAAMC,QAAQ,GAAG,CACf,CAAC,KAAD,EAAQ,IAAIC,MAAJ,CAAW,mBAAX,CAAR,CADe,EAEf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,gDAAX,CAAR,CAFe,EAGf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,+CAAX,CAAR,CAHe,EAIf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,+CAAX,CAAR,CAJe,EAKf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,iDAAX,CAAR,CALe,EAMf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,2CAAX,CAAR,CANe,EAOf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,2CAAX,CAAR,CAPe,EAQf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,iCAAX,CAAR,CARe,EASf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,yBAAX,CAAR,CATe,EAUf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,0BAAX,CAAR,CAVe,EAWf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,2BAAX,CAAR,CAXe,EAYf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,2BAAX,CAAR,CAZe,EAaf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,oCAAX,CAAR,CAbe,EAcf,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,0BAAX,CAAR,CAde,EAef,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,qBAAX,CAAR,CAfe,EAgBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,uCAAX,CAAT,CAhBe,EAiBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,kCAAX,CAAT,CAjBe,EAkBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,mCAAX,CAAT,CAlBe,EAmBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,kCAAX,CAAT,CAnBe,EAoBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,oCAAX,CAAT,CApBe,EAqBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,uCAAX,CAAT,CArBe,EAsBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,4CAAX,CAAT,CAtBe,EAuBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,6CAAX,CAAT,CAvBe,EAwBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yCAAX,CAAT,CAxBe,EAyBf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,6CAAX,CAAT,CAzBe,EA0Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,2CAAX,CAAT,CA1Be,EA2Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yCAAX,CAAT,CA3Be,EA4Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,oCAAX,CAAT,CA5Be,EA6Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yCAAX,CAAT,CA7Be,EA8Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,2CAAX,CAAT,CA9Be,EA+Bf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yCAAX,CAAT,CA/Be,EAgCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,0CAAX,CAAT,CAhCe,EAiCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,8CAAX,CAAT,CAjCe,EAkCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,6CAAX,CAAT,CAlCe,EAmCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,sCAAX,CAAT,CAnCe,EAoCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,2CAAX,CAAT,CApCe,EAqCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,8CAAX,CAAT,CArCe,EAsCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,iCAAX,CAAT,CAtCe,EAuCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,uCAAX,CAAT,CAvCe,EAwCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,+CAAX,CAAT,CAxCe,EAyCf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,8CAAX,CAAT,CAzCe,EA0Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yBAAX,CAAT,CA1Ce,EA2Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yBAAX,CAAT,CA3Ce,EA4Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,+BAAX,CAAT,CA5Ce,EA6Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,8BAAX,CAAT,CA7Ce,EA8Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,+BAAX,CAAT,CA9Ce,EA+Cf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,2BAAX,CAAT,CA/Ce,EAgDf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,0BAAX,CAAT,CAhDe,EAiDf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,qBAAX,CAAT,CAjDe,EAkDf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,oCAAX,CAAT,CAlDe,EAmDf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,0BAAX,CAAT,CAnDe,EAoDf,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,qBAAX,CAAT,CApDe,CAAjB;AAwDA,MAAMC,eAAe,GAAG,CACtB,CAAC,KAAD,EAAQ,IAAID,MAAJ,CAAW,wBAAX,CAAR,CADsB,EAEtB,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,yBAAX,CAAR,CAFsB,EAGtB,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,oCAAX,CAAR,CAHsB,EAItB,CAAC,KAAD,EAAQ,IAAIA,MAAJ,CAAW,6BAAX,CAAR,CAJsB,EAKtB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,wBAAX,CAAT,CALsB,EAMtB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,yBAAX,CAAT,CANsB,EAOtB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,6BAAX,CAAT,CAPsB,EAQtB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,qCAAX,CAAT,CARsB,EAStB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,+BAAX,CAAT,CATsB,EAYtB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,0BAAX,CAAT,CAZsB,EAatB,CAAC,MAAD,EAAS,IAAIA,MAAJ,CAAW,8BAAX,CAAT,CAbsB,CAAxB;AAgBA,MAAME,aAAa,GAAG,MAAtB;;AAGA,MAAMC,cAAN,SAA6BC,4BAA7B,CAAwC;AACtCC,EAAAA,WAAW,CAAEC,IAAI,GAAG,EAAT,EAAaC,kBAAkB,GAAG,IAAlC,EAAwC;AAEjD,WAAOD,IAAI,CAACE,KAAZ;AAEA,UAAMF,IAAN,EAAYC,kBAAZ;AACA,SAAKE,iBAAL,GAAyB,CACvB,IADuB,EAEvB,YAFuB,EAGvB,kBAHuB,CAAzB;AAKA,SAAKC,qBAAL,GAA6BA,oBAA7B;AACA,SAAKC,QAAL,GAAgB,IAAhB;AACA,SAAKC,cAAL,GAAsB,KAAtB;AACA,SAAKC,UAAL,GAAkB,IAAlB;AACA,SAAKC,aAAL,GAAqBf,QAArB;AAEA,SAAKgB,UAAL,GAAkB,EAAlB;AACA,SAAKC,QAAL,GAAgB,IAAIC,gCAAJ,CAAmB,EAAnB,EAAuB,KAAKC,gBAAL,CAAsBC,IAAtB,CAA2B,IAA3B,CAAvB,CAAhB;AAEA,SAAKC,YAAL,GAAoB,IAApB;AACA,SAAKC,oBAAL,GAA4B,EAA5B;AACD;;AAEkB,QAAbC,aAAa,CAAE,GAAGC,IAAL,EAAW;AAC5B,QAAI;AAEF,UAAI,CAACC,SAAD,EAAYC,IAAZ,IAAoB,MAAM,MAAMH,aAAN,CAAoB,GAAGC,IAAvB,CAA9B;AAEA,UAAIG,aAAa,GAAG;AAClBC,QAAAA,QAAQ,EAAE,OADQ;AAElBC,QAAAA,iBAAiB,EAAE,KAFD;AAGlBC,QAAAA,eAAe,EAAE,IAHC;AAIlBC,QAAAA,iBAAiB,EAAE,IAJD;AAKlBC,QAAAA,eAAe,EAAE,KALC;AAMlBC,QAAAA,wBAAwB,EAAE,IANR;AAOlBC,QAAAA,sBAAsB,EAAE,KAPN;AAQlBC,QAAAA,QAAQ,EAAE,EARQ;AASlBC,QAAAA,OAAO,EAAEC,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkB,KAAKZ,IAAvB;AATS,OAApB;AAYA,WAAKA,IAAL,GAAYW,MAAM,CAACC,MAAP,CAAcX,aAAd,EAA6B,KAAKD,IAAlC,CAAZ;AAEA,WAAKa,UAAL,GAAkB,KAAKC,kBAAL,EAAlB;AAEA,UAAIC,WAAW,GAAG;AAChBC,QAAAA,SAAS,EAAE,KADK;AAEhBC,QAAAA,UAAU,EAAE,IAFI;AAGhBC,QAAAA,OAAO,EAAEC,2BAHO;AAIhBC,QAAAA,qBAAqB,EAAE;AAJP,OAAlB;;AAMAC,sBAAEC,QAAF,CAAW,KAAKzC,IAAhB,EAAsBkC,WAAtB;;AAEA,UAAI,KAAKQ,eAAT,EAA0B;AACxB,YAAI,KAAK1C,IAAL,CAAU2C,GAAd,EAAmB;AACjBC,0BAAOC,IAAP,CAAa;AACvB;AACA;AACA,WAHU;AAID,SALD,MAKO;AACLD,0BAAOE,aAAP,CAAsB,wHAAtB;AACD;AACF;;AAED,UAAI,KAAK9C,IAAL,CAAU+C,MAAd,EAAsB;AACpB,aAAKC,sBAAL,CAA4B7B,IAA5B;AACA,aAAK8B,oBAAL;AACD;;AAED,UAAI,KAAKjD,IAAL,CAAU2C,GAAd,EAAmB;AAEjB,aAAK3C,IAAL,CAAU2C,GAAV,GAAgB,MAAM,KAAKtD,OAAL,CAAa6D,YAAb,CAA0B,KAAKlD,IAAL,CAAU2C,GAApC,EAAyC/C,aAAzC,CAAtB;AACA,cAAM,KAAKuD,eAAL,EAAN;AACD,OAJD,MAIO,IAAI,KAAKC,WAAT,EAAsB;AAG3BR,wBAAOS,IAAP,CAAa,sDAAD,GACP,GAAE,KAAKrD,IAAL,CAAUsD,UAAW,yBAD5B;;AAEA,cAAM,KAAKC,mBAAL,EAAN;AACD;;AAED,WAAKvD,IAAL,CAAUwD,UAAV,GAAuB,KAAKxD,IAAL,CAAUwD,UAAV,KAAwB,MAAM,oCAAkBjE,iBAAiB,CAAC,CAAD,CAAnC,EAAwCA,iBAAiB,CAAC,CAAD,CAAzD,CAA9B,CAAvB;AACA,WAAKS,IAAL,CAAUqC,OAAV,GAAoB,KAAKrC,IAAL,CAAUqC,OAAV,IAAqBC,2BAAzC;AACA,YAAM,KAAKmB,oBAAL,EAAN;AACA,aAAO,CAACvC,SAAD,EAAYC,IAAZ,CAAP;AACD,KA5DD,CA4DE,OAAOuC,CAAP,EAAU;AACV,YAAM,KAAKC,aAAL,EAAN;AACAD,MAAAA,CAAC,CAACE,OAAF,IAAa,8HAAb;;AACA,UAAI,mCAAYF,CAAZ,EAAeG,yBAAOC,sBAAtB,CAAJ,EAAmD;AACjD,cAAMJ,CAAN;AACD;;AACD,YAAMK,GAAG,GAAG,IAAIF,yBAAOC,sBAAX,CAAkCJ,CAAC,CAACE,OAApC,CAAZ;AACAG,MAAAA,GAAG,CAACC,KAAJ,GAAYN,CAAC,CAACM,KAAd;AACA,YAAMD,GAAN;AACD;AACF;;AAEa,MAAVE,UAAU,GAAI;AAEhB,WAAO,EAAP;AACD;;AAEDC,EAAAA,UAAU,GAAI;AACZ,WAAO7E,OAAO,CAAC6E,UAAR,CAAmB,KAAKC,GAAxB,EAA6B,KAAKnE,IAAlC,CAAP;AACD;;AAGDgD,EAAAA,sBAAsB,CAAE7B,IAAF,EAAQ;AAC5B,QAAI,KAAKnB,IAAL,CAAUoE,GAAd,EAAmB;AACjBxB,sBAAOS,IAAP,CAAY,6DAAZ;AACD,KAFD,MAEO;AACL,UAAI,CAAClC,IAAI,CAACkD,UAAV,EAAsB;AACpBzB,wBAAOE,aAAP,CAAqB,qEAArB;AACD;;AACD,UAAI,CAAC3B,IAAI,CAACmD,eAAV,EAA2B;AACzB1B,wBAAOE,aAAP,CAAqB,0EAArB;AACD;;AACD,UAAIyB,SAAS,GAAGpD,IAAI,CAACkD,UAAL,CAAgBG,OAAhB,CAAwB,iBAAxB,EAA2C,GAA3C,CAAhB;AACA,WAAKxE,IAAL,CAAUoE,GAAV,GAAiB,GAAEG,SAAU,KAAIpD,IAAI,CAACmD,eAAgB,EAAtD;AACD;AACF;;AAGDrB,EAAAA,oBAAoB,GAAI;AACtB,QAAI,CAAC,KAAKjD,IAAL,CAAUyE,OAAf,EAAwB;AACtB,WAAKzE,IAAL,CAAUyE,OAAV,GAAoB,YAApB;AACD,KAFD,MAEO,IAAI,CAAC,KAAKzE,IAAL,CAAUyE,OAAV,CAAkBC,WAAlB,GAAgCC,QAAhC,CAAyC,YAAzC,CAAL,EAA6D;AAClE,WAAK3E,IAAL,CAAUyE,OAAV,IAAqB,aAArB;AACD;AACF;;AAGyB,QAApBhB,oBAAoB,GAAI;AAC5Bb,oBAAOS,IAAP,CAAa,2BAA0BuB,gBAAQ,EAA/C;;AAGA,QAAI;AAACC,MAAAA,IAAD;AAAOC,MAAAA;AAAP,QAAiB,MAAMzF,OAAO,CAAC0F,qBAAR,CAA8B,KAAK/E,IAAnC,CAA3B;AACA,SAAKA,IAAL,CAAU6E,IAAV,GAAiBA,IAAjB;AACA,SAAK7E,IAAL,CAAU8E,MAAV,GAAmBA,MAAnB;AAIA,SAAKX,GAAL,GAAW,MAAM7E,oCAAe0F,SAAf,CAAyB,KAAKhF,IAA9B,CAAjB;;AAGA,QAAI,OAAM,KAAKmE,GAAL,CAASc,WAAT,EAAN,KAAgC,EAApC,EAAwC;AACtCrC,sBAAOC,IAAP,CAAY,4BAAZ;;AACA,YAAM,KAAKsB,GAAL,CAASe,kBAAT,CAA4B,GAA5B,EAAiC,CAAC,CAAC,KAAKlF,IAAL,CAAUmF,0BAA7C,CAAN;AACD;;AAGD,QAAIC,OAAO,GAAG,MAAM/F,OAAO,CAACgG,aAAR,CAAsB,KAAKlB,GAA3B,EAAgC,KAAKnE,IAArC,CAApB;;AACA,QAAIoF,OAAJ,EAAa;AAEXtD,MAAAA,MAAM,CAACC,MAAP,CAAc,KAAK/B,IAAnB,EAAyBoF,OAAzB;AACD,KAHD,MAGO;AACLA,MAAAA,OAAO,GAAG,KAAKpF,IAAf;AACD;;AAID,UAAMX,OAAO,CAACiG,UAAR,CAAmB,KAAKnB,GAAxB,EAA6B,KAAKnE,IAAlC,CAAN;;AAEA,QAAI,MAAM,KAAKmE,GAAL,CAASoB,aAAT,EAAV,EAAoC;AAClC,UAAI;AACF,cAAM,KAAKpB,GAAL,CAASqB,iBAAT,CAA2B,KAA3B,CAAN;AACA,aAAKC,mBAAL,GAA2B,IAA3B;AACD,OAHD,CAGE,OAAO1B,GAAP,EAAY;AACZnB,wBAAOC,IAAP,CAAa,kCAAiCkB,GAAG,CAACH,OAAQ,EAA1D;AACD;AACF;;AAGD,SAAKzC,IAAL,CAAUkD,UAAV,GAAuB,KAAKF,GAAL,CAASuB,WAAhC;AACA,SAAKvE,IAAL,CAAUwE,UAAV,GAAuB,KAAK3F,IAAL,CAAU6E,IAAjC;AAGA,SAAKe,kBAAL;;AAEAhD,oBAAOiD,KAAP,CAAc,mCAAkCrG,WAAY,OAAM,KAAKQ,IAAL,CAAUwD,UAAW,EAAvF;;AACA,UAAM,KAAKW,GAAL,CAAS2B,WAAT,CAAqB,KAAK9F,IAAL,CAAUwD,UAA/B,EAA2ChE,WAA3C,CAAN;;AAEA,QAAI,CAAC,KAAKQ,IAAL,CAAU+F,UAAf,EAA2B;AAEzB,YAAM1G,OAAO,CAAC2G,MAAR,CAAe,IAAf,EAAqB,KAAK7B,GAA1B,EAA+B,KAAKhD,IAApC,CAAN;AACD,KAHD,MAGO;AACLyB,sBAAOiD,KAAP,CAAc,wDAAd;AACD;;AAID,UAAM,KAAKI,OAAL,EAAN;;AAGA,QAAI,CAAC,KAAK9E,IAAL,CAAUmC,UAAf,EAA2B;AACzB,WAAKnC,IAAL,CAAUmC,UAAV,GAAuB8B,OAAO,CAAC9B,UAA/B;AACD;;AACD,QAAI,CAAC,KAAKnC,IAAL,CAAU+E,cAAf,EAA+B;AAC7B,WAAK/E,IAAL,CAAU+E,cAAV,GAA2Bd,OAAO,CAACc,cAAR,IAA0Bd,OAAO,CAAC9B,UAAlC,IAAgD,KAAKnC,IAAL,CAAUmC,UAArF;AACD;;AACD,QAAI,KAAKnC,IAAL,CAAUgF,WAAd,EAA2B;AACzB,WAAKhF,IAAL,CAAUgF,WAAV,GAAwB,gCAAoB,KAAKhF,IAAL,CAAUgF,WAA9B,EAA2C,KAAKhF,IAAL,CAAUmC,UAArD,CAAxB;AACD,KAFD,MAEO;AACL,WAAKnC,IAAL,CAAUgF,WAAV,GAAwB,gCAAoBf,OAAO,CAACe,WAA5B,EAAyC,KAAKhF,IAAL,CAAUmC,UAAnD,CAAxB;AACD;;AACD,QAAI,KAAKnC,IAAL,CAAUiF,eAAd,EAA+B;AAC7B,WAAKjF,IAAL,CAAUiF,eAAV,GAA4B,gCAAoB,KAAKjF,IAAL,CAAUiF,eAA9B,EAA+C,KAAKjF,IAAL,CAAU+E,cAAzD,CAA5B;AACD,KAFD,MAEO;AACL,WAAK/E,IAAL,CAAUiF,eAAV,GAA4B,gCAAoBhB,OAAO,CAACgB,eAAR,IAA2BhB,OAAO,CAACe,WAAnC,IAAkD,KAAKhF,IAAL,CAAUgF,WAAhF,EAC1B,KAAKhF,IAAL,CAAU+E,cADgB,CAA5B;AAED;;AAGD,UAAM,KAAK7F,QAAL,CAAcgG,YAAd,CAA2B,KAAKlF,IAAhC,CAAN;;AACA,QAAI,KAAKA,IAAL,CAAUiB,UAAV,KAAyB,KAA7B,EAAoC;AAClCQ,sBAAOS,IAAP,CAAa,oFAAb;AACD,KAFD,MAEO;AACL,YAAM,KAAKc,GAAL,CAASmC,eAAT,CAAyB,KAAKnF,IAAL,CAAU+E,cAAnC,EAAmD,KAAK/E,IAAL,CAAUiF,eAA7D,EAA8E,KAAKpG,IAAL,CAAUuG,eAAxF,CAAN;AACD;;AAGD,QAAI,KAAKvG,IAAL,CAAUwG,WAAd,EAA2B;AACzB,YAAM,KAAKC,WAAL,EAAN;AACD;;AAID,SAAKnG,cAAL,GAAsB,IAAtB;AAEA,UAAM,KAAKoG,mBAAL,EAAN;AACD;;AAEgB,QAAXD,WAAW,GAAI;AACnB,UAAME,QAAQ,GAAGC,qCAAgBC,kBAAhB,CAAmCC,IAAnC,CAAwC,IAAxC,CAAjB;;AACA,UAAMC,OAAO,GAAG,KAAK/G,IAAL,CAAUgH,kBAAV,IAAgC,IAAhD;;AACApE,oBAAOS,IAAP,CAAa,+BAA8BsD,QAAS,kBAAiBI,OAAQ,IAA7E;;AACA,UAAM,6BAAcA,OAAO,GAAG,GAAxB,EAA6B,GAA7B,EAAkC,KAAKE,UAAL,CAAgBpG,IAAhB,CAAqB,IAArB,CAAlC,EAA8D8F,QAA9D,CAAN;AACD;;AAEwB,QAAnBD,mBAAmB,GAAI;AAC3B,UAAM;AACJQ,MAAAA,UADI;AAEJ5C,MAAAA,eAFI;AAGJ6C,MAAAA,YAHI;AAIJC,MAAAA,KAJI;AAKJC,MAAAA,eALI;AAMJC,MAAAA;AANI,QAOF,MAAM,KAAKC,mBAAL,EAPV;AAQA,SAAKpG,IAAL,CAAUqG,cAAV,GAA2BC,QAAQ,CAACP,UAAD,EAAa,EAAb,CAAnC;AACA,SAAK/F,IAAL,CAAUmD,eAAV,GAA4BA,eAA5B;AACA,SAAKnD,IAAL,CAAUuG,gBAAV,GAA6BL,eAA7B;AACA,SAAKlG,IAAL,CAAUwG,mBAAV,GAAgCL,cAAhC;AACA,SAAKnG,IAAL,CAAUyG,WAAV,GAAwBR,KAAxB;AACA,SAAKjG,IAAL,CAAU0G,kBAAV,GAA+BV,YAA/B;AACD;;AAEDvB,EAAAA,kBAAkB,GAAI;AAGpB,SAAKvF,QAAL,GAAgB,IAAIyH,8BAAJ,CAAmB;AACjCC,MAAAA,IAAI,EAAE,KAAK/H,IAAL,CAAUgI,aAAV,IAA2B,KAAKhI,IAAL,CAAU+H,IAArC,IAA6C,WADlB;AAEjCvE,MAAAA,UAAU,EAAE,KAAKxD,IAAL,CAAUwD,UAFW;AAGjCyE,MAAAA,UAAU,EAAEzI,WAHqB;AAIjC2E,MAAAA,GAAG,EAAE,KAAKA,GAJuB;AAKjC+D,MAAAA,GAAG,EAAE,KAAKlI,IAAL,CAAU2C,GALkB;AAMjCwF,MAAAA,MAAM,EAAE,KAAKnI,IAAL,CAAUmI,MANe;AAOjC7E,MAAAA,UAAU,EAAE,KAAKtD,IAAL,CAAUsD,UAPW;AAQjC6C,MAAAA,WAAW,EAAE,KAAKnG,IAAL,CAAUmG,WARU;AASjCiC,MAAAA,oBAAoB,EAAE,CAAC,CAAC,KAAKpI,IAAL,CAAUoI,oBATD;AAUjCC,MAAAA,mBAAmB,EAAE,KAAKrI,IAAL,CAAUqI,mBAVE;AAWjCC,MAAAA,aAAa,EAAE,CAAC,CAAC,KAAKtI,IAAL,CAAUsI,aAXM;AAYjCC,MAAAA,mBAAmB,EAAE,KAAKvI,IAAL,CAAUwI,2BAZE;AAajCjG,MAAAA,qBAAqB,EAAE,KAAKvC,IAAL,CAAUuC,qBAbA;AAcjCkG,MAAAA,sBAAsB,EAAE,KAAKzI,IAAL,CAAUyI,sBAdD;AAejCC,MAAAA,WAAW,EAAE,KAAK1I,IAAL,CAAU0I,WAfU;AAgBjCC,MAAAA,YAAY,EAAE,KAAK3I,IAAL,CAAU2I,YAhBS;AAiBjCC,MAAAA,gBAAgB,EAAE,KAAK5I,IAAL,CAAU4I,gBAjBK;AAkBjCC,MAAAA,QAAQ,EAAE,KAAK7I,IAAL,CAAU6I,QAlBa;AAmBjCC,MAAAA,WAAW,EAAE,KAAK9I,IAAL,CAAU8I,WAnBU;AAoBjCC,MAAAA,mCAAmC,EAAE,KAAK/I,IAAL,CAAU+I;AApBd,KAAnB,CAAhB;AAsBA,SAAKC,WAAL,GAAmB,KAAK3I,QAAL,CAAc2I,WAAd,CAA0BnI,IAA1B,CAA+B,KAAKR,QAApC,CAAnB;AACD;;AAGY,QAAP4F,OAAO,GAAI;AAQf,QAAI,KAAKjG,IAAL,CAAUiJ,sBAAd,EAAsC;AACpC,YAAM5J,OAAO,CAAC4J,sBAAR,CACJ,KAAK9E,GADD,EAEJ9E,OAAO,CAAC6J,UAAR,CAAmB,KAAKlJ,IAAL,CAAUiJ,sBAA7B,CAFI,EAGJ,CAACE,2CAAD,EAAyBC,4BAAzB,CAHI,CAAN;AAKD;;AAED,QAAI,CAAC,KAAKpJ,IAAL,CAAU2C,GAAf,EAAoB;AAClB,UAAI,KAAK3C,IAAL,CAAUmC,SAAd,EAAyB;AACvBS,wBAAOE,aAAP,CAAqB,6EAArB;AACD;;AACDF,sBAAOiD,KAAP,CAAa,yDAAb;;AACA,UAAI,KAAK7F,IAAL,CAAUqJ,SAAd,EAAyB;AACvB,cAAMhK,OAAO,CAACiK,QAAR,CAAiB,KAAKnF,GAAtB,EAA2B,KAAKnE,IAAhC,CAAN;AACD;AACF;;AAED,QAAI,CAAC,KAAKA,IAAL,CAAUuJ,aAAf,EAA8B;AAC5B,YAAM,KAAKpF,GAAL,CAASqF,YAAT,CAAsB,KAAKxJ,IAAL,CAAUsD,UAAhC,CAAN;AACD;;AACD,QAAI,KAAKtD,IAAL,CAAU2C,GAAd,EAAmB;AACjB,UAAI,KAAK3C,IAAL,CAAUyJ,MAAd,EAAsB;AACpB7G,wBAAOS,IAAP,CAAY,4EACV,kFADU,GAEV,sCAFF;AAGD,OAJD,MAIO,IAAI,EAAC,MAAM,KAAKc,GAAL,CAASuF,YAAT,CAAsB,KAAK1J,IAAL,CAAU2C,GAAhC,EAAqC,KAAK3C,IAAL,CAAUsD,UAA/C,CAAP,CAAJ,EAAuE;AAC5E,cAAM,KAAKa,GAAL,CAASwF,IAAT,CAAc,KAAK3J,IAAL,CAAU2C,GAAxB,EAA6B,KAAK3C,IAAL,CAAUsD,UAAvC,CAAN;AACD;;AACD,YAAMjE,OAAO,CAACuK,UAAR,CAAmB,KAAKzF,GAAxB,EAA6B,KAAKnE,IAAlC,CAAN;AACD;;AACD,QAAI,KAAKA,IAAL,CAAUyI,sBAAd,EAAsC;AACpC7F,sBAAOiD,KAAP,CAAa,0EAAb;AACD,KAFD,MAEO;AACL,YAAM,KAAKxF,QAAL,CAAcwJ,cAAd,EAAN;;AACA,UAAI;AACF,cAAM,KAAK1F,GAAL,CAAS2F,wBAAT,CAAkCX,2CAAlC,EAA0DC,4BAA1D,CAAN;AACD,OAFD,CAEE,OAAO1F,CAAP,EAAU;AACVd,wBAAOC,IAAP,CAAa,oEAAD,IACTa,CAAC,CAACqG,MAAF,IAAYrG,CAAC,CAACE,OADL,CAAZ;AAED;AACF;AACF;;AAEkB,QAAbD,aAAa,GAAI;AACrBf,oBAAOiD,KAAP,CAAa,2BAAb;;AAEA,QAAI;AACF,UAAI,CAACrD,gBAAEwH,OAAF,CAAU,KAAKC,0BAAf,CAAL,EAAiD;AAC/C,cAAM,KAAKC,mBAAL,EAAN;AACD;AACF,KAJD,CAIE,OAAOC,GAAP,EAAY,CAAE;;AAEhB,UAAM7K,oCAAe8K,iCAAf,CAAiD,KAAKC,MAAtD,EAA8D,KAAKnJ,SAAnE,CAAN;AAEA,UAAM,KAAKoJ,yBAAL,EAAN;;AAEA,QAAI,KAAKjK,QAAT,EAAmB;AACjB,UAAI,KAAKC,cAAT,EAAyB;AACvB,cAAM,KAAKD,QAAL,CAAcsD,aAAd,EAAN;AACD;;AACD,WAAKtD,QAAL,GAAgB,IAAhB;AACD;;AACD,SAAKC,cAAL,GAAsB,KAAtB;;AAGA,QAAI,KAAK6D,GAAT,EAAc;AACZ,UAAI,KAAKsB,mBAAT,EAA8B;AAC5B,YAAI;AACF,gBAAM,KAAKtB,GAAL,CAASqB,iBAAT,CAA2B,IAA3B,CAAN;AACD,SAFD,CAEE,OAAOzB,GAAP,EAAY;AACZnB,0BAAOC,IAAP,CAAa,8BAA6BkB,GAAG,CAACH,OAAQ,EAAtD;AACD;AACF;;AACD,UAAI,KAAK5D,IAAL,CAAUuK,eAAV,IAA6B,KAAKvK,IAAL,CAAUwK,aAAvC,IACA,KAAKjK,UADT,EACqB;AACnBqC,wBAAOiD,KAAP,CAAc,qBAAoB,KAAKtF,UAAW,GAAlD;;AACA,cAAM,KAAK4D,GAAL,CAASsG,MAAT,CAAgB,KAAKlK,UAArB,CAAN;AACD;;AACD,UAAI,CAAC,KAAKmC,eAAN,IAAyB,KAAK1C,IAAL,CAAUsD,UAAnC,IAAiD,CAAC,KAAKtD,IAAL,CAAU0K,kBAAhE,EAAoF;AAClF,cAAM,KAAKvG,GAAL,CAASwG,SAAT,CAAmB,KAAK3K,IAAL,CAAUsD,UAA7B,CAAN;AACD;;AACD,UAAI,KAAKtD,IAAL,CAAUmC,SAAV,IAAuB,CAAC,KAAKnC,IAAL,CAAUuJ,aAAlC,IAAmD,CAAC,KAAKnG,WAA7D,EAA0E;AACxER,wBAAOiD,KAAP,CAAc,2CAA0C,KAAK7F,IAAL,CAAUsD,UAAW,GAA7E;;AACA,cAAM,KAAKa,GAAL,CAASqF,YAAT,CAAsB,KAAKxJ,IAAL,CAAUsD,UAAhC,CAAN;AACD;;AACD,YAAM,KAAKa,GAAL,CAASyG,UAAT,EAAN;;AACA,UAAI,KAAK5K,IAAL,CAAU+C,MAAd,EAAsB;AACpB,YAAI8H,OAAO,GAAG,KAAK7K,IAAL,CAAUoE,GAAV,CAAcI,OAAd,CAAsB,GAAtB,EAA2B,EAA3B,CAAd;;AACA5B,wBAAOiD,KAAP,CAAc,qBAAoBgF,OAAQ,GAA1C;;AACA,cAAM,KAAK1G,GAAL,CAAS2G,YAAT,CAAsBD,OAAtB,CAAN;AACD;;AACD,UAAI,OAAM,KAAK1G,GAAL,CAASc,WAAT,EAAN,KAAgC,EAApC,EAAwC;AACtCrC,wBAAOS,IAAP,CAAY,iEAAZ;;AACA,cAAM,KAAKc,GAAL,CAAS4G,yBAAT,CAAmC,CAAC,CAAC,KAAK/K,IAAL,CAAUmF,0BAA/C,CAAN;AACD;AACF;;AACD,UAAM,MAAMxB,aAAN,EAAN;;AACA,QAAI,KAAK3D,IAAL,CAAUwD,UAAV,KAAyBwH,SAA7B,EAAwC;AACtC,UAAI;AACF,cAAM,KAAK7G,GAAL,CAAS8G,iBAAT,CAA2B,KAAKjL,IAAL,CAAUwD,UAArC,CAAN;AACD,OAFD,CAEE,OAAO0H,KAAP,EAAc;AACdtI,wBAAOC,IAAP,CAAa,kCAAiCqI,KAAK,CAACtH,OAAQ,GAA5D;AAGD;AACF;AACF;;AAGoB,QAAfT,eAAe,GAAI;AACvBP,oBAAOiD,KAAP,CAAa,0CAAb;;AACA,QAAI,EAAE,MAAMsF,kBAAGC,MAAH,CAAU,KAAKpL,IAAL,CAAU2C,GAApB,CAAR,CAAJ,EAAuC;AACrCC,sBAAOE,aAAP,CAAsB,8BAA6B,KAAK9C,IAAL,CAAU2C,GAAI,GAAjE;AACD;AACF;;AAEqB,QAAhB/B,gBAAgB,GAAI,CAGzB;;AAEDyK,EAAAA,WAAW,CAAEnK,SAAF,EAAa;AACtB,UAAMmK,WAAN,CAAkBnK,SAAlB;AAGA,WAAO,IAAP;AACD;;AAEDoK,EAAAA,QAAQ,CAAEpK,SAAF,EAAa;AACnB,UAAMoK,QAAN,CAAepK,SAAf;AAGA,WAAO,IAAP;AACD;;AAEDqK,EAAAA,iBAAiB,CAAErK,SAAF,EAAa;AAC5B,UAAMqK,iBAAN,CAAwBrK,SAAxB;AAGA,SAAKV,aAAL,GAAqBgC,gBAAEgJ,KAAF,CAAQ,KAAK1K,YAAb,IAA6BrB,QAA7B,GAAwCE,eAA7D;;AACA,QAAI,KAAKK,IAAL,CAAUyL,mBAAd,EAAmC;AACjC,WAAKjL,aAAL,GAAqB,CAAC,GAAG,KAAKA,aAAT,EAAwB,CAAC,KAAD,EAAQ,IAAId,MAAJ,CAAW,4BAAX,CAAR,CAAxB,CAArB;AACD;;AAED,WAAO,KAAKc,aAAZ;AACD;;AAEkB,MAAfkC,eAAe,GAAI;AACrB,WAAOrD,OAAO,CAACqM,eAAR,CAAwB,KAAK1L,IAAL,CAAU2L,WAAlC,CAAP;AACD;;AA3bqC;;;;AA+bxC,KAAK,IAAI,CAACC,GAAD,EAAMC,EAAN,CAAT,IAAsBrJ,gBAAEsJ,OAAF,CAAUlF,oCAAV,CAAtB,EAAkD;AAEhD,MAAI,CAACpE,gBAAEmC,QAAF,CAAW,CAAC,oBAAD,CAAX,EAAmCiH,GAAnC,CAAL,EAA8C;AAC5C/L,IAAAA,cAAc,CAACkM,SAAf,CAAyBH,GAAzB,IAAgCC,EAAhC;AACD;AACF;;AAGD,KAAK,IAAI,CAACD,GAAD,EAAMC,EAAN,CAAT,IAAsBrJ,gBAAEsJ,OAAF,CAAUE,iBAAV,CAAtB,EAA2C;AACzCnM,EAAAA,cAAc,CAACkM,SAAf,CAAyBH,GAAzB,IAAgCC,EAAhC;AACD;;eAGchM,c","sourcesContent":["import _ from 'lodash';\nimport { BaseDriver, errors, isErrorType, DeviceSettings} from 'appium-base-driver';\nimport { EspressoRunner, TEST_APK_PKG } from './espresso-runner';\nimport { fs } from 'appium-support';\nimport logger from './logger';\nimport commands from './commands';\nimport { DEFAULT_ADB_PORT } from 'appium-adb';\nimport { androidHelpers, androidCommands, SETTINGS_HELPER_PKG_ID } from 'appium-android-driver';\nimport desiredCapConstraints from './desired-caps';\nimport { version } from '../../package.json'; // eslint-disable-line import/no-unresolved\nimport { findAPortNotInUse } from 'portscanner';\nimport { retryInterval } from 'asyncbox';\nimport { qualifyActivityName } from './utils';\n\n\n// TODO merge our own helpers onto this later\nconst helpers = androidHelpers;\n\n// The range of ports we can use on the system for communicating to the\n// Espresso HTTP server on the device\nconst SYSTEM_PORT_RANGE = [8300, 8399];\n\n// This is the port that the espresso server listens to on the device. We will\n// forward one of the ports above on the system to this port on the device.\nconst DEVICE_PORT = 6791;\n\n// NO_PROXY contains the paths that we never want to proxy to espresso server.\n// TODO:  Add the list of paths that we never want to proxy to espresso server.\n// TODO: Need to segregate the paths better way using regular expressions wherever applicable.\n// (Not segregating right away because more paths to be added in the NO_PROXY list)\nconst NO_PROXY = [\n  ['GET', new RegExp('^/session/(?!.*/)')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/current_activity')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/current_package')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/display_density')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/is_keyboard_shown')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/system_bars')],\n  ['GET', new RegExp('^/session/[^/]+/appium/device/system_time')],\n  ['GET', new RegExp('^/session/[^/]+/appium/settings')],\n  ['GET', new RegExp('^/session/[^/]+/context')],\n  ['GET', new RegExp('^/session/[^/]+/contexts')],\n  ['GET', new RegExp('^/session/[^/]+/ime/[^/]+')],\n  ['GET', new RegExp('^/session/[^/]+/log/types')],\n  ['GET', new RegExp('^/session/[^/]+/network_connection')],\n  ['GET', new RegExp('^/session/[^/]+/timeouts')],\n  ['GET', new RegExp('^/session/[^/]+/url')],\n  ['POST', new RegExp('^/session/[^/]+/appium/app/background')],\n  ['POST', new RegExp('^/session/[^/]+/appium/app/close')],\n  ['POST', new RegExp('^/session/[^/]+/appium/app/launch')],\n  ['POST', new RegExp('^/session/[^/]+/appium/app/reset')],\n  ['POST', new RegExp('^/session/[^/]+/appium/app/strings')],\n  ['POST', new RegExp('^/session/[^/]+/appium/compare_images')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/activate_app')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/app_installed')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/app_state')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/get_clipboard')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/install_app')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/is_locked')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/lock')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/pull_file')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/pull_folder')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/push_file')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/remove_app')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/start_activity')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/terminate_app')],\n  ['POST', new RegExp('^/session/[^/]+/appium/device/unlock')],\n  ['POST', new RegExp('^/session/[^/]+/appium/getPerformanceData')],\n  ['POST', new RegExp('^/session/[^/]+/appium/performanceData/types')],\n  ['POST', new RegExp('^/session/[^/]+/appium/settings')],\n  ['POST', new RegExp('^/session/[^/]+/appium/execute_driver')],\n  ['POST', new RegExp('^/session/[^/]+/appium/start_recording_screen')],\n  ['POST', new RegExp('^/session/[^/]+/appium/stop_recording_screen')],\n  ['POST', new RegExp('^/session/[^/]+/context')],\n  ['POST', new RegExp('^/session/[^/]+/execute')],\n  ['POST', new RegExp('^/session/[^/]+/execute/async')],\n  ['POST', new RegExp('^/session/[^/]+/execute/sync')],\n  ['POST', new RegExp('^/session/[^/]+/execute_async')],\n  ['POST', new RegExp('^/session/[^/]+/ime/[^/]+')],\n  ['POST', new RegExp('^/session/[^/]+/location')],\n  ['POST', new RegExp('^/session/[^/]+/log')],\n  ['POST', new RegExp('^/session/[^/]+/network_connection')],\n  ['POST', new RegExp('^/session/[^/]+/timeouts')],\n  ['POST', new RegExp('^/session/[^/]+/url')],\n];\n\n// This is a set of methods and paths that we never want to proxy to Chromedriver.\nconst CHROME_NO_PROXY = [\n  ['GET', new RegExp('^/session/[^/]+/appium')],\n  ['GET', new RegExp('^/session/[^/]+/context')],\n  ['GET', new RegExp('^/session/[^/]+/element/[^/]+/rect')],\n  ['GET', new RegExp('^/session/[^/]+/orientation')],\n  ['POST', new RegExp('^/session/[^/]+/appium')],\n  ['POST', new RegExp('^/session/[^/]+/context')],\n  ['POST', new RegExp('^/session/[^/]+/orientation')],\n  ['POST', new RegExp('^/session/[^/]+/touch/multi/perform')],\n  ['POST', new RegExp('^/session/[^/]+/touch/perform')],\n\n  // this is needed to make the mobile: commands working in web context\n  ['POST', new RegExp('^/session/[^/]+/execute$')],\n  ['POST', new RegExp('^/session/[^/]+/execute/sync')],\n];\n\nconst APP_EXTENSION = '.apk';\n\n\nclass EspressoDriver extends BaseDriver {\n  constructor (opts = {}, shouldValidateCaps = true) {\n    // `shell` overwrites adb.shell, so remove\n    delete opts.shell;\n\n    super(opts, shouldValidateCaps);\n    this.locatorStrategies = [\n      'id',\n      'class name',\n      'accessibility id',\n    ];\n    this.desiredCapConstraints = desiredCapConstraints;\n    this.espresso = null;\n    this.jwpProxyActive = false;\n    this.defaultIME = null;\n    this.jwpProxyAvoid = NO_PROXY;\n\n    this.apkStrings = {}; // map of language -> strings obj\n    this.settings = new DeviceSettings({}, this.onSettingsUpdate.bind(this));\n\n    this.chromedriver = null;\n    this.sessionChromedrivers = {};\n  }\n\n  async createSession (...args) {\n    try {\n      // TODO handle otherSessionData for multiple sessions\n      let [sessionId, caps] = await super.createSession(...args);\n\n      let serverDetails = {\n        platform: 'LINUX',\n        webStorageEnabled: false,\n        takesScreenshot: true,\n        javascriptEnabled: true,\n        databaseEnabled: false,\n        networkConnectionEnabled: true,\n        locationContextEnabled: false,\n        warnings: {},\n        desired: Object.assign({}, this.caps)\n      };\n\n      this.caps = Object.assign(serverDetails, this.caps);\n\n      this.curContext = this.defaultContextName();\n\n      let defaultOpts = {\n        fullReset: false,\n        autoLaunch: true,\n        adbPort: DEFAULT_ADB_PORT,\n        androidInstallTimeout: 90000\n      };\n      _.defaults(this.opts, defaultOpts);\n\n      if (this.isChromeSession) {\n        if (this.opts.app) {\n          logger.warn(`\n            'browserName' capability will be ignored.\n            Chrome browser cannot be run in Espresso sessions because Espresso automation doesn't have permission to access Chrome.\n          `);\n        } else {\n          logger.errorAndThrow(`Chrome browser sessions cannot be run in Espresso because Espresso automation doesn't have permission to access Chrome`);\n        }\n      }\n\n      if (this.opts.reboot) {\n        this.setAvdFromCapabilities(caps);\n        this.addWipeDataToAvdArgs();\n      }\n\n      if (this.opts.app) {\n        // find and copy, or download and unzip an app url or path\n        this.opts.app = await this.helpers.configureApp(this.opts.app, APP_EXTENSION);\n        await this.checkAppPresent();\n      } else if (this.appOnDevice) {\n        // the app isn't an actual app file but rather something we want to\n        // assume is on the device and just launch via the appPackage\n        logger.info(`App file was not listed, instead we're going to run ` +\n            `${this.opts.appPackage} directly on the device`);\n        await this.checkPackagePresent();\n      }\n\n      this.opts.systemPort = this.opts.systemPort || await findAPortNotInUse(SYSTEM_PORT_RANGE[0], SYSTEM_PORT_RANGE[1]);\n      this.opts.adbPort = this.opts.adbPort || DEFAULT_ADB_PORT;\n      await this.startEspressoSession();\n      return [sessionId, caps];\n    } catch (e) {\n      await this.deleteSession();\n      e.message += '. Check https://github.com/appium/appium-espresso-driver#troubleshooting regarding advanced session startup troubleshooting.';\n      if (isErrorType(e, errors.SessionNotCreatedError)) {\n        throw e;\n      }\n      const err = new errors.SessionNotCreatedError(e.message);\n      err.stack = e.stack;\n      throw err;\n    }\n  }\n\n  get driverData () {\n    // TODO fille out resource info here\n    return {};\n  }\n\n  isEmulator () {\n    return helpers.isEmulator(this.adb, this.opts);\n  }\n\n  // TODO this method is duplicated from uiautomator2-driver; consolidate\n  setAvdFromCapabilities (caps) {\n    if (this.opts.avd) {\n      logger.info('avd name defined, ignoring device name and platform version');\n    } else {\n      if (!caps.deviceName) {\n        logger.errorAndThrow('avd or deviceName should be specified when reboot option is enables');\n      }\n      if (!caps.platformVersion) {\n        logger.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');\n      }\n      let avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');\n      this.opts.avd = `${avdDevice}__${caps.platformVersion}`;\n    }\n  }\n\n  // TODO this method is duplicated from uiautomator2-driver; consolidate\n  addWipeDataToAvdArgs () {\n    if (!this.opts.avdArgs) {\n      this.opts.avdArgs = '-wipe-data';\n    } else if (!this.opts.avdArgs.toLowerCase().includes('-wipe-data')) {\n      this.opts.avdArgs += ' -wipe-data';\n    }\n  }\n\n  // TODO much of this logic is duplicated from uiautomator2\n  async startEspressoSession () {\n    logger.info(`EspressoDriver version: ${version}`);\n\n    // get device udid for this session\n    let {udid, emPort} = await helpers.getDeviceInfoFromCaps(this.opts);\n    this.opts.udid = udid;\n    this.opts.emPort = emPort;\n\n    // now that we know our java version and device info, we can create our\n    // ADB instance\n    this.adb = await androidHelpers.createADB(this.opts);\n\n    // Read https://github.com/appium/appium-android-driver/pull/461 what happens if ther is no setHiddenApiPolicy for Android P+\n    if (await this.adb.getApiLevel() >= 28) { // Android P\n      logger.warn('Relaxing hidden api policy');\n      await this.adb.setHiddenApiPolicy('1', !!this.opts.ignoreHiddenApiPolicyError);\n    }\n\n    // get appPackage et al from manifest if necessary\n    let appInfo = await helpers.getLaunchInfo(this.adb, this.opts);\n    if (appInfo) {\n      // and get it onto our 'opts' object so we use it from now on\n      Object.assign(this.opts, appInfo);\n    } else {\n      appInfo = this.opts;\n    }\n\n    // start an avd, set the language/locale, pick an emulator, etc...\n    // TODO with multiple devices we'll need to parameterize this\n    await helpers.initDevice(this.adb, this.opts);\n    // https://github.com/appium/appium-espresso-driver/issues/72\n    if (await this.adb.isAnimationOn()) {\n      try {\n        await this.adb.setAnimationState(false);\n        this.wasAnimationEnabled = true;\n      } catch (err) {\n        logger.warn(`Unable to turn off animations: ${err.message}`);\n      }\n    }\n\n    // set actual device name, udid\n    this.caps.deviceName = this.adb.curDeviceId;\n    this.caps.deviceUDID = this.opts.udid;\n\n    // set up the modified espresso server etc\n    this.initEspressoServer();\n    // Further prepare the device by forwarding the espresso port\n    logger.debug(`Forwarding Espresso Server port ${DEVICE_PORT} to ${this.opts.systemPort}`);\n    await this.adb.forwardPort(this.opts.systemPort, DEVICE_PORT);\n\n    if (!this.opts.skipUnlock) {\n      // unlock the device to prepare it for testing\n      await helpers.unlock(this, this.adb, this.caps);\n    } else {\n      logger.debug(`'skipUnlock' capability set, so skipping device unlock`);\n    }\n\n    // set up app under test\n    // prepare our actual AUT, get it on the device, etc...\n    await this.initAUT();\n\n    //Adding AUT package name in the capabilities if package name not exist in caps\n    if (!this.caps.appPackage) {\n      this.caps.appPackage = appInfo.appPackage;\n    }\n    if (!this.caps.appWaitPackage) {\n      this.caps.appWaitPackage = appInfo.appWaitPackage || appInfo.appPackage || this.caps.appPackage;\n    }\n    if (this.caps.appActivity) {\n      this.caps.appActivity = qualifyActivityName(this.caps.appActivity, this.caps.appPackage);\n    } else {\n      this.caps.appActivity = qualifyActivityName(appInfo.appActivity, this.caps.appPackage);\n    }\n    if (this.caps.appWaitActivity) {\n      this.caps.appWaitActivity = qualifyActivityName(this.caps.appWaitActivity, this.caps.appWaitPackage);\n    } else {\n      this.caps.appWaitActivity = qualifyActivityName(appInfo.appWaitActivity || appInfo.appActivity || this.caps.appActivity,\n        this.caps.appWaitPackage);\n    }\n\n    // launch espresso and wait till its online and we have a session\n    await this.espresso.startSession(this.caps);\n    if (this.caps.autoLaunch === false) {\n      logger.info(`Not waiting for the application activity to start because 'autoLaunch' is disabled`);\n    } else {\n      await this.adb.waitForActivity(this.caps.appWaitPackage, this.caps.appWaitActivity, this.opts.appWaitDuration);\n    }\n    // if we want to immediately get into a webview, set our context\n    // appropriately\n    if (this.opts.autoWebview) {\n      await this.initWebview();\n    }\n\n    // now that everything has started successfully, turn on proxying so all\n    // subsequent session requests go straight to/from espresso\n    this.jwpProxyActive = true;\n\n    await this.addDeviceInfoToCaps();\n  }\n\n  async initWebview () {\n    const viewName = androidCommands.defaultWebviewName.call(this);\n    const timeout = this.opts.autoWebviewTimeout || 2000;\n    logger.info(`Setting webview to context '${viewName}' with timeout ${timeout}ms`);\n    await retryInterval(timeout / 500, 500, this.setContext.bind(this), viewName);\n  }\n\n  async addDeviceInfoToCaps () {\n    const {\n      apiVersion,\n      platformVersion,\n      manufacturer,\n      model,\n      realDisplaySize,\n      displayDensity,\n    } = await this.mobileGetDeviceInfo();\n    this.caps.deviceApiLevel = parseInt(apiVersion, 10);\n    this.caps.platformVersion = platformVersion;\n    this.caps.deviceScreenSize = realDisplaySize;\n    this.caps.deviceScreenDensity = displayDensity;\n    this.caps.deviceModel = model;\n    this.caps.deviceManufacturer = manufacturer;\n  }\n\n  initEspressoServer () {\n    // now that we have package and activity, we can create an instance of\n    // espresso with the appropriate data\n    this.espresso = new EspressoRunner({\n      host: this.opts.remoteAdbHost || this.opts.host || 'localhost',\n      systemPort: this.opts.systemPort,\n      devicePort: DEVICE_PORT,\n      adb: this.adb,\n      apk: this.opts.app,\n      tmpDir: this.opts.tmpDir,\n      appPackage: this.opts.appPackage,\n      appActivity: this.opts.appActivity,\n      forceEspressoRebuild: !!this.opts.forceEspressoRebuild,\n      espressoBuildConfig: this.opts.espressoBuildConfig,\n      showGradleLog: !!this.opts.showGradleLog,\n      serverLaunchTimeout: this.opts.espressoServerLaunchTimeout,\n      androidInstallTimeout: this.opts.androidInstallTimeout,\n      skipServerInstallation: this.opts.skipServerInstallation,\n      useKeystore: this.opts.useKeystore,\n      keystorePath: this.opts.keystorePath,\n      keystorePassword: this.opts.keystorePassword,\n      keyAlias: this.opts.keyAlias,\n      keyPassword: this.opts.keyPassword,\n      disableSuppressAccessibilityService: this.opts.disableSuppressAccessibilityService,\n    });\n    this.proxyReqRes = this.espresso.proxyReqRes.bind(this.espresso);\n  }\n\n  // TODO this method is mostly duplicated from uiautomator2\n  async initAUT () {\n    // set the localized strings for the current language from the apk\n    // TODO: incorporate changes from appium#5308 which fix a race cond-\n    // ition bug in old appium and need to be replicated here\n    // this.apkStrings[this.opts.language] = await androidHelpers.pushStrings(\n    //     this.opts.language, this.adb, this.opts);\n\n    // Uninstall any uninstallOtherPackages which were specified in caps\n    if (this.opts.uninstallOtherPackages) {\n      await helpers.uninstallOtherPackages(\n        this.adb,\n        helpers.parseArray(this.opts.uninstallOtherPackages),\n        [SETTINGS_HELPER_PKG_ID, TEST_APK_PKG]\n      );\n    }\n\n    if (!this.opts.app) {\n      if (this.opts.fullReset) {\n        logger.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');\n      }\n      logger.debug('No app capability. Assuming it is already on the device');\n      if (this.opts.fastReset) {\n        await helpers.resetApp(this.adb, this.opts);\n      }\n    }\n\n    if (!this.opts.skipUninstall) {\n      await this.adb.uninstallApk(this.opts.appPackage);\n    }\n    if (this.opts.app) {\n      if (this.opts.noSign) {\n        logger.info('Skipping application signing because noSign capability is set to true. ' +\n          'Having the application under test with improper signature/non-signed will cause ' +\n          'Espresso automation startup failure.');\n      } else if (!await this.adb.checkApkCert(this.opts.app, this.opts.appPackage)) {\n        await this.adb.sign(this.opts.app, this.opts.appPackage);\n      }\n      await helpers.installApk(this.adb, this.opts);\n    }\n    if (this.opts.skipServerInstallation) {\n      logger.debug('skipServerInstallation capability is set. Not installig espresso-server ');\n    } else {\n      await this.espresso.installTestApk();\n      try {\n        await this.adb.addToDeviceIdleWhitelist(SETTINGS_HELPER_PKG_ID, TEST_APK_PKG);\n      } catch (e) {\n        logger.warn(`Cannot add server packages to the Doze whitelist. Original error: ` +\n          (e.stderr || e.message));\n      }\n    }\n  }\n\n  async deleteSession () {\n    logger.debug('Deleting espresso session');\n\n    try {\n      if (!_.isEmpty(this._screenRecordingProperties)) {\n        await this.stopRecordingScreen();\n      }\n    } catch (ign) {}\n\n    await androidHelpers.removeAllSessionWebSocketHandlers(this.server, this.sessionId);\n\n    await this.mobileStopScreenStreaming();\n\n    if (this.espresso) {\n      if (this.jwpProxyActive) {\n        await this.espresso.deleteSession();\n      }\n      this.espresso = null;\n    }\n    this.jwpProxyActive = false;\n\n    // TODO below logic is duplicated from uiautomator2\n    if (this.adb) {\n      if (this.wasAnimationEnabled) {\n        try {\n          await this.adb.setAnimationState(true);\n        } catch (err) {\n          logger.warn(`Unable to reset animation: ${err.message}`);\n        }\n      }\n      if (this.opts.unicodeKeyboard && this.opts.resetKeyboard &&\n          this.defaultIME) {\n        logger.debug(`Resetting IME to '${this.defaultIME}'`);\n        await this.adb.setIME(this.defaultIME);\n      }\n      if (!this.isChromeSession && this.opts.appPackage && !this.opts.dontStopAppOnReset) {\n        await this.adb.forceStop(this.opts.appPackage);\n      }\n      if (this.opts.fullReset && !this.opts.skipUninstall && !this.appOnDevice) {\n        logger.debug(`FULL_RESET set to 'true', Uninstalling '${this.opts.appPackage}'`);\n        await this.adb.uninstallApk(this.opts.appPackage);\n      }\n      await this.adb.stopLogcat();\n      if (this.opts.reboot) {\n        let avdName = this.opts.avd.replace('@', '');\n        logger.debug(`closing emulator '${avdName}'`);\n        await this.adb.killEmulator(avdName);\n      }\n      if (await this.adb.getApiLevel() >= 28) { // Android P\n        logger.info('Restoring hidden api policy to the device default configuration');\n        await this.adb.setDefaultHiddenApiPolicy(!!this.opts.ignoreHiddenApiPolicyError);\n      }\n    }\n    await super.deleteSession();\n    if (this.opts.systemPort !== undefined) {\n      try {\n        await this.adb.removePortForward(this.opts.systemPort);\n      } catch (error) {\n        logger.warn(`Unable to remove port forward '${error.message}'`);\n        //Ignore, this block will also be called when we fall in catch block\n        // and before even port forward.\n      }\n    }\n  }\n\n  // TODO method is duplicated from uiautomator2\n  async checkAppPresent () {\n    logger.debug('Checking whether app is actually present');\n    if (!(await fs.exists(this.opts.app))) {\n      logger.errorAndThrow(`Could not find app apk at '${this.opts.app}'`);\n    }\n  }\n\n  async onSettingsUpdate () {\n    // intentionally do nothing here, since commands.updateSettings proxies\n    // settings to the espresso server already\n  }\n\n  proxyActive (sessionId) {\n    super.proxyActive(sessionId);\n\n    // we always have an active proxy to the espresso server\n    return true;\n  }\n\n  canProxy (sessionId) {\n    super.canProxy(sessionId);\n\n    // we can always proxy to the espresso server\n    return true;\n  }\n\n  getProxyAvoidList (sessionId) {\n    super.getProxyAvoidList(sessionId);\n    // we are maintaining two sets of NO_PROXY lists, one for chromedriver(CHROME_NO_PROXY)\n    // and one for Espresso(NO_PROXY), based on current context will return related NO_PROXY list\n    this.jwpProxyAvoid = _.isNil(this.chromedriver) ? NO_PROXY : CHROME_NO_PROXY;\n    if (this.opts.nativeWebScreenshot) {\n      this.jwpProxyAvoid = [...this.jwpProxyAvoid, ['GET', new RegExp('^/session/[^/]+/screenshot')]];\n    }\n\n    return this.jwpProxyAvoid;\n  }\n\n  get isChromeSession () {\n    return helpers.isChromeBrowser(this.opts.browserName);\n  }\n}\n\n// first add the android-driver commands which we will fall back to\nfor (let [cmd, fn] of _.toPairs(androidCommands)) {\n  // we do some different/special things with these methods\n  if (!_.includes(['defaultWebviewName'], cmd)) {\n    EspressoDriver.prototype[cmd] = fn;\n  }\n}\n\n// then overwrite with any espresso-specific commands\nfor (let [cmd, fn] of _.toPairs(commands)) {\n  EspressoDriver.prototype[cmd] = fn;\n}\n\nexport { EspressoDriver };\nexport default EspressoDriver;\n"],"file":"lib/driver.js","sourceRoot":"../.."}