"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

require("source-map-support/register");

var _logger = _interopRequireDefault(require("../logger.js"));

var _helpers = require("../helpers.js");

var _path = _interopRequireDefault(require("path"));

var _lodash = _interopRequireDefault(require("lodash"));

var _appiumSupport = require("appium-support");

var _net = _interopRequireDefault(require("net"));

var _os = require("os");

var _logcat = _interopRequireDefault(require("../logcat"));

var _asyncbox = require("asyncbox");

var _teen_process = require("teen_process");

var _bluebird = _interopRequireDefault(require("bluebird"));

const MAX_SHELL_BUFFER_LENGTH = 1000;
const NOT_CHANGEABLE_PERM_ERROR = /not a changeable permission type/i;
const IGNORED_PERM_ERRORS = [NOT_CHANGEABLE_PERM_ERROR, /Unknown permission/i];
const MAX_PGREP_PATTERN_LEN = 15;
const HIDDEN_API_POLICY_KEYS = ['hidden_api_policy_pre_p_apps', 'hidden_api_policy_p_apps', 'hidden_api_policy'];
const PID_COLUMN_TITLE = 'PID';
const PROCESS_NAME_COLUMN_TITLE = 'NAME';
const PS_TITLE_PATTERN = new RegExp(`^(.*\\b${PID_COLUMN_TITLE}\\b.*\\b${PROCESS_NAME_COLUMN_TITLE}\\b.*)$`, 'm');
let methods = {};

methods.getAdbWithCorrectAdbPath = async function getAdbWithCorrectAdbPath() {
  this.executable.path = await this.getSdkBinaryPath('adb');
  return this.adb;
};

methods.initAapt = async function initAapt() {
  await this.getSdkBinaryPath('aapt');
};

methods.initAapt2 = async function initAapt2() {
  await this.getSdkBinaryPath('aapt2');
};

methods.initZipAlign = async function initZipAlign() {
  await this.getSdkBinaryPath('zipalign');
};

methods.initBundletool = async function initBundletool() {
  try {
    this.binaries.bundletool = await _appiumSupport.fs.which('bundletool.jar');
  } catch (err) {
    throw new Error('bundletool.jar binary is expected to be present in PATH. ' + 'Visit https://github.com/google/bundletool for more details.');
  }
};

methods.getApiLevel = async function getApiLevel() {
  if (!_lodash.default.isInteger(this._apiLevel)) {
    try {
      const strOutput = await this.getDeviceProperty('ro.build.version.sdk');
      let apiLevel = parseInt(strOutput.trim(), 10);
      const charCodeQ = 'q'.charCodeAt(0);
      const apiLevelDiff = apiLevel - 28;
      const codename = String.fromCharCode(charCodeQ + apiLevelDiff);

      if (apiLevelDiff >= 0 && (await this.getPlatformVersion()).toLowerCase() === codename) {
        _logger.default.debug(`Release version is ${codename.toUpperCase()} but found API Level ${apiLevel}. Setting API Level to ${apiLevel + 1}`);

        apiLevel++;
      }

      this._apiLevel = apiLevel;

      _logger.default.debug(`Device API level: ${this._apiLevel}`);

      if (isNaN(this._apiLevel)) {
        throw new Error(`The actual output '${strOutput}' cannot be converted to an integer`);
      }
    } catch (e) {
      throw new Error(`Error getting device API level. Original error: ${e.message}`);
    }
  }

  return this._apiLevel;
};

methods.getPlatformVersion = async function getPlatformVersion() {
  _logger.default.info('Getting device platform version');

  try {
    return await this.getDeviceProperty('ro.build.version.release');
  } catch (e) {
    throw new Error(`Error getting device platform version. Original error: ${e.message}`);
  }
};

methods.isDeviceConnected = async function isDeviceConnected() {
  let devices = await this.getConnectedDevices();
  return devices.length > 0;
};

methods.mkdir = async function mkdir(remotePath) {
  return await this.shell(['mkdir', '-p', remotePath]);
};

methods.isValidClass = function isValidClass(classString) {
  return new RegExp(/^[a-zA-Z0-9./_]+$/).exec(classString);
};

methods.forceStop = async function forceStop(pkg) {
  return await this.shell(['am', 'force-stop', pkg]);
};

methods.killPackage = async function killPackage(pkg) {
  return await this.shell(['am', 'kill', pkg]);
};

methods.clear = async function clear(pkg) {
  return await this.shell(['pm', 'clear', pkg]);
};

methods.grantAllPermissions = async function grantAllPermissions(pkg, apk) {
  const apiLevel = await this.getApiLevel();
  let targetSdk = 0;
  let dumpsysOutput = null;

  try {
    if (!apk) {
      dumpsysOutput = await this.shell(['dumpsys', 'package', pkg]);
      targetSdk = await this.targetSdkVersionUsingPKG(pkg, dumpsysOutput);
    } else {
      targetSdk = await this.targetSdkVersionFromManifest(apk);
    }
  } catch (e) {
    _logger.default.warn(`Ran into problem getting target SDK version; ignoring...`);
  }

  if (apiLevel >= 23 && targetSdk >= 23) {
    dumpsysOutput = dumpsysOutput || (await this.shell(['dumpsys', 'package', pkg]));
    const requestedPermissions = await this.getReqPermissions(pkg, dumpsysOutput);
    const grantedPermissions = await this.getGrantedPermissions(pkg, dumpsysOutput);

    const permissionsToGrant = _lodash.default.difference(requestedPermissions, grantedPermissions);

    if (_lodash.default.isEmpty(permissionsToGrant)) {
      _logger.default.info(`${pkg} contains no permissions available for granting`);
    } else {
      await this.grantPermissions(pkg, permissionsToGrant);
    }
  }
};

methods.grantPermissions = async function grantPermissions(pkg, permissions) {
  _logger.default.debug(`Granting permissions ${JSON.stringify(permissions)} to '${pkg}'`);

  const commands = [];
  let cmdChunk = [];

  for (const permission of permissions) {
    const nextCmd = ['pm', 'grant', pkg, permission, ';'];

    if (nextCmd.join(' ').length + cmdChunk.join(' ').length >= MAX_SHELL_BUFFER_LENGTH) {
      commands.push(cmdChunk);
      cmdChunk = [];
    }

    cmdChunk = [...cmdChunk, ...nextCmd];
  }

  if (!_lodash.default.isEmpty(cmdChunk)) {
    commands.push(cmdChunk);
  }

  _logger.default.debug(`Got the following command chunks to execute: ${JSON.stringify(commands)}`);

  let lastError = null;

  for (const cmd of commands) {
    try {
      await this.shell(cmd);
    } catch (e) {
      if (!IGNORED_PERM_ERRORS.some(msgRegex => msgRegex.test(e.stderr || e.message))) {
        lastError = e;
      }
    }
  }

  if (lastError) {
    throw lastError;
  }
};

methods.grantPermission = async function grantPermission(pkg, permission) {
  try {
    await this.shell(['pm', 'grant', pkg, permission]);
  } catch (e) {
    if (!NOT_CHANGEABLE_PERM_ERROR.test(e.stderr || e.message)) {
      throw e;
    }
  }
};

methods.revokePermission = async function revokePermission(pkg, permission) {
  try {
    await this.shell(['pm', 'revoke', pkg, permission]);
  } catch (e) {
    if (!NOT_CHANGEABLE_PERM_ERROR.test(e.stderr || e.message)) {
      throw e;
    }
  }
};

methods.getGrantedPermissions = async function getGrantedPermissions(pkg, cmdOutput = null) {
  _logger.default.debug('Retrieving granted permissions');

  const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
  return (0, _helpers.extractMatchingPermissions)(stdout, ['install', 'runtime'], true);
};

methods.getDeniedPermissions = async function getDeniedPermissions(pkg, cmdOutput = null) {
  _logger.default.debug('Retrieving denied permissions');

  const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
  return (0, _helpers.extractMatchingPermissions)(stdout, ['install', 'runtime'], false);
};

methods.getReqPermissions = async function getReqPermissions(pkg, cmdOutput = null) {
  _logger.default.debug('Retrieving requested permissions');

  const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
  return (0, _helpers.extractMatchingPermissions)(stdout, ['requested']);
};

methods.getLocationProviders = async function getLocationProviders() {
  let stdout = await this.getSetting('secure', 'location_providers_allowed');
  return stdout.trim().split(',').map(p => p.trim()).filter(Boolean);
};

methods.toggleGPSLocationProvider = async function toggleGPSLocationProvider(enabled) {
  await this.setSetting('secure', 'location_providers_allowed', `${enabled ? '+' : '-'}gps`);
};

methods.setHiddenApiPolicy = async function setHiddenApiPolicy(value, ignoreError = false) {
  try {
    await this.shell(HIDDEN_API_POLICY_KEYS.map(k => `settings put global ${k} ${value}`).join(';'));
  } catch (e) {
    if (!ignoreError) {
      throw e;
    }

    _logger.default.info(`Failed to set setting keys '${HIDDEN_API_POLICY_KEYS}' to '${value}'. Original error: ${e.message}`);
  }
};

methods.setDefaultHiddenApiPolicy = async function setDefaultHiddenApiPolicy(ignoreError = false) {
  try {
    await this.shell(HIDDEN_API_POLICY_KEYS.map(k => `settings delete global ${k}`).join(';'));
  } catch (e) {
    if (!ignoreError) {
      throw e;
    }

    _logger.default.info(`Failed to delete keys '${HIDDEN_API_POLICY_KEYS}'. Original error: ${e.message}`);
  }
};

methods.stopAndClear = async function stopAndClear(pkg) {
  try {
    await this.forceStop(pkg);
    await this.clear(pkg);
  } catch (e) {
    throw new Error(`Cannot stop and clear ${pkg}. Original error: ${e.message}`);
  }
};

methods.availableIMEs = async function availableIMEs() {
  try {
    return (0, _helpers.getIMEListFromOutput)(await this.shell(['ime', 'list', '-a']));
  } catch (e) {
    throw new Error(`Error getting available IME's. Original error: ${e.message}`);
  }
};

methods.enabledIMEs = async function enabledIMEs() {
  try {
    return (0, _helpers.getIMEListFromOutput)(await this.shell(['ime', 'list']));
  } catch (e) {
    throw new Error(`Error getting enabled IME's. Original error: ${e.message}`);
  }
};

methods.enableIME = async function enableIME(imeId) {
  await this.shell(['ime', 'enable', imeId]);
};

methods.disableIME = async function disableIME(imeId) {
  await this.shell(['ime', 'disable', imeId]);
};

methods.setIME = async function setIME(imeId) {
  await this.shell(['ime', 'set', imeId]);
};

methods.defaultIME = async function defaultIME() {
  try {
    let engine = await this.getSetting('secure', 'default_input_method');

    if (engine === 'null') {
      return null;
    }

    return engine.trim();
  } catch (e) {
    throw new Error(`Error getting default IME. Original error: ${e.message}`);
  }
};

methods.keyevent = async function keyevent(keycode) {
  let code = parseInt(keycode, 10);
  await this.shell(['input', 'keyevent', code]);
};

methods.inputText = async function inputText(text) {
  text = text.replace(/\\/g, '\\\\').replace(/\(/g, '\(').replace(/\)/g, '\)').replace(/</g, '\<').replace(/>/g, '\>').replace(/\|/g, '\|').replace(/;/g, '\;').replace(/&/g, '\&').replace(/\*/g, '\*').replace(/~/g, '\~').replace(/"/g, '\"').replace(/'/g, "\'").replace(/ /g, '%s');
  await this.shell(['input', 'text', text]);
};

methods.clearTextField = async function clearTextField(length = 100) {
  _logger.default.debug(`Clearing up to ${length} characters`);

  if (length === 0) {
    return;
  }

  let args = ['input', 'keyevent'];

  for (let i = 0; i < length; i++) {
    args.push('67', '112');
  }

  await this.shell(args);
};

methods.lock = async function lock() {
  if (await this.isScreenLocked()) {
    _logger.default.debug('Screen is already locked. Doing nothing.');

    return;
  }

  _logger.default.debug('Pressing the KEYCODE_POWER button to lock screen');

  await this.keyevent(26);
  const timeoutMs = 5000;

  try {
    await (0, _asyncbox.waitForCondition)(async () => await this.isScreenLocked(), {
      waitMs: timeoutMs,
      intervalMs: 500
    });
  } catch (e) {
    throw new Error(`The device screen is still locked after ${timeoutMs}ms timeout`);
  }
};

methods.back = async function back() {
  _logger.default.debug('Pressing the BACK button');

  await this.keyevent(4);
};

methods.goToHome = async function goToHome() {
  _logger.default.debug('Pressing the HOME button');

  await this.keyevent(3);
};

methods.getAdbPath = function getAdbPath() {
  return this.executable.path;
};

methods.getScreenOrientation = async function getScreenOrientation() {
  let stdout = await this.shell(['dumpsys', 'input']);
  return (0, _helpers.getSurfaceOrientation)(stdout);
};

methods.isScreenLocked = async function isScreenLocked() {
  let stdout = await this.shell(['dumpsys', 'window']);

  if (process.env.APPIUM_LOG_DUMPSYS) {
    let dumpsysFile = _path.default.resolve(process.cwd(), 'dumpsys.log');

    _logger.default.debug(`Writing dumpsys output to ${dumpsysFile}`);

    await _appiumSupport.fs.writeFile(dumpsysFile, stdout);
  }

  return (0, _helpers.isShowingLockscreen)(stdout) || (0, _helpers.isCurrentFocusOnKeyguard)(stdout) || !(0, _helpers.isScreenOnFully)(stdout);
};

methods.isSoftKeyboardPresent = async function isSoftKeyboardPresent() {
  try {
    const stdout = await this.shell(['dumpsys', 'input_method']);
    const inputShownMatch = /mInputShown=(\w+)/.exec(stdout);
    const inputViewShownMatch = /mIsInputViewShown=(\w+)/.exec(stdout);
    return {
      isKeyboardShown: !!(inputShownMatch && inputShownMatch[1] === 'true'),
      canCloseKeyboard: !!(inputViewShownMatch && inputViewShownMatch[1] === 'true')
    };
  } catch (e) {
    throw new Error(`Error finding softkeyboard. Original error: ${e.message}`);
  }
};

methods.sendTelnetCommand = async function sendTelnetCommand(command) {
  _logger.default.debug(`Sending telnet command to device: ${command}`);

  let port = await this.getEmulatorPort();
  return await new _bluebird.default((resolve, reject) => {
    let conn = _net.default.createConnection(port, 'localhost'),
        connected = false,
        readyRegex = /^OK$/m,
        dataStream = '',
        res = null;

    conn.on('connect', () => {
      _logger.default.debug('Socket connection to device created');
    });
    conn.on('data', data => {
      data = data.toString('utf8');

      if (!connected) {
        if (readyRegex.test(data)) {
          connected = true;

          _logger.default.debug('Socket connection to device ready');

          conn.write(`${command}\n`);
        }
      } else {
        dataStream += data;

        if (readyRegex.test(data)) {
          res = dataStream.replace(readyRegex, '').trim();
          res = _lodash.default.last(res.trim().split('\n'));

          _logger.default.debug(`Telnet command got response: ${res}`);

          conn.write('quit\n');
        }
      }
    });
    conn.on('error', err => {
      _logger.default.debug(`Telnet command error: ${err.message}`);

      reject(err);
    });
    conn.on('close', () => {
      if (res === null) {
        reject(new Error('Never got a response from command'));
      } else {
        resolve(res);
      }
    });
  });
};

methods.isAirplaneModeOn = async function isAirplaneModeOn() {
  let stdout = await this.getSetting('global', 'airplane_mode_on');
  return parseInt(stdout, 10) !== 0;
};

methods.setAirplaneMode = async function setAirplaneMode(on) {
  await this.setSetting('global', 'airplane_mode_on', on ? 1 : 0);
};

methods.broadcastAirplaneMode = async function broadcastAirplaneMode(on) {
  await this.shell(['am', 'broadcast', '-a', 'android.intent.action.AIRPLANE_MODE', '--ez', 'state', on ? 'true' : 'false']);
};

methods.isWifiOn = async function isWifiOn() {
  let stdout = await this.getSetting('global', 'wifi_on');
  return parseInt(stdout, 10) !== 0;
};

methods.isDataOn = async function isDataOn() {
  let stdout = await this.getSetting('global', 'mobile_data');
  return parseInt(stdout, 10) !== 0;
};

methods.setWifiAndData = async function setWifiAndData({
  wifi,
  data
}, isEmulator = false) {
  if (_appiumSupport.util.hasValue(wifi)) {
    await this.setWifiState(wifi, isEmulator);
  }

  if (_appiumSupport.util.hasValue(data)) {
    await this.setDataState(data, isEmulator);
  }
};

methods.isAnimationOn = async function isAnimationOn() {
  let animator_duration_scale = await this.getSetting('global', 'animator_duration_scale');
  let transition_animation_scale = await this.getSetting('global', 'transition_animation_scale');
  let window_animation_scale = await this.getSetting('global', 'window_animation_scale');
  return _lodash.default.some([animator_duration_scale, transition_animation_scale, window_animation_scale], setting => setting !== '0.0');
};

methods.rimraf = async function rimraf(path) {
  await this.shell(['rm', '-rf', path]);
};

methods.push = async function push(localPath, remotePath, opts) {
  await this.mkdir(_path.default.posix.dirname(remotePath));
  await this.adbExec(['push', localPath, remotePath], opts);
};

methods.pull = async function pull(remotePath, localPath) {
  await this.adbExec(['pull', remotePath, localPath], {
    timeout: 60000
  });
};

methods.processExists = async function processExists(processName) {
  return !_lodash.default.isEmpty(await this.getPIDsByName(processName));
};

methods.getForwardList = async function getForwardList() {
  _logger.default.debug(`List forwarding ports`);

  const connections = await this.adbExec(['forward', '--list']);
  return connections.split(_os.EOL).filter(line => Boolean(line.trim()));
};

methods.forwardPort = async function forwardPort(systemPort, devicePort) {
  _logger.default.debug(`Forwarding system: ${systemPort} to device: ${devicePort}`);

  await this.adbExec(['forward', `tcp:${systemPort}`, `tcp:${devicePort}`]);
};

methods.removePortForward = async function removePortForward(systemPort) {
  _logger.default.debug(`Removing forwarded port socket connection: ${systemPort} `);

  await this.adbExec(['forward', `--remove`, `tcp:${systemPort}`]);
};

methods.getReverseList = async function getReverseList() {
  _logger.default.debug(`List reverse forwarding ports`);

  const connections = await this.adbExec(['reverse', '--list']);
  return connections.split(_os.EOL).filter(line => Boolean(line.trim()));
};

methods.reversePort = async function reversePort(devicePort, systemPort) {
  _logger.default.debug(`Forwarding device: ${devicePort} to system: ${systemPort}`);

  await this.adbExec(['reverse', `tcp:${devicePort}`, `tcp:${systemPort}`]);
};

methods.removePortReverse = async function removePortReverse(devicePort) {
  _logger.default.debug(`Removing reverse forwarded port socket connection: ${devicePort} `);

  await this.adbExec(['reverse', `--remove`, `tcp:${devicePort}`]);
};

methods.forwardAbstractPort = async function forwardAbstractPort(systemPort, devicePort) {
  _logger.default.debug(`Forwarding system: ${systemPort} to abstract device: ${devicePort}`);

  await this.adbExec(['forward', `tcp:${systemPort}`, `localabstract:${devicePort}`]);
};

methods.ping = async function ping() {
  let stdout = await this.shell(['echo', 'ping']);

  if (stdout.indexOf('ping') === 0) {
    return true;
  }

  throw new Error(`ADB ping failed, returned ${stdout}`);
};

methods.restart = async function restart() {
  try {
    await this.stopLogcat();
    await this.restartAdb();
    await this.waitForDevice(60);
    await this.startLogcat();
  } catch (e) {
    throw new Error(`Restart failed. Original error: ${e.message}`);
  }
};

methods.startLogcat = async function startLogcat() {
  if (!_lodash.default.isEmpty(this.logcat)) {
    throw new Error("Trying to start logcat capture but it's already started!");
  }

  this.logcat = new _logcat.default({
    adb: this.executable,
    debug: false,
    debugTrace: false,
    clearDeviceLogsOnStart: !!this.clearDeviceLogsOnStart
  });
  await this.logcat.startCapture();
};

methods.stopLogcat = async function stopLogcat() {
  if (_lodash.default.isEmpty(this.logcat)) {
    return;
  }

  try {
    await this.logcat.stopCapture();
  } finally {
    this.logcat = null;
  }
};

methods.getLogcatLogs = function getLogcatLogs() {
  if (_lodash.default.isEmpty(this.logcat)) {
    throw new Error("Can't get logcat logs since logcat hasn't started");
  }

  return this.logcat.getLogs();
};

methods.setLogcatListener = function setLogcatListener(listener) {
  if (_lodash.default.isEmpty(this.logcat)) {
    throw new Error("Logcat process hasn't been started");
  }

  this.logcat.on('output', listener);
};

methods.removeLogcatListener = function removeLogcatListener(listener) {
  if (_lodash.default.isEmpty(this.logcat)) {
    throw new Error("Logcat process hasn't been started");
  }

  this.logcat.removeListener('output', listener);
};

methods.getNameByPid = async function getNameByPid(pid) {
  if (isNaN(pid)) {
    throw new Error(`The PID value must be a valid number. '${pid}' is given instead`);
  }

  pid = parseInt(pid, 10);
  const stdout = await this.shell(['ps']);
  const titleMatch = PS_TITLE_PATTERN.exec(stdout);

  if (!titleMatch) {
    _logger.default.debug(stdout);

    throw new Error(`Could not get the process name for PID '${pid}'`);
  }

  const allTitles = titleMatch[1].trim().split(/\s+/);
  const pidIndex = allTitles.indexOf(PID_COLUMN_TITLE);
  const nameOffset = allTitles.indexOf(PROCESS_NAME_COLUMN_TITLE) - allTitles.length;
  const pidRegex = new RegExp(`^(.*\\b${pid}\\b.*)$`, 'gm');
  let matchedLine;

  while (matchedLine = pidRegex.exec(stdout)) {
    const items = matchedLine[1].trim().split(/\s+/);

    if (parseInt(items[pidIndex], 10) === pid && items[items.length + nameOffset]) {
      return items[items.length + nameOffset];
    }
  }

  _logger.default.debug(stdout);

  throw new Error(`Could not get the process name for PID '${pid}'`);
};

methods.getPIDsByName = async function getPIDsByName(name) {
  _logger.default.debug(`Getting IDs of all '${name}' processes`);

  if (!this.isValidClass(name)) {
    throw new Error(`Invalid process name: '${name}'`);
  }

  if ((await this.getApiLevel()) >= 23) {
    if (!_lodash.default.isBoolean(this._isPgrepAvailable)) {
      const pgrepOutput = _lodash.default.trim(await this.shell(['pgrep --help; echo $?']));

      this._isPgrepAvailable = parseInt(_lodash.default.last(pgrepOutput.split(/\s+/)), 10) === 0;

      if (this._isPgrepAvailable) {
        this._canPgrepUseFullCmdLineSearch = /^-f\b/m.test(pgrepOutput);
      } else {
        this._isPidofAvailable = parseInt(await this.shell(['pidof --help > /dev/null; echo $?']), 10) === 0;
      }
    }

    if (this._isPgrepAvailable || this._isPidofAvailable) {
      const shellCommand = this._isPgrepAvailable ? this._canPgrepUseFullCmdLineSearch ? ['pgrep', '-f', _lodash.default.escapeRegExp(name)] : [`pgrep ^${_lodash.default.escapeRegExp(name.slice(-MAX_PGREP_PATTERN_LEN))}$ || pgrep ^${_lodash.default.escapeRegExp(name.slice(0, MAX_PGREP_PATTERN_LEN))}$`] : ['pidof', name];

      try {
        return (await this.shell(shellCommand)).split(/\s+/).map(x => parseInt(x, 10)).filter(x => _lodash.default.isInteger(x));
      } catch (e) {
        if (e.code === 1) {
          return [];
        }

        throw new Error(`Could not extract process ID of '${name}': ${e.message}`);
      }
    }
  }

  _logger.default.debug('Using ps-based PID detection');

  const stdout = await this.shell(['ps']);
  const titleMatch = PS_TITLE_PATTERN.exec(stdout);

  if (!titleMatch) {
    _logger.default.debug(stdout);

    throw new Error(`Could not extract PID of '${name}' from ps output`);
  }

  const allTitles = titleMatch[1].trim().split(/\s+/);
  const pidIndex = allTitles.indexOf(PID_COLUMN_TITLE);
  const pids = [];
  const processNameRegex = new RegExp(`^(.*\\b\\d+\\b.*\\b${_lodash.default.escapeRegExp(name)}\\b.*)$`, 'gm');
  let matchedLine;

  while (matchedLine = processNameRegex.exec(stdout)) {
    const items = matchedLine[1].trim().split(/\s+/);

    if (pidIndex >= allTitles.length || isNaN(items[pidIndex])) {
      _logger.default.debug(stdout);

      throw new Error(`Could not extract PID of '${name}' from '${matchedLine[1].trim()}'`);
    }

    pids.push(parseInt(items[pidIndex], 10));
  }

  return pids;
};

methods.killProcessesByName = async function killProcessesByName(name) {
  try {
    _logger.default.debug(`Attempting to kill all ${name} processes`);

    let pids = await this.getPIDsByName(name);

    if (_lodash.default.isEmpty(pids)) {
      _logger.default.info(`No '${name}' process has been found`);

      return;
    }

    for (let pid of pids) {
      await this.killProcessByPID(pid);
    }
  } catch (e) {
    throw new Error(`Unable to kill ${name} processes. Original error: ${e.message}`);
  }
};

methods.killProcessByPID = async function killProcessByPID(pid) {
  _logger.default.debug(`Attempting to kill process ${pid}`);

  let wasRoot = false;
  let becameRoot = false;

  try {
    try {
      await this.shell(['kill', '-0', pid]);
    } catch (e) {
      if (_lodash.default.includes(e.stderr, 'No such process')) {
        return e.stderr;
      }

      if (!_lodash.default.includes(e.stderr, 'Operation not permitted')) {
        throw e;
      }

      try {
        wasRoot = await this.isRoot();
      } catch (ign) {}

      if (wasRoot) {
        throw e;
      }

      _logger.default.info(`Cannot kill PID ${pid} due to insufficient permissions. Retrying as root`);

      ({
        isSuccessful: becameRoot
      } = await this.root());

      try {
        await this.shell(['kill', '-0', pid]);
      } catch (e1) {
        if (_lodash.default.includes(e1.stderr, 'No such process')) {
          return e1.stderr;
        }

        throw e1;
      }
    }

    const timeoutMs = 1000;
    let stdout;

    try {
      await (0, _asyncbox.waitForCondition)(async () => {
        try {
          stdout = await this.shell(['kill', pid]);
          return false;
        } catch (e) {
          return true;
        }
      }, {
        waitMs: timeoutMs,
        intervalMs: 300
      });
    } catch (err) {
      _logger.default.warn(`Cannot kill process ${pid} in ${timeoutMs} ms. Trying to force kill...`);

      stdout = await this.shell(['kill', '-9', pid]);
    }

    return stdout;
  } finally {
    if (becameRoot) {
      await this.unroot();
    }
  }
};

methods.broadcastProcessEnd = async function broadcastProcessEnd(intent, processName) {
  this.broadcast(intent);
  let start = Date.now();
  let timeoutMs = 40000;

  try {
    while (Date.now() - start < timeoutMs) {
      if (await this.processExists(processName)) {
        await (0, _asyncbox.sleep)(400);
        continue;
      }

      return;
    }

    throw new Error(`Process never died within ${timeoutMs} ms`);
  } catch (e) {
    throw new Error(`Unable to broadcast process end. Original error: ${e.message}`);
  }
};

methods.broadcast = async function broadcast(intent) {
  if (!this.isValidClass(intent)) {
    throw new Error(`Invalid intent ${intent}`);
  }

  _logger.default.debug(`Broadcasting: ${intent}`);

  await this.shell(['am', 'broadcast', '-a', intent]);
};

methods.endAndroidCoverage = async function endAndroidCoverage() {
  if (this.instrumentProc && this.instrumentProc.isRunning) {
    await this.instrumentProc.stop();
  }
};

methods.instrument = async function instrument(pkg, activity, instrumentWith) {
  if (activity[0] !== '.') {
    pkg = '';
  }

  let pkgActivity = (pkg + activity).replace(/\.+/g, '.');
  let stdout = await this.shell(['am', 'instrument', '-e', 'main_activity', pkgActivity, instrumentWith]);

  if (stdout.indexOf('Exception') !== -1) {
    throw new Error(`Unknown exception during instrumentation. Original error ${stdout.split('\n')[0]}`);
  }
};

methods.androidCoverage = async function androidCoverage(instrumentClass, waitPkg, waitActivity) {
  if (!this.isValidClass(instrumentClass)) {
    throw new Error(`Invalid class ${instrumentClass}`);
  }

  return await new _bluebird.default(async (resolve, reject) => {
    let args = this.executable.defaultArgs.concat(['shell', 'am', 'instrument', '-e', 'coverage', 'true', '-w']).concat([instrumentClass]);

    _logger.default.debug(`Collecting coverage data with: ${[this.executable.path].concat(args).join(' ')}`);

    try {
      this.instrumentProc = new _teen_process.SubProcess(this.executable.path, args);
      await this.instrumentProc.start(0);
      this.instrumentProc.on('output', (stdout, stderr) => {
        if (stderr) {
          reject(new Error(`Failed to run instrumentation. Original error: ${stderr}`));
        }
      });
      await this.waitForActivity(waitPkg, waitActivity);
      resolve();
    } catch (e) {
      reject(new Error(`Android coverage failed. Original error: ${e.message}`));
    }
  });
};

methods.getDeviceProperty = async function getDeviceProperty(property) {
  let stdout = await this.shell(['getprop', property]);
  let val = stdout.trim();

  _logger.default.debug(`Current device property '${property}': ${val}`);

  return val;
};

methods.setDeviceProperty = async function setDeviceProperty(prop, val, opts = {}) {
  const {
    privileged = true
  } = opts;

  _logger.default.debug(`Setting device property '${prop}' to '${val}'`);

  await this.shell(['setprop', prop, val], {
    privileged
  });
};

methods.getDeviceSysLanguage = async function getDeviceSysLanguage() {
  return await this.getDeviceProperty('persist.sys.language');
};

methods.getDeviceSysCountry = async function getDeviceSysCountry() {
  return await this.getDeviceProperty('persist.sys.country');
};

methods.getDeviceSysLocale = async function getDeviceSysLocale() {
  return await this.getDeviceProperty('persist.sys.locale');
};

methods.getDeviceProductLanguage = async function getDeviceProductLanguage() {
  return await this.getDeviceProperty('ro.product.locale.language');
};

methods.getDeviceProductCountry = async function getDeviceProductCountry() {
  return await this.getDeviceProperty('ro.product.locale.region');
};

methods.getDeviceProductLocale = async function getDeviceProductLocale() {
  return await this.getDeviceProperty('ro.product.locale');
};

methods.getModel = async function getModel() {
  return await this.getDeviceProperty('ro.product.model');
};

methods.getManufacturer = async function getManufacturer() {
  return await this.getDeviceProperty('ro.product.manufacturer');
};

methods.getScreenSize = async function getScreenSize() {
  let stdout = await this.shell(['wm', 'size']);
  let size = new RegExp(/Physical size: ([^\r?\n]+)*/g).exec(stdout);

  if (size && size.length >= 2) {
    return size[1].trim();
  }

  return null;
};

methods.getScreenDensity = async function getScreenDensity() {
  let stdout = await this.shell(['wm', 'density']);
  let density = new RegExp(/Physical density: ([^\r?\n]+)*/g).exec(stdout);

  if (density && density.length >= 2) {
    let densityNumber = parseInt(density[1].trim(), 10);
    return isNaN(densityNumber) ? null : densityNumber;
  }

  return null;
};

methods.setHttpProxy = async function setHttpProxy(proxyHost, proxyPort) {
  let proxy = `${proxyHost}:${proxyPort}`;

  if (_lodash.default.isUndefined(proxyHost)) {
    throw new Error(`Call to setHttpProxy method with undefined proxy_host: ${proxy}`);
  }

  if (_lodash.default.isUndefined(proxyPort)) {
    throw new Error(`Call to setHttpProxy method with undefined proxy_port ${proxy}`);
  }

  const httpProxySettins = [['http_proxy', proxy], ['global_http_proxy_host', proxyHost], ['global_http_proxy_port', proxyPort]];

  for (const [settingKey, settingValue] of httpProxySettins) {
    await this.setSetting('global', settingKey, settingValue);
  }
};

methods.deleteHttpProxy = async function deleteHttpProxy() {
  const httpProxySettins = ['http_proxy', 'global_http_proxy_host', 'global_http_proxy_port', 'global_http_proxy_exclusion_list'];

  for (const setting of httpProxySettins) {
    await this.shell(['settings', 'delete', 'global', setting]);
  }
};

methods.setSetting = async function setSetting(namespace, setting, value) {
  return await this.shell(['settings', 'put', namespace, setting, value]);
};

methods.getSetting = async function getSetting(namespace, setting) {
  return await this.shell(['settings', 'get', namespace, setting]);
};

methods.bugreport = async function bugreport(timeout = 120000) {
  return await this.adbExec(['bugreport'], {
    timeout
  });
};

methods.screenrecord = function screenrecord(destination, options = {}) {
  const cmd = ['screenrecord'];
  const {
    videoSize,
    bitRate,
    timeLimit,
    bugReport
  } = options;

  if (_appiumSupport.util.hasValue(videoSize)) {
    cmd.push('--size', videoSize);
  }

  if (_appiumSupport.util.hasValue(timeLimit)) {
    cmd.push('--time-limit', timeLimit);
  }

  if (_appiumSupport.util.hasValue(bitRate)) {
    cmd.push('--bit-rate', bitRate);
  }

  if (bugReport) {
    cmd.push('--bugreport');
  }

  cmd.push(destination);
  const fullCmd = [...this.executable.defaultArgs, 'shell', ...cmd];

  _logger.default.debug(`Building screenrecord process with the command line: adb ${_appiumSupport.util.quote(fullCmd)}`);

  return new _teen_process.SubProcess(this.executable.path, fullCmd);
};

methods.runInImeContext = async function runInImeContext(ime, fn) {
  const originalIme = await this.defaultIME();

  if (originalIme === ime) {
    _logger.default.debug(`The original IME is the same as '${ime}'. There is no need to reset it`);
  } else {
    await this.setIME(ime);
  }

  try {
    return await fn();
  } finally {
    if (originalIme !== ime) {
      await this.setIME(originalIme);
    }
  }
};

methods.getTimeZone = async function getTimeZone() {
  _logger.default.debug('Getting current timezone');

  try {
    return await this.getDeviceProperty('persist.sys.timezone');
  } catch (e) {
    throw new Error(`Error getting timezone. Original error: ${e.message}`);
  }
};

methods.listFeatures = async function listFeatures() {
  this._memoizedFeatures = this._memoizedFeatures || _lodash.default.memoize(async () => await this.adbExec(['features']), () => this.curDeviceId);

  try {
    return (await this._memoizedFeatures()).split(/\s+/).map(x => x.trim()).filter(Boolean);
  } catch (e) {
    if (_lodash.default.includes(e.stderr, 'unknown command')) {
      return [];
    }

    throw e;
  }
};

methods.isStreamedInstallSupported = async function isStreamedInstallSupported() {
  const proto = Object.getPrototypeOf(this);
  proto._helpOutput = proto._helpOutput || (await this.adbExec(['help']));
  return proto._helpOutput.includes('--streaming') && (await this.listFeatures()).includes('cmd');
};

var _default = methods;
exports.default = _default;require('source-map-support').install();


//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/tools/adb-commands.js"],"names":["MAX_SHELL_BUFFER_LENGTH","NOT_CHANGEABLE_PERM_ERROR","IGNORED_PERM_ERRORS","MAX_PGREP_PATTERN_LEN","HIDDEN_API_POLICY_KEYS","PID_COLUMN_TITLE","PROCESS_NAME_COLUMN_TITLE","PS_TITLE_PATTERN","RegExp","methods","getAdbWithCorrectAdbPath","executable","path","getSdkBinaryPath","adb","initAapt","initAapt2","initZipAlign","initBundletool","binaries","bundletool","fs","which","err","Error","getApiLevel","_","isInteger","_apiLevel","strOutput","getDeviceProperty","apiLevel","parseInt","trim","charCodeQ","charCodeAt","apiLevelDiff","codename","String","fromCharCode","getPlatformVersion","toLowerCase","log","debug","toUpperCase","isNaN","e","message","info","isDeviceConnected","devices","getConnectedDevices","length","mkdir","remotePath","shell","isValidClass","classString","exec","forceStop","pkg","killPackage","clear","grantAllPermissions","apk","targetSdk","dumpsysOutput","targetSdkVersionUsingPKG","targetSdkVersionFromManifest","warn","requestedPermissions","getReqPermissions","grantedPermissions","getGrantedPermissions","permissionsToGrant","difference","isEmpty","grantPermissions","permissions","JSON","stringify","commands","cmdChunk","permission","nextCmd","join","push","lastError","cmd","some","msgRegex","test","stderr","grantPermission","revokePermission","cmdOutput","stdout","getDeniedPermissions","getLocationProviders","getSetting","split","map","p","filter","Boolean","toggleGPSLocationProvider","enabled","setSetting","setHiddenApiPolicy","value","ignoreError","k","setDefaultHiddenApiPolicy","stopAndClear","availableIMEs","enabledIMEs","enableIME","imeId","disableIME","setIME","defaultIME","engine","keyevent","keycode","code","inputText","text","replace","clearTextField","args","i","lock","isScreenLocked","timeoutMs","waitMs","intervalMs","back","goToHome","getAdbPath","getScreenOrientation","process","env","APPIUM_LOG_DUMPSYS","dumpsysFile","resolve","cwd","writeFile","isSoftKeyboardPresent","inputShownMatch","inputViewShownMatch","isKeyboardShown","canCloseKeyboard","sendTelnetCommand","command","port","getEmulatorPort","B","reject","conn","net","createConnection","connected","readyRegex","dataStream","res","on","data","toString","write","last","isAirplaneModeOn","setAirplaneMode","broadcastAirplaneMode","isWifiOn","isDataOn","setWifiAndData","wifi","isEmulator","util","hasValue","setWifiState","setDataState","isAnimationOn","animator_duration_scale","transition_animation_scale","window_animation_scale","setting","rimraf","localPath","opts","posix","dirname","adbExec","pull","timeout","processExists","processName","getPIDsByName","getForwardList","connections","EOL","line","forwardPort","systemPort","devicePort","removePortForward","getReverseList","reversePort","removePortReverse","forwardAbstractPort","ping","indexOf","restart","stopLogcat","restartAdb","waitForDevice","startLogcat","logcat","Logcat","debugTrace","clearDeviceLogsOnStart","startCapture","stopCapture","getLogcatLogs","getLogs","setLogcatListener","listener","removeLogcatListener","removeListener","getNameByPid","pid","titleMatch","allTitles","pidIndex","nameOffset","pidRegex","matchedLine","items","name","isBoolean","_isPgrepAvailable","pgrepOutput","_canPgrepUseFullCmdLineSearch","_isPidofAvailable","shellCommand","escapeRegExp","slice","x","pids","processNameRegex","killProcessesByName","killProcessByPID","wasRoot","becameRoot","includes","isRoot","ign","isSuccessful","root","e1","unroot","broadcastProcessEnd","intent","broadcast","start","Date","now","endAndroidCoverage","instrumentProc","isRunning","stop","instrument","activity","instrumentWith","pkgActivity","androidCoverage","instrumentClass","waitPkg","waitActivity","defaultArgs","concat","SubProcess","waitForActivity","property","val","setDeviceProperty","prop","privileged","getDeviceSysLanguage","getDeviceSysCountry","getDeviceSysLocale","getDeviceProductLanguage","getDeviceProductCountry","getDeviceProductLocale","getModel","getManufacturer","getScreenSize","size","getScreenDensity","density","densityNumber","setHttpProxy","proxyHost","proxyPort","proxy","isUndefined","httpProxySettins","settingKey","settingValue","deleteHttpProxy","namespace","bugreport","screenrecord","destination","options","videoSize","bitRate","timeLimit","bugReport","fullCmd","quote","runInImeContext","ime","fn","originalIme","getTimeZone","listFeatures","_memoizedFeatures","memoize","curDeviceId","isStreamedInstallSupported","proto","Object","getPrototypeOf","_helpOutput"],"mappings":"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","sourcesContent":["import log from '../logger.js';\nimport {\n  getIMEListFromOutput, isShowingLockscreen, isCurrentFocusOnKeyguard,\n  getSurfaceOrientation, isScreenOnFully, extractMatchingPermissions,\n} from '../helpers.js';\nimport path from 'path';\nimport _ from 'lodash';\nimport { fs, util } from 'appium-support';\nimport net from 'net';\nimport { EOL } from 'os';\nimport Logcat from '../logcat';\nimport { sleep, waitForCondition } from 'asyncbox';\nimport { SubProcess } from 'teen_process';\nimport B from 'bluebird';\n\nconst MAX_SHELL_BUFFER_LENGTH = 1000;\nconst NOT_CHANGEABLE_PERM_ERROR = /not a changeable permission type/i;\nconst IGNORED_PERM_ERRORS = [\n  NOT_CHANGEABLE_PERM_ERROR,\n  /Unknown permission/i,\n];\nconst MAX_PGREP_PATTERN_LEN = 15;\nconst HIDDEN_API_POLICY_KEYS = [\n  'hidden_api_policy_pre_p_apps',\n  'hidden_api_policy_p_apps',\n  'hidden_api_policy'\n];\nconst PID_COLUMN_TITLE = 'PID';\nconst PROCESS_NAME_COLUMN_TITLE = 'NAME';\nconst PS_TITLE_PATTERN = new RegExp(`^(.*\\\\b${PID_COLUMN_TITLE}\\\\b.*\\\\b${PROCESS_NAME_COLUMN_TITLE}\\\\b.*)$`, 'm');\n\n\nlet methods = {};\n\n/**\n * Get the path to adb executable amd assign it\n * to this.executable.path and this.binaries.adb properties.\n *\n * @return {string} Full path to adb executable.\n */\nmethods.getAdbWithCorrectAdbPath = async function getAdbWithCorrectAdbPath () {\n  this.executable.path = await this.getSdkBinaryPath('adb');\n  return this.adb;\n};\n\n/**\n * Get the full path to aapt tool and assign it to\n * this.binaries.aapt property\n */\nmethods.initAapt = async function initAapt () {\n  await this.getSdkBinaryPath('aapt');\n};\n\n/**\n * Get the full path to aapt2 tool and assign it to\n * this.binaries.aapt2 property\n */\nmethods.initAapt2 = async function initAapt2 () {\n  await this.getSdkBinaryPath('aapt2');\n};\n\n/**\n * Get the full path to zipalign tool and assign it to\n * this.binaries.zipalign property\n */\nmethods.initZipAlign = async function initZipAlign () {\n  await this.getSdkBinaryPath('zipalign');\n};\n\n/**\n * Get the full path to bundletool binary and assign it to\n * this.binaries.bundletool property\n */\nmethods.initBundletool = async function initBundletool () {\n  try {\n    this.binaries.bundletool = await fs.which('bundletool.jar');\n  } catch (err) {\n    throw new Error('bundletool.jar binary is expected to be present in PATH. ' +\n      'Visit https://github.com/google/bundletool for more details.');\n  }\n};\n\n/**\n * Retrieve the API level of the device under test.\n *\n * @return {number} The API level as integer number, for example 21 for\n *                  Android Lollipop. The result of this method is cached, so all the further\n * calls return the same value as the first one.\n */\nmethods.getApiLevel = async function getApiLevel () {\n  if (!_.isInteger(this._apiLevel)) {\n    try {\n      const strOutput = await this.getDeviceProperty('ro.build.version.sdk');\n      let apiLevel = parseInt(strOutput.trim(), 10);\n\n      // Workaround for preview/beta platform API level\n      const charCodeQ = 'q'.charCodeAt(0);\n      // 28 is the first API Level, where Android SDK started returning letters in response to getPlatformVersion\n      const apiLevelDiff = apiLevel - 28;\n      const codename = String.fromCharCode(charCodeQ + apiLevelDiff);\n      if (apiLevelDiff >= 0 && (await this.getPlatformVersion()).toLowerCase() === codename) {\n        log.debug(`Release version is ${codename.toUpperCase()} but found API Level ${apiLevel}. Setting API Level to ${apiLevel + 1}`);\n        apiLevel++;\n      }\n\n      this._apiLevel = apiLevel;\n      log.debug(`Device API level: ${this._apiLevel}`);\n      if (isNaN(this._apiLevel)) {\n        throw new Error(`The actual output '${strOutput}' cannot be converted to an integer`);\n      }\n    } catch (e) {\n      throw new Error(`Error getting device API level. Original error: ${e.message}`);\n    }\n  }\n  return this._apiLevel;\n};\n\n/**\n * Retrieve the platform version of the device under test.\n *\n * @return {string} The platform version as a string, for example '5.0' for\n * Android Lollipop.\n */\nmethods.getPlatformVersion = async function getPlatformVersion () {\n  log.info('Getting device platform version');\n  try {\n    return await this.getDeviceProperty('ro.build.version.release');\n  } catch (e) {\n    throw new Error(`Error getting device platform version. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Verify whether a device is connected.\n *\n * @return {boolean} True if at least one device is visible to adb.\n */\nmethods.isDeviceConnected = async function isDeviceConnected () {\n  let devices = await this.getConnectedDevices();\n  return devices.length > 0;\n};\n\n/**\n * Recursively create a new folder on the device under test.\n *\n * @param {string} remotePath - The new path to be created.\n * @return {string} mkdir command output.\n */\nmethods.mkdir = async function mkdir (remotePath) {\n  return await this.shell(['mkdir', '-p', remotePath]);\n};\n\n/**\n * Verify whether the given argument is a\n * valid class name.\n *\n * @param {string} classString - The actual class name to be verified.\n * @return {?Array.<Match>} The result of Regexp.exec operation\n *                          or _null_ if no matches are found.\n */\nmethods.isValidClass = function isValidClass (classString) {\n  // some.package/some.package.Activity\n  return new RegExp(/^[a-zA-Z0-9./_]+$/).exec(classString);\n};\n\n/**\n * Force application to stop on the device under test.\n *\n * @param {string} pkg - The package name to be stopped.\n * @return {string} The output of the corresponding adb command.\n */\nmethods.forceStop = async function forceStop (pkg) {\n  return await this.shell(['am', 'force-stop', pkg]);\n};\n\n/*\n * Kill application\n *\n * @param {string} pkg - The package name to be stopped.\n * @return {string} The output of the corresponding adb command.\n */\nmethods.killPackage = async function killPackage (pkg) {\n  return await this.shell(['am', 'kill', pkg]);\n};\n\n/**\n * Clear the user data of the particular application on the device\n * under test.\n *\n * @param {string} pkg - The package name to be cleared.\n * @return {string} The output of the corresponding adb command.\n */\nmethods.clear = async function clear (pkg) {\n  return await this.shell(['pm', 'clear', pkg]);\n};\n\n/**\n * Grant all permissions requested by the particular package.\n * This method is only useful on Android 6.0+ and for applications\n * that support components-based permissions setting.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} apk - The path to the actual apk file.\n * @throws {Error} If there was an error while granting permissions\n */\nmethods.grantAllPermissions = async function grantAllPermissions (pkg, apk) {\n  const apiLevel = await this.getApiLevel();\n  let targetSdk = 0;\n  let dumpsysOutput = null;\n  try {\n    if (!apk) {\n      /**\n       * If apk not provided, considering apk already installed on the device\n       * and fetching targetSdk using package name.\n       */\n      dumpsysOutput = await this.shell(['dumpsys', 'package', pkg]);\n      targetSdk = await this.targetSdkVersionUsingPKG(pkg, dumpsysOutput);\n    } else {\n      targetSdk = await this.targetSdkVersionFromManifest(apk);\n    }\n  } catch (e) {\n    //avoiding logging error stack, as calling library function would have logged\n    log.warn(`Ran into problem getting target SDK version; ignoring...`);\n  }\n  if (apiLevel >= 23 && targetSdk >= 23) {\n    /**\n     * If the device is running Android 6.0(API 23) or higher, and your app's target SDK is 23 or higher:\n     * The app has to list the permissions in the manifest.\n     * refer: https://developer.android.com/training/permissions/requesting.html\n     */\n    dumpsysOutput = dumpsysOutput || await this.shell(['dumpsys', 'package', pkg]);\n    const requestedPermissions = await this.getReqPermissions(pkg, dumpsysOutput);\n    const grantedPermissions = await this.getGrantedPermissions(pkg, dumpsysOutput);\n    const permissionsToGrant = _.difference(requestedPermissions, grantedPermissions);\n    if (_.isEmpty(permissionsToGrant)) {\n      log.info(`${pkg} contains no permissions available for granting`);\n    } else {\n      await this.grantPermissions(pkg, permissionsToGrant);\n    }\n  }\n};\n\n/**\n * Grant multiple permissions for the particular package.\n * This call is more performant than `grantPermission` one, since it combines\n * multiple `adb shell` calls into a single command.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {Array<string>} permissions - The list of permissions to be granted.\n * @throws {Error} If there was an error while changing permissions.\n */\nmethods.grantPermissions = async function grantPermissions (pkg, permissions) {\n  // As it consumes more time for granting each permission,\n  // trying to grant all permission by forming equivalent command.\n  // Also, it is necessary to split long commands into chunks, since the maximum length of\n  // adb shell buffer is limited\n  log.debug(`Granting permissions ${JSON.stringify(permissions)} to '${pkg}'`);\n  const commands = [];\n  let cmdChunk = [];\n  for (const permission of permissions) {\n    const nextCmd = ['pm', 'grant', pkg, permission, ';'];\n    if (nextCmd.join(' ').length + cmdChunk.join(' ').length >= MAX_SHELL_BUFFER_LENGTH) {\n      commands.push(cmdChunk);\n      cmdChunk = [];\n    }\n    cmdChunk = [...cmdChunk, ...nextCmd];\n  }\n  if (!_.isEmpty(cmdChunk)) {\n    commands.push(cmdChunk);\n  }\n  log.debug(`Got the following command chunks to execute: ${JSON.stringify(commands)}`);\n  let lastError = null;\n  for (const cmd of commands) {\n    try {\n      await this.shell(cmd);\n    } catch (e) {\n      // this is to give the method a chance to assign all the requested permissions\n      // before to quit in case we'd like to ignore the error on the higher level\n      if (!IGNORED_PERM_ERRORS.some((msgRegex) => msgRegex.test(e.stderr || e.message))) {\n        lastError = e;\n      }\n    }\n  }\n  if (lastError) {\n    throw lastError;\n  }\n};\n\n/**\n * Grant single permission for the particular package.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} permission - The full name of the permission to be granted.\n * @throws {Error} If there was an error while changing permissions.\n */\nmethods.grantPermission = async function grantPermission (pkg, permission) {\n  try {\n    await this.shell(['pm', 'grant', pkg, permission]);\n  } catch (e) {\n    if (!NOT_CHANGEABLE_PERM_ERROR.test(e.stderr || e.message)) {\n      throw e;\n    }\n  }\n};\n\n/**\n * Revoke single permission from the particular package.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} permission - The full name of the permission to be revoked.\n * @throws {Error} If there was an error while changing permissions.\n */\nmethods.revokePermission = async function revokePermission (pkg, permission) {\n  try {\n    await this.shell(['pm', 'revoke', pkg, permission]);\n  } catch (e) {\n    if (!NOT_CHANGEABLE_PERM_ERROR.test(e.stderr || e.message)) {\n      throw e;\n    }\n  }\n};\n\n/**\n * Retrieve the list of granted permissions for the particular package.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} cmdOutput [null] - Optional parameter containing command output of\n *                                    _dumpsys package_ command. It may speed up the method execution.\n * @return {Array<String>} The list of granted permissions or an empty list.\n * @throws {Error} If there was an error while changing permissions.\n */\nmethods.getGrantedPermissions = async function getGrantedPermissions (pkg, cmdOutput = null) {\n  log.debug('Retrieving granted permissions');\n  const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);\n  return extractMatchingPermissions(stdout, ['install', 'runtime'], true);\n};\n\n/**\n * Retrieve the list of denied permissions for the particular package.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} cmdOutput [null] - Optional parameter containing command output of\n *                                    _dumpsys package_ command. It may speed up the method execution.\n * @return {Array<String>} The list of denied permissions or an empty list.\n */\nmethods.getDeniedPermissions = async function getDeniedPermissions (pkg, cmdOutput = null) {\n  log.debug('Retrieving denied permissions');\n  const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);\n  return extractMatchingPermissions(stdout, ['install', 'runtime'], false);\n};\n\n/**\n * Retrieve the list of requested permissions for the particular package.\n *\n * @param {string} pkg - The package name to be processed.\n * @param {string} cmdOutput [null] - Optional parameter containing command output of\n *                                    _dumpsys package_ command. It may speed up the method execution.\n * @return {Array<String>} The list of requested permissions or an empty list.\n */\nmethods.getReqPermissions = async function getReqPermissions (pkg, cmdOutput = null) {\n  log.debug('Retrieving requested permissions');\n  const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);\n  return extractMatchingPermissions(stdout, ['requested']);\n};\n\n/**\n * Retrieve the list of location providers for the device under test.\n *\n * @return {Array.<String>} The list of available location providers or an empty list.\n */\nmethods.getLocationProviders = async function getLocationProviders () {\n  let stdout = await this.getSetting('secure', 'location_providers_allowed');\n  return stdout.trim().split(',')\n    .map((p) => p.trim())\n    .filter(Boolean);\n};\n\n/**\n * Toggle the state of GPS location provider.\n *\n * @param {boolean} enabled - Whether to enable (true) or disable (false) the GPS provider.\n */\nmethods.toggleGPSLocationProvider = async function toggleGPSLocationProvider (enabled) {\n  await this.setSetting('secure', 'location_providers_allowed', `${enabled ? '+' : '-'}gps`);\n};\n\n/**\n * Set hidden api policy to manage access to non-SDK APIs.\n * https://developer.android.com/preview/restrictions-non-sdk-interfaces\n *\n * @param {number|string} value - The API enforcement policy.\n *     For Android P\n *     0: Disable non-SDK API usage detection. This will also disable logging, and also break the strict mode API,\n *        detectNonSdkApiUsage(). Not recommended.\n *     1: \"Just warn\" - permit access to all non-SDK APIs, but keep warnings in the log.\n *        The strict mode API will keep working.\n *     2: Disallow usage of dark grey and black listed APIs.\n *     3: Disallow usage of blacklisted APIs, but allow usage of dark grey listed APIs.\n *\n *     For Android Q\n *     https://developer.android.com/preview/non-sdk-q#enable-non-sdk-access\n *     0: Disable all detection of non-SDK interfaces. Using this setting disables all log messages for non-SDK interface usage\n *        and prevents you from testing your app using the StrictMode API. This setting is not recommended.\n *     1: Enable access to all non-SDK interfaces, but print log messages with warnings for any non-SDK interface usage.\n *        Using this setting also allows you to test your app using the StrictMode API.\n *     2: Disallow usage of non-SDK interfaces that belong to either the black list\n *        or to a restricted greylist for your target API level.\n *\n * @param {boolean} ignoreError [false] Whether to ignore an exception in 'adb shell settings put global' command\n * @throws {error} If there was an error and ignoreError was true while executing 'adb shell settings put global'\n *                 command on the device under test.\n */\nmethods.setHiddenApiPolicy = async function setHiddenApiPolicy (value, ignoreError = false) {\n  try {\n    await this.shell(HIDDEN_API_POLICY_KEYS.map((k) => `settings put global ${k} ${value}`).join(';'));\n  } catch (e) {\n    if (!ignoreError) {\n      throw e;\n    }\n    log.info(`Failed to set setting keys '${HIDDEN_API_POLICY_KEYS}' to '${value}'. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Reset access to non-SDK APIs to its default setting.\n * https://developer.android.com/preview/restrictions-non-sdk-interfaces\n *\n * @param {boolean} ignoreError [false] Whether to ignore an exception in 'adb shell settings delete global' command\n * @throws {error} If there was an error and ignoreError was true while executing 'adb shell settings delete global'\n *                 command on the device under test.\n */\nmethods.setDefaultHiddenApiPolicy = async function setDefaultHiddenApiPolicy (ignoreError = false) {\n  try {\n    await this.shell(HIDDEN_API_POLICY_KEYS.map((k) => `settings delete global ${k}`).join(';'));\n  } catch (e) {\n    if (!ignoreError) {\n      throw e;\n    }\n    log.info(`Failed to delete keys '${HIDDEN_API_POLICY_KEYS}'. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Stop the particular package if it is running and clears its application data.\n *\n * @param {string} pkg - The package name to be processed.\n */\nmethods.stopAndClear = async function stopAndClear (pkg) {\n  try {\n    await this.forceStop(pkg);\n    await this.clear(pkg);\n  } catch (e) {\n    throw new Error(`Cannot stop and clear ${pkg}. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Retrieve the list of available input methods (IMEs) for the device under test.\n *\n * @return {Array.<String>} The list of IME names or an empty list.\n */\nmethods.availableIMEs = async function availableIMEs () {\n  try {\n    return getIMEListFromOutput(await this.shell(['ime', 'list', '-a']));\n  } catch (e) {\n    throw new Error(`Error getting available IME's. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Retrieve the list of enabled input methods (IMEs) for the device under test.\n *\n * @return {Array.<String>} The list of enabled IME names or an empty list.\n */\nmethods.enabledIMEs = async function enabledIMEs () {\n  try {\n    return getIMEListFromOutput(await this.shell(['ime', 'list']));\n  } catch (e) {\n    throw new Error(`Error getting enabled IME's. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Enable the particular input method on the device under test.\n *\n * @param {string} imeId - One of existing IME ids.\n */\nmethods.enableIME = async function enableIME (imeId) {\n  await this.shell(['ime', 'enable', imeId]);\n};\n\n/**\n * Disable the particular input method on the device under test.\n *\n * @param {string} imeId - One of existing IME ids.\n */\nmethods.disableIME = async function disableIME (imeId) {\n  await this.shell(['ime', 'disable', imeId]);\n};\n\n/**\n * Set the particular input method on the device under test.\n *\n * @param {string} imeId - One of existing IME ids.\n */\nmethods.setIME = async function setIME (imeId) {\n  await this.shell(['ime', 'set', imeId]);\n};\n\n/**\n * Get the default input method on the device under test.\n *\n * @return {?string} The name of the default input method\n */\nmethods.defaultIME = async function defaultIME () {\n  try {\n    let engine = await this.getSetting('secure', 'default_input_method');\n    if (engine === 'null') {\n      return null;\n    }\n    return engine.trim();\n  } catch (e) {\n    throw new Error(`Error getting default IME. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Send the particular keycode to the device under test.\n *\n * @param {string|number} keycode - The actual key code to be sent.\n */\nmethods.keyevent = async function keyevent (keycode) {\n  // keycode must be an int.\n  let code = parseInt(keycode, 10);\n  await this.shell(['input', 'keyevent', code]);\n};\n\n/**\n * Send the particular text to the device under test.\n *\n * @param {string} text - The actual text to be sent.\n */\nmethods.inputText = async function inputText (text) {\n  /* eslint-disable no-useless-escape */\n  // need to escape whitespace and ( ) < > | ; & * \\ ~ \" '\n  text = text\n          .replace(/\\\\/g, '\\\\\\\\')\n          .replace(/\\(/g, '\\(')\n          .replace(/\\)/g, '\\)')\n          .replace(/</g, '\\<')\n          .replace(/>/g, '\\>')\n          .replace(/\\|/g, '\\|')\n          .replace(/;/g, '\\;')\n          .replace(/&/g, '\\&')\n          .replace(/\\*/g, '\\*')\n          .replace(/~/g, '\\~')\n          .replace(/\"/g, '\\\"')\n          .replace(/'/g, \"\\'\")\n          .replace(/ /g, '%s');\n  /* eslint-disable no-useless-escape */\n  await this.shell(['input', 'text', text]);\n};\n\n/**\n * Clear the active text field on the device under test by sending\n * special keyevents to it.\n *\n * @param {number} length [100] - The maximum length of the text in the field to be cleared.\n */\nmethods.clearTextField = async function clearTextField (length = 100) {\n  // assumes that the EditText field already has focus\n  log.debug(`Clearing up to ${length} characters`);\n  if (length === 0) {\n    return;\n  }\n  let args = ['input', 'keyevent'];\n  for (let i = 0; i < length; i++) {\n    // we cannot know where the cursor is in the text field, so delete both before\n    // and after so that we get rid of everything\n    // https://developer.android.com/reference/android/view/KeyEvent.html#KEYCODE_DEL\n    // https://developer.android.com/reference/android/view/KeyEvent.html#KEYCODE_FORWARD_DEL\n    args.push('67', '112');\n  }\n  await this.shell(args);\n};\n\n/**\n * Send the special keycode to the device under test in order to lock it.\n */\nmethods.lock = async function lock () {\n  if (await this.isScreenLocked()) {\n    log.debug('Screen is already locked. Doing nothing.');\n    return;\n  }\n  log.debug('Pressing the KEYCODE_POWER button to lock screen');\n  await this.keyevent(26);\n\n  const timeoutMs = 5000;\n  try {\n    await waitForCondition(async () => await this.isScreenLocked(), {\n      waitMs: timeoutMs,\n      intervalMs: 500,\n    });\n  } catch (e) {\n    throw new Error(`The device screen is still locked after ${timeoutMs}ms timeout`);\n  }\n};\n\n/**\n * Send the special keycode to the device under test in order to emulate\n * Back button tap.\n */\nmethods.back = async function back () {\n  log.debug('Pressing the BACK button');\n  await this.keyevent(4);\n};\n\n/**\n * Send the special keycode to the device under test in order to emulate\n * Home button tap.\n */\nmethods.goToHome = async function goToHome () {\n  log.debug('Pressing the HOME button');\n  await this.keyevent(3);\n};\n\n/**\n * @return {string} the actual path to adb executable.\n */\nmethods.getAdbPath = function getAdbPath () {\n  return this.executable.path;\n};\n\n/**\n * Retrieve current screen orientation of the device under test.\n *\n * @return {number} The current orientation encoded as an integer number.\n */\nmethods.getScreenOrientation = async function getScreenOrientation () {\n  let stdout = await this.shell(['dumpsys', 'input']);\n  return getSurfaceOrientation(stdout);\n};\n\n/**\n * Retrieve the screen lock state of the device under test.\n *\n * @return {boolean} True if the device is locked.\n */\nmethods.isScreenLocked = async function isScreenLocked () {\n  let stdout = await this.shell(['dumpsys', 'window']);\n  if (process.env.APPIUM_LOG_DUMPSYS) {\n    // optional debugging\n    // if the method is not working, turn it on and send us the output\n    let dumpsysFile = path.resolve(process.cwd(), 'dumpsys.log');\n    log.debug(`Writing dumpsys output to ${dumpsysFile}`);\n    await fs.writeFile(dumpsysFile, stdout);\n  }\n  return (isShowingLockscreen(stdout) || isCurrentFocusOnKeyguard(stdout) ||\n          !isScreenOnFully(stdout));\n};\n\n/**\n * @typedef {Object} KeyboardState\n * @property {boolean} isKeyboardShown - Whether soft keyboard is currently visible.\n * @property {boolean} canCloseKeyboard - Whether the keyboard can be closed.\n */\n\n/**\n * Retrieve the state of the software keyboard on the device under test.\n *\n * @return {KeyboardState} The keyboard state.\n */\nmethods.isSoftKeyboardPresent = async function isSoftKeyboardPresent () {\n  try {\n    const stdout = await this.shell(['dumpsys', 'input_method']);\n    const inputShownMatch = /mInputShown=(\\w+)/.exec(stdout);\n    const inputViewShownMatch = /mIsInputViewShown=(\\w+)/.exec(stdout);\n    return {\n      isKeyboardShown: !!(inputShownMatch && inputShownMatch[1] === 'true'),\n      canCloseKeyboard: !!(inputViewShownMatch && inputViewShownMatch[1] === 'true'),\n    };\n  } catch (e) {\n    throw new Error(`Error finding softkeyboard. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Send an arbitrary Telnet command to the device under test.\n *\n * @param {string} command - The command to be sent.\n *\n * @return {string} The actual output of the given command.\n */\nmethods.sendTelnetCommand = async function sendTelnetCommand (command) {\n  log.debug(`Sending telnet command to device: ${command}`);\n  let port = await this.getEmulatorPort();\n  return await new B((resolve, reject) => {\n    let conn = net.createConnection(port, 'localhost'),\n        connected = false,\n        readyRegex = /^OK$/m,\n        dataStream = '',\n        res = null;\n    conn.on('connect', () => {\n      log.debug('Socket connection to device created');\n    });\n    conn.on('data', (data) => {\n      data = data.toString('utf8');\n      if (!connected) {\n        if (readyRegex.test(data)) {\n          connected = true;\n          log.debug('Socket connection to device ready');\n          conn.write(`${command}\\n`);\n        }\n      } else {\n        dataStream += data;\n        if (readyRegex.test(data)) {\n          res = dataStream.replace(readyRegex, '').trim();\n          res = _.last(res.trim().split('\\n'));\n          log.debug(`Telnet command got response: ${res}`);\n          conn.write('quit\\n');\n        }\n      }\n    });\n    conn.on('error', (err) => { // eslint-disable-line promise/prefer-await-to-callbacks\n      log.debug(`Telnet command error: ${err.message}`);\n      reject(err);\n    });\n    conn.on('close', () => {\n      if (res === null) {\n        reject(new Error('Never got a response from command'));\n      } else {\n        resolve(res);\n      }\n    });\n  });\n};\n\n/**\n * Check the state of Airplane mode on the device under test.\n *\n * @return {boolean} True if Airplane mode is enabled.\n */\nmethods.isAirplaneModeOn = async function isAirplaneModeOn () {\n  let stdout = await this.getSetting('global', 'airplane_mode_on');\n  return parseInt(stdout, 10) !== 0;\n};\n\n/**\n * Change the state of Airplane mode in Settings on the device under test.\n *\n * @param {boolean} on - True to enable the Airplane mode in Settings and false to disable it.\n */\nmethods.setAirplaneMode = async function setAirplaneMode (on) {\n  await this.setSetting('global', 'airplane_mode_on', on ? 1 : 0);\n};\n\n/**\n * Broadcast the state of Airplane mode on the device under test.\n * This method should be called after {@link #setAirplaneMode}, otherwise\n * the mode change is not going to be applied for the device.\n *\n * @param {boolean} on - True to broadcast enable and false to broadcast disable.\n */\nmethods.broadcastAirplaneMode = async function broadcastAirplaneMode (on) {\n  await this.shell([\n    'am', 'broadcast',\n    '-a', 'android.intent.action.AIRPLANE_MODE',\n    '--ez', 'state', on ? 'true' : 'false'\n  ]);\n};\n\n/**\n * Check the state of WiFi on the device under test.\n *\n * @return {boolean} True if WiFi is enabled.\n */\nmethods.isWifiOn = async function isWifiOn () {\n  let stdout = await this.getSetting('global', 'wifi_on');\n  return (parseInt(stdout, 10) !== 0);\n};\n\n/**\n * Check the state of Data transfer on the device under test.\n *\n * @return {boolean} True if Data transfer is enabled.\n */\nmethods.isDataOn = async function isDataOn () {\n  let stdout = await this.getSetting('global', 'mobile_data');\n  return (parseInt(stdout, 10) !== 0);\n};\n\n/**\n * Change the state of WiFi and/or Data transfer on the device under test.\n *\n * @param {boolean} wifi - True to enable and false to disable WiFi.\n * @param {boolean} data - True to enable and false to disable Data transfer.\n * @param {boolean} isEmulator [false] - Set it to true if the device under test\n *                                       is an emulator rather than a real device.\n */\nmethods.setWifiAndData = async function setWifiAndData ({wifi, data}, isEmulator = false) {\n  if (util.hasValue(wifi)) {\n    await this.setWifiState(wifi, isEmulator);\n  }\n  if (util.hasValue(data)) {\n    await this.setDataState(data, isEmulator);\n  }\n};\n\n/**\n * Check the state of animation on the device under test.\n *\n * @return {boolean} True if at least one of animation scale settings\n *                   is not equal to '0.0'.\n */\nmethods.isAnimationOn = async function isAnimationOn () {\n  let animator_duration_scale = await this.getSetting('global', 'animator_duration_scale');\n  let transition_animation_scale = await this.getSetting('global', 'transition_animation_scale');\n  let window_animation_scale = await this.getSetting('global', 'window_animation_scale');\n  return _.some([animator_duration_scale, transition_animation_scale, window_animation_scale],\n                (setting) => setting !== '0.0');\n};\n\n/**\n * Forcefully recursively remove a path on the device under test.\n * Be careful while calling this method.\n *\n * @param {string} path - The path to be removed recursively.\n */\nmethods.rimraf = async function rimraf (path) {\n  await this.shell(['rm', '-rf', path]);\n};\n\n/**\n * Send a file to the device under test.\n *\n * @param {string} localPath - The path to the file on the local file system.\n * @param {string} remotePath - The destination path on the remote device.\n * @param {object} opts - Additional options mapping. See\n *                        https://github.com/appium/node-teen_process,\n *                        _exec_ method options, for more information about available\n *                        options.\n */\nmethods.push = async function push (localPath, remotePath, opts) {\n  await this.mkdir(path.posix.dirname(remotePath));\n  await this.adbExec(['push', localPath, remotePath], opts);\n};\n\n/**\n * Receive a file from the device under test.\n *\n * @param {string} remotePath - The source path on the remote device.\n * @param {string} localPath - The destination path to the file on the local file system.\n */\nmethods.pull = async function pull (remotePath, localPath) {\n  // pull folder can take more time, increasing time out to 60 secs\n  await this.adbExec(['pull', remotePath, localPath], {timeout: 60000});\n};\n\n/**\n * Check whether the process with the particular name is running on the device\n * under test.\n *\n * @param {string} processName - The name of the process to be checked.\n * @return {boolean} True if the given process is running.\n * @throws {Error} If the given process name is not a valid class name.\n */\nmethods.processExists = async function processExists (processName) {\n  return !_.isEmpty(await this.getPIDsByName(processName));\n};\n\n/**\n * Get TCP port forwarding with adb on the device under test.\n * @return {Array.<String>} The output of the corresponding adb command. An array contains each forwarding line of output\n */\nmethods.getForwardList = async function getForwardList () {\n  log.debug(`List forwarding ports`);\n  const connections = await this.adbExec(['forward', '--list']);\n  return connections.split(EOL).filter((line) => Boolean(line.trim()));\n};\n\n/**\n * Setup TCP port forwarding with adb on the device under test.\n *\n * @param {string|number} systemPort - The number of the local system port.\n * @param {string|number} devicePort - The number of the remote device port.\n */\nmethods.forwardPort = async function forwardPort (systemPort, devicePort) {\n  log.debug(`Forwarding system: ${systemPort} to device: ${devicePort}`);\n  await this.adbExec(['forward', `tcp:${systemPort}`, `tcp:${devicePort}`]);\n};\n\n/**\n * Remove TCP port forwarding with adb on the device under test. The forwarding\n * for the given port should be setup with {@link #forwardPort} first.\n *\n * @param {string|number} systemPort - The number of the local system port\n *                                     to remove forwarding on.\n */\nmethods.removePortForward = async function removePortForward (systemPort) {\n  log.debug(`Removing forwarded port socket connection: ${systemPort} `);\n  await this.adbExec(['forward', `--remove`, `tcp:${systemPort}`]);\n};\n\n/**\n * Get TCP port forwarding with adb on the device under test.\n * @return {Array.<String>} The output of the corresponding adb command. An array contains each forwarding line of output\n */\nmethods.getReverseList = async function getReverseList () {\n  log.debug(`List reverse forwarding ports`);\n  const connections = await this.adbExec(['reverse', '--list']);\n  return connections.split(EOL).filter((line) => Boolean(line.trim()));\n};\n\n/**\n * Setup TCP port forwarding with adb on the device under test.\n * Only available for API 21+.\n *\n * @param {string|number} devicePort - The number of the remote device port.\n * @param {string|number} systemPort - The number of the local system port.\n */\nmethods.reversePort = async function reversePort (devicePort, systemPort) {\n  log.debug(`Forwarding device: ${devicePort} to system: ${systemPort}`);\n  await this.adbExec(['reverse', `tcp:${devicePort}`, `tcp:${systemPort}`]);\n};\n\n/**\n * Remove TCP port forwarding with adb on the device under test. The forwarding\n * for the given port should be setup with {@link #forwardPort} first.\n *\n * @param {string|number} devicePort - The number of the remote device port\n *                                     to remove forwarding on.\n */\nmethods.removePortReverse = async function removePortReverse (devicePort) {\n  log.debug(`Removing reverse forwarded port socket connection: ${devicePort} `);\n  await this.adbExec(['reverse', `--remove`, `tcp:${devicePort}`]);\n};\n\n/**\n * Setup TCP port forwarding with adb on the device under test. The difference\n * between {@link #forwardPort} is that this method does setup for an abstract\n * local port.\n *\n * @param {string|number} systemPort - The number of the local system port.\n * @param {string|number} devicePort - The number of the remote device port.\n */\nmethods.forwardAbstractPort = async function forwardAbstractPort (systemPort, devicePort) {\n  log.debug(`Forwarding system: ${systemPort} to abstract device: ${devicePort}`);\n  await this.adbExec(['forward', `tcp:${systemPort}`, `localabstract:${devicePort}`]);\n};\n\n/**\n * Execute ping shell command on the device under test.\n *\n * @return {boolean} True if the command output contains 'ping' substring.\n * @throws {error} If there was an error while executing 'ping' command on the\n *                 device under test.\n */\nmethods.ping = async function ping () {\n  let stdout = await this.shell(['echo', 'ping']);\n  if (stdout.indexOf('ping') === 0) {\n    return true;\n  }\n  throw new Error(`ADB ping failed, returned ${stdout}`);\n};\n\n/**\n * Restart the device under test using adb commands.\n *\n * @throws {error} If start fails.\n */\nmethods.restart = async function restart () {\n  try {\n    await this.stopLogcat();\n    await this.restartAdb();\n    await this.waitForDevice(60);\n    await this.startLogcat();\n  } catch (e) {\n    throw new Error(`Restart failed. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Start the logcat process to gather logs.\n *\n * @throws {error} If restart fails.\n */\nmethods.startLogcat = async function startLogcat () {\n  if (!_.isEmpty(this.logcat)) {\n    throw new Error(\"Trying to start logcat capture but it's already started!\");\n  }\n  this.logcat = new Logcat({\n    adb: this.executable,\n    debug: false,\n    debugTrace: false,\n    clearDeviceLogsOnStart: !!this.clearDeviceLogsOnStart,\n  });\n  await this.logcat.startCapture();\n};\n\n/**\n * Stop the active logcat process which gathers logs.\n * The call will be ignored if no logcat process is running.\n */\nmethods.stopLogcat = async function stopLogcat () {\n  if (_.isEmpty(this.logcat)) {\n    return;\n  }\n  try {\n    await this.logcat.stopCapture();\n  } finally {\n    this.logcat = null;\n  }\n};\n\n/**\n * Retrieve the output from the currently running logcat process.\n * The logcat process should be executed by {2link #startLogcat} method.\n *\n * @return {string} The collected logcat output.\n * @throws {Error} If logcat process is not running.\n */\nmethods.getLogcatLogs = function getLogcatLogs () {\n  if (_.isEmpty(this.logcat)) {\n    throw new Error(\"Can't get logcat logs since logcat hasn't started\");\n  }\n  return this.logcat.getLogs();\n};\n\n/**\n * Set the callback for the logcat output event.\n *\n * @param {Function} listener - The listener function, which accepts one argument. The argument is\n *                              a log record object with `timestamp`, `level` and `message` properties.\n * @throws {Error} If logcat process is not running.\n */\nmethods.setLogcatListener = function setLogcatListener (listener) {\n  if (_.isEmpty(this.logcat)) {\n    throw new Error(\"Logcat process hasn't been started\");\n  }\n  this.logcat.on('output', listener);\n};\n\n/**\n * Removes the previously set callback for the logcat output event.\n *\n * @param {Function} listener - The listener function, which has been previously\n *                              passed to `setLogcatListener`\n * @throws {Error} If logcat process is not running.\n */\nmethods.removeLogcatListener = function removeLogcatListener (listener) {\n  if (_.isEmpty(this.logcat)) {\n    throw new Error(\"Logcat process hasn't been started\");\n  }\n  this.logcat.removeListener('output', listener);\n};\n\n/**\n * Returns process name for the given process identifier\n *\n * @param {string|number} pid - The valid process identifier\n * @throws {Error} If the given PID is either invalid or is not present\n * in the active processes list\n * @returns {string} The process name\n */\nmethods.getNameByPid = async function getNameByPid (pid) {\n  if (isNaN(pid)) {\n    throw new Error(`The PID value must be a valid number. '${pid}' is given instead`);\n  }\n  pid = parseInt(pid, 10);\n\n  const stdout = await this.shell(['ps']);\n  const titleMatch = PS_TITLE_PATTERN.exec(stdout);\n  if (!titleMatch) {\n    log.debug(stdout);\n    throw new Error(`Could not get the process name for PID '${pid}'`);\n  }\n  const allTitles = titleMatch[1].trim().split(/\\s+/);\n  const pidIndex = allTitles.indexOf(PID_COLUMN_TITLE);\n  // it might not be stable to take NAME by index, because depending on the\n  // actual SDK the ps output might not contain an abbreviation for the S flag:\n  // USER     PID   PPID  VSIZE  RSS     WCHAN    PC        NAME\n  // USER     PID   PPID  VSIZE  RSS     WCHAN    PC   S    NAME\n  const nameOffset = allTitles.indexOf(PROCESS_NAME_COLUMN_TITLE) - allTitles.length;\n  const pidRegex = new RegExp(`^(.*\\\\b${pid}\\\\b.*)$`, 'gm');\n  let matchedLine;\n  while ((matchedLine = pidRegex.exec(stdout))) {\n    const items = matchedLine[1].trim().split(/\\s+/);\n    if (parseInt(items[pidIndex], 10) === pid && items[items.length + nameOffset]) {\n      return items[items.length + nameOffset];\n    }\n  }\n  log.debug(stdout);\n  throw new Error(`Could not get the process name for PID '${pid}'`);\n};\n\n/**\n * Get the list of process ids for the particular process on the device under test.\n *\n * @param {string} name - The part of process name.\n * @return {Array.<number>} The list of matched process IDs or an empty list.\n * @throws {Error} If the passed process name is not a valid one\n */\nmethods.getPIDsByName = async function getPIDsByName (name) {\n  log.debug(`Getting IDs of all '${name}' processes`);\n  if (!this.isValidClass(name)) {\n    throw new Error(`Invalid process name: '${name}'`);\n  }\n  // https://github.com/appium/appium/issues/13567\n  if (await this.getApiLevel() >= 23) {\n    if (!_.isBoolean(this._isPgrepAvailable)) {\n      // pgrep is in priority, since pidof has been reported of having bugs on some platforms\n      const pgrepOutput = _.trim(await this.shell(['pgrep --help; echo $?']));\n      this._isPgrepAvailable = parseInt(_.last(pgrepOutput.split(/\\s+/)), 10) === 0;\n      if (this._isPgrepAvailable) {\n        this._canPgrepUseFullCmdLineSearch = /^-f\\b/m.test(pgrepOutput);\n      } else {\n        this._isPidofAvailable = parseInt(await this.shell(['pidof --help > /dev/null; echo $?']), 10) === 0;\n      }\n    }\n    if (this._isPgrepAvailable || this._isPidofAvailable) {\n      const shellCommand = this._isPgrepAvailable\n        ? (this._canPgrepUseFullCmdLineSearch\n          ? ['pgrep', '-f', _.escapeRegExp(name)]\n          // https://github.com/appium/appium/issues/13872\n          : [`pgrep ^${_.escapeRegExp(name.slice(-MAX_PGREP_PATTERN_LEN))}$ || pgrep ^${_.escapeRegExp(name.slice(0, MAX_PGREP_PATTERN_LEN))}$`])\n        : ['pidof', name];\n      try {\n        return (await this.shell(shellCommand))\n          .split(/\\s+/)\n          .map((x) => parseInt(x, 10))\n          .filter((x) => _.isInteger(x));\n      } catch (e) {\n        // error code 1 is returned if the utility did not find any processes\n        // with the given name\n        if (e.code === 1) {\n          return [];\n        }\n        throw new Error(`Could not extract process ID of '${name}': ${e.message}`);\n      }\n    }\n  }\n\n  log.debug('Using ps-based PID detection');\n  const stdout = await this.shell(['ps']);\n  const titleMatch = PS_TITLE_PATTERN.exec(stdout);\n  if (!titleMatch) {\n    log.debug(stdout);\n    throw new Error(`Could not extract PID of '${name}' from ps output`);\n  }\n  const allTitles = titleMatch[1].trim().split(/\\s+/);\n  const pidIndex = allTitles.indexOf(PID_COLUMN_TITLE);\n  const pids = [];\n  const processNameRegex = new RegExp(`^(.*\\\\b\\\\d+\\\\b.*\\\\b${_.escapeRegExp(name)}\\\\b.*)$`, 'gm');\n  let matchedLine;\n  while ((matchedLine = processNameRegex.exec(stdout))) {\n    const items = matchedLine[1].trim().split(/\\s+/);\n    if (pidIndex >= allTitles.length || isNaN(items[pidIndex])) {\n      log.debug(stdout);\n      throw new Error(`Could not extract PID of '${name}' from '${matchedLine[1].trim()}'`);\n    }\n    pids.push(parseInt(items[pidIndex], 10));\n  }\n  return pids;\n};\n\n/**\n * Get the list of process ids for the particular process on the device under test.\n *\n * @param {string} name - The part of process name.\n * @return {Array.<number>} The list of matched process IDs or an empty list.\n */\nmethods.killProcessesByName = async function killProcessesByName (name) {\n  try {\n    log.debug(`Attempting to kill all ${name} processes`);\n    let pids = await this.getPIDsByName(name);\n    if (_.isEmpty(pids)) {\n      log.info(`No '${name}' process has been found`);\n      return;\n    }\n    for (let pid of pids) {\n      await this.killProcessByPID(pid);\n    }\n  } catch (e) {\n    throw new Error(`Unable to kill ${name} processes. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Kill the particular process on the device under test.\n * The current user is automatically switched to root if necessary in order\n * to properly kill the process.\n *\n * @param {string|number} pid - The ID of the process to be killed.\n * @return {string} Kill command's stdout or stderr if there was no such process.\n * @throws {Error} If the process cannot be killed.\n */\nmethods.killProcessByPID = async function killProcessByPID (pid) {\n  log.debug(`Attempting to kill process ${pid}`);\n  let wasRoot = false;\n  let becameRoot = false;\n  try {\n    try {\n      // Check if the process exists and throw an exception otherwise\n      await this.shell(['kill', '-0', pid]);\n    } catch (e) {\n      if (_.includes(e.stderr, 'No such process')) {\n        return e.stderr;\n      }\n      if (!_.includes(e.stderr, 'Operation not permitted')) {\n        throw e;\n      }\n      try {\n        wasRoot = await this.isRoot();\n      } catch (ign) {}\n      if (wasRoot) {\n        throw e;\n      }\n      log.info(`Cannot kill PID ${pid} due to insufficient permissions. Retrying as root`);\n      ({isSuccessful: becameRoot} = await this.root());\n      try {\n        await this.shell(['kill', '-0', pid]);\n      } catch (e1) {\n        if (_.includes(e1.stderr, 'No such process')) {\n          return e1.stderr;\n        }\n        throw e1;\n      }\n    }\n    const timeoutMs = 1000;\n    let stdout;\n    try {\n      await waitForCondition(async () => {\n        try {\n          stdout = await this.shell(['kill', pid]);\n          return false;\n        } catch (e) {\n          // kill returns non-zero code if the process is already killed\n          return true;\n        }\n      }, {waitMs: timeoutMs, intervalMs: 300});\n    } catch (err) {\n      log.warn(`Cannot kill process ${pid} in ${timeoutMs} ms. Trying to force kill...`);\n      stdout = await this.shell(['kill', '-9', pid]);\n    }\n    return stdout;\n  } finally {\n    if (becameRoot) {\n      await this.unroot();\n    }\n  }\n};\n\n/**\n * Broadcast process killing on the device under test.\n *\n * @param {string} intent - The name of the intent to broadcast to.\n * @param {string} processName - The name of the killed process.\n * @throws {error} If the process was not killed.\n */\nmethods.broadcastProcessEnd = async function broadcastProcessEnd (intent, processName) {\n  // start the broadcast without waiting for it to finish.\n  this.broadcast(intent);\n  // wait for the process to end\n  let start = Date.now();\n  let timeoutMs = 40000;\n  try {\n    while ((Date.now() - start) < timeoutMs) {\n      if (await this.processExists(processName)) {\n        // cool down\n        await sleep(400);\n        continue;\n      }\n      return;\n    }\n    throw new Error(`Process never died within ${timeoutMs} ms`);\n  } catch (e) {\n    throw new Error(`Unable to broadcast process end. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Broadcast a message to the given intent.\n *\n * @param {string} intent - The name of the intent to broadcast to.\n * @throws {error} If intent name is not a valid class name.\n */\nmethods.broadcast = async function broadcast (intent) {\n  if (!this.isValidClass(intent)) {\n    throw new Error(`Invalid intent ${intent}`);\n  }\n  log.debug(`Broadcasting: ${intent}`);\n  await this.shell(['am', 'broadcast', '-a', intent]);\n};\n\n/**\n * Kill Android instruments if they are currently running.\n */\nmethods.endAndroidCoverage = async function endAndroidCoverage () {\n  if (this.instrumentProc && this.instrumentProc.isRunning) {\n    await this.instrumentProc.stop();\n  }\n};\n\n/**\n * Instrument the particular activity.\n *\n * @param {string} pkg - The name of the package to be instrumented.\n * @param {string} activity - The name of the main activity in this package.\n * @param {string} instrumentWith - The name of the package to instrument\n *                                  the activity with.\n * @throws {error} If any exception is reported by adb shell.\n */\nmethods.instrument = async function instrument (pkg, activity, instrumentWith) {\n  if (activity[0] !== '.') {\n    pkg = '';\n  }\n  let pkgActivity = (pkg + activity).replace(/\\.+/g, '.'); // Fix pkg..activity error\n  let stdout = await this.shell([\n    'am', 'instrument',\n    '-e', 'main_activity',\n    pkgActivity,\n    instrumentWith,\n  ]);\n  if (stdout.indexOf('Exception') !== -1) {\n    throw new Error(`Unknown exception during instrumentation. Original error ${stdout.split('\\n')[0]}`);\n  }\n};\n\n/**\n * Collect Android coverage by instrumenting the particular activity.\n *\n * @param {string} instrumentClass - The name of the instrumentation class.\n * @param {string} waitPkg - The name of the package to be instrumented.\n * @param {string} waitActivity - The name of the main activity in this package.\n *\n * @return {promise} The promise is successfully resolved if the instrumentation starts\n *                   without errors.\n */\nmethods.androidCoverage = async function androidCoverage (instrumentClass, waitPkg, waitActivity) {\n  if (!this.isValidClass(instrumentClass)) {\n    throw new Error(`Invalid class ${instrumentClass}`);\n  }\n  return await new B(async (resolve, reject) => {\n    let args = this.executable.defaultArgs\n      .concat(['shell', 'am', 'instrument', '-e', 'coverage', 'true', '-w'])\n      .concat([instrumentClass]);\n    log.debug(`Collecting coverage data with: ${[this.executable.path].concat(args).join(' ')}`);\n    try {\n      // am instrument runs for the life of the app process.\n      this.instrumentProc = new SubProcess(this.executable.path, args);\n      await this.instrumentProc.start(0);\n      this.instrumentProc.on('output', (stdout, stderr) => {\n        if (stderr) {\n          reject(new Error(`Failed to run instrumentation. Original error: ${stderr}`));\n        }\n      });\n      await this.waitForActivity(waitPkg, waitActivity);\n      resolve();\n    } catch (e) {\n      reject(new Error(`Android coverage failed. Original error: ${e.message}`));\n    }\n  });\n};\n\n/**\n * Get the particular property of the device under test.\n *\n * @param {string} property - The name of the property. This name should\n *                            be known to _adb shell getprop_ tool.\n *\n * @return {string} The value of the given property.\n */\nmethods.getDeviceProperty = async function getDeviceProperty (property) {\n  let stdout = await this.shell(['getprop', property]);\n  let val = stdout.trim();\n  log.debug(`Current device property '${property}': ${val}`);\n  return val;\n};\n\n/**\n * @typedef {object} setPropOpts\n * @property {boolean} privileged - Do we run setProp as a privileged command? Default true.\n */\n\n/**\n * Set the particular property of the device under test.\n *\n * @param {string} property - The name of the property. This name should\n *                            be known to _adb shell setprop_ tool.\n * @param {string} val - The new property value.\n * @param {setPropOpts} opts\n *\n * @throws {error} If _setprop_ utility fails to change property value.\n */\nmethods.setDeviceProperty = async function setDeviceProperty (prop, val, opts = {}) {\n  const {privileged = true} = opts;\n  log.debug(`Setting device property '${prop}' to '${val}'`);\n  await this.shell(['setprop', prop, val], {\n    privileged,\n  });\n};\n\n/**\n * @return {string} Current system language on the device under test.\n */\nmethods.getDeviceSysLanguage = async function getDeviceSysLanguage () {\n  return await this.getDeviceProperty('persist.sys.language');\n};\n\n/**\n * @return {string} Current country name on the device under test.\n */\nmethods.getDeviceSysCountry = async function getDeviceSysCountry () {\n  return await this.getDeviceProperty('persist.sys.country');\n};\n\n/**\n * @return {string} Current system locale name on the device under test.\n */\nmethods.getDeviceSysLocale = async function getDeviceSysLocale () {\n  return await this.getDeviceProperty('persist.sys.locale');\n};\n\n/**\n * @return {string} Current product language name on the device under test.\n */\nmethods.getDeviceProductLanguage = async function getDeviceProductLanguage () {\n  return await this.getDeviceProperty('ro.product.locale.language');\n};\n\n/**\n * @return {string} Current product country name on the device under test.\n */\nmethods.getDeviceProductCountry = async function getDeviceProductCountry () {\n  return await this.getDeviceProperty('ro.product.locale.region');\n};\n\n/**\n * @return {string} Current product locale name on the device under test.\n */\nmethods.getDeviceProductLocale = async function getDeviceProductLocale () {\n  return await this.getDeviceProperty('ro.product.locale');\n};\n\n/**\n * @return {string} The model name of the device under test.\n */\nmethods.getModel = async function getModel () {\n  return await this.getDeviceProperty('ro.product.model');\n};\n\n/**\n * @return {string} The manufacturer name of the device under test.\n */\nmethods.getManufacturer = async function getManufacturer () {\n  return await this.getDeviceProperty('ro.product.manufacturer');\n};\n\n/**\n * Get the current screen size.\n *\n * @return {string} Device screen size as string in format 'WxH' or\n *                  _null_ if it cannot be determined.\n */\nmethods.getScreenSize = async function getScreenSize () {\n  let stdout = await this.shell(['wm', 'size']);\n  let size = new RegExp(/Physical size: ([^\\r?\\n]+)*/g).exec(stdout);\n  if (size && size.length >= 2) {\n    return size[1].trim();\n  }\n  return null;\n};\n\n/**\n * Get the current screen density in dpi\n *\n * @return {?number} Device screen density as a number or _null_ if it\n *                  cannot be determined\n */\nmethods.getScreenDensity = async function getScreenDensity () {\n  let stdout = await this.shell(['wm', 'density']);\n  let density = new RegExp(/Physical density: ([^\\r?\\n]+)*/g).exec(stdout);\n  if (density && density.length >= 2) {\n    let densityNumber = parseInt(density[1].trim(), 10);\n    return isNaN(densityNumber) ? null : densityNumber;\n  }\n  return null;\n};\n\n/**\n * Setup HTTP proxy in device global settings.\n * Read https://android.googlesource.com/platform/frameworks/base/+/android-9.0.0_r21/core/java/android/provider/Settings.java for each property\n *\n * @param {string} proxyHost - The host name of the proxy.\n * @param {string|number} proxyPort - The port number to be set.\n */\nmethods.setHttpProxy = async function setHttpProxy (proxyHost, proxyPort) {\n  let proxy = `${proxyHost}:${proxyPort}`;\n  if (_.isUndefined(proxyHost)) {\n    throw new Error(`Call to setHttpProxy method with undefined proxy_host: ${proxy}`);\n  }\n  if (_.isUndefined(proxyPort)) {\n    throw new Error(`Call to setHttpProxy method with undefined proxy_port ${proxy}`);\n  }\n\n  const httpProxySettins = [\n    ['http_proxy', proxy],\n    ['global_http_proxy_host', proxyHost],\n    ['global_http_proxy_port', proxyPort]\n  ];\n  for (const [settingKey, settingValue] of httpProxySettins) {\n    await this.setSetting('global', settingKey, settingValue);\n  }\n};\n\n/**\n * Delete HTTP proxy in device global settings.\n * Rebooting the test device is necessary to apply the change.\n */\nmethods.deleteHttpProxy = async function deleteHttpProxy () {\n  const httpProxySettins = [\n    'http_proxy',\n    'global_http_proxy_host',\n    'global_http_proxy_port',\n    'global_http_proxy_exclusion_list' // `global_http_proxy_exclusion_list=` was generated by `settings global htto_proxy xxxx`\n  ];\n  for (const setting of httpProxySettins) {\n    await this.shell(['settings', 'delete', 'global', setting]);\n  }\n};\n\n/**\n * Set device property.\n * [android.provider.Settings]{@link https://developer.android.com/reference/android/provider/Settings.html}\n *\n * @param {string} namespace - one of {system, secure, global}, case-insensitive.\n * @param {string} setting - property name.\n * @param {string|number} value - property value.\n * @return {string} command output.\n */\nmethods.setSetting = async function setSetting (namespace, setting, value) {\n  return await this.shell(['settings', 'put', namespace, setting, value]);\n};\n\n/**\n * Get device property.\n * [android.provider.Settings]{@link https://developer.android.com/reference/android/provider/Settings.html}\n *\n * @param {string} namespace - one of {system, secure, global}, case-insensitive.\n * @param {string} setting - property name.\n * @return {string} property value.\n */\nmethods.getSetting = async function getSetting (namespace, setting) {\n  return await this.shell(['settings', 'get', namespace, setting]);\n};\n\n/**\n * Retrieve the `adb bugreport` command output. This\n * operation may take up to several minutes.\n *\n * @param {?number} timeout [120000] - Command timeout in milliseconds\n * @returns {string} Command stdout\n */\nmethods.bugreport = async function bugreport (timeout = 120000) {\n  return await this.adbExec(['bugreport'], {timeout});\n};\n\n/**\n * @typedef {Object} ScreenrecordOptions\n * @property {?string} videoSize - The format is widthxheight.\n *                  The default value is the device's native display resolution (if supported),\n *                  1280x720 if not. For best results,\n *                  use a size supported by your device's Advanced Video Coding (AVC) encoder.\n *                  For example, \"1280x720\"\n * @property {?boolean} bugReport - Set it to `true` in order to display additional information on the video overlay,\n *                                  such as a timestamp, that is helpful in videos captured to illustrate bugs.\n *                                  This option is only supported since API level 27 (Android P).\n * @property {?string|number} timeLimit - The maximum recording time, in seconds.\n *                                        The default (and maximum) value is 180 (3 minutes).\n * @property {?string|number} bitRate - The video bit rate for the video, in megabits per second.\n *                The default value is 4. You can increase the bit rate to improve video quality,\n *                but doing so results in larger movie files.\n */\n\n/**\n * Initiate screenrecord utility on the device\n *\n * @param {string} destination - Full path to the writable media file destination\n *                               on the device file system.\n * @param {?ScreenrecordOptions} options [{}]\n * @returns {SubProcess} screenrecord process, which can be then controlled by the client code\n */\nmethods.screenrecord = function screenrecord (destination, options = {}) {\n  const cmd = ['screenrecord'];\n  const {\n    videoSize,\n    bitRate,\n    timeLimit,\n    bugReport,\n  } = options;\n  if (util.hasValue(videoSize)) {\n    cmd.push('--size', videoSize);\n  }\n  if (util.hasValue(timeLimit)) {\n    cmd.push('--time-limit', timeLimit);\n  }\n  if (util.hasValue(bitRate)) {\n    cmd.push('--bit-rate', bitRate);\n  }\n  if (bugReport) {\n    cmd.push('--bugreport');\n  }\n  cmd.push(destination);\n\n  const fullCmd = [\n    ...this.executable.defaultArgs,\n    'shell',\n    ...cmd\n  ];\n  log.debug(`Building screenrecord process with the command line: adb ${util.quote(fullCmd)}`);\n  return new SubProcess(this.executable.path, fullCmd);\n};\n\n/**\n * Executes the given function with the given input method context\n * and then restores the IME to the original value\n *\n * @param {string} ime - Valid IME identifier\n * @param {Function} fn - Function to execute\n * @returns {*} The result of the given function\n */\nmethods.runInImeContext = async function runInImeContext (ime, fn) {\n  const originalIme = await this.defaultIME();\n  if (originalIme === ime) {\n    log.debug(`The original IME is the same as '${ime}'. There is no need to reset it`);\n  } else {\n    await this.setIME(ime);\n  }\n  try {\n    return await fn();\n  } finally {\n    if (originalIme !== ime) {\n      await this.setIME(originalIme);\n    }\n  }\n};\n\n/**\n * Get tz database time zone formatted timezone\n *\n * @returns {string} TZ database Time Zones format\n *\n * @throws {error} If any exception is reported by adb shell.\n */\nmethods.getTimeZone = async function getTimeZone () {\n  log.debug('Getting current timezone');\n  try {\n    return await this.getDeviceProperty('persist.sys.timezone');\n  } catch (e) {\n    throw new Error(`Error getting timezone. Original error: ${e.message}`);\n  }\n};\n\n/**\n * Retrieves the list of features supported by the device under test\n *\n * @returns {Array<string>} the list of supported feature names or an empty list.\n * An example adb command output:\n * ```\n * cmd\n * ls_v2\n * fixed_push_mkdir\n * shell_v2\n * abb\n * stat_v2\n * apex\n * abb_exec\n * remount_shell\n * fixed_push_symlink_timestamp\n * ```\n * @throws {Error} if there was an error while retrieving the list\n */\nmethods.listFeatures = async function listFeatures () {\n  this._memoizedFeatures = this._memoizedFeatures\n    || _.memoize(async () => await this.adbExec(['features']), () => this.curDeviceId);\n  try {\n    return (await this._memoizedFeatures())\n      .split(/\\s+/)\n      .map((x) => x.trim())\n      .filter(Boolean);\n  } catch (e) {\n    if (_.includes(e.stderr, 'unknown command')) {\n      return [];\n    }\n    throw e;\n  }\n};\n\n/**\n * Checks the state of streamed install feature.\n * This feature allows to speed up apk installation\n * since it does not require the original apk to be pushed to\n * the device under test first, which also saves space.\n * Although, it is required that both the device under test\n * and the adb server have the mentioned functionality.\n * See https://github.com/aosp-mirror/platform_system_core/blob/master/adb/client/adb_install.cpp\n * for more details\n *\n * @returns {boolean} `true` if the feature is supported by both adb and the\n * device under test\n */\nmethods.isStreamedInstallSupported = async function isStreamedInstallSupported () {\n  const proto = Object.getPrototypeOf(this);\n  proto._helpOutput = proto._helpOutput || await this.adbExec(['help']);\n  return proto._helpOutput.includes('--streaming') && (await this.listFeatures()).includes('cmd');\n};\n\nexport default methods;\n"],"file":"lib/tools/adb-commands.js","sourceRoot":"../../.."}