appium-android-driver 4.46.0 → 4.47.0

package/build/lib/commands/execute.js

@@ -54,6 +54,7 @@ extensions.executeMobile = async function executeMobile(mobileCommand, opts = {}
     deleteFile: 'mobileDeleteFile',
     startService: 'mobileStartService',
     stopService: 'mobileStopService',
+    startActivity: 'mobileStartActivity',
     getContexts: 'mobileGetContexts'
   };
 
@@ -68,4 +69,4 @@ var _default = extensions;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/commands/index.js

@@ -45,15 +45,15 @@ var _fileActions = _interopRequireDefault(require("./file-actions"));
 
 var _appManagement = _interopRequireDefault(require("./app-management"));
 
-var _services = _interopRequireDefault(require("./services"));
+var _intent = _interopRequireDefault(require("./intent"));
 
 var _log = _interopRequireDefault(require("./log"));
 
 let commands = {};
 exports.commands = commands;
-Object.assign(commands, _find.default, _general.default, _alert.default, _element.default, _context.default, _actions.default, _touch.default, _ime.default, _network.default, _coverage.default, _recordscreen.default, _services.default, _streamscreen.default, _performance.default, _execute.default, _shell.default, _emuConsole.default, _appManagement.default, _fileActions.default, _log.default);
+Object.assign(commands, _find.default, _general.default, _alert.default, _element.default, _context.default, _actions.default, _touch.default, _ime.default, _network.default, _coverage.default, _recordscreen.default, _intent.default, _streamscreen.default, _performance.default, _execute.default, _shell.default, _emuConsole.default, _appManagement.default, _fileActions.default, _log.default);
 var _default = commands;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/commands/intent.js

@@ -0,0 +1,193 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.commands = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _appiumBaseDriver = require("appium-base-driver");
+
+const NO_VALUE_ARG_TYPE = 'sn';
+const SUPPORTED_EXTRA_TYPES = ['s', NO_VALUE_ARG_TYPE, 'z', 'i', 'l', 'f', 'u', 'cn', 'ia', 'ial', 'la', 'lal', 'fa', 'fal', 'sa', 'sal'];
+const API_LEVEL_ANDROID_8 = 26;
+const commands = {};
+exports.commands = commands;
+
+function requireOptions(opts, requiredKeys = []) {
+  const missingKeys = _lodash.default.difference(requiredKeys, _lodash.default.keys(opts));
+
+  if (!_lodash.default.isEmpty(missingKeys)) {
+    throw new _appiumBaseDriver.errors.InvalidArgumentError(`The following options are required: ${missingKeys}`);
+  }
+
+  return opts;
+}
+
+function parseCommonIntentArguments(opts = {}) {
+  const {
+    action,
+    uri,
+    mimeType,
+    identifier,
+    categories,
+    component,
+    extras,
+    flags
+  } = opts;
+  const resultArgs = [];
+
+  if (action) {
+    resultArgs.push('-a', action);
+  }
+
+  if (uri) {
+    resultArgs.push('-d', uri);
+  }
+
+  if (mimeType) {
+    resultArgs.push('-t', mimeType);
+  }
+
+  if (!_lodash.default.isNil(identifier)) {
+    resultArgs.push('-i', identifier);
+  }
+
+  if (categories) {
+    if (_lodash.default.isArray(categories)) {
+      resultArgs.push(..._lodash.default.flatMap(categories.map(cName => ['-c', cName])));
+    } else {
+      resultArgs.push('-c', categories);
+    }
+  }
+
+  if (component) {
+    resultArgs.push('-n', component);
+  }
+
+  if (extras) {
+    if (!_lodash.default.isArray(extras)) {
+      throw new _appiumBaseDriver.errors.InvalidArgumentError(`'extras' must be an array`);
+    }
+
+    for (const item of extras) {
+      let type;
+      let value;
+
+      if (_lodash.default.isArray(item)) {
+        [type, value] = item;
+      } else {
+        type = item;
+      }
+
+      if (!_lodash.default.includes(SUPPORTED_EXTRA_TYPES, type)) {
+        throw new _appiumBaseDriver.errors.InvalidArgumentError(`Intent argument type '${type}' is not known. ` + `Supported intent argument types are: ${SUPPORTED_EXTRA_TYPES}`);
+      }
+
+      if (type === NO_VALUE_ARG_TYPE) {
+        resultArgs.push(`--e${type}`);
+      } else if (_lodash.default.isUndefined(value)) {
+        throw new _appiumBaseDriver.errors.InvalidArgumentError(`Intent argument type '${type}' requires a ` + `value to be provided`);
+      } else {
+        resultArgs.push(`--e${type}`, value);
+      }
+    }
+  }
+
+  if (flags) {
+    resultArgs.push('-f', flags);
+  }
+
+  return resultArgs;
+}
+
+commands.mobileStartActivity = async function mobileStartActivity(opts = {}) {
+  const {
+    intent,
+    user,
+    wait,
+    stop,
+    windowingMode,
+    activityType,
+    display
+  } = requireOptions(opts, ['intent']);
+  const cmd = ['am', (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8 ? 'start' : 'start-activity'];
+
+  if (!_lodash.default.isNil(user)) {
+    cmd.push('--user', user);
+  }
+
+  if (wait) {
+    cmd.push('-W');
+  }
+
+  if (stop) {
+    cmd.push('-S');
+  }
+
+  if (!_lodash.default.isNil(windowingMode)) {
+    cmd.push('--windowingMode', windowingMode);
+  }
+
+  if (!_lodash.default.isNil(activityType)) {
+    cmd.push('--activityType', activityType);
+  }
+
+  if (!_lodash.default.isNil(display)) {
+    cmd.push('--display', display);
+  }
+
+  cmd.push(...parseCommonIntentArguments(opts));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+commands.mobileStartService = async function mobileStartService(opts = {}) {
+  const {
+    intent,
+    user,
+    foreground
+  } = requireOptions(opts, ['intent']);
+  const cmd = ['am'];
+
+  if ((await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8) {
+    cmd.push('startservice');
+  } else {
+    cmd.push(foreground ? 'start-foreground-service' : 'start-service');
+  }
+
+  if (!_lodash.default.isNil(user)) {
+    cmd.push('--user', user);
+  }
+
+  cmd.push(...parseCommonIntentArguments(opts));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+commands.mobileStopService = async function mobileStopService(opts = {}) {
+  const {
+    intent,
+    user
+  } = requireOptions(opts, ['intent']);
+  const cmd = ['am', (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8 ? 'stopservice' : 'stop-service'];
+
+  if (!_lodash.default.isNil(user)) {
+    cmd.push('--user', user);
+  }
+
+  cmd.push(...parseCommonIntentArguments(opts));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+var _default = commands;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/commands/intent.js"],"names":["NO_VALUE_ARG_TYPE","SUPPORTED_EXTRA_TYPES","API_LEVEL_ANDROID_8","commands","requireOptions","opts","requiredKeys","missingKeys","_","difference","keys","isEmpty","errors","InvalidArgumentError","parseCommonIntentArguments","action","uri","mimeType","identifier","categories","component","extras","flags","resultArgs","push","isNil","isArray","flatMap","map","cName","item","type","value","includes","isUndefined","mobileStartActivity","intent","user","wait","stop","windowingMode","activityType","display","cmd","adb","getApiLevel","shell","mobileStartService","foreground","mobileStopService"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { errors } from 'appium-base-driver';\n\nconst NO_VALUE_ARG_TYPE = 'sn';\nconst SUPPORTED_EXTRA_TYPES = [\n  's', NO_VALUE_ARG_TYPE, 'z', 'i', 'l', 'f', 'u', 'cn',\n  'ia', 'ial', 'la', 'lal', 'fa', 'fal', 'sa', 'sal',\n];\nconst API_LEVEL_ANDROID_8 = 26;\n\nconst commands = {};\n\nfunction requireOptions (opts, requiredKeys = []) {\n  const missingKeys = _.difference(requiredKeys, _.keys(opts));\n  if (!_.isEmpty(missingKeys)) {\n    throw new errors.InvalidArgumentError(`The following options are required: ${missingKeys}`);\n  }\n  return opts;\n}\n\nfunction parseCommonIntentArguments (opts = {}) {\n  const {\n    action,\n    uri,\n    mimeType,\n    identifier,\n    categories,\n    component,\n    extras,\n    flags,\n  } = opts;\n  const resultArgs = [];\n  if (action) {\n    resultArgs.push('-a', action);\n  }\n  if (uri) {\n    resultArgs.push('-d', uri);\n  }\n  if (mimeType) {\n    resultArgs.push('-t', mimeType);\n  }\n  if (!_.isNil(identifier)) {\n    resultArgs.push('-i', identifier);\n  }\n  if (categories) {\n    if (_.isArray(categories)) {\n      resultArgs.push(...(_.flatMap(categories.map((cName) => ['-c', cName]))));\n    } else {\n      resultArgs.push('-c', categories);\n    }\n  }\n  if (component) {\n    resultArgs.push('-n', component);\n  }\n  if (extras) {\n    if (!_.isArray(extras)) {\n      throw new errors.InvalidArgumentError(`'extras' must be an array`);\n    }\n    for (const item of extras) {\n      let type;\n      let value;\n      if (_.isArray(item)) {\n        [type, value] = item;\n      } else {\n        type = item;\n      }\n      if (!_.includes(SUPPORTED_EXTRA_TYPES, type)) {\n        throw new errors.InvalidArgumentError(`Intent argument type '${type}' is not known. ` +\n          `Supported intent argument types are: ${SUPPORTED_EXTRA_TYPES}`);\n      }\n      if (type === NO_VALUE_ARG_TYPE) {\n        resultArgs.push(`--e${type}`);\n      } else if (_.isUndefined(value)) {\n        throw new errors.InvalidArgumentError(`Intent argument type '${type}' requires a ` +\n          `value to be provided`);\n      } else {\n        resultArgs.push(`--e${type}`, value);\n      }\n    }\n  }\n  if (flags) {\n    resultArgs.push('-f', flags);\n  }\n  return resultArgs;\n}\n\n/**\n * @typedef {Object} StartActivityOptions\n * @property {!string} intent - The name of the activity intent to start, for example\n * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.\n * @property {?string|number} user ['current'] - The user ID for which the service is started.\n * The `current` user id is used by default\n * @property {?boolean} wait [false] - Set it to `true` if you want to block the method call\n * until the activity manager's process returns the control to the system.\n * @property {?boolean} stop [false] - Set it to `true` to force stop the target\n * app before starting the activity\n * @property {?number|string} windowingMode - The windowing mode to launch the activity into.\n * Check https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java\n * for more details on possible windowing modes (constants starting with `WINDOWING_MODE_`).\n * @property {?number|string} activityType - The activity type to launch the activity as.\n * Check https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java\n * for more details on possible activity types (constants starting with `ACTIVITY_TYPE_`).\n * @property {?number|string} display - The display identifier to launch the activity into.\n * @property {?string} action - Action name\n * @property {?string} uri - Unified resource identifier\n * @property {?string} mimeType - Mime type\n * @property {?string} identifier - Optional identifier\n * @property {?string|Array<string>} categories - One or more category names\n * @property {?string} component - Component name\n * @property {Array<string|Array<string>>} extras - Optional intent arguments. Must be represented\n * as array of arrays, where each subarray item contains two items: value type and the value itself.\n * Supported value types are:\n * - s: string. Value must be a valid string\n * - sn: null. Value is ignored for this type\n * - z: boolean. Value must be either `true` or `false`\n * - i: integer. Value must be a valid 4-byte integer number\n * - l: long. Value must be a valid 8-byte long number\n * - f: float: Value must be a valid float number\n * - u: uri. Value must be a valid uniform resource identifier string\n * - cn: component name. Value must be a valid component name string\n * - ia: Integer[]. Value must be a string of comma-separated integers\n * - ial: List<Integer>. Value must be a string of comma-separated integers\n * - la: Long[]. Value must be a string of comma-separated long numbers\n * - lal: List<Long>. Value must be a string of comma-separated long numbers\n * - fa: Float[]. Value must be a string of comma-separated float numbers\n * - fal: List<Float>. Value must be a string of comma-separated float numbers\n * - sa: String[]. Value must be comma-separated strings. To embed a comma into a string,\n * escape it using \"\\,\"\n * - sal: List<String>. Value must be comma-separated strings. To embed a comma into a string,\n * escape it using \"\\,\"\n * For example: [['s', 'My String1'], ['s', 'My String2'], ['ia', '1,2,3,4']]\n * @property {?string} flags - Intent startup-specific flags as a hexadecimal string.\n * See https://developer.android.com/reference/android/content/Intent.html\n * for the list of available flag values (constants starting with FLAG_ACTIVITY_).\n * Flag values could be merged using the logical 'or' operation.\n * For example, 0x10200000 is the combination of two flags:\n * 0x10000000 `FLAG_ACTIVITY_NEW_TASK` | 0x00200000 `FLAG_ACTIVITY_RESET_TASK_IF_NEEDED`\n */\n\n/**\n * Starts the given activity intent.\n *\n * @param {StartActivityOptions} opts\n * @returns {string} The command output\n * @throws {Error} If there was a failure while starting the activity\n * or required options are missing\n */\ncommands.mobileStartActivity = async function mobileStartActivity (opts = {}) {\n  const {\n    intent,\n    user,\n    wait,\n    stop,\n    windowingMode,\n    activityType,\n    display,\n  } = requireOptions(opts, ['intent']);\n  const cmd = [\n    'am', (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) ? 'start' : 'start-activity',\n  ];\n  if (!_.isNil(user)) {\n    cmd.push('--user', user);\n  }\n  if (wait) {\n    cmd.push('-W');\n  }\n  if (stop) {\n    cmd.push('-S');\n  }\n  if (!_.isNil(windowingMode)) {\n    cmd.push('--windowingMode', windowingMode);\n  }\n  if (!_.isNil(activityType)) {\n    cmd.push('--activityType', activityType);\n  }\n  if (!_.isNil(display)) {\n    cmd.push('--display', display);\n  }\n  cmd.push(...(parseCommonIntentArguments(opts)));\n  cmd.push(intent);\n  return await this.adb.shell(cmd);\n};\n\n/**\n * @typedef {Object} StartServiceOptions\n * @property {!string} intent - The name of the service intent to start, for example\n * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.\n * @property {?string|number} user ['current'] - The user ID for which the service is started.\n * The `current` user id is used by default\n * @property {?boolean} foreground [false] - Set it to `true` if your service must be\n * started as foreground service. This option is ignored if the API level of the\n * device under test is below 26 (Android 8).\n * @property {?string} action - Action name\n * @property {?string} uri - Unified resource identifier\n * @property {?string} mimeType - Mime type\n * @property {?string} identifier - Optional identifier\n * @property {?string|Array<string>} categories - One or more category names\n * @property {?string} component - Component name\n * @property {Array<string|Array<string>>} extras - Optional intent arguments. Must be represented\n * as array of arrays, where each subarray item contains two items: value type and the value itself.\n * Supported value types are:\n * - s: string. Value must be a valid string\n * - sn: null. Value is ignored for this type\n * - z: boolean. Value must be either `true` or `false`\n * - i: integer. Value must be a valid 4-byte integer number\n * - l: long. Value must be a valid 8-byte long number\n * - f: float: Value must be a valid float number\n * - u: uri. Value must be a valid uniform resource identifier string\n * - cn: component name. Value must be a valid component name string\n * - ia: Integer[]. Value must be a string of comma-separated integers\n * - ial: List<Integer>. Value must be a string of comma-separated integers\n * - la: Long[]. Value must be a string of comma-separated long numbers\n * - lal: List<Long>. Value must be a string of comma-separated long numbers\n * - fa: Float[]. Value must be a string of comma-separated float numbers\n * - fal: List<Float>. Value must be a string of comma-separated float numbers\n * - sa: String[]. Value must be comma-separated strings. To embed a comma into a string,\n * escape it using \"\\,\"\n * - sal: List<String>. Value must be comma-separated strings. To embed a comma into a string,\n * escape it using \"\\,\"\n * For example: [['s', 'My String1'], ['s', 'My String2'], ['ia', '1,2,3,4']]\n * @property {?string} flags - Intent startup-specific flags as a hexadecimal string.\n * See https://developer.android.com/reference/android/content/Intent.html\n * for the list of available flag values (constants starting with FLAG_ACTIVITY_).\n * Flag values could be merged using the logical 'or' operation.\n * For example, 0x10200000 is the combination of two flags:\n * 0x10000000 `FLAG_ACTIVITY_NEW_TASK` | 0x00200000 `FLAG_ACTIVITY_RESET_TASK_IF_NEEDED`\n */\n\n/**\n * Starts the given service intent.\n *\n * @param {StartServiceOptions} opts\n * @returns {string} The command output\n * @throws {Error} If there was a failure while starting the service\n * or required options are missing\n */\ncommands.mobileStartService = async function mobileStartService (opts = {}) {\n  const {\n    intent,\n    user,\n    foreground,\n  } = requireOptions(opts, ['intent']);\n  const cmd = ['am'];\n  if (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) {\n    cmd.push('startservice');\n  } else {\n    cmd.push(foreground ? 'start-foreground-service' : 'start-service');\n  }\n  if (!_.isNil(user)) {\n    cmd.push('--user', user);\n  }\n  cmd.push(...(parseCommonIntentArguments(opts)));\n  cmd.push(intent);\n  return await this.adb.shell(cmd);\n};\n\n/**\n * @typedef {Object} StopServiceOptions\n * @property {!string} intent - The name of the service intent to stop, for example\n * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.\n * @property {string|number} user ['current'] - The user ID for which the service is running.\n * The `current` user id is used by default\n */\n\n/**\n * Stops the given service intent.\n *\n * @param {StopServiceOptions} opts\n * @returns {string} The command output\n * @throws {Error} If there was a failure while stopping the service\n * or required options are missing\n */\ncommands.mobileStopService = async function mobileStopService (opts = {}) {\n  const {\n    intent,\n    user,\n  } = requireOptions(opts, ['intent']);\n  const cmd = [\n    'am',\n    (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) ? 'stopservice' : 'stop-service'\n  ];\n  if (!_.isNil(user)) {\n    cmd.push('--user', user);\n  }\n  cmd.push(...(parseCommonIntentArguments(opts)));\n  cmd.push(intent);\n  return await this.adb.shell(cmd);\n};\n\n\nexport { commands };\nexport default commands;\n"],"file":"lib/commands/intent.js","sourceRoot":"../../.."}

package/lib/commands/execute.js

@@ -51,6 +51,7 @@ extensions.executeMobile = async function executeMobile (mobileCommand, opts = {
 
     startService: 'mobileStartService',
     stopService: 'mobileStopService',
+    startActivity: 'mobileStartActivity',
 
     getContexts: 'mobileGetContexts',
   };

package/lib/commands/index.js

@@ -16,7 +16,7 @@ import shellCmds from './shell';
 import emuConsoleCmds from './emu-console';
 import fileActionsCmds from './file-actions';
 import appManagementCmds from './app-management';
-import servicesCmds from './services';
+import intentCmds from './intent';
 import logCmds from './log';
 
 
@@ -34,7 +34,7 @@ Object.assign(
   networkCmds,
   coverageCmds,
   recordscreenCmds,
-  servicesCmds,
+  intentCmds,
   screenStreamCmds,
   performanceCmds,
   executeCmds,

package/lib/commands/intent.js

@@ -0,0 +1,292 @@
+import _ from 'lodash';
+import { errors } from 'appium-base-driver';
+
+const NO_VALUE_ARG_TYPE = 'sn';
+const SUPPORTED_EXTRA_TYPES = [
+  's', NO_VALUE_ARG_TYPE, 'z', 'i', 'l', 'f', 'u', 'cn',
+  'ia', 'ial', 'la', 'lal', 'fa', 'fal', 'sa', 'sal',
+];
+const API_LEVEL_ANDROID_8 = 26;
+
+const commands = {};
+
+function requireOptions (opts, requiredKeys = []) {
+  const missingKeys = _.difference(requiredKeys, _.keys(opts));
+  if (!_.isEmpty(missingKeys)) {
+    throw new errors.InvalidArgumentError(`The following options are required: ${missingKeys}`);
+  }
+  return opts;
+}
+
+function parseCommonIntentArguments (opts = {}) {
+  const {
+    action,
+    uri,
+    mimeType,
+    identifier,
+    categories,
+    component,
+    extras,
+    flags,
+  } = opts;
+  const resultArgs = [];
+  if (action) {
+    resultArgs.push('-a', action);
+  }
+  if (uri) {
+    resultArgs.push('-d', uri);
+  }
+  if (mimeType) {
+    resultArgs.push('-t', mimeType);
+  }
+  if (!_.isNil(identifier)) {
+    resultArgs.push('-i', identifier);
+  }
+  if (categories) {
+    if (_.isArray(categories)) {
+      resultArgs.push(...(_.flatMap(categories.map((cName) => ['-c', cName]))));
+    } else {
+      resultArgs.push('-c', categories);
+    }
+  }
+  if (component) {
+    resultArgs.push('-n', component);
+  }
+  if (extras) {
+    if (!_.isArray(extras)) {
+      throw new errors.InvalidArgumentError(`'extras' must be an array`);
+    }
+    for (const item of extras) {
+      let type;
+      let value;
+      if (_.isArray(item)) {
+        [type, value] = item;
+      } else {
+        type = item;
+      }
+      if (!_.includes(SUPPORTED_EXTRA_TYPES, type)) {
+        throw new errors.InvalidArgumentError(`Intent argument type '${type}' is not known. ` +
+          `Supported intent argument types are: ${SUPPORTED_EXTRA_TYPES}`);
+      }
+      if (type === NO_VALUE_ARG_TYPE) {
+        resultArgs.push(`--e${type}`);
+      } else if (_.isUndefined(value)) {
+        throw new errors.InvalidArgumentError(`Intent argument type '${type}' requires a ` +
+          `value to be provided`);
+      } else {
+        resultArgs.push(`--e${type}`, value);
+      }
+    }
+  }
+  if (flags) {
+    resultArgs.push('-f', flags);
+  }
+  return resultArgs;
+}
+
+/**
+ * @typedef {Object} StartActivityOptions
+ * @property {!string} intent - The name of the activity intent to start, for example
+ * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.
+ * @property {?string|number} user ['current'] - The user ID for which the service is started.
+ * The `current` user id is used by default
+ * @property {?boolean} wait [false] - Set it to `true` if you want to block the method call
+ * until the activity manager's process returns the control to the system.
+ * @property {?boolean} stop [false] - Set it to `true` to force stop the target
+ * app before starting the activity
+ * @property {?number|string} windowingMode - The windowing mode to launch the activity into.
+ * Check https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java
+ * for more details on possible windowing modes (constants starting with `WINDOWING_MODE_`).
+ * @property {?number|string} activityType - The activity type to launch the activity as.
+ * Check https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java
+ * for more details on possible activity types (constants starting with `ACTIVITY_TYPE_`).
+ * @property {?number|string} display - The display identifier to launch the activity into.
+ * @property {?string} action - Action name
+ * @property {?string} uri - Unified resource identifier
+ * @property {?string} mimeType - Mime type
+ * @property {?string} identifier - Optional identifier
+ * @property {?string|Array<string>} categories - One or more category names
+ * @property {?string} component - Component name
+ * @property {Array<string|Array<string>>} extras - Optional intent arguments. Must be represented
+ * as array of arrays, where each subarray item contains two items: value type and the value itself.
+ * Supported value types are:
+ * - s: string. Value must be a valid string
+ * - sn: null. Value is ignored for this type
+ * - z: boolean. Value must be either `true` or `false`
+ * - i: integer. Value must be a valid 4-byte integer number
+ * - l: long. Value must be a valid 8-byte long number
+ * - f: float: Value must be a valid float number
+ * - u: uri. Value must be a valid uniform resource identifier string
+ * - cn: component name. Value must be a valid component name string
+ * - ia: Integer[]. Value must be a string of comma-separated integers
+ * - ial: List<Integer>. Value must be a string of comma-separated integers
+ * - la: Long[]. Value must be a string of comma-separated long numbers
+ * - lal: List<Long>. Value must be a string of comma-separated long numbers
+ * - fa: Float[]. Value must be a string of comma-separated float numbers
+ * - fal: List<Float>. Value must be a string of comma-separated float numbers
+ * - sa: String[]. Value must be comma-separated strings. To embed a comma into a string,
+ * escape it using "\,"
+ * - sal: List<String>. Value must be comma-separated strings. To embed a comma into a string,
+ * escape it using "\,"
+ * For example: [['s', 'My String1'], ['s', 'My String2'], ['ia', '1,2,3,4']]
+ * @property {?string} flags - Intent startup-specific flags as a hexadecimal string.
+ * See https://developer.android.com/reference/android/content/Intent.html
+ * for the list of available flag values (constants starting with FLAG_ACTIVITY_).
+ * Flag values could be merged using the logical 'or' operation.
+ * For example, 0x10200000 is the combination of two flags:
+ * 0x10000000 `FLAG_ACTIVITY_NEW_TASK` | 0x00200000 `FLAG_ACTIVITY_RESET_TASK_IF_NEEDED`
+ */
+
+/**
+ * Starts the given activity intent.
+ *
+ * @param {StartActivityOptions} opts
+ * @returns {string} The command output
+ * @throws {Error} If there was a failure while starting the activity
+ * or required options are missing
+ */
+commands.mobileStartActivity = async function mobileStartActivity (opts = {}) {
+  const {
+    intent,
+    user,
+    wait,
+    stop,
+    windowingMode,
+    activityType,
+    display,
+  } = requireOptions(opts, ['intent']);
+  const cmd = [
+    'am', (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) ? 'start' : 'start-activity',
+  ];
+  if (!_.isNil(user)) {
+    cmd.push('--user', user);
+  }
+  if (wait) {
+    cmd.push('-W');
+  }
+  if (stop) {
+    cmd.push('-S');
+  }
+  if (!_.isNil(windowingMode)) {
+    cmd.push('--windowingMode', windowingMode);
+  }
+  if (!_.isNil(activityType)) {
+    cmd.push('--activityType', activityType);
+  }
+  if (!_.isNil(display)) {
+    cmd.push('--display', display);
+  }
+  cmd.push(...(parseCommonIntentArguments(opts)));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+/**
+ * @typedef {Object} StartServiceOptions
+ * @property {!string} intent - The name of the service intent to start, for example
+ * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.
+ * @property {?string|number} user ['current'] - The user ID for which the service is started.
+ * The `current` user id is used by default
+ * @property {?boolean} foreground [false] - Set it to `true` if your service must be
+ * started as foreground service. This option is ignored if the API level of the
+ * device under test is below 26 (Android 8).
+ * @property {?string} action - Action name
+ * @property {?string} uri - Unified resource identifier
+ * @property {?string} mimeType - Mime type
+ * @property {?string} identifier - Optional identifier
+ * @property {?string|Array<string>} categories - One or more category names
+ * @property {?string} component - Component name
+ * @property {Array<string|Array<string>>} extras - Optional intent arguments. Must be represented
+ * as array of arrays, where each subarray item contains two items: value type and the value itself.
+ * Supported value types are:
+ * - s: string. Value must be a valid string
+ * - sn: null. Value is ignored for this type
+ * - z: boolean. Value must be either `true` or `false`
+ * - i: integer. Value must be a valid 4-byte integer number
+ * - l: long. Value must be a valid 8-byte long number
+ * - f: float: Value must be a valid float number
+ * - u: uri. Value must be a valid uniform resource identifier string
+ * - cn: component name. Value must be a valid component name string
+ * - ia: Integer[]. Value must be a string of comma-separated integers
+ * - ial: List<Integer>. Value must be a string of comma-separated integers
+ * - la: Long[]. Value must be a string of comma-separated long numbers
+ * - lal: List<Long>. Value must be a string of comma-separated long numbers
+ * - fa: Float[]. Value must be a string of comma-separated float numbers
+ * - fal: List<Float>. Value must be a string of comma-separated float numbers
+ * - sa: String[]. Value must be comma-separated strings. To embed a comma into a string,
+ * escape it using "\,"
+ * - sal: List<String>. Value must be comma-separated strings. To embed a comma into a string,
+ * escape it using "\,"
+ * For example: [['s', 'My String1'], ['s', 'My String2'], ['ia', '1,2,3,4']]
+ * @property {?string} flags - Intent startup-specific flags as a hexadecimal string.
+ * See https://developer.android.com/reference/android/content/Intent.html
+ * for the list of available flag values (constants starting with FLAG_ACTIVITY_).
+ * Flag values could be merged using the logical 'or' operation.
+ * For example, 0x10200000 is the combination of two flags:
+ * 0x10000000 `FLAG_ACTIVITY_NEW_TASK` | 0x00200000 `FLAG_ACTIVITY_RESET_TASK_IF_NEEDED`
+ */
+
+/**
+ * Starts the given service intent.
+ *
+ * @param {StartServiceOptions} opts
+ * @returns {string} The command output
+ * @throws {Error} If there was a failure while starting the service
+ * or required options are missing
+ */
+commands.mobileStartService = async function mobileStartService (opts = {}) {
+  const {
+    intent,
+    user,
+    foreground,
+  } = requireOptions(opts, ['intent']);
+  const cmd = ['am'];
+  if (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) {
+    cmd.push('startservice');
+  } else {
+    cmd.push(foreground ? 'start-foreground-service' : 'start-service');
+  }
+  if (!_.isNil(user)) {
+    cmd.push('--user', user);
+  }
+  cmd.push(...(parseCommonIntentArguments(opts)));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+/**
+ * @typedef {Object} StopServiceOptions
+ * @property {!string} intent - The name of the service intent to stop, for example
+ * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.
+ * @property {string|number} user ['current'] - The user ID for which the service is running.
+ * The `current` user id is used by default
+ */
+
+/**
+ * Stops the given service intent.
+ *
+ * @param {StopServiceOptions} opts
+ * @returns {string} The command output
+ * @throws {Error} If there was a failure while stopping the service
+ * or required options are missing
+ */
+commands.mobileStopService = async function mobileStopService (opts = {}) {
+  const {
+    intent,
+    user,
+  } = requireOptions(opts, ['intent']);
+  const cmd = [
+    'am',
+    (await this.adb.getApiLevel() < API_LEVEL_ANDROID_8) ? 'stopservice' : 'stop-service'
+  ];
+  if (!_.isNil(user)) {
+    cmd.push('--user', user);
+  }
+  cmd.push(...(parseCommonIntentArguments(opts)));
+  cmd.push(intent);
+  return await this.adb.shell(cmd);
+};
+
+
+export { commands };
+export default commands;

package/package.json

@@ -9,7 +9,7 @@
     "mobile",
     "mobile testing"
   ],
-  "version": "4.46.0",
+  "version": "4.47.0",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {

package/build/lib/commands/services.js

@@ -1,62 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.commands = void 0;
-
-require("source-map-support/register");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-const commands = {};
-exports.commands = commands;
-
-function requireOptions(opts, requiredKeys = []) {
-  const missingKeys = _lodash.default.difference(requiredKeys, _lodash.default.keys(opts));
-
-  if (!_lodash.default.isEmpty(missingKeys)) {
-    throw new Error(`The following options are required: ${missingKeys}`);
-  }
-
-  return opts;
-}
-
-commands.mobileStartService = async function mobileStartService(opts = {}) {
-  const {
-    intent,
-    user,
-    foreground
-  } = requireOptions(opts, ['intent']);
-  const cmd = ['am', foreground ? 'start-foreground-service' : 'start-service'];
-
-  if (user) {
-    cmd.push('--user', user);
-  }
-
-  cmd.push(intent);
-  return await this.adb.shell(cmd);
-};
-
-commands.mobileStopService = async function mobileStopService(opts = {}) {
-  const {
-    intent,
-    user
-  } = requireOptions(opts, ['intent']);
-  const cmd = ['am', 'stop-service'];
-
-  if (user) {
-    cmd.push('--user', user);
-  }
-
-  cmd.push(intent);
-  return await this.adb.shell(cmd);
-};
-
-var _default = commands;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/commands/services.js

@@ -1,80 +0,0 @@
-import _ from 'lodash';
-
-const commands = {};
-
-function requireOptions (opts, requiredKeys = []) {
-  const missingKeys = _.difference(requiredKeys, _.keys(opts));
-  if (!_.isEmpty(missingKeys)) {
-    throw new Error(`The following options are required: ${missingKeys}`);
-  }
-  return opts;
-}
-
-/**
- * @typedef {Object} StartServiceOptions
- * @property {!string} intent - The name of the service intent to start, for example
- * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.
- * @property {string|number} user ['current'] - The user ID for which the service is started.
- * The `current` user id is used by default
- * @property {boolean} foreground [false] - Set it to `true` if your service must be
- * started as foreground service.
- */
-
-/**
- * Starts the given service intent.
- *
- * @param {StartServiceOptions} opts
- * @returns {string} The command output
- * @throws {Error} If there was a failure while starting the service
- * or required options are missing
- */
-commands.mobileStartService = async function mobileStartService (opts = {}) {
-  const {
-    intent,
-    user,
-    foreground,
-  } = requireOptions(opts, ['intent']);
-  const cmd = [
-    'am', foreground ? 'start-foreground-service' : 'start-service',
-  ];
-  if (user) {
-    cmd.push('--user', user);
-  }
-  cmd.push(intent);
-  return await this.adb.shell(cmd);
-};
-
-/**
- * @typedef {Object} StopServiceOptions
- * @property {!string} intent - The name of the service intent to stop, for example
- * `com.some.package.name/.YourServiceSubClassName`. This option is mandatory.
- * @property {string|number} user ['current'] - The user ID for which the service is running.
- * The `current` user id is used by default
- */
-
-/**
- * Stops the given service intent.
- *
- * @param {StopServiceOptions} opts
- * @returns {string} The command output
- * @throws {Error} If there was a failure while stopping the service
- * or required options are missing
- */
-commands.mobileStopService = async function mobileStopService (opts = {}) {
-  const {
-    intent,
-    user,
-  } = requireOptions(opts, ['intent']);
-  const cmd = [
-    'am', 'stop-service',
-  ];
-  if (user) {
-    cmd.push('--user', user);
-  }
-  cmd.push(intent);
-  return await this.adb.shell(cmd);
-};
-
-
-export { commands };
-export default commands;