appium-android-driver 7.8.3 → 8.0.1

package/lib/commands/performance.js

@@ -2,9 +2,8 @@
 import {retryInterval} from 'asyncbox';
 import _ from 'lodash';
 import {requireArgs} from '../utils';
-import {mixin} from './mixins';
 
-const NETWORK_KEYS = [
+export const NETWORK_KEYS = [
   [
     'bucketStart',
     'activeTime',
@@ -17,9 +16,9 @@ const NETWORK_KEYS = [
   ],
   ['st', 'activeTime', 'rb', 'rp', 'tb', 'tp', 'op', 'bucketDuration'],
 ];
-const CPU_KEYS = /** @type {const} */ (['user', 'kernel']);
-const BATTERY_KEYS = ['power'];
-const MEMORY_KEYS = [
+export const CPU_KEYS = /** @type {const} */ (['user', 'kernel']);
+export const BATTERY_KEYS = ['power'];
+export const MEMORY_KEYS = [
   'totalPrivateDirty',
   'nativePrivateDirty',
   'dalvikPrivateDirty',
@@ -36,7 +35,7 @@ const MEMORY_KEYS = [
   'dalvikRss',
   'totalRss',
 ];
-const SUPPORTED_PERFORMANCE_DATA_TYPES = Object.freeze({
+export const SUPPORTED_PERFORMANCE_DATA_TYPES = Object.freeze({
   cpuinfo:
     'the amount of cpu by user and kernel process - cpu information for applications on real devices and simulators',
   memoryinfo:
@@ -46,7 +45,7 @@ const SUPPORTED_PERFORMANCE_DATA_TYPES = Object.freeze({
   networkinfo:
     'the network statistics - network rx/tx information for applications on real devices and simulators',
 });
-const MEMINFO_TITLES = Object.freeze({
+export const MEMINFO_TITLES = Object.freeze({
   NATIVE: 'Native',
   DALVIK: 'Dalvik',
   EGL: 'EGL',
@@ -57,6 +56,81 @@ const MEMINFO_TITLES = Object.freeze({
 });
 const RETRY_PAUSE_MS = 1000;
 
+/**
+ * @this {AndroidDriver}
+ * @returns {Promise<import('./types').PerformanceDataType[]>}
+ */
+export async function getPerformanceDataTypes() {
+  return /** @type {import('./types').PerformanceDataType[]} */ (
+    _.keys(SUPPORTED_PERFORMANCE_DATA_TYPES)
+  );
+}
+
+/**
+ * @this {AndroidDriver}
+ * @param {string} packageName
+ * @param {string} dataType
+ * @param {number} [retries=2]
+ * @returns {Promise<any[][]>}
+ */
+export async function getPerformanceData(packageName, dataType, retries = 2) {
+  let result;
+  switch (_.toLower(dataType)) {
+    case 'batteryinfo':
+      result = await getBatteryInfo.call(this, retries);
+      break;
+    case 'cpuinfo':
+      result = await getCPUInfo.call(this, packageName, retries);
+      break;
+    case 'memoryinfo':
+      result = await getMemoryInfo.call(this, packageName, retries);
+      break;
+    case 'networkinfo':
+      result = await getNetworkTrafficInfo.call(this, retries);
+      break;
+    default:
+      throw new Error(
+        `No performance data of type '${dataType}' found. ` +
+          `Only the following values are supported: ${JSON.stringify(
+            SUPPORTED_PERFORMANCE_DATA_TYPES,
+            [' '],
+            2,
+          )}`,
+      );
+  }
+  return /** @type {any[][]} */ (result);
+}
+
+/**
+ * Retrieves performance data about the given Android subsystem.
+ * The data is parsed from the output of the dumpsys utility.
+ *
+ * The output depends on the selected subsystem.
+ * It is orginized into a table, where the first row represent column names
+ * and the following rows represent the sampled data for each column.
+ * Example output for different data types:
+ * - batteryinfo: [[power], [23]]
+ * - memory info: [[totalPrivateDirty, nativePrivateDirty, dalvikPrivateDirty, eglPrivateDirty, glPrivateDirty, totalPss,
+ *   nativePss, dalvikPss, eglPss, glPss, nativeHeapAllocatedSize, nativeHeapSize], [18360, 8296, 6132, null, null, 42588, 8406, 7024, null, null, 26519, 10344]]
+ * - networkinfo: [[bucketStart, activeTime, rxBytes, rxPackets, txBytes, txPackets, operations, bucketDuration,],
+ *   [1478091600000, null, 1099075, 610947, 928, 114362, 769, 0, 3600000], [1478095200000, null, 1306300, 405997, 509, 46359, 370, 0, 3600000]]
+ *
+ *   [[st, activeTime, rb, rp, tb, tp, op, bucketDuration], [1478088000, null, null, 32115296, 34291, 2956805, 25705, 0, 3600],
+ *   [1478091600, null, null, 2714683, 11821, 1420564, 12650, 0, 3600], [1478095200, null, null, 10079213, 19962, 2487705, 20015, 0, 3600],
+ *   [1478098800, null, null, 4444433, 10227, 1430356, 10493, 0, 3600]]
+ * - cpuinfo: [[user, kernel], [0.9, 1.3]]
+ *
+ * @this {AndroidDriver}
+ * @param {import('./types').PerformanceDataOpts} opts
+ * @returns {Promise<any[][]>}
+ */
+export async function mobileGetPerformanceData(opts) {
+  const {packageName, dataType} = requireArgs(['packageName', 'dataType'], opts);
+  return await this.getPerformanceData(packageName, dataType);
+}
+
+// #region Internal helpers
+
 /**
  * API level between 18 and 30
  * ['<System Type>', '<Memory Type>', <pss total>, <private dirty>, <private clean>, <swapPss dirty>, <heap size>, <heap alloc>, <heap free>]
@@ -151,7 +225,7 @@ function parseMeminfoForApiAbove29(entries, valDict) {
  * @param {string} packageName
  * @param {number} retries
  */
-async function getMemoryInfo(packageName, retries = 2) {
+export async function getMemoryInfo(packageName, retries = 2) {
   return await retryInterval(retries, RETRY_PAUSE_MS, async () => {
     const cmd = [
       'dumpsys',
@@ -193,7 +267,7 @@ async function getMemoryInfo(packageName, retries = 2) {
  * @this {AndroidDriver}
  * @param {number} retries
  */
-async function getNetworkTrafficInfo(retries = 2) {
+export async function getNetworkTrafficInfo(retries = 2) {
   return await retryInterval(retries, RETRY_PAUSE_MS, async () => {
     let returnValue = [];
     let bucketDuration, bucketStart, activeTime, rxBytes, rxPackets, txBytes, txPackets, operations;
@@ -376,7 +450,7 @@ async function getNetworkTrafficInfo(retries = 2) {
  *                  '14.3' is usage by the user (%), '28.2' is usage by the kernel (%)
  * @throws {Error} If it failed to parse the result of dumpsys, or no package name exists.
  */
-async function getCPUInfo(packageName, retries = 2) {
+export async function getCPUInfo(packageName, retries = 2) {
   // TODO: figure out why this is
   // sometimes, the function of 'adb.shell' fails. when I tested this function on the target of 'Galaxy Note5',
   // adb.shell(dumpsys cpuinfo) returns cpu datas for other application packages, but I can't find the data for packageName.
@@ -401,13 +475,13 @@ async function getCPUInfo(packageName, retries = 2) {
     //    +0% 2209/io.appium.android.apis: 0.1% user + 0.2% kernel / faults: 70 minor
     const usagesPattern = new RegExp(
       `^.+\\/${_.escapeRegExp(packageName)}:\\D+([\\d.]+)%\\s+user\\s+\\+\\s+([\\d.]+)%\\s+kernel`,
-      'm'
+      'm',
     );
     const match = usagesPattern.exec(output);
     if (!match) {
       this.log.debug(output);
       throw new Error(
-        `Unable to parse cpu usage data for '${packageName}'. Check the server log for more details`
+        `Unable to parse cpu usage data for '${packageName}'. Check the server log for more details`,
       );
     }
     const user = /** @type {string} */ (match[1]);
@@ -420,7 +494,7 @@ async function getCPUInfo(packageName, retries = 2) {
  * @this {AndroidDriver}
  * @param {number} retries
  */
-async function getBatteryInfo(retries = 2) {
+export async function getBatteryInfo(retries = 2) {
   return await retryInterval(retries, RETRY_PAUSE_MS, async () => {
     let cmd = ['dumpsys', 'battery', '|', 'grep', 'level'];
     let data = await this.adb.shell(cmd);
@@ -436,66 +510,7 @@ async function getBatteryInfo(retries = 2) {
   });
 }
 
-/**
- * @type {import('./mixins').PerformanceMixin & ThisType<import('../driver').AndroidDriver>}
- * @satisfies {import('@appium/types').ExternalDriver}
- */
-const PerformanceMixin = {
-  async getPerformanceDataTypes() {
-    return /** @type {import('./types').PerformanceDataType[]} */ (
-      _.keys(SUPPORTED_PERFORMANCE_DATA_TYPES)
-    );
-  },
-
-  async getPerformanceData(packageName, dataType, retries = 2) {
-    let result;
-    switch (_.toLower(dataType)) {
-      case 'batteryinfo':
-        result = await getBatteryInfo.call(this, retries);
-        break;
-      case 'cpuinfo':
-        result = await getCPUInfo.call(this, packageName, retries);
-        break;
-      case 'memoryinfo':
-        result = await getMemoryInfo.call(this, packageName, retries);
-        break;
-      case 'networkinfo':
-        result = await getNetworkTrafficInfo.call(this, retries);
-        break;
-      default:
-        throw new Error(
-          `No performance data of type '${dataType}' found. ` +
-            `Only the following values are supported: ${JSON.stringify(
-              SUPPORTED_PERFORMANCE_DATA_TYPES,
-              [' '],
-              2
-            )}`
-        );
-    }
-    return /** @type {any[][]} */ (result);
-  },
-
-  async mobileGetPerformanceData(opts) {
-    const {packageName, dataType} = requireArgs(['packageName', 'dataType'], opts);
-    return await this.getPerformanceData(packageName, dataType);
-  },
-};
-
-mixin(PerformanceMixin);
-
-export {
-  BATTERY_KEYS,
-  CPU_KEYS,
-  MEMORY_KEYS,
-  NETWORK_KEYS,
-  SUPPORTED_PERFORMANCE_DATA_TYPES,
-  getBatteryInfo,
-  getCPUInfo,
-  getMemoryInfo,
-  getNetworkTrafficInfo,
-};
-
-export default PerformanceMixin;
+// #endregion
 
 /**
  * @typedef {import('../driver').AndroidDriver} AndroidDriver

package/lib/commands/permissions.js

@@ -1,10 +1,7 @@
-// @ts-check
-
 import {errors} from 'appium/driver';
 import B from 'bluebird';
 import _ from 'lodash';
 import {ADB_SHELL_FEATURE} from '../utils';
-import {mixin} from './mixins';
 
 const ALL_PERMISSIONS_MAGIC = 'all';
 const PM_ACTION = Object.freeze({
@@ -27,23 +24,92 @@ const PERMISSIONS_TYPE = Object.freeze({
   REQUESTED: 'requested',
 });
 
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @param {import('./types').ChangePermissionsOpts} opts
+ * @returns {Promise<void>}
+ */
+export async function mobileChangePermissions(opts) {
+  const {
+    permissions,
+    appPackage = this.opts.appPackage,
+    action = _.toLower(opts.target) === PERMISSION_TARGET.APPOPS
+      ? APPOPS_ACTION.ALLOW
+      : PM_ACTION.GRANT,
+    target = PERMISSION_TARGET.PM,
+  } = opts;
+  if (_.isNil(permissions)) {
+    throw new errors.InvalidArgumentError(`'permissions' argument is required`);
+  }
+  if (_.isEmpty(permissions)) {
+    throw new errors.InvalidArgumentError(`'permissions' argument must not be empty`);
+  }
+
+  switch (_.toLower(target)) {
+    case PERMISSION_TARGET.PM:
+      return await changePermissionsViaPm.bind(this)(permissions, appPackage, _.toLower(action));
+    case PERMISSION_TARGET.APPOPS:
+      this.ensureFeatureEnabled(ADB_SHELL_FEATURE);
+      return await changePermissionsViaAppops.bind(this)(
+        permissions,
+        appPackage,
+        _.toLower(action),
+      );
+    default:
+      throw new errors.InvalidArgumentError(
+        `'target' argument must be one of: ${_.values(PERMISSION_TARGET)}`,
+      );
+  }
+}
+
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @param {import('./types').GetPermissionsOpts} [opts={}]
+ * @returns {Promise<string[]>}
+ */
+export async function mobileGetPermissions(opts = {}) {
+  const {type = PERMISSIONS_TYPE.REQUESTED, appPackage = this.opts.appPackage} = opts;
+  /**
+   * @type {(pkg: string) => Promise<string[]>}
+   */
+  let actionFunc;
+  switch (_.toLower(type)) {
+    case PERMISSIONS_TYPE.REQUESTED:
+      actionFunc = (pkg) => this.adb.getReqPermissions(pkg);
+      break;
+    case PERMISSIONS_TYPE.GRANTED:
+      actionFunc = (pkg) => this.adb.getGrantedPermissions(pkg);
+      break;
+    case PERMISSIONS_TYPE.DENIED:
+      actionFunc = (pkg) => this.adb.getDeniedPermissions(pkg);
+      break;
+    default:
+      throw new errors.InvalidArgumentError(
+        `Unknown permissions type '${type}'. ` +
+          `Only ${JSON.stringify(_.values(PERMISSIONS_TYPE))} types are supported`,
+      );
+  }
+  return await actionFunc(/** @type {string} */ (appPackage));
+}
+
+// #region Internal helpers
+
 /**
  * @this {AndroidDriver}
- * @param {*} permissions
- * @param {*} appPackage
- * @param {*} action
- * @todo FIXME: type this
+ * @param {string|string[]} permissions
+ * @param {string} appPackage
+ * @param {import('type-fest').ValueOf<PM_ACTION>} action
  */
 async function changePermissionsViaPm(permissions, appPackage, action) {
   if (!_.values(PM_ACTION).includes(action)) {
     throw new errors.InvalidArgumentError(
       `Unknown action '${action}'. ` +
-        `Only ${JSON.stringify(_.values(PM_ACTION))} actions are supported`
+        `Only ${JSON.stringify(_.values(PM_ACTION))} actions are supported`,
     );
   }
 
   let affectedPermissions = _.isArray(permissions) ? permissions : [permissions];
-  if (_.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
+  if (_.isString(permissions) && _.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
     const dumpsys = await this.adb.shell(['dumpsys', 'package', appPackage]);
     const grantedPermissions = await this.adb.getGrantedPermissions(appPackage, dumpsys);
     if (action === PM_ACTION.GRANT) {
@@ -66,99 +132,32 @@ async function changePermissionsViaPm(permissions, appPackage, action) {
 }
 /**
  * @this {AndroidDriver}
- * @param {*} permissions
- * @param {*} appPackage
- * @param {*} action
- * @todo FIXME: type this
+ * @param {string|string[]} permissions
+ * @param {string} appPackage
+ * @param {import('type-fest').ValueOf<APPOPS_ACTION>} action
  */
 async function changePermissionsViaAppops(permissions, appPackage, action) {
   if (!_.values(APPOPS_ACTION).includes(action)) {
     throw new errors.InvalidArgumentError(
       `Unknown action '${action}'. ` +
-        `Only ${JSON.stringify(_.values(APPOPS_ACTION))} actions are supported`
+        `Only ${JSON.stringify(_.values(APPOPS_ACTION))} actions are supported`,
     );
   }
-  if (_.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
+  if (_.isString(permissions) && _.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
     throw new errors.InvalidArgumentError(
       `'${ALL_PERMISSIONS_MAGIC}' permission is only supported for ` +
         `'${PERMISSION_TARGET.PM}' target. ` +
-        `Check AppOpsManager.java from Android platform sources to get the full list of supported AppOps permissions`
+        `Check AppOpsManager.java from Android platform sources to get the full list of supported AppOps permissions`,
     );
   }
 
   const promises = (_.isArray(permissions) ? permissions : [permissions]).map((permission) =>
-    this.adb.shell(['appops', 'set', appPackage, permission, action])
+    this.adb.shell(['appops', 'set', appPackage, permission, action]),
   );
   await B.all(promises);
 }
 
-/**
- * @type {import('./mixins').PermissionsMixin & ThisType<import('../driver').AndroidDriver>}
- * @satisfies {import('@appium/types').ExternalDriver}
- */
-const PermissionsMixin = {
-  async mobileChangePermissions(opts) {
-    const {
-      permissions,
-      appPackage = this.opts.appPackage,
-      action = _.toLower(opts.target) === PERMISSION_TARGET.APPOPS
-        ? APPOPS_ACTION.ALLOW
-        : PM_ACTION.GRANT,
-      target = PERMISSION_TARGET.PM,
-    } = opts;
-    if (_.isNil(permissions)) {
-      throw new errors.InvalidArgumentError(`'permissions' argument is required`);
-    }
-    if (_.isEmpty(permissions)) {
-      throw new errors.InvalidArgumentError(`'permissions' argument must not be empty`);
-    }
-
-    switch (_.toLower(target)) {
-      case PERMISSION_TARGET.PM:
-        return await changePermissionsViaPm.bind(this)(permissions, appPackage, _.toLower(action));
-      case PERMISSION_TARGET.APPOPS:
-        this.ensureFeatureEnabled(ADB_SHELL_FEATURE);
-        return await changePermissionsViaAppops.bind(this)(
-          permissions,
-          appPackage,
-          _.toLower(action)
-        );
-      default:
-        throw new errors.InvalidArgumentError(
-          `'target' argument must be one of: ${_.values(PERMISSION_TARGET)}`
-        );
-    }
-  },
-
-  async mobileGetPermissions(opts = {}) {
-    const {type = PERMISSIONS_TYPE.REQUESTED, appPackage = this.opts.appPackage} = opts;
-    /**
-     * @type {(pkg: string) => Promise<string[]>}
-     */
-    let actionFunc;
-    switch (_.toLower(type)) {
-      case PERMISSIONS_TYPE.REQUESTED:
-        actionFunc = (pkg) => this.adb.getReqPermissions(pkg);
-        break;
-      case PERMISSIONS_TYPE.GRANTED:
-        actionFunc = (pkg) => this.adb.getGrantedPermissions(pkg);
-        break;
-      case PERMISSIONS_TYPE.DENIED:
-        actionFunc = (pkg) => this.adb.getDeniedPermissions(pkg);
-        break;
-      default:
-        throw new errors.InvalidArgumentError(
-          `Unknown permissions type '${type}'. ` +
-            `Only ${JSON.stringify(_.values(PERMISSIONS_TYPE))} types are supported`
-        );
-    }
-    return await actionFunc(/** @type {string} */ (appPackage));
-  },
-};
-
-mixin(PermissionsMixin);
-
-export default PermissionsMixin;
+// #endregion
 
 /**
  * @typedef {import('appium-adb').ADB} ADB