appium-adb 9.4.0 → 9.6.1

package/lib/helpers.js

@@ -12,6 +12,8 @@ const APK_EXTENSION = '.apk';
 const APK_INSTALL_TIMEOUT = 60000;
 const APKS_INSTALL_TIMEOUT = APK_INSTALL_TIMEOUT * 2;
 const DEFAULT_ADB_EXEC_TIMEOUT = 20000; // in milliseconds
+const MAIN_ACTION = 'android.intent.action.MAIN';
+const LAUNCHER_CATEGORY = 'android.intent.category.LAUNCHER';
 
 /**
  * Retrieves the actual path to SDK root folder from the system environment
@@ -570,10 +572,8 @@ function parseManifest (manifest) {
         continue;
       }
 
-      const isMainAction = actions
-        .some(({name}) => name === 'android.intent.action.MAIN');
-      const isLauncherCategory = categories
-        .some(({name}) => name === 'android.intent.category.LAUNCHER');
+      const isMainAction = actions.some(({name}) => name === MAIN_ACTION);
+      const isLauncherCategory = categories.some(({name}) => name === LAUNCHER_CATEGORY);
       if (isMainAction && isLauncherCategory) {
         result.activity = activity.name;
         return result;
@@ -930,6 +930,101 @@ function escapeShellArg (arg) {
   return arg.replace(/&/g, '\\&');
 }
 
+/**
+ * Parses the name of launchable package activity
+ * from dumpsys output.
+ *
+ * @param {string} dumpsys the actual dumpsys output
+ * @returns {string[]} Either the fully qualified
+ * activity name as a single list item or an empty list if nothing could be parsed.
+ * In Android 6 and older there is no reliable way to determine
+ * the category name for the given activity, so this API just
+ * returns all activity names belonging to 'android.intent.action.MAIN'
+ * with the expectation that the app manifest could be parsed next
+ * in order to determine category names for these.
+ */
+function parseLaunchableActivityNames (dumpsys) {
+  const mainActivityNameRe = new RegExp(`^\\s*${_.escapeRegExp(MAIN_ACTION)}:$`);
+  const categoryNameRe = /^\s*Category:\s+"([a-zA-Z0-9._/-]+)"$/;
+  const blocks = [];
+  let blockStartIndent;
+  let block = [];
+  for (const line of dumpsys.split('\n').map(_.trimEnd)) {
+    const currentIndent = line.length - _.trimStart(line).length;
+    if (mainActivityNameRe.test(line)) {
+      blockStartIndent = currentIndent;
+      if (!_.isEmpty(block)) {
+        blocks.push(block);
+        block = [];
+      }
+      continue;
+    }
+    if (_.isNil(blockStartIndent)) {
+      continue;
+    }
+
+    if (currentIndent > blockStartIndent) {
+      block.push(line);
+    } else {
+      if (!_.isEmpty(block)) {
+        blocks.push(block);
+        block = [];
+      }
+      blockStartIndent = null;
+    }
+  }
+  if (!_.isEmpty(block)) {
+    blocks.push(block);
+  }
+
+  const result = [];
+  for (const item of blocks) {
+    let hasCategory = false;
+    let isLauncherCategory = false;
+    for (const line of item) {
+      const match = categoryNameRe.exec(line);
+      if (!match) {
+        continue;
+      }
+
+      hasCategory = true;
+      isLauncherCategory = match[1] === LAUNCHER_CATEGORY;
+      break;
+    }
+    // On older Android versions the category name
+    // might not be listed, so we just try to fetch
+    // all matches instead
+    if (hasCategory && !isLauncherCategory) {
+      continue;
+    }
+
+    for (const activityNameStr of item.map(_.trim).filter(Boolean)) {
+      const fqActivityName = activityNameStr.split(/\s+/)[1];
+      if (!matchComponentName(fqActivityName)) {
+        continue;
+      }
+
+      if (isLauncherCategory) {
+        return [fqActivityName];
+      }
+      result.push(fqActivityName);
+    }
+  }
+  return result;
+}
+
+/**
+ * Check if the given string is a valid component name
+ *
+ * @param {string} classString The string to verify
+ * @return {?Array<Match>} The result of Regexp.exec operation
+ * or _null_ if no matches are found
+ */
+function matchComponentName (classString) {
+  // some.package/some.package.Activity
+  return /^[a-z0-9./_]+$/i.exec(classString);
+}
+
 export {
   getAndroidPlatformAndPath, unzipFile,
   getIMEListFromOutput, getJavaForOs, isShowingLockscreen, isCurrentFocusOnKeyguard,
@@ -940,4 +1035,5 @@ export {
   DEFAULT_ADB_EXEC_TIMEOUT, parseManifest, parseAaptStrings, parseAapt2Strings,
   formatConfigMarker, parseJsonData, unsignApk, toAvdLocaleArgs, requireSdkRoot,
   getSdkRootFromEnv, getAndroidPrefsRoot, dirExists, escapeShellArg,
+  parseLaunchableActivityNames, matchComponentName,
 };

package/lib/tools/adb-commands.js

@@ -1,10 +1,11 @@
 import log from '../logger.js';
 import {
   getIMEListFromOutput, getSurfaceOrientation, extractMatchingPermissions,
+  parseLaunchableActivityNames, matchComponentName,
 } from '../helpers.js';
 import path from 'path';
 import _ from 'lodash';
-import { fs, util } from '@appium/support';
+import { fs, util, tempDir } from '@appium/support';
 import { EOL } from 'os';
 import Logcat from '../logcat';
 import { sleep, waitForCondition } from 'asyncbox';
@@ -207,7 +208,54 @@ methods.mkdir = async function mkdir (remotePath) {
  */
 methods.isValidClass = function isValidClass (classString) {
   // some.package/some.package.Activity
-  return new RegExp(/^[a-zA-Z0-9./_]+$/).exec(classString);
+  return matchComponentName(classString);
+};
+
+/**
+ * Fetches the fully qualified name of the launchable activity for the
+ * given package. It is expected the package is already installed on
+ * the device under test.
+ *
+ * @param {string} pkg - The target package identifier
+ * @return {string} Fully qualified name of the launchable activity
+ * @throws {Error} If there was an error while resolving the activity name
+ */
+methods.resolveLaunchableActivity = async function resolveLaunchableActivity (pkg) {
+  if (await this.getApiLevel() < 24) {
+    const stdout = await this.shell(['dumpsys', 'package', pkg]);
+    const names = parseLaunchableActivityNames(stdout);
+    if (_.isEmpty(names)) {
+      log.debug(stdout);
+      throw new Error(`Unable to resolve the launchable activity of '${pkg}'. Is it installed on the device?`);
+    }
+    if (names.length === 1) {
+      return names[0];
+    }
+
+    const tmpRoot = await tempDir.openDir();
+    try {
+      const tmpApp = await this.pullApk(pkg, tmpRoot);
+      const {apkActivity} = await this.packageAndLaunchActivityFromManifest(tmpApp);
+      return apkActivity;
+    } catch (e) {
+      log.debug(e.stack);
+      log.warn(`Unable to resolve the launchable activity of '${pkg}'. ` +
+        `The very first match of the dumpsys output is going to be used. ` +
+        `Original error: ${e.message}`);
+      return names[0];
+    } finally {
+      await fs.rimraf(tmpRoot);
+    }
+  }
+  const {stdout, stderr} = await this.shell(['cmd', 'package', 'resolve-activity', '--brief', pkg], {
+    outputFormat: this.EXEC_OUTPUT_FORMAT.FULL
+  });
+  for (const line of (stdout || '').split('\n').map(_.trim)) {
+    if (this.isValidClass(line)) {
+      return line;
+    }
+  }
+  throw new Error(`Unable to resolve the launchable activity of '${pkg}'. Original error: ${stderr || stdout}`);
 };
 
 /**

package/lib/tools/apk-utils.js

@@ -1102,10 +1102,24 @@ apkUtilsMethods.getPackageInfo = async function getPackageInfo (pkg) {
   return result;
 };
 
+/**
+ * Fetches base.apk of the given package to the local file system
+ *
+ * @param {string} pkg The package identifier (must be already installed on the device)
+ * @param {string} tmpDir The destination folder path
+ * @returns {string} Full path to the downloaded file
+ * @throws {Error} If there was an error while fetching the .apk
+ */
 apkUtilsMethods.pullApk = async function pullApk (pkg, tmpDir) {
-  const pkgPath = (await this.adbExec(['shell', 'pm', 'path', pkg])).replace('package:', '');
+  const stdout = _.trim(await this.shell(['pm', 'path', pkg]));
+  const packageMarker = 'package:';
+  if (!_.startsWith(stdout, packageMarker)) {
+    throw new Error(`Cannot pull the .apk package for '${pkg}'. Original error: ${stdout}`);
+  }
+
+  const remotePath = stdout.replace(packageMarker, '');
   const tmpApp = path.resolve(tmpDir, `${pkg}.apk`);
-  await this.pull(pkgPath, tmpApp);
+  await this.pull(remotePath, tmpApp);
   log.debug(`Pulled app for package '${pkg}' to '${tmpApp}'`);
   return tmpApp;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-adb",
-  "version": "9.4.0",
+  "version": "9.6.1",
   "description": "Android Debug Bridge interface",
   "main": "./build/index.js",
   "scripts": {