appium-android-driver 5.0.5 → 5.0.8

package/lib/commands/context.js

@@ -1,5 +1,4 @@
 import _ from 'lodash';
-import log from '../logger';
 import Chromedriver from 'appium-chromedriver';
 import PortFinder from 'portfinder';
 import B from 'bluebird';
@@ -116,7 +115,7 @@ 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];
-  log.debug(`Available contexts: ${JSON.stringify(this.contexts)}`);
+  this.log.debug(`Available contexts: ${JSON.stringify(this.contexts)}`);
   return this.contexts;
 };
 
@@ -132,7 +131,7 @@ helpers.switchContext = async function switchContext (name, webviewsMapping) {
     // to true then kill chromedriver session using stopChromedriverProxies or
     // else simply suspend proxying to the latter
     if (this.opts.recreateChromeDriverSessions) {
-      log.debug('recreateChromeDriverSessions set to true; killing existing chromedrivers');
+      this.log.debug('recreateChromeDriverSessions set to true; killing existing chromedrivers');
       await this.stopChromedriverProxies();
     } else {
       await this.suspendChromedriverProxy();
@@ -164,15 +163,15 @@ helpers.isWebContext = function isWebContext () {
 
 // Turn on proxying to an existing Chromedriver session or a new one
 helpers.startChromedriverProxy = async function startChromedriverProxy (context, webviewsMapping) {
-  log.debug(`Connecting to chrome-backed webview context '${context}'`);
+  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
-    log.debug(`Found existing Chromedriver for context '${context}'. Using it.`);
+    this.log.debug(`Found existing Chromedriver for context '${context}'. Using it.`);
     cd = this.sessionChromedrivers[context];
-    await setupExistingChromedriver(cd);
+    await setupExistingChromedriver(this.log, cd);
   } else {
     let opts = _.cloneDeep(this.opts);
     opts.chromeUseRunningApp = true;
@@ -200,7 +199,7 @@ helpers.startChromedriverProxy = async function startChromedriverProxy (context,
             const appState = await this.queryAppState(knownPackage);
             if (_.includes([APP_STATE.RUNNING_IN_BACKGROUND, APP_STATE.RUNNING_IN_FOREGROUND], appState)) {
               opts.chromeAndroidPackage = knownPackage;
-              log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
+              this.log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
                 `for context '${context}' by querying states of Chrome app packages`);
               break;
             }
@@ -209,7 +208,7 @@ helpers.startChromedriverProxy = async function startChromedriverProxy (context,
           for (const wm of webviewsMapping) {
             if (wm.webviewName === context && _.has(wm?.info, 'Android-Package')) {
               opts.chromeAndroidPackage = wm.info['Android-Package'];
-              log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
+              this.log.debug(`Identified chromeAndroidPackage as '${opts.chromeAndroidPackage}' ` +
                 `for context '${context}' by CDP`);
               break;
             }
@@ -246,7 +245,7 @@ helpers.suspendChromedriverProxy = function suspendChromedriverProxy () {
 
 // Handle an out-of-band Chromedriver stop event
 helpers.onChromedriverStop = async function onChromedriverStop (context) {
-  log.warn(`Chromedriver for context ${context} stopped unexpectedly`);
+  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
@@ -255,8 +254,8 @@ helpers.onChromedriverStop = async function onChromedriverStop (context) {
   } 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.
-    log.warn("Chromedriver quit unexpectedly, but it wasn't the active " +
-                'context, ignoring');
+    this.log.warn("Chromedriver quit unexpectedly, but it wasn't the active " +
+      'context, ignoring');
     delete this.sessionChromedrivers[context];
   }
 };
@@ -267,13 +266,13 @@ 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];
-    log.debug(`Stopping chromedriver for context ${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) {
-      log.warn(`Error stopping Chromedriver: ${err.message}`);
+      this.log.warn(`Error stopping Chromedriver: ${err.message}`);
     }
     delete this.sessionChromedrivers[context];
   }
@@ -290,10 +289,10 @@ helpers.shouldDismissChromeWelcome = function shouldDismissChromeWelcome () {
 };
 
 helpers.dismissChromeWelcome = async function dismissChromeWelcome () {
-  log.info('Trying to dismiss Chrome welcome');
+  this.log.info('Trying to dismiss Chrome welcome');
   let activity = await this.getCurrentActivity();
   if (activity !== 'org.chromium.chrome.browser.firstrun.FirstRunActivity') {
-    log.info('Chrome welcome dialog never showed up! Continuing');
+    this.log.info('Chrome welcome dialog never showed up! Continuing');
     return;
   }
   let el = await this.findElOrEls('id', 'com.android.chrome:id/terms_accept', false);
@@ -304,12 +303,12 @@ helpers.dismissChromeWelcome = async function dismissChromeWelcome () {
   } catch (e) {
     // DO NOTHING, THIS DEVICE DIDNT LAUNCH THE SIGNIN DIALOG
     // IT MUST BE A NON GMS DEVICE
-    log.warn(`This device did not show Chrome SignIn dialog, ${e.message}`);
+    this.log.warn(`This device did not show Chrome SignIn dialog, ${e.message}`);
   }
 };
 
 helpers.startChromeSession = async function startChromeSession () {
-  log.info('Starting a chrome-based browser session');
+  this.log.info('Starting a chrome-based browser session');
   let opts = _.cloneDeep(this.opts);
 
   const knownPackages = [
@@ -352,7 +351,7 @@ helpers.startChromeSession = async function startChromeSession () {
  * Internal library functions
  * -------------------------- */
 
-async function setupExistingChromedriver (chromedriver) {
+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()) {
@@ -366,28 +365,29 @@ async function setupExistingChromedriver (chromedriver) {
 /**
  * Find a free port to have Chromedriver listen on.
  *
- * @param {array} [portSpec] - Array which is a list of ports. A list item may
+ * @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) {
+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}`);
+    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)}`);
+  log?.debug(`Finding a free port for chromedriver using spec ${JSON.stringify(portSpec)}`);
   let foundPort = null;
   for (const potentialPort of portSpec) {
     let port, stopPort;
@@ -398,11 +398,11 @@ async function getChromedriverPort (portSpec) {
       stopPort = port;
     }
     try {
-      log.debug(`Checking port range ${port}:${stopPort}`);
+      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`);
+      log?.debug(`Nothing in port range ${port}:${stopPort} was available`);
     }
   }
 
@@ -411,7 +411,7 @@ async function getChromedriverPort (portSpec) {
                     `chromedriverPorts spec ${JSON.stringify(portSpec)}`);
   }
 
-  log.debug(`Using free port ${foundPort} for chromedriver`);
+  log?.debug(`Using free port ${foundPort} for chromedriver`);
   return foundPort;
 }
 
@@ -419,27 +419,27 @@ helpers.isChromedriverAutodownloadEnabled = function isChromedriverAutodownloadE
   if (this.isFeatureEnabled(CHROMEDRIVER_AUTODOWNLOAD_FEATURE)) {
     return true;
   }
-  log.debug(`Automated Chromedriver download is disabled. ` +
+  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) {
-    log.warn(`The 'chromeDriverPort' capability is deprecated. Please use 'chromedriverPort' instead`);
+    this?.log?.warn(`The 'chromeDriverPort' capability is deprecated. Please use 'chromedriverPort' instead`);
     opts.chromedriverPort = opts.chromeDriverPort;
   }
 
   if (opts.chromedriverPort) {
-    log.debug(`Using user-specified port ${opts.chromedriverPort} for chromedriver`);
+    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);
+    opts.chromedriverPort = await getChromedriverPort(opts.chromedriverPorts, this?.log);
   }
 
   const details = context ? webviewHelpers.getWebviewDetails(adb, context) : undefined;
   if (!_.isEmpty(details)) {
-    log.debug('Passing web view details to the Chromedriver constructor: ' +
+    this?.log?.debug('Passing web view details to the Chromedriver constructor: ' +
       JSON.stringify(details, null, 2));
   }
 
@@ -455,8 +455,7 @@ helpers.setupNewChromedriver = async function setupNewChromedriver (opts, curDev
     useSystemExecutable: opts.chromedriverUseSystemExecutable,
     disableBuildCheck: opts.chromedriverDisableBuildCheck,
     details,
-    isAutodownloadEnabled: (this || {}).isChromedriverAutodownloadEnabled
-      ? this.isChromedriverAutodownloadEnabled() : undefined,
+    isAutodownloadEnabled: this?.isChromedriverAutodownloadEnabled?.()
   });
 
   // make sure there are chromeOptions
@@ -465,13 +464,13 @@ helpers.setupNewChromedriver = async function setupNewChromedriver (opts, curDev
   // and strip the prefix
   for (const opt of _.keys(opts)) {
     if (opt.endsWith(':chromeOptions')) {
-      log.warn(`Merging '${opt}' into 'chromeOptions'. This may cause unexpected behavior`);
+      this?.log?.warn(`Merging '${opt}' into 'chromeOptions'. This may cause unexpected behavior`);
       _.merge(opts.chromeOptions, opts[opt]);
     }
   }
 
   const caps = webviewHelpers.createChromedriverCaps(opts, curDeviceId, details);
-  log.debug(`Before starting chromedriver, androidPackage is '${caps.chromeOptions.androidPackage}'`);
+  this?.log?.debug(`Before starting chromedriver, androidPackage is '${caps.chromeOptions.androidPackage}'`);
   await chromedriver.start(caps);
   return chromedriver;
 };

package/lib/commands/coverage.js

@@ -1,6 +1,3 @@
-import log from '../logger';
-
-
 const commands = {};
 
 
@@ -11,7 +8,7 @@ commands.endCoverage = async function endCoverage (intentToBroadcast, ecOnDevice
     await this.adb.broadcastProcessEnd(intentToBroadcast, this.appProcess);
     return await this.pullFile(ecOnDevicePath);
   } catch (err) {
-    log.warn(`Error ending test coverage: ${err.message}`);
+    this.log.warn(`Error ending test coverage: ${err.message}`);
   }
   return '';
 };

package/lib/commands/element.js

@@ -1,6 +1,5 @@
 import androidHelpers from '../android-helpers';
 import { retryInterval } from 'asyncbox';
-import logger from '../logger';
 import { util } from '@appium/support';
 
 
@@ -90,12 +89,12 @@ commands.clear = async function clear (elementId) {
     length = 100;
   }
   await this.click(elementId);
-  logger.debug(`Sending up to ${length} clear characters to device`);
+  this.log.debug(`Sending up to ${length} clear characters to device`);
   return await retryInterval(5, 500, async () => {
     let remainingLength = length;
     while (remainingLength > 0) {
       let lengthToSend = remainingLength < 50 ? remainingLength : 50;
-      logger.debug(`Sending ${lengthToSend} clear characters to device`);
+      this.log.debug(`Sending ${lengthToSend} clear characters to device`);
       await this.adb.clearTextField(lengthToSend);
       remainingLength -= lengthToSend;
     }

package/lib/commands/emu-console.js

@@ -1,4 +1,4 @@
-import log from '../logger';
+import { errors } from '@appium/base-driver';
 
 const EMU_CONSOLE_FEATURE = 'emulator_console';
 
@@ -37,7 +37,7 @@ commands.mobileExecEmuConsoleCommand = async function mobileExecEmuConsoleComman
   } = opts;
 
   if (!command) {
-    log.errorAndThrow(`The 'command' argument is mandatory`);
+    throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
   }
 
   return await this.adb.execEmuConsoleCommand(command, {

package/lib/commands/execute.js

@@ -1,12 +1,11 @@
 import _ from 'lodash';
 import { errors, PROTOCOLS } from '@appium/base-driver';
-import logger from '../logger';
 
-let extensions = {};
+const extensions = {};
 
 extensions.execute = async function execute (script, args) {
   if (script.match(/^mobile:/)) {
-    logger.info(`Executing native command '${script}'`);
+    this.log.info(`Executing native command '${script}'`);
     script = script.replace(/^mobile:/, '').trim();
     return await this.executeMobile(script, _.isArray(args) ? args[0] : args);
   }

package/lib/commands/file-actions.js

@@ -1,7 +1,7 @@
 import _ from 'lodash';
-import { fs, util, zip, tempDir} from '@appium/support';
-import log from '../logger';
+import { fs, util, zip, tempDir } from '@appium/support';
 import path from 'path';
+import { errors } from '@appium/base-driver';
 
 
 const CONTAINER_PATH_MARKER = '@';
@@ -24,8 +24,8 @@ const commands = {};
 function parseContainerPath (remotePath) {
   const match = CONTAINER_PATH_PATTERN.exec(remotePath);
   if (!match) {
-    log.errorAndThrow(`It is expected that package identifier is separated from the relative path with a single slash. ` +
-                      `'${remotePath}' is given instead`);
+    throw new Error(`It is expected that package identifier is separated from the relative path with a single slash. ` +
+      `'${remotePath}' is given instead`);
   }
   return [match[1], path.posix.resolve(`/data/data/${match[1]}`, match[2])];
 }
@@ -36,10 +36,11 @@ function parseContainerPath (remotePath) {
  * Exceptions are ignored and written into the log.
  *
  * @param {ADB} adb ADB instance
+ * @param {Object?} log Logger instance
  * @param {string} remotePath The file/folder path on the remote device
  */
-async function scanMedia (adb, remotePath) {
-  log.debug(`Performing media scan of '${remotePath}'`);
+async function scanMedia (adb, remotePath, log = null) {
+  log?.debug(`Performing media scan of '${remotePath}'`);
   try {
     // https://github.com/appium/appium/issues/16184
     if (await adb.getApiLevel() >= 29) {
@@ -52,7 +53,7 @@ async function scanMedia (adb, remotePath) {
       ]);
     }
   } catch (e) {
-    log.warn(`Ignoring an unexpected error upon media scanning of '${remotePath}': ${e.stderr || e.message}`);
+    log?.warn(`Ignoring an unexpected error upon media scanning of '${remotePath}': ${e.stderr || e.message}`);
   }
 }
 
@@ -79,13 +80,13 @@ function escapePath (p) {
  */
 commands.pullFile = async function pullFile (remotePath) {
   if (remotePath.endsWith('/')) {
-    log.errorAndThrow(`It is expected that remote path points to a file and not to a folder. ` +
-                      `'${remotePath}' is given instead`);
+    throw new errors.InvalidArgumentError(`It is expected that remote path points to a file and not to a folder. ` +
+      `'${remotePath}' is given instead`);
   }
   let tmpDestination = null;
   if (remotePath.startsWith(CONTAINER_PATH_MARKER)) {
     const [packageId, pathInContainer] = parseContainerPath(remotePath);
-    log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'. Will get the data from '${pathInContainer}'`);
+    this.log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'. Will get the data from '${pathInContainer}'`);
     tmpDestination = `/data/local/tmp/${path.posix.basename(pathInContainer)}`;
     try {
       await this.adb.shell(['run-as', packageId, `chmod 777 '${escapePath(pathInContainer)}'`]);
@@ -94,7 +95,7 @@ commands.pullFile = async function pullFile (remotePath) {
         `cp -f '${escapePath(pathInContainer)}' '${escapePath(tmpDestination)}'`
       ]);
     } catch (e) {
-      log.errorAndThrow(`Cannot access the container of '${packageId}' application. ` +
+      this.log.errorAndThrow(`Cannot access the container of '${packageId}' application. ` +
                         `Is the application installed and has 'debuggable' build option set to true? ` +
                         `Original error: ${e.message}`);
     }
@@ -126,8 +127,10 @@ commands.pullFile = async function pullFile (remotePath) {
  */
 commands.pushFile = async function pushFile (remotePath, base64Data) {
   if (remotePath.endsWith('/')) {
-    log.errorAndThrow(`It is expected that remote path points to a file and not to a folder. ` +
-                      `'${remotePath}' is given instead`);
+    throw new errors.InvalidArgumentError(
+      `It is expected that remote path points to a file and not to a folder. ` +
+      `'${remotePath}' is given instead`
+    );
   }
   const localFile = await tempDir.path({prefix: 'appium', suffix: '.tmp'});
   if (_.isArray(base64Data)) {
@@ -141,7 +144,8 @@ commands.pushFile = async function pushFile (remotePath, base64Data) {
     await fs.writeFile(localFile, content.toString('binary'), 'binary');
     if (remotePath.startsWith(CONTAINER_PATH_MARKER)) {
       const [packageId, pathInContainer] = parseContainerPath(remotePath);
-      log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'. Will put the data into '${pathInContainer}'`);
+      this.log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'. ` +
+        `Will put the data into '${pathInContainer}'`);
       tmpDestination = `/data/local/tmp/${path.posix.basename(pathInContainer)}`;
       try {
         await this.adb.shell(
@@ -155,7 +159,7 @@ commands.pushFile = async function pushFile (remotePath, base64Data) {
           `cp -f '${escapePath(tmpDestination)}' '${escapePath(pathInContainer)}'`
         ]);
       } catch (e) {
-        log.errorAndThrow(`Cannot access the container of '${packageId}' application. ` +
+        this.log.errorAndThrow(`Cannot access the container of '${packageId}' application. ` +
                           `Is the application installed and has 'debuggable' build option set to true? ` +
                           `Original error: ${e.message}`);
       }
@@ -165,7 +169,7 @@ commands.pushFile = async function pushFile (remotePath, base64Data) {
 
       // if we have pushed a file, it might be a media file, so ensure that
       // apps know about it
-      await scanMedia(this.adb, remotePath);
+      await scanMedia(this.adb, remotePath, this.log);
     }
   } finally {
     if (await fs.exists(localFile)) {
@@ -224,7 +228,7 @@ async function deleteFileOrFolder (adb, remotePath) {
   let pkgId = null;
   if (remotePath.startsWith(CONTAINER_PATH_MARKER)) {
     const [packageId, pathInContainer] = parseContainerPath(remotePath);
-    log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'`);
+    this.log.debug(`Parsed package identifier '${packageId}' from '${remotePath}'`);
     dstPath = pathInContainer;
     pkgId = packageId;
   }
@@ -233,22 +237,22 @@ async function deleteFileOrFolder (adb, remotePath) {
     try {
       await adb.shell(['run-as', pkgId, 'ls']);
     } catch (e) {
-      log.errorAndThrow(`Cannot access the container of '${pkgId}' application. ` +
+      this.log.errorAndThrow(`Cannot access the container of '${pkgId}' application. ` +
         `Is the application installed and has 'debuggable' build option set to true? ` +
         `Original error: ${e.message}`);
     }
   }
 
   if (!await isPresent(dstPath, pkgId)) {
-    log.info(`The item at '${dstPath}' does not exist. Perhaps, already deleted?`);
+    this.log.info(`The item at '${dstPath}' does not exist. Perhaps, already deleted?`);
     return false;
   }
 
   const expectsFile = !remotePath.endsWith('/');
   if (expectsFile && !await isFile(dstPath, pkgId)) {
-    log.errorAndThrow(`The item at '${dstPath}' is not a file`);
+    this.log.errorAndThrow(`The item at '${dstPath}' is not a file`);
   } else if (!expectsFile && !await isDir(dstPath, pkgId)) {
-    log.errorAndThrow(`The item at '${dstPath}' is not a folder`);
+    this.log.errorAndThrow(`The item at '${dstPath}' is not a folder`);
   }
 
   if (pkgId) {
@@ -258,7 +262,7 @@ async function deleteFileOrFolder (adb, remotePath) {
     await adb.shell(['rm', `-f${expectsFile ? '' : 'r'}`, dstPath]);
   }
   if (await isPresent(dstPath, pkgId)) {
-    log.errorAndThrow(`The item at '${dstPath}' still exists after being deleted. ` +
+    this.log.errorAndThrow(`The item at '${dstPath}' still exists after being deleted. ` +
       `Is it writable?`);
   }
   return true;
@@ -283,11 +287,13 @@ async function deleteFileOrFolder (adb, remotePath) {
 commands.mobileDeleteFile = async function mobileDeleteFile (opts = {}) {
   const {remotePath} = opts;
   if (!remotePath) {
-    log.errorAndThrow(`The 'remotePath' argument is mandatory`);
+    throw new errors.InvalidArgumentError(`The 'remotePath' argument is mandatory`);
   }
   if (remotePath.endsWith('/')) {
-    log.errorAndThrow(`It is expected that remote path points to a folder and not to a file. ` +
-                      `'${remotePath}' is given instead`);
+    throw new errors.InvalidArgumentError(
+      `It is expected that remote path points to a folder and not to a file. ` +
+      `'${remotePath}' is given instead`
+    );
   }
   return await deleteFileOrFolder(this.adb, remotePath);
 };

package/lib/commands/general.js

@@ -1,9 +1,9 @@
 import _ from 'lodash';
 import androidHelpers from '../android-helpers';
 import { util } from '@appium/support';
-import log from '../logger';
 import moment from 'moment';
 import { longSleep } from 'asyncbox';
+import { errors } from '@appium/base-driver';
 
 const MOMENT_FORMAT_ISO8601 = 'YYYY-MM-DDTHH:mm:ssZ';
 
@@ -36,13 +36,13 @@ commands.doSendKeys = async function doSendKeys (params) {
  * @return {string} Formatted datetime string or the raw command output if formatting fails
  */
 commands.getDeviceTime = async function getDeviceTime (format = MOMENT_FORMAT_ISO8601) {
-  log.debug('Attempting to capture android device date and time. ' +
+  this.log.debug('Attempting to capture android device date and time. ' +
     `The format specifier is '${format}'`);
   const deviceTimestamp = (await this.adb.shell(['date', '+%Y-%m-%dT%T%z'])).trim();
-  log.debug(`Got device timestamp: ${deviceTimestamp}`);
+  this.log.debug(`Got device timestamp: ${deviceTimestamp}`);
   const parsedTimestamp = moment.utc(deviceTimestamp, 'YYYY-MM-DDTHH:mm:ssZZ');
   if (!parsedTimestamp.isValid()) {
-    log.warn('Cannot parse the returned timestamp. Returning as is');
+    this.log.warn('Cannot parse the returned timestamp. Returning as is');
     return deviceTimestamp;
   }
   return parsedTimestamp.utcOffset(parsedTimestamp._tzm || 0).format(format);
@@ -128,7 +128,7 @@ commands.background = async function background (seconds) {
   const progressCb = ({elapsedMs, progress}) => {
     const waitSecs = (elapsedMs / 1000).toFixed(0);
     const progressPct = (progress * 100).toFixed(2);
-    log.debug(`Waited ${waitSecs}s so far (${progressPct}%)`);
+    this.log.debug(`Waited ${waitSecs}s so far (${progressPct}%)`);
   };
   await longSleep(sleepMs, {thresholdMs, intervalMs, progressCb});
 
@@ -138,7 +138,7 @@ commands.background = async function background (seconds) {
     args = this._cachedActivityArgs[`${appPackage}/${appActivity}`];
   } else {
     try {
-      log.debug(`Activating app '${appPackage}' in order to restore it`);
+      this.log.debug(`Activating app '${appPackage}' in order to restore it`);
       await this.activateApp(appPackage);
       return true;
     } catch (ign) {}
@@ -165,14 +165,14 @@ commands.background = async function background (seconds) {
         stopApp: false};
   }
   args = await util.filterObject(args);
-  log.debug(`Bringing application back to foreground with arguments: ${JSON.stringify(args)}`);
+  this.log.debug(`Bringing application back to foreground with arguments: ${JSON.stringify(args)}`);
   return await this.adb.startApp(args);
 };
 
 commands.getStrings = async function getStrings (language) {
   if (!language) {
     language = await this.adb.getDeviceLanguage();
-    log.info(`No language specified, returning strings for: ${language}`);
+    this.log.info(`No language specified, returning strings for: ${language}`);
   }
 
   // Clients require the resulting mapping to have both keys
@@ -207,7 +207,7 @@ commands.launchApp = async function launchApp () {
 commands.startActivity = async function startActivity (appPackage, appActivity,
   appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags,
   optionalIntentArguments, dontStopAppOnReset) {
-  log.debug(`Starting package '${appPackage}' and activity '${appActivity}'`);
+  this.log.debug(`Starting package '${appPackage}' and activity '${appActivity}'`);
 
   // dontStopAppOnReset is both an argument here, and a desired capability
   // if the argument is set, use it, otherwise use the cap
@@ -277,7 +277,7 @@ commands.getDisplayDensity = async function getDisplayDensity () {
     if (!isNaN(val)) {
       return val;
     }
-    log.debug(`Parsed density value was NaN: "${out}"`);
+    this.log.debug(`Parsed density value was NaN: "${out}"`);
   }
   // fallback to trying property for emulators
   out = await this.adb.shell(['getprop', 'qemu.sf.lcd_density']);
@@ -286,16 +286,16 @@ commands.getDisplayDensity = async function getDisplayDensity () {
     if (!isNaN(val)) {
       return val;
     }
-    log.debug(`Parsed density value was NaN: "${out}"`);
+    this.log.debug(`Parsed density value was NaN: "${out}"`);
   }
   // couldn't get anything, so error out
-  log.errorAndThrow('Failed to get display density property.');
+  this.log.errorAndThrow('Failed to get display density property.');
 };
 
 commands.mobilePerformEditorAction = async function mobilePerformEditorAction (opts = {}) {
   const {action} = opts;
   if (!util.hasValue(action)) {
-    log.errorAndThrow(`'action' argument is required`);
+    throw new errors.InvalidArgumentError(`'action' argument is required`);
   }
 
   await this.adb.performEditorAction(action);
@@ -328,7 +328,7 @@ commands.mobileChangePermissions = async function mobileChangePermissions (opts
     action = PERMISSION_ACTION.GRANT,
   } = opts;
   if (!util.hasValue(permissions)) {
-    log.errorAndThrow(`'permissions' argument is required`);
+    throw new errors.InvalidArgumentError(`'permissions' argument is required`);
   }
 
   let actionFunc;
@@ -340,9 +340,8 @@ commands.mobileChangePermissions = async function mobileChangePermissions (opts
       actionFunc = (appPackage, permission) => this.adb.revokePermission(appPackage, permission);
       break;
     default:
-      log.errorAndThrow(`Unknown action '${action}'. ` +
+      throw new errors.InvalidArgumentError(`Unknown action '${action}'. ` +
         `Only ${JSON.stringify(_.values(PERMISSION_ACTION))} actions are supported`);
-      break;
   }
   for (const permission of (_.isArray(permissions) ? permissions : [permissions])) {
     await actionFunc(appPackage, permission);
@@ -389,9 +388,8 @@ commands.mobileGetPermissions = async function mobileGetPermissions (opts = {})
       actionFunc = (appPackage) => this.adb.getDeniedPermissions(appPackage);
       break;
     default:
-      log.errorAndThrow(`Unknown permissions type '${type}'. ` +
+      throw new errors.InvalidArgumentError(`Unknown permissions type '${type}'. ` +
         `Only ${JSON.stringify(_.values(PERMISSIONS_TYPE))} types are supported`);
-      break;
   }
   return await actionFunc(appPackage);
 };

package/lib/commands/ime.js

@@ -1,4 +1,3 @@
-import log from '../logger';
 import { errors } from '@appium/base-driver';
 
 let commands = {}, helpers = {}, extensions = {};
@@ -9,32 +8,32 @@ commands.isIMEActivated = async function isIMEActivated () { // eslint-disable-l
 };
 
 commands.availableIMEEngines = async function availableIMEEngines () {
-  log.debug('Retrieving available IMEs');
+  this.log.debug('Retrieving available IMEs');
   let engines = await this.adb.availableIMEs();
-  log.debug(`Engines: ${JSON.stringify(engines)}`);
+  this.log.debug(`Engines: ${JSON.stringify(engines)}`);
   return engines;
 };
 
 commands.getActiveIMEEngine = async function getActiveIMEEngine () {
-  log.debug('Retrieving current default IME');
+  this.log.debug('Retrieving current default IME');
   return await this.adb.defaultIME();
 };
 
 commands.activateIMEEngine = async function activateIMEEngine (imeId) {
-  log.debug(`Attempting to activate IME ${imeId}`);
+  this.log.debug(`Attempting to activate IME ${imeId}`);
   let availableEngines = await this.adb.availableIMEs();
   if (availableEngines.indexOf(imeId) === -1) {
-    log.debug('IME not found, failing');
+    this.log.debug('IME not found, failing');
     throw new errors.IMENotAvailableError();
   }
-  log.debug('Found installed IME, attempting to activate');
+  this.log.debug('Found installed IME, attempting to activate');
   await this.adb.enableIME(imeId);
   await this.adb.setIME(imeId);
 };
 
 commands.deactivateIMEEngine = async function deactivateIMEEngine () {
   let currentEngine = await this.getActiveIMEEngine();
-  log.debug(`Attempting to deactivate ${currentEngine}`);
+  this.log.debug(`Attempting to deactivate ${currentEngine}`);
   await this.adb.disableIME(currentEngine);
 };