appium-adb 16.0.0 → 16.0.2

package/lib/tools/aab-utils.ts

@@ -1,12 +1,14 @@
-import {log} from '../logger.js';
+import crypto from 'node:crypto';
 import path from 'node:path';
+
 import {fs, tempDir, util} from '@appium/support';
-import {LRUCache} from 'lru-cache';
 import AsyncLock from 'async-lock';
-import crypto from 'node:crypto';
+import {LRUCache} from 'lru-cache';
+
 import type {ADB} from '../adb.js';
-import type {ApkCreationOptions, StringRecord} from './types.js';
+import {log} from '../logger.js';
 import {unzipFile} from '../utils/index.js';
+import type {ApkCreationOptions, StringRecord} from './types.js';
 
 const AAB_CACHE = new LRUCache<string, string>({
   max: 10,
@@ -21,9 +23,7 @@ process.on('exit', () => {
   }
 
   const paths = [...AAB_CACHE.values()];
-  log.debug(
-    `Performing cleanup of ${paths.length} cached .aab ` + util.pluralize('package', paths.length),
-  );
+  log.debug(`Performing cleanup of ${paths.length} cached .aab ` + util.pluralize('package', paths.length));
   for (const appPath of paths) {
     try {
       // Asynchronous calls are not supported in onExit handler
@@ -45,11 +45,7 @@ process.on('exit', () => {
  * by default.
  * @throws {Error} If there was an error while creating the universal .apk
  */
-export async function extractUniversalApk(
-  this: ADB,
-  aabPath: string,
-  opts: ApkCreationOptions = {},
-): Promise<string> {
+export async function extractUniversalApk(this: ADB, aabPath: string, opts: ApkCreationOptions = {}): Promise<string> {
   if (!(await fs.exists(aabPath))) {
     throw new Error(`The file at '${aabPath}' either does not exist or is not accessible`);
   }
@@ -65,9 +61,7 @@ export async function extractUniversalApk(
       let cacheHash = aabHash;
       if (keystore) {
         if (!(await fs.exists(keystore))) {
-          throw new Error(
-            `The keystore file at '${keystore}' either does not exist ` + `or is not accessible`,
-          );
+          throw new Error(`The keystore file at '${keystore}' either does not exist or is not accessible`);
         }
         if (!keystorePassword || !keyAlias || !keyPassword) {
           throw new Error(

package/lib/tools/android-manifest.ts

@@ -1,10 +1,12 @@
-import {exec} from 'teen_process';
-import {log} from '../logger.js';
-import {fs, zip, tempDir, util} from '@appium/support';
 import path from 'node:path';
+
+import {fs, zip, tempDir, util} from '@appium/support';
+import {exec} from 'teen_process';
+
 import type {ADB} from '../adb.js';
-import type {APKInfo, PlatformInfo, StringRecord} from './types.js';
+import {log} from '../logger.js';
 import {APKS_EXTENSION, readPackageManifest, unzipFile} from '../utils/index.js';
+import type {APKInfo, PlatformInfo, StringRecord} from './types.js';
 
 /**
  * Extract package and main activity name from application manifest.
@@ -14,10 +16,7 @@ import {APKS_EXTENSION, readPackageManifest, unzipFile} from '../utils/index.js'
  * @throws {error} If there was an error while getting the data from the given
  *                 application package.
  */
-export async function packageAndLaunchActivityFromManifest(
-  this: ADB,
-  appPath: string,
-): Promise<APKInfo> {
+export async function packageAndLaunchActivityFromManifest(this: ADB, appPath: string): Promise<APKInfo> {
   if (appPath.endsWith(APKS_EXTENSION)) {
     appPath = await this.extractBaseApk(appPath);
   }
@@ -48,10 +47,7 @@ export async function targetSdkVersionFromManifest(this: ADB, appPath: string):
 
   const {targetSdkVersion} = await readPackageManifest.bind(this)(appPath);
   if (!targetSdkVersion) {
-    throw new Error(
-      `Cannot extract targetSdkVersion of '${originalAppPath}'. Does ` +
-        `the package manifest define it?`,
-    );
+    throw new Error(`Cannot extract targetSdkVersion of '${originalAppPath}'. Does the package manifest define it?`);
   }
   return targetSdkVersion;
 }
@@ -71,9 +67,7 @@ export async function targetSdkVersionUsingPKG(
 ): Promise<number> {
   const stdout = cmdOutput || (await this.shell(['dumpsys', 'package', pkg]));
   const targetSdkVersionMatch = new RegExp(/targetSdk=([^\s\s]+)/g).exec(stdout);
-  return targetSdkVersionMatch && targetSdkVersionMatch.length >= 2
-    ? parseInt(targetSdkVersionMatch[1], 10)
-    : 0;
+  return targetSdkVersionMatch && targetSdkVersionMatch.length >= 2 ? parseInt(targetSdkVersionMatch[1], 10) : 0;
 }
 
 /**
@@ -93,9 +87,7 @@ export async function compileManifest(
 ): Promise<void> {
   const {platform, platformPath} = await getAndroidPlatformAndPath(this.sdkRoot as string);
   if (!platform || !platformPath) {
-    throw new Error(
-      'Cannot compile the manifest. The required platform does not exist (API level >= 17)',
-    );
+    throw new Error('Cannot compile the manifest. The required platform does not exist (API level >= 17)');
   }
   const resultPath = `${manifest}.apk`;
   const androidJarPath = path.resolve(platformPath, 'android.jar');
@@ -169,12 +161,7 @@ export async function compileManifest(
  * @param dstApk - Full path to the resulting package.
  *                          The file will be overridden if it already exists.
  */
-export async function insertManifest(
-  this: ADB,
-  manifest: string,
-  srcApk: string,
-  dstApk: string,
-): Promise<void> {
+export async function insertManifest(this: ADB, manifest: string, srcApk: string, dstApk: string): Promise<void> {
   log.debug(`Inserting manifest '${manifest}', src: '${srcApk}', dst: '${dstApk}'`);
   await zip.assertValidZip(srcApk);
   await unzipFile(`${manifest}.apk`);
@@ -221,10 +208,7 @@ export async function insertManifest(
  * @param appPath - The full path to .apk(s) package.
  * @return True if the manifest requires Internet access permission.
  */
-export async function hasInternetPermissionFromManifest(
-  this: ADB,
-  appPath: string,
-): Promise<boolean> {
+export async function hasInternetPermissionFromManifest(this: ADB, appPath: string): Promise<boolean> {
   log.debug(`Checking if '${appPath}' requires internet access permission in the manifest`);
   if (appPath.endsWith(APKS_EXTENSION)) {
     appPath = await this.extractBaseApk(appPath);

package/lib/tools/apk-signing.ts

@@ -1,12 +1,14 @@
 import _fs from 'node:fs';
-import {exec, type ExecError} from 'teen_process';
 import path from 'node:path';
-import {log} from '../logger.js';
+
 import {tempDir, system, mkdirp, fs, util, zip} from '@appium/support';
 import {LRUCache} from 'lru-cache';
+import {exec, type ExecError} from 'teen_process';
+
 import type {ADB} from '../adb.js';
-import type {StringRecord, SignedAppCacheValue, CertCheckOptions, KeystoreHash} from './types.js';
+import {log} from '../logger.js';
 import {APKS_EXTENSION, getJavaForOs, getJavaHome, getResourcePath} from '../utils/index.js';
+import type {StringRecord, SignedAppCacheValue, CertCheckOptions, KeystoreHash} from './types.js';
 
 const DEFAULT_PRIVATE_KEY = path.join('keys', 'testkey.pk8');
 const DEFAULT_CERTIFICATE = path.join('keys', 'testkey.x509.pem');
@@ -134,11 +136,7 @@ export async function signWithCustomCert(this: ADB, apk: string): Promise<void>
       } else {
         log.debug(`'${apk}' does not need to be unsigned`);
       }
-      const jarsigner = path.resolve(
-        await getJavaHome(),
-        'bin',
-        `jarsigner${system.isWindows() ? '.exe' : ''}`,
-      );
+      const jarsigner = path.resolve(await getJavaHome(), 'bin', `jarsigner${system.isWindows() ? '.exe' : ''}`);
       const fullCmd: string[] = [
         jarsigner,
         '-sigalg',
@@ -158,11 +156,9 @@ export async function signWithCustomCert(this: ADB, apk: string): Promise<void>
       await exec(fullCmd[0], fullCmd.slice(1));
     } catch (e) {
       const execErr = e as ExecError;
-      throw new Error(
-        `Could not sign with custom certificate. ` +
-          `Original error: ${execErr.stderr || execErr.message}`,
-        {cause: e},
-      );
+      throw new Error(`Could not sign with custom certificate. Original error: ${execErr.stderr || execErr.message}`, {
+        cause: e,
+      });
     }
   }
 }
@@ -239,10 +235,7 @@ export async function zipAlignApk(this: ADB, apk: string): Promise<boolean> {
     if (await fs.exists(alignedApk)) {
       await fs.unlink(alignedApk);
     }
-    throw new Error(
-      `zipAlignApk failed. Original error: ${err.message || (err as ExecError).stderr}`,
-      {cause: e},
-    );
+    throw new Error(`zipAlignApk failed. Original error: ${err.message || (err as ExecError).stderr}`, {cause: e});
   }
 }
 
@@ -253,11 +246,7 @@ export async function zipAlignApk(this: ADB, apk: string): Promise<boolean> {
  * @param opts - Certificate checking options
  * @returns True if given application is already signed.
  */
-export async function checkApkCert(
-  this: ADB,
-  appPath: string,
-  opts: CertCheckOptions = {},
-): Promise<boolean> {
+export async function checkApkCert(this: ADB, appPath: string, opts: CertCheckOptions = {}): Promise<boolean> {
   log.debug(`Checking app cert for ${appPath}`);
   if (!(await fs.exists(appPath))) {
     log.debug(`'${appPath}' does not exist`);
@@ -299,15 +288,9 @@ export async function checkApkCert(
     const output = await this.executeApksigner(['verify', '--print-certs', actualAppPath]);
     const hasMatch = hashMatches(output, expected);
     if (hasMatch) {
-      log.info(
-        `'${actualAppPath}' is signed with the ` +
-          `${this.useKeystore ? 'keystore' : 'default'} certificate`,
-      );
+      log.info(`'${actualAppPath}' is signed with the ${this.useKeystore ? 'keystore' : 'default'} certificate`);
     } else {
-      log.info(
-        `'${actualAppPath}' is signed with a ` +
-          `non-${this.useKeystore ? 'keystore' : 'default'} certificate`,
-      );
+      log.info(`'${actualAppPath}' is signed with a non-${this.useKeystore ? 'keystore' : 'default'} certificate`);
     }
     const isSigned = (!this.useKeystore && !requireDefaultCert) || hasMatch;
     if (isSigned) {
@@ -339,10 +322,7 @@ export async function checkApkCert(
       log.warn(`Assuming '${actualAppPath}' is already signed and continuing anyway`);
       return true;
     }
-    throw new Error(
-      `Cannot verify the signature of '${actualAppPath}'. ` + `Original error: ${errMsg}`,
-      {cause: err},
-    );
+    throw new Error(`Cannot verify the signature of '${actualAppPath}'. Original error: ${errMsg}`, {cause: err});
   }
 }
 
@@ -354,11 +334,7 @@ export async function checkApkCert(
  */
 export async function getKeystoreHash(this: ADB): Promise<KeystoreHash> {
   log.debug(`Getting hash of the '${this.keystorePath}' keystore`);
-  const keytool = path.resolve(
-    await getJavaHome(),
-    'bin',
-    `keytool${system.isWindows() ? '.exe' : ''}`,
-  );
+  const keytool = path.resolve(await getJavaHome(), 'bin', `keytool${system.isWindows() ? '.exe' : ''}`);
   if (!(await fs.exists(keytool))) {
     throw new Error(`The keytool utility cannot be found at '${keytool}'`);
   }
@@ -394,8 +370,7 @@ export async function getKeystoreHash(this: ADB): Promise<KeystoreHash> {
   } catch (e) {
     const err = e as ExecError;
     throw new Error(
-      `Cannot get the hash of '${this.keystorePath}' keystore. ` +
-        `Original error: ${err.stderr || err.message}`,
+      `Cannot get the hash of '${this.keystorePath}' keystore. Original error: ${err.stderr || err.message}`,
       {cause: e},
     );
   }

package/lib/tools/apk-utils.ts

@@ -1,11 +1,13 @@
-import {exec, type ExecError} from 'teen_process';
-import {log} from '../logger.js';
+import os from 'node:os';
 import path from 'node:path';
+
 import {fs, util, mkdirp, timing} from '@appium/support';
-import * as semver from 'semver';
-import os from 'node:os';
 import {LRUCache} from 'lru-cache';
+import * as semver from 'semver';
+import {exec, type ExecError} from 'teen_process';
+
 import type {ADB} from '../adb.js';
+import {log} from '../logger.js';
 import {
   APKS_EXTENSION,
   APK_INSTALL_TIMEOUT,
@@ -38,11 +40,7 @@ export const REMOTE_CACHE_ROOT = '/data/local/tmp/appium_cache';
  * @returns True if the package was found on the device and
  *                   successfully uninstalled.
  */
-export async function uninstallApk(
-  this: ADB,
-  pkg: string,
-  options: UninstallOptions = {},
-): Promise<boolean> {
+export async function uninstallApk(this: ADB, pkg: string, options: UninstallOptions = {}): Promise<boolean> {
   log.debug(`Uninstalling ${pkg}`);
   if (!options.skipInstallCheck && !(await this.isAppInstalled(pkg))) {
     log.info(`${pkg} was not uninstalled, because it was not present on the device`);
@@ -98,11 +96,7 @@ export async function installFromDevicePath(
  * @returns Full path to the cached apk on the remote file system
  * @throws if there was a failure while caching the app
  */
-export async function cacheApk(
-  this: ADB,
-  apkPath: string,
-  options: CachingOptions = {},
-): Promise<string> {
+export async function cacheApk(this: ADB, apkPath: string, options: CachingOptions = {}): Promise<string> {
   const appHash = await fs.hash(apkPath);
   const remotePath = path.posix.join(REMOTE_CACHE_ROOT, `${appHash}.apk`);
   const remoteCachedFiles: string[] = [];
@@ -110,21 +104,12 @@ export async function cacheApk(
   try {
     const errorMarker = '_ERROR_';
     let lsOutput: string | null = null;
-    if (
-      this._areExtendedLsOptionsSupported === true ||
-      typeof this._areExtendedLsOptionsSupported !== 'boolean'
-    ) {
+    if (this._areExtendedLsOptionsSupported === true || typeof this._areExtendedLsOptionsSupported !== 'boolean') {
       lsOutput = await this.shell([`ls -t -1 ${REMOTE_CACHE_ROOT} 2>&1 || echo ${errorMarker}`]);
     }
-    if (
-      typeof lsOutput !== 'string' ||
-      (lsOutput.includes(errorMarker) && !lsOutput.includes(REMOTE_CACHE_ROOT))
-    ) {
+    if (typeof lsOutput !== 'string' || (lsOutput.includes(errorMarker) && !lsOutput.includes(REMOTE_CACHE_ROOT))) {
       if (typeof this._areExtendedLsOptionsSupported !== 'boolean') {
-        log.debug(
-          'The current Android API does not support extended ls options. ' +
-            'Defaulting to no-options call',
-        );
+        log.debug('The current Android API does not support extended ls options. Defaulting to no-options call');
       }
       lsOutput = await this.shell([`ls ${REMOTE_CACHE_ROOT} 2>&1 || echo ${errorMarker}`]);
       this._areExtendedLsOptionsSupported = false;
@@ -206,11 +191,7 @@ export async function cacheApk(
  * @param options - The set of installation options.
  * @throws If an unexpected error happens during install.
  */
-export async function install(
-  this: ADB,
-  appPath: string,
-  options: InstallOptions = {},
-): Promise<void> {
+export async function install(this: ADB, appPath: string, options: InstallOptions = {}): Promise<void> {
   if (appPath.endsWith(APKS_EXTENSION)) {
     return await this.installApks(appPath, options);
   }
@@ -218,8 +199,7 @@ export async function install(
   options = cloneDeep(options);
   defaults(options, {
     replace: true,
-    timeout:
-      this.adbExecTimeout === DEFAULT_ADB_EXEC_TIMEOUT ? APK_INSTALL_TIMEOUT : this.adbExecTimeout,
+    timeout: this.adbExecTimeout === DEFAULT_ADB_EXEC_TIMEOUT ? APK_INSTALL_TIMEOUT : this.adbExecTimeout,
     timeoutCapName: 'androidInstallTimeout',
   });
 
@@ -237,9 +217,7 @@ export async function install(
   try {
     const timer = new timing.Timer().start();
     const output = await this.adbExec(installCmd, installOpts);
-    log.info(
-      `The installation of '${path.basename(appPath)}' took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
-    );
+    log.info(`The installation of '${path.basename(appPath)}' took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
     log.debug(`Install command stdout: ${util.truncateString(output, {length: 300})}`);
     if (/\[INSTALL[A-Z_]+FAILED[A-Z_]+\]/.test(output)) {
       if (this.isTestPackageOnlyError(output)) {
@@ -283,11 +261,7 @@ export async function getApplicationInstallState(
     return this.APP_INSTALL_STATE.UNKNOWN;
   }
 
-  const {
-    versionCode: pkgVersionCode,
-    versionName: pkgVersionNameStr,
-    isInstalled,
-  } = await this.getPackageInfo(pkg);
+  const {versionCode: pkgVersionCode, versionName: pkgVersionNameStr, isInstalled} = await this.getPackageInfo(pkg);
   if (!isInstalled) {
     log.debug(`App '${appPath}' is not installed`);
     return this.APP_INSTALL_STATE.NOT_INSTALLED;
@@ -375,10 +349,7 @@ export async function installOrUpgrade(
     if ('name' in apkInfo) {
       pkg = apkInfo.name;
     } else {
-      log.warn(
-        `Cannot determine the package name of '${appPath}'. ` +
-          `Continuing with the install anyway`,
-      );
+      log.warn(`Cannot determine the package name of '${appPath}'. Continuing with the install anyway`);
     }
   }
 
@@ -431,9 +402,7 @@ export async function installOrUpgrade(
     await this.install(appPath, {...options, replace: true});
   } catch (err) {
     const error = err as Error;
-    log.warn(
-      `Cannot install/upgrade '${pkg}' because of '${error.message}'. Trying full reinstall`,
-    );
+    log.warn(`Cannot install/upgrade '${pkg}' because of '${error.message}'. Trying full reinstall`);
     await uninstallPackage();
     await this.install(appPath, {...options, replace: false});
   }
@@ -472,11 +441,7 @@ export async function extractStringsFromApk(
 
     configMarker = await formatConfigMarker(
       async () => {
-        const {stdout} = await exec((this.binaries as StringRecord).aapt as string, [
-          'd',
-          'configurations',
-          appPath,
-        ]);
+        const {stdout} = await exec((this.binaries as StringRecord).aapt as string, ['d', 'configurations', appPath]);
         return util.uniq(stdout.split(os.EOL));
       },
       language,
@@ -492,20 +457,13 @@ export async function extractStringsFromApk(
     apkStrings = parseAaptStrings(stdout, configMarker);
   } catch (e) {
     const err = e as ExecError;
-    log.debug(
-      'Cannot extract resources using aapt. Trying aapt2. ' +
-        `Original error: ${err.stderr || err.message}`,
-    );
+    log.debug(`Cannot extract resources using aapt. Trying aapt2. Original error: ${err.stderr || err.message}`);
 
     await this.initAapt2();
 
     configMarker = await formatConfigMarker(
       async () => {
-        const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, [
-          'd',
-          'configurations',
-          appPath,
-        ]);
+        const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, ['d', 'configurations', appPath]);
         return util.uniq(stdout.split(os.EOL));
       },
       language,
@@ -513,18 +471,13 @@ export async function extractStringsFromApk(
     );
 
     try {
-      const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, [
-        'd',
-        'resources',
-        appPath,
-      ]);
+      const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, ['d', 'resources', appPath]);
       apkStrings = parseAapt2Strings(stdout, configMarker);
     } catch (e) {
       const error = e as Error;
-      throw new Error(
-        `Cannot extract resources from '${originalAppPath}'. ` + `Original error: ${error.message}`,
-        {cause: e},
-      );
+      throw new Error(`Cannot extract resources from '${originalAppPath}'. Original error: ${error.message}`, {
+        cause: e,
+      });
     }
   }
 
@@ -673,9 +626,7 @@ export function parseAapt2Strings(rawOutput: string, configMarker: string): Stri
           lineIndex = idx;
           if (typeof content === 'string') {
             apkStrings[currentResourceId] = [
-              ...(Array.isArray(apkStrings[currentResourceId])
-                ? apkStrings[currentResourceId]
-                : []),
+              ...(Array.isArray(apkStrings[currentResourceId]) ? apkStrings[currentResourceId] : []),
               content,
             ];
           }
@@ -796,14 +747,8 @@ async function formatConfigMarker(
   const configs = await configsGetter();
   log.debug(`Resource configurations: ${JSON.stringify(configs)}`);
   // Assume the 'en' configuration is the default one
-  if (
-    configMarker.toLowerCase().startsWith('en') &&
-    !configs.some((x) => x.trim() === configMarker)
-  ) {
-    log.debug(
-      `Resource configuration name '${configMarker}' is unknown. ` +
-        `Replacing it with '${defaultMarker}'`,
-    );
+  if (configMarker.toLowerCase().startsWith('en') && !configs.some((x) => x.trim() === configMarker)) {
+    log.debug(`Resource configuration name '${configMarker}' is unknown. Replacing it with '${defaultMarker}'`);
     configMarker = defaultMarker;
   } else {
     log.debug(`Selected configuration: '${configMarker}'`);

package/lib/tools/apks-utils.ts

@@ -1,12 +1,14 @@
-import {exec} from 'teen_process';
-import {log} from '../logger.js';
 import path from 'node:path';
+
 import {fs, tempDir, util} from '@appium/support';
-import {LRUCache} from 'lru-cache';
 import AsyncLock from 'async-lock';
+import {LRUCache} from 'lru-cache';
+import {exec} from 'teen_process';
+
 import type {ADB} from '../adb.js';
-import type {InstallMultipleApksOptions, InstallApksOptions, StringRecord} from './types.js';
+import {log} from '../logger.js';
 import {APK_INSTALL_TIMEOUT, buildInstallArgs, getJavaForOs, unzipFile} from '../utils/index.js';
+import type {InstallMultipleApksOptions, InstallApksOptions, StringRecord} from './types.js';
 
 const BASE_APK = 'base-master.apk';
 const LANGUAGE_APK = (lang: string) => `base-${lang}.apk`;
@@ -24,9 +26,7 @@ process.on('exit', () => {
   }
 
   const paths = [...APKS_CACHE.values()];
-  log.debug(
-    `Performing cleanup of ${paths.length} cached .apks ` + util.pluralize('package', paths.length),
-  );
+  log.debug(`Performing cleanup of ${paths.length} cached .apks ` + util.pluralize('package', paths.length));
   for (const appPath of paths) {
     try {
       // Asynchronous calls are not supported in onExit handler
@@ -125,11 +125,7 @@ export async function installMultipleApks(
  * @param options - Installation options
  * @throws {Error} If the .apks bundle cannot be installed
  */
-export async function installApks(
-  this: ADB,
-  apks: string,
-  options: InstallApksOptions = {},
-): Promise<void> {
+export async function installApks(this: ADB, apks: string, options: InstallApksOptions = {}): Promise<void> {
   const {grantPermissions, allowTestPackages, timeout} = options;
 
   const args: string[] = [
@@ -147,10 +143,7 @@ export async function installApks(
     args.push('--allow-test-only');
   }
   const tasks: Promise<any>[] = [
-    this.execBundletool(
-      args,
-      `Cannot install '${path.basename(apks)}' to the device ${this.curDeviceId}`,
-    ),
+    this.execBundletool(args, `Cannot install '${path.basename(apks)}' to the device ${this.curDeviceId}`),
   ];
   if (grantPermissions) {
     tasks.push(this.getApkInfo(apks));
@@ -184,11 +177,7 @@ export async function extractBaseApk(this: ADB, apks: string): Promise<string> {
  * if language split is not enabled for the bundle.
  * @throws {Error} If there was an error while extracting/finding the file
  */
-export async function extractLanguageApk(
-  this: ADB,
-  apks: string,
-  language: string | null = null,
-): Promise<string> {
+export async function extractLanguageApk(this: ADB, apks: string, language: string | null = null): Promise<string> {
   if (language) {
     try {
       return await extractFromApks(apks, ['splits', LANGUAGE_APK(language)]);