appium-android-driver 5.0.6 → 5.0.9

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);
 };
 

package/lib/commands/network.js

@@ -1,4 +1,3 @@
-import log from '../logger';
 import _ from 'lodash';
 import { errors } from '@appium/base-driver';
 import B from 'bluebird';
@@ -16,7 +15,7 @@ const DATA_MASK = 0b100;
 const GEO_EPSILON = Number.MIN_VALUE;
 
 commands.getNetworkConnection = async function getNetworkConnection () {
-  log.info('Getting network connection');
+  this.log.info('Getting network connection');
   let airplaneModeOn = await this.adb.isAirplaneModeOn();
   let connection = airplaneModeOn ? AIRPLANE_MODE_MASK : 0;
 
@@ -39,7 +38,7 @@ commands.isWifiOn = async function isWifiOn () {
 };
 
 commands.setNetworkConnection = async function setNetworkConnection (type) {
-  log.info('Setting network connection');
+  this.log.info('Setting network connection');
   // decode the input
   const shouldEnableAirplaneMode = (type & AIRPLANE_MODE_MASK) !== 0;
   const shouldEnableWifi = (type & WIFI_MASK) !== 0;
@@ -58,12 +57,12 @@ commands.setNetworkConnection = async function setNetworkConnection (type) {
       await this.adb.broadcastAirplaneMode(shouldEnableAirplaneMode);
     });
   } else {
-    log.info(`Not changing airplane mode, since it is already ` +
+    this.log.info(`Not changing airplane mode, since it is already ` +
              `${shouldEnableAirplaneMode ? 'enabled' : 'disabled'}`);
   }
 
   if (shouldEnableWifi === isWiFiEnabled && shouldEnableDataConnection === isDataEnabled) {
-    log.info('Not changing data connection/Wi-Fi states, since they are already set to expected values');
+    this.log.info('Not changing data connection/Wi-Fi states, since they are already set to expected values');
     if (await this.adb.isAirplaneModeOn()) {
       return AIRPLANE_MODE_MASK | currentState;
     }
@@ -74,15 +73,15 @@ commands.setNetworkConnection = async function setNetworkConnection (type) {
     if (shouldEnableWifi !== isWiFiEnabled) {
       await this.setWifiState(shouldEnableWifi);
     } else {
-      log.info(`Not changing Wi-Fi state, since it is already ` +
-               `${shouldEnableWifi ? 'enabled' : 'disabled'}`);
+      this.log.info(`Not changing Wi-Fi state, since it is already ` +
+        `${shouldEnableWifi ? 'enabled' : 'disabled'}`);
     }
 
     if (shouldEnableAirplaneMode) {
-      log.info('Not changing data connection state, because airplane mode is enabled');
+      this.log.info('Not changing data connection state, because airplane mode is enabled');
     } else if (shouldEnableDataConnection === isDataEnabled) {
-      log.info(`Not changing data connection state, since it is already ` +
-               `${shouldEnableDataConnection ? 'enabled' : 'disabled'}`);
+      this.log.info(`Not changing data connection state, since it is already ` +
+        `${shouldEnableDataConnection ? 'enabled' : 'disabled'}`);
     } else {
       await this.adb.setDataState(shouldEnableDataConnection, this.isEmulator());
     }
@@ -100,7 +99,7 @@ commands.setWifiState = async function setWifiState (wifi) {
 
 commands.toggleData = async function toggleData () {
   let data = !(await this.adb.isDataOn());
-  log.info(`Turning network data ${data ? 'on' : 'off'}`);
+  this.log.info(`Turning network data ${data ? 'on' : 'off'}`);
   await this.wrapBootstrapDisconnect(async () => {
     await this.adb.setWifiAndData({data}, this.isEmulator());
   });
@@ -108,7 +107,7 @@ commands.toggleData = async function toggleData () {
 
 commands.toggleWiFi = async function toggleWiFi () {
   let wifi = !(await this.adb.isWifiOn());
-  log.info(`Turning WiFi ${wifi ? 'on' : 'off'}`);
+  this.log.info(`Turning WiFi ${wifi ? 'on' : 'off'}`);
   await this.wrapBootstrapDisconnect(async () => {
     await this.adb.setWifiAndData({wifi}, this.isEmulator());
   });
@@ -120,7 +119,7 @@ commands.toggleFlightMode = async function toggleFlightMode () {
    * real devices, it should throw a NotYetImplementedError
    */
   let flightMode = !(await this.adb.isAirplaneModeOn());
-  log.info(`Turning flight mode ${flightMode ? 'on' : 'off'}`);
+  this.log.info(`Turning flight mode ${flightMode ? 'on' : 'off'}`);
   await this.wrapBootstrapDisconnect(async () => {
     await this.adb.setAirplaneMode(flightMode);
   });
@@ -134,8 +133,8 @@ commands.setGeoLocation = async function setGeoLocation (location) {
   try {
     return await this.getGeoLocation();
   } catch (e) {
-    log.warn(`Could not get the current geolocation info: ${e.message}`);
-    log.warn(`Returning the default zero'ed values`);
+    this.log.warn(`Could not get the current geolocation info: ${e.message}`);
+    this.log.warn(`Returning the default zero'ed values`);
     return {
       latitude: GEO_EPSILON,
       longitude: GEO_EPSILON,
@@ -182,7 +181,7 @@ const KeyCode = {
   CENTER: 23
 };
 commands.toggleLocationServices = async function toggleLocationServices () {
-  log.info('Toggling location services');
+  this.log.info('Toggling location services');
   let api = await this.adb.getApiLevel();
   if (this.isEmulator()) {
     let providers = await this.adb.getLocationProviders();

package/lib/commands/performance.js

@@ -1,6 +1,5 @@
 import _ from 'lodash';
 import { retryInterval } from 'asyncbox';
-import log from '../logger';
 
 const commands = {}, helpers = {}, extensions = {};
 
@@ -150,7 +149,7 @@ helpers.getCPUInfo = async function getCPUInfo (packageName, retries = 2) {
       output = await this.adb.shell(['dumpsys', 'cpuinfo']);
     } catch (e) {
       if (e.stderr) {
-        log.info(e.stderr);
+        this.log.info(e.stderr);
       }
       throw e;
     }
@@ -160,7 +159,7 @@ helpers.getCPUInfo = async function getCPUInfo (packageName, retries = 2) {
       new RegExp(`^.+\\/${_.escapeRegExp(packageName)}:\\D+([\\d.]+)%\\s+user\\s+\\+\\s+([\\d.]+)%\\s+kernel`, 'm');
     const match = usagesPattern.exec(output);
     if (!match) {
-      log.debug(output);
+      this.log.debug(output);
       throw new Error(`Unable to parse cpu usage data for '${packageName}'. Check the server log for more details`);
     }
     return [CPU_KEYS, [match[1], match[2]]];

package/lib/commands/recordscreen.js

@@ -1,7 +1,6 @@
 import _ from 'lodash';
 import { waitForCondition } from 'asyncbox';
 import { util, fs, net, tempDir, system, timing } from '@appium/support';
-import log from '../logger';
 import { exec } from 'teen_process';
 import path from 'path';
 
@@ -21,8 +20,6 @@ const FFMPEG_BINARY = `ffmpeg${system.isWindows() ? '.exe' : ''}`;
 
 async function uploadRecordedMedia (localFile, remotePath = null, uploadOptions = {}) {
   if (_.isEmpty(remotePath)) {
-    const {size} = await fs.stat(localFile);
-    log.debug(`The size of the resulting screen recording is ${util.toReadableSizeString(size)}`);
     return (await util.toInMemoryBase64(localFile)).toString();
   }
 
@@ -50,7 +47,7 @@ async function verifyScreenRecordIsSupported (adb, isEmulator) {
   }
 }
 
-async function scheduleScreenRecord (adb, recordingProperties) {
+async function scheduleScreenRecord (adb, recordingProperties, log = null) {
   if (recordingProperties.stopped) {
     return;
   }
@@ -83,10 +80,10 @@ async function scheduleScreenRecord (adb, recordingProperties) {
       return;
     }
     const currentDuration = timer.getDuration().asSeconds.toFixed(0);
-    log.debug(`The overall screen recording duration is ${currentDuration}s so far`);
+    log?.debug(`The overall screen recording duration is ${currentDuration}s so far`);
     const timeLimitInt = parseInt(timeLimit, 10);
     if (isNaN(timeLimitInt) || currentDuration >= timeLimitInt) {
-      log.debug('There is no need to start the next recording chunk');
+      log?.debug('There is no need to start the next recording chunk');
       return;
     }
 
@@ -94,11 +91,11 @@ async function scheduleScreenRecord (adb, recordingProperties) {
     const chunkDuration = recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC
       ? recordingProperties.currentTimeLimit
       : MAX_RECORDING_TIME_SEC;
-    log.debug(`Starting the next ${chunkDuration}s-chunk ` +
+    log?.debug(`Starting the next ${chunkDuration}s-chunk ` +
       `of screen recording in order to achieve ${timeLimitInt}s total duration`);
-    scheduleScreenRecord(adb, recordingProperties)
+    scheduleScreenRecord(adb, recordingProperties, log)
       .catch((e) => {
-        log.error(e.stack);
+        log?.error(e.stack);
         recordingProperties.stopped = true;
       });
   });
@@ -116,7 +113,7 @@ async function scheduleScreenRecord (adb, recordingProperties) {
   recordingProperties.recordingProcess = recordingProc;
 }
 
-async function mergeScreenRecords (mediaFiles) {
+async function mergeScreenRecords (mediaFiles, log = null) {
   try {
     await fs.which(FFMPEG_BINARY);
   } catch (e) {
@@ -127,10 +124,10 @@ async function mergeScreenRecords (mediaFiles) {
     .join('\n');
   const configFile = path.resolve(path.dirname(mediaFiles[0]), 'config.txt');
   await fs.writeFile(configFile, configContent, 'utf8');
-  log.debug(`Generated ffmpeg merging config '${configFile}' with items:\n${configContent}`);
+  log?.debug(`Generated ffmpeg merging config '${configFile}' with items:\n${configContent}`);
   const result = path.resolve(path.dirname(mediaFiles[0]), `merge_${Math.floor(new Date())}${DEFAULT_EXT}`);
   const args = ['-safe', '0', '-f', 'concat', '-i', configFile, '-c', 'copy', result];
-  log.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);
+  log?.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);
   await exec(FFMPEG_BINARY, args);
   return result;
 }
@@ -217,7 +214,7 @@ commands.startRecordingScreen = async function startRecordingScreen (options = {
   }
 
   if (await terminateBackgroundScreenRecording(this.adb, true)) {
-    log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` +
+    this.log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` +
       `in the background. Make sure you stop screen recording each time after it is started, ` +
       `otherwise the recorded media might quickly exceed all the free space on the device under test.`);
   }
@@ -246,7 +243,7 @@ commands.startRecordingScreen = async function startRecordingScreen (options = {
     recordingProcess: null,
     stopped: false,
   };
-  await scheduleScreenRecord(this.adb, this._screenRecordingProperties);
+  await scheduleScreenRecord(this.adb, this._screenRecordingProperties, this.log);
   return result;
 };
 
@@ -289,14 +286,14 @@ commands.stopRecordingScreen = async function stopRecordingScreen (options = {})
   try {
     await terminateBackgroundScreenRecording(this.adb, false);
   } catch (err) {
-    log.warn(err.message);
+    this.log.warn(err.message);
     if (!_.isEmpty(this._screenRecordingProperties)) {
-      log.warn('The resulting video might be corrupted');
+      this.log.warn('The resulting video might be corrupted');
     }
   }
 
   if (_.isEmpty(this._screenRecordingProperties)) {
-    log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);
+    this.log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);
     return '';
   }
 
@@ -304,13 +301,13 @@ commands.stopRecordingScreen = async function stopRecordingScreen (options = {})
     try {
       await this._screenRecordingProperties.recordingProcess.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT);
     } catch (e) {
-      log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);
+      this.log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);
     }
     this._screenRecordingProperties.recordingProcess = null;
   }
 
   if (_.isEmpty(this._screenRecordingProperties.records)) {
-    log.errorAndThrow(`No screen recordings have been stored on the device so far. ` +
+    this.log.errorAndThrow(`No screen recordings have been stored on the device so far. ` +
       `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`);
   }
 
@@ -324,14 +321,18 @@ commands.stopRecordingScreen = async function stopRecordingScreen (options = {})
     }
     let resultFilePath = _.last(localRecords);
     if (localRecords.length > 1) {
-      log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
+      this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
       try {
-        resultFilePath = await mergeScreenRecords(localRecords);
+        resultFilePath = await mergeScreenRecords(localRecords, this.log);
       } catch (e) {
-        log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +
+        this.log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +
           `Original error: ${e.message}`);
       }
     }
+    if (_.isEmpty(options.remotePath)) {
+      const {size} = await fs.stat(resultFilePath);
+      this.log.debug(`The size of the resulting screen recording is ${util.toReadableSizeString(size)}`);
+    }
     return await uploadRecordedMedia(resultFilePath, options.remotePath, options);
   } finally {
     await fs.rimraf(tmpRoot);

package/lib/commands/shell.js

@@ -1,7 +1,7 @@
-import log from '../logger';
 import _ from 'lodash';
 import { exec } from 'teen_process';
 import { util } from '@appium/support';
+import { errors } from '@appium/base-driver';
 
 const ADB_SHELL_FEATURE = 'adb_shell';
 
@@ -18,7 +18,7 @@ commands.mobileShell = async function mobileShell (opts = {}) {
   } = opts;
 
   if (!_.isString(command)) {
-    log.errorAndThrow(`The 'command' argument is mandatory`);
+    throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
   }
 
   const adbArgs = [
@@ -27,7 +27,7 @@ commands.mobileShell = async function mobileShell (opts = {}) {
     command,
     ...(_.isArray(args) ? args : [args])
   ];
-  log.debug(`Running '${this.adb.executable.path} ${util.quote(adbArgs)}'`);
+  this.log.debug(`Running '${this.adb.executable.path} ${util.quote(adbArgs)}'`);
   try {
     const {stdout, stderr} = await exec(this.adb.executable.path, adbArgs, {timeout});
     if (includeStderr) {
@@ -38,9 +38,9 @@ commands.mobileShell = async function mobileShell (opts = {}) {
     }
     return stdout;
   } catch (err) {
-    log.errorAndThrow(`Cannot execute the '${command}' shell command. ` +
-                      `Original error: ${err.message}. ` +
-                      `StdOut: ${err.stdout}. StdErr: ${err.stderr}`);
+    this.log.errorAndThrow(`Cannot execute the '${command}' shell command. ` +
+      `Original error: ${err.message}. ` +
+      `StdOut: ${err.stdout}. StdErr: ${err.stderr}`);
   }
 };
 

package/lib/commands/streamscreen.js

@@ -1,6 +1,5 @@
 import _ from 'lodash';
 import { fs, system, logger, util } from '@appium/support';
-import log from '../logger';
 import { exec, SubProcess } from 'teen_process';
 import { checkPortStatus } from 'portscanner';
 import http from 'http';
@@ -74,7 +73,7 @@ async function verifyStreamingRequirements (adb) {
   await B.all(moduleCheckPromises);
 }
 
-async function getDeviceInfo (adb) {
+async function getDeviceInfo (adb, log = null) {
   const output = await adb.shell(['dumpsys', 'display']);
   const result = {};
   for (const [key, pattern] of [
@@ -84,7 +83,7 @@ async function getDeviceInfo (adb) {
   ]) {
     const match = pattern.exec(output);
     if (!match) {
-      log.debug(output);
+      log?.debug(output);
       throw new Error(`Cannot parse the device ${key} from the adb command output. ` +
         `Check the server log for more details.`);
     }
@@ -94,7 +93,7 @@ async function getDeviceInfo (adb) {
   return result;
 }
 
-async function initDeviceStreamingProc (adb, deviceInfo, opts = {}) {
+async function initDeviceStreamingProc (adb, log, deviceInfo, opts = {}) {
   const {
     width,
     height,
@@ -158,7 +157,7 @@ async function initDeviceStreamingProc (adb, deviceInfo, opts = {}) {
   return deviceStreaming;
 }
 
-async function initGstreamerPipeline (deviceStreamingProc, deviceInfo, opts = {}) {
+async function initGstreamerPipeline (deviceStreamingProc, deviceInfo, log, opts = {}) {
   const {
     width,
     height,
@@ -291,30 +290,30 @@ commands.mobileStartScreenStreaming = async function mobileStartScreenStreaming
     await verifyStreamingRequirements(this.adb);
   }
   if (!_.isEmpty(this._screenStreamingProps)) {
-    log.info(`The screen streaming session is already running. ` +
+    this.log.info(`The screen streaming session is already running. ` +
       `Stop it first in order to start a new one.`);
     return;
   }
   if ((await checkPortStatus(port, host)) === 'open') {
-    log.info(`The port #${port} at ${host} is busy. ` +
+    this.log.info(`The port #${port} at ${host} is busy. ` +
       `Assuming the screen streaming is already running`);
     return;
   }
   if ((await checkPortStatus(tcpPort, TCP_HOST)) === 'open') {
-    log.errorAndThrow(`The port #${tcpPort} at ${TCP_HOST} is busy. ` +
+    this.log.errorAndThrow(`The port #${tcpPort} at ${TCP_HOST} is busy. ` +
       `Make sure there are no leftovers from previous sessions.`);
   }
   this._screenStreamingProps = null;
 
-  const deviceInfo = await getDeviceInfo(this.adb);
-  const deviceStreamingProc = await initDeviceStreamingProc(this.adb, deviceInfo, {
+  const deviceInfo = await getDeviceInfo(this.adb, this.log);
+  const deviceStreamingProc = await initDeviceStreamingProc(this.adb, this.log, deviceInfo, {
     width,
     height,
     bitRate,
   });
   let gstreamerPipeline;
   try {
-    gstreamerPipeline = await initGstreamerPipeline(deviceStreamingProc, deviceInfo, {
+    gstreamerPipeline = await initGstreamerPipeline(deviceStreamingProc, deviceInfo, this.log, {
       width,
       height,
       quality,
@@ -334,15 +333,15 @@ commands.mobileStartScreenStreaming = async function mobileStartScreenStreaming
   try {
     await new B((resolve, reject) => {
       mjpegSocket = net.createConnection(tcpPort, TCP_HOST, () => {
-        log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
+        this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
         mjpegServer = http.createServer((req, res) => {
           const remoteAddress = extractRemoteAddress(req);
           const currentPathname = url.parse(req.url).pathname;
-          log.info(`Got an incoming screen bradcasting request from ${remoteAddress} ` +
+          this.log.info(`Got an incoming screen bradcasting request from ${remoteAddress} ` +
             `(${req.headers['user-agent'] || 'User Agent unknown'}) at ${currentPathname}`);
 
           if (pathname && currentPathname !== pathname) {
-            log.info('Rejecting the broadcast request since it does not match the given pathname');
+            this.log.info('Rejecting the broadcast request since it does not match the given pathname');
             res.writeHead(404, {
               Connection: 'close',
               'Content-Type': 'text/plain; charset=utf-8',
@@ -352,7 +351,7 @@ commands.mobileStartScreenStreaming = async function mobileStartScreenStreaming
             return;
           }
 
-          log.info('Starting MJPEG broadcast');
+          this.log.info('Starting MJPEG broadcast');
           res.writeHead(200, {
             'Cache-Control': 'no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0',
             Pragma: 'no-cache',
@@ -363,20 +362,20 @@ commands.mobileStartScreenStreaming = async function mobileStartScreenStreaming
           mjpegSocket.pipe(res);
         });
         mjpegServer.on('error', (e) => {
-          log.warn(e);
+          this.log.warn(e);
           reject(e);
         });
         mjpegServer.on('close', () => {
-          log.debug(`MJPEG server at http://${host}:${port} has been closed`);
+          this.log.debug(`MJPEG server at http://${host}:${port} has been closed`);
         });
         mjpegServer.on('listening', () => {
-          log.info(`Successfully started MJPEG server at http://${host}:${port}`);
+          this.log.info(`Successfully started MJPEG server at http://${host}:${port}`);
           resolve();
         });
         mjpegServer.listen(port, host);
       });
       mjpegSocket.on('error', (e) => {
-        log.error(e);
+        this.log.error(e);
         reject(e);
       });
     }).timeout(STREAMING_STARTUP_TIMEOUT_MS,
@@ -412,7 +411,7 @@ commands.mobileStartScreenStreaming = async function mobileStartScreenStreaming
 commands.mobileStopScreenStreaming = async function mobileStopScreenStreaming (/* options = {} */) {
   if (_.isEmpty(this._screenStreamingProps)) {
     if (!_.isUndefined(this._screenStreamingProps)) {
-      log.debug(`Screen streaming is not running. There is nothing to stop`);
+      this.log.debug(`Screen streaming is not running. There is nothing to stop`);
     }
     return;
   }
@@ -436,15 +435,15 @@ commands.mobileStopScreenStreaming = async function mobileStopScreenStreaming (/
       try {
         await gstreamerPipeline.stop('SIGINT');
       } catch (e) {
-        log.warn(e);
+        this.log.warn(e);
         try {
           await gstreamerPipeline.stop('SIGKILL');
         } catch (e1) {
-          log.error(e1);
+          this.log.error(e1);
         }
       }
     }
-    log.info(`Successfully terminated the screen streaming MJPEG server`);
+    this.log.info(`Successfully terminated the screen streaming MJPEG server`);
   } finally {
     this._screenStreamingProps = null;
   }

package/lib/commands/system-bars.js

@@ -1,5 +1,4 @@
 import _ from 'lodash';
-import log from '../logger';
 
 const WINDOW_TITLE_PATTERN = /^\s+Window\s#\d+\sWindow\{[0-9a-f]+\s\w+\s([\w-]+)\}:$/;
 const FRAME_PATTERN = /^\s+mFrame=\[([0-9.-]+),([0-9.-]+)\]\[([0-9.-]+),([0-9.-]+)\]/m;
@@ -28,15 +27,16 @@ const commands = {};
  * @param {string} name The name of the window whose properties are being parsed
  * @param {Array<string>} props The list of particular window property lines.
  * Check the corresponding unit tests for more details on the input format.
+ * @param {Object?} log Logger instance
  * @returns {WindowProperties} Parsed properties object
  * @throws {Error} If there was an issue while parsing the properties string
  */
-function parseWindowProperties (name, props) {
+function parseWindowProperties (name, props, log = null) {
   const result = _.cloneDeep(DEFAULT_WINDOW_PROPERTIES);
   const propLines = props.join('\n');
   const frameMatch = FRAME_PATTERN.exec(propLines);
   if (!frameMatch) {
-    log.debug(propLines);
+    log?.debug(propLines);
     throw new Error(`Cannot parse the frame size from '${name}' window properties`);
   }
   result.x = parseFloat(frameMatch[1]);
@@ -47,7 +47,7 @@ function parseWindowProperties (name, props) {
   result.height = top - result.y;
   const visibilityMatch = SURFACE_PATTERN.exec(propLines);
   if (!visibilityMatch) {
-    log.debug(propLines);
+    log?.debug(propLines);
     throw new Error(`Cannot parse the visibility value from '${name}' window properties`);
   }
   result.visible = visibilityMatch[1] === 'true';
@@ -59,11 +59,12 @@ function parseWindowProperties (name, props) {
  *
  * @param {Array<string>} lines Output from dumpsys command.
  * Check the corresponding unit tests for more details on the input format.
+ * @param {Object?} log Logger instance
  * @return {Object} An object containing two items where keys are statusBar and navigationBar,
  * and values are corresponding WindowProperties objects
  * @throws {Error} If no window properties could be parsed
  */
-function parseWindows (lines) {
+function parseWindows (lines, log = null) {
   const windows = {};
   let currentWindowName = null;
   let windowNameRowIndent = null;
@@ -91,16 +92,16 @@ function parseWindows (lines) {
     windows[currentWindowName].push(line);
   }
   if (_.isEmpty(windows)) {
-    log.debug(lines.join('\n'));
+    log?.debug(lines.join('\n'));
     throw new Error('Cannot parse any window information from the dumpsys output');
   }
 
   const result = {statusBar: null, navigationBar: null};
   for (const [name, props] of _.toPairs(windows)) {
     if (name.startsWith(STATUS_BAR_WINDOW_NAME_PREFIX)) {
-      result.statusBar = parseWindowProperties(name, props);
+      result.statusBar = parseWindowProperties(name, props, log);
     } else if (name.startsWith(NAVIGATION_BAR_WINDOW_NAME_PREFIX)) {
-      result.navigationBar = parseWindowProperties(name, props);
+      result.navigationBar = parseWindowProperties(name, props, log);
     }
   }
   const unmatchedWindows = [
@@ -108,7 +109,7 @@ function parseWindows (lines) {
     ['navigationBar', NAVIGATION_BAR_WINDOW_NAME_PREFIX]
   ].filter(([name]) => _.isNil(result[name]));
   for (const [window, namePrefix] of unmatchedWindows) {
-    log.info(`No windows have been found whose title matches to ` +
+    log?.info(`No windows have been found whose title matches to ` +
       `'${namePrefix}'. Assuming it is invisible. ` +
       `Only the following windows are available: ${_.keys(windows)}`);
     result[window] = _.cloneDeep(DEFAULT_WINDOW_PROPERTIES);
@@ -123,7 +124,7 @@ commands.getSystemBars = async function getSystemBars () {
   } catch (e) {
     throw new Error(`Cannot retrieve system bars details. Original error: ${e.message}`);
   }
-  return parseWindows(stdout);
+  return parseWindows(stdout, this.log);
 };
 
 // for unit tests

package/lib/commands/touch.js

@@ -1,4 +1,3 @@
-import log from '../logger';
 import _ from 'lodash';
 import androidHelpers from '../android-helpers';
 import B from 'bluebird';
@@ -49,10 +48,10 @@ commands.doTouchAction = async function doTouchAction (action, opts = {}) {
       return await this.touchLongClick(null, x, y, duration || 1000);
     case 'cancel':
       // TODO: clarify behavior of 'cancel' action and fix this
-      log.warn('Cancel action currently has no effect');
+      this.log.warn('Cancel action currently has no effect');
       break;
     default:
-      log.errorAndThrow(`unknown action ${action}`);
+      this.log.errorAndThrow(`unknown action ${action}`);
   }
 };
 
@@ -146,7 +145,7 @@ helpers.performGesture = async function performGesture (gesture) {
     if (isErrorType(e, errors.NoSuchElementError) && gesture.action === 'release' &&
         gesture.options.element) {
       delete gesture.options.element;
-      log.debug(`retrying release without element opts: ${gesture.options}.`);
+      this.log.debug(`retrying release without element opts: ${gesture.options}.`);
       return await this.doTouchAction(gesture.action, gesture.options || {});
     }
     throw e;