appium-android-driver 5.14.7 → 6.0.1

package/lib/commands/context.js

@@ -1,479 +1,495 @@
-import _ from 'lodash';
+/* eslint-disable require-await */
+// @ts-check
+import {util} from '@appium/support';
 import Chromedriver from 'appium-chromedriver';
-import PortFinder from 'portfinder';
+import {errors} from 'appium/driver';
 import B from 'bluebird';
-import { util } from '@appium/support';
-import { errors } from 'appium/driver';
+import _ from 'lodash';
+import PortFinder from 'portfinder';
 import {
-  default as webviewHelpers,
-  NATIVE_WIN, WEBVIEW_BASE, WEBVIEW_WIN, CHROMIUM_WIN, KNOWN_CHROME_PACKAGE_NAMES
-} from '../webview-helpers';
-import { APP_STATE } from '../android-helpers';
+  APP_STATE,
+  CHROMIUM_WIN,
+  KNOWN_CHROME_PACKAGE_NAMES,
+  NATIVE_WIN,
+  WEBVIEW_BASE,
+  WEBVIEW_WIN,
+  WebviewHelpers,
+} from '../helpers';
+import {mixin} from './mixins';
 
 const CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'chromedriver_autodownload';
 
-let commands = {}, helpers = {}, extensions = {};
-
-
-/* -------------------------------
- * Actual MJSONWP command handlers
- * ------------------------------- */
-commands.getCurrentContext = async function getCurrentContext () { // eslint-disable-line require-await
-  // if the current context is `null`, indicating no context
-  // explicitly set, it is the default context
-  return this.curContext || this.defaultContextName();
-};
-
-commands.getContexts = async function getContexts () {
-  const webviewsMapping = await webviewHelpers.getWebViewsMapping(this.adb, this.opts);
-  return this.assignContexts(webviewsMapping);
-};
-
-commands.setContext = async function setContext (name) {
-  if (!util.hasValue(name)) {
-    name = this.defaultContextName();
-  } else if (name === WEBVIEW_WIN) {
-    // handle setContext "WEBVIEW"
-    name = this.defaultWebviewName();
-  }
-  // if we're already in the context we want, do nothing
-  if (name === this.curContext) {
-    return;
-  }
-
-  const webviewsMapping = await webviewHelpers.getWebViewsMapping(this.adb, this.opts);
-  const contexts = this.assignContexts(webviewsMapping);
-  // if the context we want doesn't exist, fail
-  if (!_.includes(contexts, name)) {
-    throw new errors.NoSuchContextError();
-  }
-
-  await this.switchContext(name, webviewsMapping);
-  this.curContext = name;
-};
-
 /**
- * @typedef {Object} WebviewsMapping
- * @property {string} proc The name of the Devtools Unix socket
- * @property {string} webview The web view alias. Looks like `WEBVIEW_`
- * prefix plus PID or package name
- * @property {?Object} info Webview information as it is retrieved by
- * /json/version CDP endpoint
- * @property {?Array<Object>} pages Webview pages list as it is retrieved by
- * /json/list CDP endpoint
- * @propery {?string} webviewName An actual webview name for switching context.
- * This value becomes null when failing to find a PID for a webview.
- *
- * The following json demonstrates the example of WebviewsMapping object.
- * Note that `description` in `page` can be an empty string most likely when it comes to Mobile Chrome)
- * {
- *   "proc": "@webview_devtools_remote_22138",
- *   "webview": "WEBVIEW_22138",
- *   "info": {
- *     "Android-Package": "io.appium.settings",
- *     "Browser": "Chrome/74.0.3729.185",
- *     "Protocol-Version": "1.3",
- *     "User-Agent": "Mozilla/5.0 (Linux; Android 10; Android SDK built for x86 Build/QSR1.190920.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.185 Mobile Safari/537.36",
- *     "V8-Version": "7.4.288.28",
- *     "WebKit-Version": "537.36 (@22955682f94ce09336197bfb8dffea991fa32f0d)",
- *     "webSocketDebuggerUrl": "ws://127.0.0.1:10900/devtools/browser"
- *   },
- *   "pages": [
- *     {
- *       "description": "{\"attached\":true,\"empty\":false,\"height\":1458,\"screenX\":0,\"screenY\":336,\"visible\":true,\"width\":1080}",
- *       "devtoolsFrontendUrl": "http://chrome-devtools-frontend.appspot.com/serve_rev/@22955682f94ce09336197bfb8dffea991fa32f0d/inspector.html?ws=127.0.0.1:10900/devtools/page/27325CC50B600D31B233F45E09487B1F",
- *       "id": "27325CC50B600D31B233F45E09487B1F",
- *       "title": "Releases · appium/appium · GitHub",
- *       "type": "page",
- *       "url": "https://github.com/appium/appium/releases",
- *       "webSocketDebuggerUrl": "ws://127.0.0.1:10900/devtools/page/27325CC50B600D31B233F45E09487B1F"
- *     }
- *   ],
- *   "webviewName": "WEBVIEW_com.io.appium.setting"
- * }
+ * @type {import('./mixins').ContextMixin & ThisType<import('../driver').AndroidDriver>}
+ * @satisfies {import('@appium/types').ExternalDriver}
  */
-
-/**
- * Returns a webviewsMapping based on CDP endpoints
- *
- * @return {Array<WebviewsMapping>} webviewsMapping
- */
-commands.mobileGetContexts = async function mobileGetContexts () {
-  const opts = {
-    androidDeviceSocket: this.opts.androidDeviceSocket,
-    ensureWebviewsHavePages: true,
-    webviewDevtoolsPort: this.opts.webviewDevtoolsPort,
-    enableWebviewDetailsCollection: true
-  };
-  return await webviewHelpers.getWebViewsMapping(this.adb, opts);
-};
-
-helpers.assignContexts = function assignContexts (webviewsMapping) {
-  const opts = Object.assign({isChromeSession: this.isChromeSession}, this.opts);
-  const webviews = webviewHelpers.parseWebviewNames(webviewsMapping, opts);
-  this.contexts = [NATIVE_WIN, ...webviews];
-  this.log.debug(`Available contexts: ${JSON.stringify(this.contexts)}`);
-  return this.contexts;
-};
-
-helpers.switchContext = async function switchContext (name, webviewsMapping) {
-  // We have some options when it comes to webviews. If we want a
-  // Chromedriver webview, we can only control one at a time.
-  if (this.isChromedriverContext(name)) {
-    // start proxying commands directly to chromedriver
-    await this.startChromedriverProxy(name, webviewsMapping);
-  } else if (this.isChromedriverContext(this.curContext)) {
-    // if we're moving to a non-chromedriver webview, and our current context
-    // _is_ a chromedriver webview, if caps recreateChromeDriverSessions is set
-    // to true then kill chromedriver session using stopChromedriverProxies or
-    // else simply suspend proxying to the latter
-    if (this.opts.recreateChromeDriverSessions) {
-      this.log.debug('recreateChromeDriverSessions set to true; killing existing chromedrivers');
-      await this.stopChromedriverProxies();
-    } else {
-      await this.suspendChromedriverProxy();
+const ContextMixin = {
+  /* -------------------------------
+   * Actual MJSONWP command handlers
+   * ------------------------------- */
+  async getCurrentContext() {
+    // if the current context is `null`, indicating no context
+    // explicitly set, it is the default context
+    return this.curContext || this.defaultContextName();
+  },
+
+  async getContexts() {
+    const webviewsMapping = await WebviewHelpers.getWebViewsMapping(
+      /** @type {ADB} */ (this.adb),
+      this.opts
+    );
+    return this.assignContexts(webviewsMapping);
+  },
+
+  async setContext(name) {
+    if (!util.hasValue(name)) {
+      name = this.defaultContextName();
+    } else if (name === WEBVIEW_WIN) {
+      // handle setContext "WEBVIEW"
+      name = this.defaultWebviewName();
+    }
+    // if we're already in the context we want, do nothing
+    if (name === this.curContext) {
+      return;
     }
-  } else {
-    throw new Error(`Didn't know how to handle switching to context '${name}'`);
-  }
-};
-
-
-/* ---------------------------------
- * On-object context-related helpers
- * --------------------------------- */
-
-// The reason this is a function and not just a constant is that both android-
-// driver and selendroid-driver use this logic, and each one returns
-// a different default context name
-helpers.defaultContextName = function defaultContextName () {
-  return NATIVE_WIN;
-};
-
-helpers.defaultWebviewName = function defaultWebviewName () {
-  return WEBVIEW_BASE + (this.opts.autoWebviewName || this.opts.appPackage);
-};
 
-helpers.isWebContext = function isWebContext () {
-  return this.curContext !== null && this.curContext !== NATIVE_WIN;
-};
+    const webviewsMapping = await WebviewHelpers.getWebViewsMapping(
+      /** @type {ADB} */ (this.adb),
+      this.opts
+    );
+    const contexts = this.assignContexts(webviewsMapping);
+    // if the context we want doesn't exist, fail
+    if (!_.includes(contexts, name)) {
+      throw new errors.NoSuchContextError();
+    }
 
-// Turn on proxying to an existing Chromedriver session or a new one
-helpers.startChromedriverProxy = async function startChromedriverProxy (context, webviewsMapping) {
-  this.log.debug(`Connecting to chrome-backed webview context '${context}'`);
-
-  let cd;
-  if (this.sessionChromedrivers[context]) {
-    // in the case where we've already set up a chromedriver for a context,
-    // we want to reconnect to it, not create a whole new one
-    this.log.debug(`Found existing Chromedriver for context '${context}'. Using it.`);
-    cd = this.sessionChromedrivers[context];
-    await setupExistingChromedriver(this.log, cd);
-  } else {
-    let opts = _.cloneDeep(this.opts);
-    opts.chromeUseRunningApp = true;
-
-    // if requested, tell chromedriver to attach to the android package we have
-    // associated with the context name, rather than the package of the AUT.
-    // And turn this on by default for chrome--if chrome pops up with a webview
-    // and someone wants to switch to it, we should let chromedriver connect to
-    // chrome rather than staying stuck on the AUT
-    if (opts.extractChromeAndroidPackageFromContextName || context === `${WEBVIEW_BASE}chrome`) {
-      let androidPackage = context.match(`${WEBVIEW_BASE}(.+)`);
-      if (androidPackage && androidPackage.length > 0) {
-        opts.chromeAndroidPackage = androidPackage[1];
+    await this.switchContext(name, webviewsMapping);
+    this.curContext = name;
+  },
+
+  async mobileGetContexts() {
+    const opts = {
+      androidDeviceSocket: this.opts.androidDeviceSocket,
+      ensureWebviewsHavePages: true,
+      webviewDevtoolsPort: this.opts.webviewDevtoolsPort,
+      enableWebviewDetailsCollection: true,
+    };
+    return await WebviewHelpers.getWebViewsMapping(/** @type {ADB} */ (this.adb), opts);
+  },
+
+  assignContexts(webviewsMapping) {
+    const opts = Object.assign({isChromeSession: this.isChromeSession}, this.opts);
+    const webviews = WebviewHelpers.parseWebviewNames(webviewsMapping, opts);
+    this.contexts = [NATIVE_WIN, ...webviews];
+    this.log.debug(`Available contexts: ${JSON.stringify(this.contexts)}`);
+    return this.contexts;
+  },
+
+  async switchContext(name, webviewsMapping) {
+    // We have some options when it comes to webviews. If we want a
+    // Chromedriver webview, we can only control one at a time.
+    if (this.isChromedriverContext(name)) {
+      // start proxying commands directly to chromedriver
+      await this.startChromedriverProxy(name, webviewsMapping);
+    } else if (this.isChromedriverContext(this.curContext)) {
+      // if we're moving to a non-chromedriver webview, and our current context
+      // _is_ a chromedriver webview, if caps recreateChromeDriverSessions is set
+      // to true then kill chromedriver session using stopChromedriverProxies or
+      // else simply suspend proxying to the latter
+      if (this.opts.recreateChromeDriverSessions) {
+        this.log.debug('recreateChromeDriverSessions set to true; killing existing chromedrivers');
+        await this.stopChromedriverProxies();
+      } else {
+        this.suspendChromedriverProxy();
       }
-      if (!opts.extractChromeAndroidPackageFromContextName) {
-        if (_.has(this.opts, 'enableWebviewDetailsCollection') && !this.opts.enableWebviewDetailsCollection) {
-          // When enableWebviewDetailsCollection capability is explicitly disabled, try to identify
-          // chromeAndroidPackage based on contexts, known chrome variant packages and queryAppState result
-          // since webviewsMapping does not have info object
-          const contexts = webviewsMapping.map((wm) => wm.webviewName);
-          for (const knownPackage of KNOWN_CHROME_PACKAGE_NAMES) {
-            if (_.includes(contexts, `${WEBVIEW_BASE}${knownPackage}`)) {
-              continue;
-            }
-            const appState = await this.queryAppState(knownPackage);
-            if (_.includes([APP_STATE.RUNNING_IN_BACKGROUND, APP_STATE.RUNNING_IN_FOREGROUND], appState)) {
-              opts.chromeAndroidPackage = knownPackage;
-              this.log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
-                `for context '${context}' by querying states of Chrome app packages`);
-              break;
+    } else {
+      throw new Error(`Didn't know how to handle switching to context '${name}'`);
+    }
+  },
+
+  /* ---------------------------------
+   * On-object context-related helpers
+   * --------------------------------- */
+
+  // The reason this is a function and not just a constant is that both android-
+  // driver and selendroid-driver use this logic, and each one returns
+  // a different default context name
+  defaultContextName() {
+    return NATIVE_WIN;
+  },
+
+  defaultWebviewName() {
+    return WEBVIEW_BASE + (this.opts.autoWebviewName || this.opts.appPackage);
+  },
+
+  isWebContext() {
+    return this.curContext !== null && this.curContext !== NATIVE_WIN;
+  },
+
+  // Turn on proxying to an existing Chromedriver session or a new one
+  async startChromedriverProxy(context, webviewsMapping) {
+    this.log.debug(`Connecting to chrome-backed webview context '${context}'`);
+
+    let cd;
+    if (this.sessionChromedrivers[context]) {
+      // in the case where we've already set up a chromedriver for a context,
+      // we want to reconnect to it, not create a whole new one
+      this.log.debug(`Found existing Chromedriver for context '${context}'. Using it.`);
+      cd = this.sessionChromedrivers[context];
+      await this.setupExistingChromedriver(this.log, cd);
+    } else {
+      // XXX: this suppresses errors about putting arbitrary stuff on opts
+      const opts = /** @type {any} */ (_.cloneDeep(this.opts));
+      opts.chromeUseRunningApp = true;
+
+      // if requested, tell chromedriver to attach to the android package we have
+      // associated with the context name, rather than the package of the AUT.
+      // And turn this on by default for chrome--if chrome pops up with a webview
+      // and someone wants to switch to it, we should let chromedriver connect to
+      // chrome rather than staying stuck on the AUT
+      if (opts.extractChromeAndroidPackageFromContextName || context === `${WEBVIEW_BASE}chrome`) {
+        let androidPackage = context.match(`${WEBVIEW_BASE}(.+)`);
+        if (androidPackage && androidPackage.length > 0) {
+          opts.chromeAndroidPackage = androidPackage[1];
+        }
+        if (!opts.extractChromeAndroidPackageFromContextName) {
+          if (
+            _.has(this.opts, 'enableWebviewDetailsCollection') &&
+            !this.opts.enableWebviewDetailsCollection
+          ) {
+            // When enableWebviewDetailsCollection capability is explicitly disabled, try to identify
+            // chromeAndroidPackage based on contexts, known chrome variant packages and queryAppState result
+            // since webviewsMapping does not have info object
+            const contexts = webviewsMapping.map((wm) => wm.webviewName);
+            for (const knownPackage of KNOWN_CHROME_PACKAGE_NAMES) {
+              if (_.includes(contexts, `${WEBVIEW_BASE}${knownPackage}`)) {
+                continue;
+              }
+              const appState = await this.queryAppState(knownPackage);
+              if (
+                _.includes(
+                  [APP_STATE.RUNNING_IN_BACKGROUND, APP_STATE.RUNNING_IN_FOREGROUND],
+                  appState
+                )
+              ) {
+                opts.chromeAndroidPackage = knownPackage;
+                this.log.debug(
+                  `Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
+                    `for context '${context}' by querying states of Chrome app packages`
+                );
+                break;
+              }
             }
-          }
-        } else {
-          for (const wm of webviewsMapping) {
-            if (wm.webviewName === context && _.has(wm?.info, 'Android-Package')) {
-              opts.chromeAndroidPackage = wm.info['Android-Package'];
-              this.log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
-                `for context '${context}' by CDP`);
-              break;
+          } else {
+            for (const wm of webviewsMapping) {
+              if (wm.webviewName === context && _.has(wm?.info, 'Android-Package')) {
+                // XXX: should be a type guard here
+                opts.chromeAndroidPackage =
+                  /** @type {NonNullable<import('./types').WebviewsMapping['info']>} */ (wm.info)[
+                    'Android-Package'
+                  ];
+                this.log.debug(
+                  `Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
+                    `for context '${context}' by CDP`
+                );
+                break;
+              }
             }
           }
         }
       }
-    }
 
-    cd = await this.setupNewChromedriver(opts, this.adb.curDeviceId, this.adb, context);
-    // bind our stop/exit handler, passing in context so we know which
-    // one stopped unexpectedly
-    cd.on(Chromedriver.EVENT_CHANGED, (msg) => {
+      cd = await this.setupNewChromedriver(
+        opts,
+        /** @type {string} */ (/** @type {ADB} */ (this.adb).curDeviceId),
+        /** @type {ADB} */ (this.adb),
+        context
+      );
+      // bind our stop/exit handler, passing in context so we know which
+      // one stopped unexpectedly
+      cd.on(Chromedriver.EVENT_CHANGED, (msg) => {
+        if (msg.state === Chromedriver.STATE_STOPPED) {
+          this.onChromedriverStop(context);
+        }
+      });
+      // save the chromedriver object under the context
+      this.sessionChromedrivers[context] = cd;
+    }
+    // hook up the local variables so we can proxy this biz
+    this.chromedriver = cd;
+    this.proxyReqRes = this.chromedriver.proxyReq.bind(this.chromedriver);
+    this.proxyCommand = /** @type {import('@appium/types').ExternalDriver['proxyCommand']} */ (
+      this.chromedriver.jwproxy.command.bind(this.chromedriver.jwproxy)
+    );
+    this.jwpProxyActive = true;
+  },
+
+  // Stop proxying to any Chromedriver
+  suspendChromedriverProxy() {
+    this.chromedriver = undefined;
+    this.proxyReqRes = undefined;
+    this.proxyCommand = undefined;
+    this.jwpProxyActive = false;
+  },
+
+  // Handle an out-of-band Chromedriver stop event
+  async onChromedriverStop(context) {
+    this.log.warn(`Chromedriver for context ${context} stopped unexpectedly`);
+    if (context === this.curContext) {
+      // we exited unexpectedly while automating the current context and so want
+      // to shut down the session and respond with an error
+      let err = new Error('Chromedriver quit unexpectedly during session');
+      await this.startUnexpectedShutdown(err);
+    } else {
+      // if a Chromedriver in the non-active context barfs, we don't really
+      // care, we'll just make a new one next time we need the context.
+      this.log.warn(
+        "Chromedriver quit unexpectedly, but it wasn't the active " + 'context, ignoring'
+      );
+      delete this.sessionChromedrivers[context];
+    }
+  },
+
+  // Intentionally stop all the chromedrivers currently active, and ignore
+  // their exit events
+  async stopChromedriverProxies() {
+    this.suspendChromedriverProxy(); // make sure we turn off the proxy flag
+    for (let context of _.keys(this.sessionChromedrivers)) {
+      let cd = this.sessionChromedrivers[context];
+      this.log.debug(`Stopping chromedriver for context ${context}`);
+      // stop listening for the stopped state event
+      cd.removeAllListeners(Chromedriver.EVENT_CHANGED);
+      try {
+        await cd.stop();
+      } catch (err) {
+        this.log.warn(`Error stopping Chromedriver: ${/** @type {Error} */ (err).message}`);
+      }
+      delete this.sessionChromedrivers[context];
+    }
+  },
+
+  isChromedriverContext(viewName) {
+    return _.includes(viewName, WEBVIEW_WIN) || viewName === CHROMIUM_WIN;
+  },
+
+  shouldDismissChromeWelcome() {
+    return (
+      !!this.opts.chromeOptions &&
+      _.isArray(this.opts.chromeOptions.args) &&
+      this.opts.chromeOptions.args.includes('--no-first-run')
+    );
+  },
+
+  async dismissChromeWelcome() {
+    this.log.info('Trying to dismiss Chrome welcome');
+    let activity = await this.getCurrentActivity();
+    if (activity !== 'org.chromium.chrome.browser.firstrun.FirstRunActivity') {
+      this.log.info('Chrome welcome dialog never showed up! Continuing');
+      return;
+    }
+    let el = await this.findElOrEls('id', 'com.android.chrome:id/terms_accept', false);
+    await this.click(/** @type {string} */ (el.ELEMENT));
+    try {
+      let el = await this.findElOrEls('id', 'com.android.chrome:id/negative_button', false);
+      await this.click(/** @type {string} */ (el.ELEMENT));
+    } catch (e) {
+      // DO NOTHING, THIS DEVICE DIDNT LAUNCH THE SIGNIN DIALOG
+      // IT MUST BE A NON GMS DEVICE
+      this.log.warn(
+        `This device did not show Chrome SignIn dialog, ${/** @type {Error} */ (e).message}`
+      );
+    }
+  },
+
+  async startChromeSession() {
+    this.log.info('Starting a chrome-based browser session');
+    // XXX: this suppresses errors about putting arbitrary stuff on opts
+    const opts = /** @type {any} */ (_.cloneDeep(this.opts));
+
+    const knownPackages = [
+      'org.chromium.chrome.shell',
+      'com.android.chrome',
+      'com.chrome.beta',
+      'org.chromium.chrome',
+      'org.chromium.webview_shell',
+    ];
+
+    if (_.includes(knownPackages, this.opts.appPackage)) {
+      opts.chromeBundleId = this.opts.appPackage;
+    } else {
+      opts.chromeAndroidActivity = this.opts.appActivity;
+    }
+    this.chromedriver = await this.setupNewChromedriver(
+      opts,
+      /** @type {string} */ (/** @type {ADB} */ (this.adb).curDeviceId),
+      /** @type {ADB} */ (this.adb)
+    );
+    this.chromedriver.on(Chromedriver.EVENT_CHANGED, (msg) => {
       if (msg.state === Chromedriver.STATE_STOPPED) {
-        this.onChromedriverStop(context);
+        this.onChromedriverStop(CHROMIUM_WIN);
       }
     });
-    // save the chromedriver object under the context
-    this.sessionChromedrivers[context] = cd;
-  }
-  // hook up the local variables so we can proxy this biz
-  this.chromedriver = cd;
-  this.proxyReqRes = this.chromedriver.proxyReq.bind(this.chromedriver);
-  this.proxyCommand = this.chromedriver.jwproxy.command.bind(this.chromedriver.jwproxy);
-  this.jwpProxyActive = true;
-};
-
-// Stop proxying to any Chromedriver
-helpers.suspendChromedriverProxy = function suspendChromedriverProxy () {
-  this.chromedriver = null;
-  this.proxyReqRes = null;
-  this.proxyCommand = null;
-  this.jwpProxyActive = false;
-};
 
-// Handle an out-of-band Chromedriver stop event
-helpers.onChromedriverStop = async function onChromedriverStop (context) {
-  this.log.warn(`Chromedriver for context ${context} stopped unexpectedly`);
-  if (context === this.curContext) {
-    // we exited unexpectedly while automating the current context and so want
-    // to shut down the session and respond with an error
-    let err = new Error('Chromedriver quit unexpectedly during session');
-    await this.startUnexpectedShutdown(err);
-  } else {
-    // if a Chromedriver in the non-active context barfs, we don't really
-    // care, we'll just make a new one next time we need the context.
-    this.log.warn("Chromedriver quit unexpectedly, but it wasn't the active " +
-      'context, ignoring');
-    delete this.sessionChromedrivers[context];
-  }
-};
-
-// Intentionally stop all the chromedrivers currently active, and ignore
-// their exit events
-helpers.stopChromedriverProxies = async function stopChromedriverProxies () {
-  this.suspendChromedriverProxy(); // make sure we turn off the proxy flag
-  for (let context of _.keys(this.sessionChromedrivers)) {
-    let cd = this.sessionChromedrivers[context];
-    this.log.debug(`Stopping chromedriver for context ${context}`);
-    // stop listening for the stopped state event
-    cd.removeAllListeners(Chromedriver.EVENT_CHANGED);
-    try {
-      await cd.stop();
-    } catch (err) {
-      this.log.warn(`Error stopping Chromedriver: ${err.message}`);
+    // Now that we have a Chrome session, we ensure that the context is
+    // appropriately set and that this chromedriver is added to the list
+    // of session chromedrivers so we can switch back and forth
+    this.curContext = CHROMIUM_WIN;
+    this.sessionChromedrivers[CHROMIUM_WIN] = this.chromedriver;
+    this.proxyReqRes = this.chromedriver.proxyReq.bind(this.chromedriver);
+    this.proxyCommand = /** @type {import('@appium/types').ExternalDriver['proxyCommand']} */ (
+      this.chromedriver.jwproxy.command.bind(this.chromedriver.jwproxy)
+    );
+    this.jwpProxyActive = true;
+
+    if (this.shouldDismissChromeWelcome()) {
+      // dismiss Chrome welcome dialog
+      await this.dismissChromeWelcome();
+    }
+  },
+
+  /* --------------------------
+   * Internal library functions
+   * -------------------------- */
+
+  async setupExistingChromedriver(log, chromedriver) {
+    // check the status by sending a simple window-based command to ChromeDriver
+    // if there is an error, we want to recreate the ChromeDriver session
+    if (!(await chromedriver.hasWorkingWebview())) {
+      log.debug('ChromeDriver is not associated with a window. ' + 'Re-initializing the session.');
+      await chromedriver.restart();
+    }
+    return chromedriver;
+  },
+
+  async getChromedriverPort(portSpec, log) {
+    const getPort = /** @type {(opts?: import('portfinder').PortFinderOptions) => B<number>} */ (
+      B.promisify(PortFinder.getPort, {context: PortFinder})
+    );
+
+    // if the user didn't give us any specific information about chromedriver
+    // port ranges, just find any free port
+    if (!portSpec) {
+      const port = await getPort();
+      log?.debug(`A port was not given, using random free port: ${port}`);
+      return port;
     }
-    delete this.sessionChromedrivers[context];
-  }
-};
-
-helpers.isChromedriverContext = function isChromedriverContext (viewName) {
-  return _.includes(viewName, WEBVIEW_WIN) || viewName === CHROMIUM_WIN;
-};
-
-helpers.shouldDismissChromeWelcome = function shouldDismissChromeWelcome () {
-  return !!this.opts.chromeOptions &&
-         _.isArray(this.opts.chromeOptions.args) &&
-         this.opts.chromeOptions.args.includes('--no-first-run');
-};
-
-helpers.dismissChromeWelcome = async function dismissChromeWelcome () {
-  this.log.info('Trying to dismiss Chrome welcome');
-  let activity = await this.getCurrentActivity();
-  if (activity !== 'org.chromium.chrome.browser.firstrun.FirstRunActivity') {
-    this.log.info('Chrome welcome dialog never showed up! Continuing');
-    return;
-  }
-  let el = await this.findElOrEls('id', 'com.android.chrome:id/terms_accept', false);
-  await this.click(el.ELEMENT);
-  try {
-    let el = await this.findElOrEls('id', 'com.android.chrome:id/negative_button', false);
-    await this.click(el.ELEMENT);
-  } catch (e) {
-    // DO NOTHING, THIS DEVICE DIDNT LAUNCH THE SIGNIN DIALOG
-    // IT MUST BE A NON GMS DEVICE
-    this.log.warn(`This device did not show Chrome SignIn dialog, ${e.message}`);
-  }
-};
 
-helpers.startChromeSession = async function startChromeSession () {
-  this.log.info('Starting a chrome-based browser session');
-  let opts = _.cloneDeep(this.opts);
-
-  const knownPackages = [
-    'org.chromium.chrome.shell',
-    'com.android.chrome',
-    'com.chrome.beta',
-    'org.chromium.chrome',
-    'org.chromium.webview_shell',
-  ];
-
-  if (_.includes(knownPackages, this.opts.appPackage)) {
-    opts.chromeBundleId = this.opts.appPackage;
-  } else {
-    opts.chromeAndroidActivity = this.opts.appActivity;
-  }
-  this.chromedriver = await this.setupNewChromedriver(opts, this.adb.curDeviceId, this.adb);
-  this.chromedriver.on(Chromedriver.EVENT_CHANGED, (msg) => {
-    if (msg.state === Chromedriver.STATE_STOPPED) {
-      this.onChromedriverStop(CHROMIUM_WIN);
+    // otherwise find the free port based on a list or range provided by the user
+    log?.debug(`Finding a free port for chromedriver using spec ${JSON.stringify(portSpec)}`);
+    let foundPort = null;
+    for (const potentialPort of portSpec) {
+      /** @type {number} */
+      let port;
+      /** @type {number} */
+      let stopPort;
+      if (_.isArray(potentialPort)) {
+        [port, stopPort] = potentialPort.map((p) => parseInt(String(p), 10));
+      } else {
+        port = parseInt(String(potentialPort), 10); // ensure we have a number and not a string
+        stopPort = port;
+      }
+      try {
+        log?.debug(`Checking port range ${port}:${stopPort}`);
+        foundPort = await getPort({port, stopPort});
+        break;
+      } catch (e) {
+        log?.debug(`Nothing in port range ${port}:${stopPort} was available`);
+      }
     }
-  });
-
-  // Now that we have a Chrome session, we ensure that the context is
-  // appropriately set and that this chromedriver is added to the list
-  // of session chromedrivers so we can switch back and forth
-  this.curContext = CHROMIUM_WIN;
-  this.sessionChromedrivers[CHROMIUM_WIN] = this.chromedriver;
-  this.proxyReqRes = this.chromedriver.proxyReq.bind(this.chromedriver);
-  this.proxyCommand = this.chromedriver.jwproxy.command.bind(this.chromedriver.jwproxy);
-  this.jwpProxyActive = true;
-
-  if (this.shouldDismissChromeWelcome()) {
-    // dismiss Chrome welcome dialog
-    await this.dismissChromeWelcome();
-  }
-};
 
+    if (foundPort === null) {
+      throw new Error(
+        `Could not find a free port for chromedriver using ` +
+          `chromedriverPorts spec ${JSON.stringify(portSpec)}`
+      );
+    }
 
-/* --------------------------
- * Internal library functions
- * -------------------------- */
+    log?.debug(`Using free port ${foundPort} for chromedriver`);
+    return foundPort;
+  },
 
-async function setupExistingChromedriver (log, chromedriver) {
-  // check the status by sending a simple window-based command to ChromeDriver
-  // if there is an error, we want to recreate the ChromeDriver session
-  if (!await chromedriver.hasWorkingWebview()) {
-    log.debug('ChromeDriver is not associated with a window. ' +
-                 'Re-initializing the session.');
-    await chromedriver.restart();
-  }
-  return chromedriver;
-}
+  isChromedriverAutodownloadEnabled() {
+    if (this.isFeatureEnabled(CHROMEDRIVER_AUTODOWNLOAD_FEATURE)) {
+      return true;
+    }
+    this?.log?.debug(
+      `Automated Chromedriver download is disabled. ` +
+        `Use '${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}' server feature to enable it`
+    );
+    return false;
+  },
+
+  async setupNewChromedriver(opts, curDeviceId, adb, context) {
+    if (opts.chromeDriverPort) {
+      this?.log?.warn(
+        `The 'chromeDriverPort' capability is deprecated. Please use 'chromedriverPort' instead`
+      );
+      opts.chromedriverPort = opts.chromeDriverPort;
+    }
 
-/**
- * Find a free port to have Chromedriver listen on.
- *
- * @param {array} portSpec - Array which is a list of ports. A list item may
- * also itself be an array of length 2 specifying a start and end port of
- * a range. Some valid port specs:
- *    - [8000, 8001, 8002]
- *    - [[8000, 8005]]
- *    - [8000, [9000, 9100]]
- * @param {Object?} log Logger instance
- *
- * @return {number} A free port
- */
-async function getChromedriverPort (portSpec, log = null) {
-  const getPort = B.promisify(PortFinder.getPort, {context: PortFinder});
-
-  // if the user didn't give us any specific information about chromedriver
-  // port ranges, just find any free port
-  if (!portSpec) {
-    const port = await getPort();
-    log?.debug(`A port was not given, using random free port: ${port}`);
-    return port;
-  }
-
-  // otherwise find the free port based on a list or range provided by the user
-  log?.debug(`Finding a free port for chromedriver using spec ${JSON.stringify(portSpec)}`);
-  let foundPort = null;
-  for (const potentialPort of portSpec) {
-    let port, stopPort;
-    if (_.isArray(potentialPort)) {
-      ([port, stopPort] = potentialPort);
+    if (opts.chromedriverPort) {
+      this?.log?.debug(`Using user-specified port ${opts.chromedriverPort} for chromedriver`);
     } else {
-      port = parseInt(potentialPort, 10); // ensure we have a number and not a string
-      stopPort = port;
+      // if a single port wasn't given, we'll look for a free one
+      opts.chromedriverPort = await this.getChromedriverPort(opts.chromedriverPorts, this?.log);
     }
-    try {
-      log?.debug(`Checking port range ${port}:${stopPort}`);
-      foundPort = await getPort({port, stopPort});
-      break;
-    } catch (e) {
-      log?.debug(`Nothing in port range ${port}:${stopPort} was available`);
+
+    const details = context ? WebviewHelpers.getWebviewDetails(adb, context) : undefined;
+    if (!_.isEmpty(details)) {
+      this?.log?.debug(
+        'Passing web view details to the Chromedriver constructor: ' +
+          JSON.stringify(details, null, 2)
+      );
     }
-  }
-
-  if (foundPort === null) {
-    throw new Error(`Could not find a free port for chromedriver using ` +
-                    `chromedriverPorts spec ${JSON.stringify(portSpec)}`);
-  }
-
-  log?.debug(`Using free port ${foundPort} for chromedriver`);
-  return foundPort;
-}
-
-helpers.isChromedriverAutodownloadEnabled = function isChromedriverAutodownloadEnabled () {
-  if (this.isFeatureEnabled(CHROMEDRIVER_AUTODOWNLOAD_FEATURE)) {
-    return true;
-  }
-  this?.log?.debug(`Automated Chromedriver download is disabled. ` +
-    `Use '${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}' server feature to enable it`);
-  return false;
-};
 
-helpers.setupNewChromedriver = async function setupNewChromedriver (opts, curDeviceId, adb, context = null) {
-  if (opts.chromeDriverPort) {
-    this?.log?.warn(`The 'chromeDriverPort' capability is deprecated. Please use 'chromedriverPort' instead`);
-    opts.chromedriverPort = opts.chromeDriverPort;
-  }
-
-  if (opts.chromedriverPort) {
-    this?.log?.debug(`Using user-specified port ${opts.chromedriverPort} for chromedriver`);
-  } else {
-    // if a single port wasn't given, we'll look for a free one
-    opts.chromedriverPort = await getChromedriverPort(opts.chromedriverPorts, this?.log);
-  }
-
-  const details = context ? webviewHelpers.getWebviewDetails(adb, context) : undefined;
-  if (!_.isEmpty(details)) {
-    this?.log?.debug('Passing web view details to the Chromedriver constructor: ' +
-      JSON.stringify(details, null, 2));
-  }
-
-  const chromedriver = new Chromedriver({
-    port: opts.chromedriverPort,
-    executable: opts.chromedriverExecutable,
-    adb,
-    cmdArgs: opts.chromedriverArgs,
-    verbose: !!opts.showChromedriverLog,
-    executableDir: opts.chromedriverExecutableDir,
-    mappingPath: opts.chromedriverChromeMappingFile,
-    bundleId: opts.chromeBundleId,
-    useSystemExecutable: opts.chromedriverUseSystemExecutable,
-    disableBuildCheck: opts.chromedriverDisableBuildCheck,
-    details,
-    isAutodownloadEnabled: this?.isChromedriverAutodownloadEnabled?.()
-  });
-
-  // make sure there are chromeOptions
-  opts.chromeOptions = opts.chromeOptions || {};
-  // try out any prefixed chromeOptions,
-  // and strip the prefix
-  for (const opt of _.keys(opts)) {
-    if (opt.endsWith(':chromeOptions')) {
-      this?.log?.warn(`Merging '${opt}' into 'chromeOptions'. This may cause unexpected behavior`);
-      _.merge(opts.chromeOptions, opts[opt]);
+    const chromedriver = new Chromedriver({
+      port: String(opts.chromedriverPort),
+      executable: opts.chromedriverExecutable,
+      // eslint-disable-next-line object-shorthand
+      adb: /** @type {any} */ (adb),
+      cmdArgs: /** @type {string[]} */ (opts.chromedriverArgs),
+      verbose: !!opts.showChromedriverLog,
+      executableDir: opts.chromedriverExecutableDir,
+      mappingPath: opts.chromedriverChromeMappingFile,
+      // @ts-expect-error arbitrary value on opts?
+      bundleId: opts.chromeBundleId,
+      useSystemExecutable: opts.chromedriverUseSystemExecutable,
+      disableBuildCheck: opts.chromedriverDisableBuildCheck,
+      // @ts-expect-error FIXME: chromedriver typing are probably too strict
+      details,
+      isAutodownloadEnabled: this?.isChromedriverAutodownloadEnabled?.(),
+    });
+
+    // make sure there are chromeOptions
+    opts.chromeOptions = opts.chromeOptions || {};
+    // try out any prefixed chromeOptions,
+    // and strip the prefix
+    for (const opt of _.keys(opts)) {
+      if (opt.endsWith(':chromeOptions')) {
+        this?.log?.warn(
+          `Merging '${opt}' into 'chromeOptions'. This may cause unexpected behavior`
+        );
+        // @ts-expect-error unsafe types
+        _.merge(opts.chromeOptions, opts[opt]);
+      }
     }
-  }
 
-  const caps = webviewHelpers.createChromedriverCaps(opts, curDeviceId, details);
-  this?.log?.debug(`Before starting chromedriver, androidPackage is '${caps.chromeOptions.androidPackage}'`);
-  await chromedriver.start(caps);
-  return chromedriver;
+    const caps = /** @type {any} */ (
+      WebviewHelpers.createChromedriverCaps(opts, curDeviceId, details)
+    );
+    this?.log?.debug(
+      `Before starting chromedriver, androidPackage is '${caps.chromeOptions.androidPackage}'`
+    );
+    await chromedriver.start(caps);
+    return chromedriver;
+  },
 };
-const setupNewChromedriver = helpers.setupNewChromedriver;
 
+mixin(ContextMixin);
+
+export default ContextMixin;
+export const setupNewChromedriver = ContextMixin.setupNewChromedriver;
 
-Object.assign(extensions, commands, helpers);
-export { commands, helpers, setupNewChromedriver };
-export default extensions;
+/**
+ * @typedef {import('appium-adb').ADB} ADB
+ */