appium-android-driver 4.49.0 → 4.52.1

package/lib/unlock-helpers.js

@@ -8,85 +8,80 @@ const PIN_UNLOCK_KEY_EVENT = 'pinWithKeyEvent';
 const PASSWORD_UNLOCK = 'password';
 const PATTERN_UNLOCK = 'pattern';
 const FINGERPRINT_UNLOCK = 'fingerprint';
-const UNLOCK_TYPES = [PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, PASSWORD_UNLOCK, PATTERN_UNLOCK, FINGERPRINT_UNLOCK];
+const UNLOCK_TYPES = [
+  PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, PASSWORD_UNLOCK,
+  PATTERN_UNLOCK, FINGERPRINT_UNLOCK
+];
 const KEYCODE_NUMPAD_ENTER = 66;
-const KEYCODE_POWER = 26;
-const KEYCODE_WAKEUP = 224; // Can work over API Level 20
 const UNLOCK_WAIT_TIME = 100;
-const HIDE_KEYBOARD_WAIT_TIME = 100;
 const INPUT_KEYS_WAIT_TIME = 100;
 const NUMBER_ZERO_KEYCODE = 7;
 
-let helpers = {};
-helpers.isValidUnlockType = function isValidUnlockType (type) {
-  return UNLOCK_TYPES.includes(type);
-};
+const helpers = {};
 
-helpers.isValidKey = function isValidKey (type, key) {
-  if (_.isUndefined(key)) {
-    return false;
-  }
-  if ([PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, FINGERPRINT_UNLOCK].includes(type)) {
-    return /^[0-9]+$/.test(key.trim());
+helpers.validateUnlockCapabilities = function validateUnlockCapabilities (caps = {}) {
+  const {
+    unlockKey,
+    unlockType,
+  } = caps;
+  if (_.isNil(unlockKey) || unlockKey === '') {
+    throw new Error('A non-empty unlock key value must be provided');
   }
-  if (type === PATTERN_UNLOCK) {
-    if (!/^[1-9]{2,9}$/.test(key.trim())) {
-      return false;
+
+  if ([PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, FINGERPRINT_UNLOCK].includes(unlockType)) {
+    if (!/^[0-9]+$/.test(_.trim(unlockKey))) {
+      throw new Error(`Unlock key value '${unlockKey}' must only consist of digits`);
     }
-    return !(/([1-9]).*?\1/.test(key.trim()));
-  }
-  // Dont trim password key, you can use blank spaces in your android password
-  // ¯\_(ツ)_/¯
-  if (type === PASSWORD_UNLOCK) {
-    return /.{4,}/g.test(key);
+  } else if (unlockType === PATTERN_UNLOCK) {
+    if (!/^[1-9]{2,9}$/.test(_.trim(unlockKey))) {
+      throw new Error(`Unlock key value '${unlockKey}' must only include from two to nine digits in range 1..9`);
+    }
+    if (/([1-9]).*?\1/.test(_.trim(unlockKey))) {
+      throw new Error(`Unlock key value '${unlockKey}' must define a valid pattern where repeats are not allowed`);
+    }
+  } else if (unlockType === PASSWORD_UNLOCK) {
+    // Dont trim password key, you can use blank spaces in your android password
+    // ¯\_(ツ)_/¯
+    if (!/.{4,}/g.test(unlockKey)) {
+      throw new Error(`The minimum allowed length of unlock key value '${unlockKey}' is 4 characters`);
+    }
+  } else {
+    throw new Error(`Invalid unlock type '${unlockType}'. ` +
+      `Only the following unlock types are supported: ${UNLOCK_TYPES}`);
   }
-  throw new Error(`Invalid unlock type ${type}`);
+  return caps;
 };
 
-helpers.dismissKeyguard = async function dismissKeyguard (driver, adb) {
-  logger.info('Waking up the device to unlock it');
-  // Screen off once to force pre-inputted text field clean after wake-up
-  // Just screen on if the screen defaults off
-  await driver.pressKeyCode(KEYCODE_POWER);
-  await driver.pressKeyCode(KEYCODE_WAKEUP);
-  let isKeyboardShown = await driver.isKeyboardShown();
-  if (isKeyboardShown) {
-    await driver.hideKeyboard();
-    // Waits a bit for the keyboard to hide
-    await sleep(HIDE_KEYBOARD_WAIT_TIME);
+helpers.fastUnlock = async function fastUnlock (adb, opts = {}) {
+  const {
+    credential,
+    credentialType,
+  } = opts;
+  logger.info(`Unlocking the device via ADB using ${credentialType} credential '${credential}'`);
+  const wasLockEnabled = await adb.isLockEnabled();
+  if (wasLockEnabled) {
+    await adb.clearLockCredential(credential);
+    // not sure why, but the device's screen still remains locked
+    // if a preliminary wake up cycle has not been performed
+    await adb.cycleWakeUp();
+  } else {
+    logger.info('No active lock has been detected. Proceeding to the keyguard dismissal');
   }
-  // dismiss notifications
-  logger.info('Dismiss notifications from unlock view');
-  await adb.shell(['service', 'call', 'notification', '1']);
-  await adb.back();
-  if (await adb.getApiLevel() > 21) {
-    logger.info('Trying to dismiss keyguard');
-    await adb.shell(['wm', 'dismiss-keyguard']);
-    return;
+  try {
+    await adb.dismissKeyguard();
+  } finally {
+    if (wasLockEnabled) {
+      await adb.setLockCredential(credentialType, credential);
+    }
   }
-  logger.info('Swiping up to dismiss keyguard');
-  await helpers.swipeUp(driver);
-};
-
-helpers.swipeUp = async function swipeUp (driver) {
-  let windowSize = await driver.getWindowSize();
-  let x0 = parseInt(windowSize.x / 2, 10);
-  let y0 = windowSize.y - 10;
-  let yP = 100;
-  let actions = [
-    {action: 'press', options: {element: null, x: x0, y: y0}},
-    {action: 'moveTo', options: {element: null, x: x0, y: yP}},
-    {action: 'release'}
-  ];
-  await driver.performTouch(actions);
 };
 
 helpers.encodePassword = function encodePassword (key) {
-  return key.replace(/\s/ig, '%s');
+  return `${key}`.replace(/\s/ig, '%s');
 };
 
 helpers.stringKeyToArr = function stringKeyToArr (key) {
-  return key.trim().replace(/\s+/g, '').split(/\s*/);
+  return `${key}`.trim().replace(/\s+/g, '').split(/\s*/);
 };
 
 helpers.fingerprintUnlock = async function fingerprintUnlock (adb, driver, capabilities) {
@@ -99,26 +94,26 @@ helpers.fingerprintUnlock = async function fingerprintUnlock (adb, driver, capab
 
 helpers.pinUnlock = async function pinUnlock (adb, driver, capabilities) {
   logger.info(`Trying to unlock device using pin ${capabilities.unlockKey}`);
-  await helpers.dismissKeyguard(driver, adb);
-  let keys = helpers.stringKeyToArr(capabilities.unlockKey);
+  await adb.dismissKeyguard();
+  const keys = helpers.stringKeyToArr(capabilities.unlockKey);
   if (await adb.getApiLevel() >= 21) {
-    let els = await driver.findElOrEls('id', 'com.android.systemui:id/digit_text', true);
+    const els = await driver.findElOrEls('id', 'com.android.systemui:id/digit_text', true);
     if (_.isEmpty(els)) {
       // fallback to pin with key event
       return await helpers.pinUnlockWithKeyEvent(adb, driver, capabilities);
     }
-    let pins = {};
-    for (let el of els) {
-      let text = await driver.getAttribute('text', util.unwrapElement(el));
+    const pins = {};
+    for (const el of els) {
+      const text = await driver.getAttribute('text', util.unwrapElement(el));
       pins[text] = el;
     }
-    for (let pin of keys) {
-      let el = pins[pin];
+    for (const pin of keys) {
+      const el = pins[pin];
       await driver.click(util.unwrapElement(el));
     }
   } else {
-    for (let pin of keys) {
-      let el = await driver.findElOrEls('id', `com.android.keyguard:id/key${pin}`, false);
+    for (const pin of keys) {
+      const el = await driver.findElOrEls('id', `com.android.keyguard:id/key${pin}`, false);
       if (el === null) {
         // fallback to pin with key event
         return await helpers.pinUnlockWithKeyEvent(adb, driver, capabilities);
@@ -126,10 +121,9 @@ helpers.pinUnlock = async function pinUnlock (adb, driver, capabilities) {
       await driver.click(util.unwrapElement(el));
     }
   }
-  await waitForUnlock(adb, driver);
+  await waitForUnlock(adb);
 };
 
-
 /**
  * Wait for the display to be unlocked.
  * Some devices automatically accept typed 'pin' and 'password' code
@@ -139,21 +133,20 @@ helpers.pinUnlock = async function pinUnlock (adb, driver, capabilities) {
  * the enter key code.
  *
  * @param {ADB} adb The instance of ADB
- * @param {AndroidDriver} driver The instance of AndroidDriver
  */
-async function waitForUnlock (adb, driver) {
+async function waitForUnlock (adb) {
   await sleep(UNLOCK_WAIT_TIME);
   if (!await adb.isScreenLocked()) {
     return;
   }
 
-  await driver.pressKeyCode(KEYCODE_NUMPAD_ENTER);
+  await adb.keyevent(KEYCODE_NUMPAD_ENTER);
   await sleep(UNLOCK_WAIT_TIME);
 }
 
 helpers.pinUnlockWithKeyEvent = async function pinUnlockWithKeyEvent (adb, driver, capabilities) {
   logger.info(`Trying to unlock device using pin with keycode ${capabilities.unlockKey}`);
-  await helpers.dismissKeyguard(driver, adb);
+  await adb.dismissKeyguard();
   const keys = helpers.stringKeyToArr(capabilities.unlockKey);
 
   // Some device does not have system key ids like 'com.android.keyguard:id/key'
@@ -167,11 +160,11 @@ helpers.pinUnlockWithKeyEvent = async function pinUnlockWithKeyEvent (adb, drive
 };
 
 helpers.passwordUnlock = async function passwordUnlock (adb, driver, capabilities) {
-  logger.info(`Trying to unlock device using password ${capabilities.unlockKey}`);
-  await helpers.dismissKeyguard(driver, adb);
-  let key = capabilities.unlockKey;
+  const { unlockKey } = capabilities;
+  logger.info(`Trying to unlock device using password ${unlockKey}`);
+  await adb.dismissKeyguard();
   // Replace blank spaces with %s
-  key = helpers.encodePassword(key);
+  const key = helpers.encodePassword(unlockKey);
   // Why adb ? It was less flaky
   await adb.shell(['input', 'text', key]);
   // Why sleeps ? Avoid some flakyness waiting for the input to receive the keys
@@ -192,21 +185,24 @@ helpers.getPatternKeyPosition = function getPatternKeyPosition (key, initPos, pi
   const pins = 9;
   const xPos = (key, x, piece) => Math.round(x + ((key % cols) || cols) * piece - piece / 2);
   const yPos = (key, y, piece) => Math.round(y + (Math.ceil(((key % pins) || pins) / cols) * piece - piece / 2));
-  return {x: xPos(key, initPos.x, piece), y: yPos(key, initPos.y, piece)};
+  return {
+    x: xPos(key, initPos.x, piece),
+    y: yPos(key, initPos.y, piece)
+  };
 };
 
 helpers.getPatternActions = function getPatternActions (keys, initPos, piece) {
-  let actions = [];
+  const actions = [];
   let lastPos;
   for (let key of keys) {
-    let keyPos = helpers.getPatternKeyPosition(key, initPos, piece);
+    const keyPos = helpers.getPatternKeyPosition(key, initPos, piece);
     if (key === keys[0]) {
       actions.push({action: 'press', options: {element: null, x: keyPos.x, y: keyPos.y}});
       lastPos = keyPos;
       continue;
     }
-    let moveTo = {x: 0, y: 0};
-    let diffX = keyPos.x - lastPos.x;
+    const moveTo = {x: 0, y: 0};
+    const diffX = keyPos.x - lastPos.x;
     if (diffX > 0) {
       moveTo.x = piece;
       if (Math.abs(diffX) > piece) {
@@ -218,7 +214,7 @@ helpers.getPatternActions = function getPatternActions (keys, initPos, piece) {
         moveTo.x -= piece;
       }
     }
-    let diffY = keyPos.y - lastPos.y;
+    const diffY = keyPos.y - lastPos.y;
     if (diffY > 0) {
       moveTo.y = piece;
       if (Math.abs(diffY) > piece) {
@@ -230,7 +226,10 @@ helpers.getPatternActions = function getPatternActions (keys, initPos, piece) {
         moveTo.y -= piece;
       }
     }
-    actions.push({action: 'moveTo', options: {element: null, x: moveTo.x + lastPos.x, y: moveTo.y + lastPos.y}});
+    actions.push({
+      action: 'moveTo',
+      options: {element: null, x: moveTo.x + lastPos.x, y: moveTo.y + lastPos.y}
+    });
     lastPos = keyPos;
   }
   actions.push({action: 'release'});
@@ -238,9 +237,10 @@ helpers.getPatternActions = function getPatternActions (keys, initPos, piece) {
 };
 
 helpers.patternUnlock = async function patternUnlock (adb, driver, capabilities) {
-  logger.info(`Trying to unlock device using pattern ${capabilities.unlockKey}`);
-  await helpers.dismissKeyguard(driver, adb);
-  let keys = helpers.stringKeyToArr(capabilities.unlockKey);
+  const { unlockKey } = capabilities;
+  logger.info(`Trying to unlock device using pattern ${unlockKey}`);
+  await adb.dismissKeyguard();
+  const keys = helpers.stringKeyToArr(unlockKey);
   /* We set the device pattern buttons as number of a regular phone
    *  | • • • |     | 1 2 3 |
    *  | • • • | --> | 4 5 6 |
@@ -250,15 +250,15 @@ helpers.patternUnlock = async function patternUnlock (adb, driver, capabilities)
   included inside a FrameLayout, so we are going to try clicking on the buttons
   using the parent view bounds and math.
   */
-  let apiLevel = await adb.getApiLevel();
-  let el = await driver.findElOrEls('id',
+  const apiLevel = await adb.getApiLevel();
+  const el = await driver.findElOrEls('id',
     `com.android.${apiLevel >= 21 ? 'systemui' : 'keyguard'}:id/lockPatternView`,
     false
   );
-  let initPos = await driver.getLocation(util.unwrapElement(el));
-  let size = await driver.getSize(util.unwrapElement(el));
+  const initPos = await driver.getLocation(util.unwrapElement(el));
+  const size = await driver.getSize(util.unwrapElement(el));
   // Get actions to perform
-  let actions = helpers.getPatternActions(keys, initPos, size.width / 3);
+  const actions = helpers.getPatternActions(keys, initPos, size.width / 3);
   // Perform gesture
   await driver.performTouch(actions);
   // Waits a bit for the device to be unlocked
@@ -271,5 +271,8 @@ helpers.PASSWORD_UNLOCK = PASSWORD_UNLOCK;
 helpers.PATTERN_UNLOCK = PATTERN_UNLOCK;
 helpers.FINGERPRINT_UNLOCK = FINGERPRINT_UNLOCK;
 
-export { PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, PASSWORD_UNLOCK, PATTERN_UNLOCK, FINGERPRINT_UNLOCK, helpers };
+export {
+  PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, PASSWORD_UNLOCK, PATTERN_UNLOCK,
+  FINGERPRINT_UNLOCK, helpers
+};
 export default helpers;

package/lib/webview-helpers.js

@@ -517,17 +517,20 @@ helpers.createChromedriverCaps = function createChromedriverCaps (opts, deviceId
   // add device id from adb
   caps.chromeOptions.androidDeviceSerial = deviceId;
 
-  if (opts.loggingPrefs) {
-    caps.loggingPrefs = opts.loggingPrefs;
+  if (_.isPlainObject(opts.loggingPrefs) || _.isPlainObject(opts.chromeLoggingPrefs)) {
+    if (opts.loggingPrefs) {
+      logger.warn(`The 'loggingPrefs' cap is deprecated; use the 'chromeLoggingPrefs' cap instead`);
+    }
+    caps.loggingPrefs = opts.chromeLoggingPrefs || opts.loggingPrefs;
   }
   if (opts.enablePerformanceLogging) {
     logger.warn(`The 'enablePerformanceLogging' cap is deprecated; simply use ` +
-      `the 'loggingPrefs' cap instead, with a 'performance' key set to 'ALL'`);
+      `the 'chromeLoggingPrefs' cap instead, with a 'performance' key set to 'ALL'`);
     const newPref = {performance: 'ALL'};
     // don't overwrite other logging prefs that have been sent in if they exist
-    caps.loggingPrefs = caps.loggingPrefs ?
-      Object.assign({}, caps.loggingPrefs, newPref) :
-      newPref;
+    caps.loggingPrefs = caps.loggingPrefs
+      ? Object.assign({}, caps.loggingPrefs, newPref)
+      : newPref;
   }
 
   if (opts.chromeOptions?.Arguments) {

package/package.json

@@ -9,7 +9,7 @@
     "mobile",
     "mobile testing"
   ],
-  "version": "4.49.0",
+  "version": "4.52.1",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {
@@ -36,7 +36,7 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "appium-adb": "^8.11.0",
+    "appium-adb": "^8.16.0",
     "appium-base-driver": "^7.0.0",
     "appium-chromedriver": "^4.13.0",
     "appium-support": "^2.47.1",
@@ -77,6 +77,7 @@
     "precommit-test"
   ],
   "devDependencies": {
+    "@xmldom/xmldom": "^0.x",
     "android-apidemos": "^3.0.0",
     "appium-gulp-plugins": "^5.4.0",
     "appium-test-support": "^1.0.0",
@@ -87,8 +88,7 @@
     "mocha": "^9.0.0",
     "mock-fs": "^5.0.0",
     "pre-commit": "^1.1.3",
-    "sinon": "^11.0.0",
-    "xmldom": "^0.x",
+    "sinon": "^12.0.0",
     "xpath": "^0.x"
   }
 }