appium-adb 14.1.0 → 14.1.2

package/lib/tools/apk-utils.ts

@@ -1,17 +1,19 @@
 import {
-  APKS_EXTENSION, buildInstallArgs,
-  APK_INSTALL_TIMEOUT, DEFAULT_ADB_EXEC_TIMEOUT,
-  readPackageManifest
+  APKS_EXTENSION,
+  buildInstallArgs,
+  APK_INSTALL_TIMEOUT,
+  DEFAULT_ADB_EXEC_TIMEOUT,
+  readPackageManifest,
 } from '../helpers.js';
-import { exec, type ExecError } from 'teen_process';
-import { log } from '../logger.js';
+import {exec, type ExecError} from 'teen_process';
+import {log} from '../logger.js';
 import path from 'path';
 import _ from 'lodash';
-import { fs, util, mkdirp, timing } from '@appium/support';
+import {fs, util, mkdirp, timing} from '@appium/support';
 import * as semver from 'semver';
 import os from 'os';
-import { LRUCache } from 'lru-cache';
-import type { ADB } from '../adb.js';
+import {LRUCache} from 'lru-cache';
+import type {ADB} from '../adb.js';
 import type {
   UninstallOptions,
   ShellExecOptions,
@@ -22,7 +24,7 @@ import type {
   ApkStrings,
   AppInfo,
   InstallState,
-  StringRecord
+  StringRecord,
 } from './types.js';
 
 export const REMOTE_CACHE_ROOT = '/data/local/tmp/appium_cache';
@@ -35,9 +37,13 @@ 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)) {
+  if (!options.skipInstallCheck && !(await this.isAppInstalled(pkg))) {
     log.info(`${pkg} was not uninstalled, because it was not present on the device`);
     return false;
   }
@@ -72,7 +78,11 @@ export async function uninstallApk (this: ADB, pkg: string, options: UninstallOp
  * @param opts - Additional exec options.
  * @throws If there was a failure during application install.
  */
-export async function installFromDevicePath (this: ADB, apkPathOnDevice: string, opts: ShellExecOptions = {}): Promise<void> {
+export async function installFromDevicePath(
+  this: ADB,
+  apkPathOnDevice: string,
+  opts: ShellExecOptions = {},
+): Promise<void> {
   const stdout = await this.shell(['pm', 'install', '-r', apkPathOnDevice], opts);
   if (stdout.includes('Failure')) {
     throw new Error(`Remote install failed: ${stdout}`);
@@ -87,7 +97,11 @@ export async function installFromDevicePath (this: ADB, apkPathOnDevice: string,
  * @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[] = [];
@@ -95,13 +109,21 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
   try {
     const errorMarker = '_ERROR_';
     let lsOutput: string | null = null;
-    if (this._areExtendedLsOptionsSupported === true || !_.isBoolean(this._areExtendedLsOptionsSupported)) {
+    if (
+      this._areExtendedLsOptionsSupported === true ||
+      !_.isBoolean(this._areExtendedLsOptionsSupported)
+    ) {
       lsOutput = await this.shell([`ls -t -1 ${REMOTE_CACHE_ROOT} 2>&1 || echo ${errorMarker}`]);
     }
-    if (!_.isString(lsOutput) || (lsOutput.includes(errorMarker) && !lsOutput.includes(REMOTE_CACHE_ROOT))) {
+    if (
+      !_.isString(lsOutput) ||
+      (lsOutput.includes(errorMarker) && !lsOutput.includes(REMOTE_CACHE_ROOT))
+    ) {
       if (!_.isBoolean(this._areExtendedLsOptionsSupported)) {
-        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;
@@ -111,15 +133,18 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
     if (lsOutput.includes(errorMarker)) {
       throw new Error(lsOutput.substring(0, lsOutput.indexOf(errorMarker)));
     }
-    remoteCachedFiles.push(...(
-      lsOutput.split('\n')
+    remoteCachedFiles.push(
+      ...lsOutput
+        .split('\n')
         .map((x) => x.trim())
-        .filter(Boolean)
-    ));
+        .filter(Boolean),
+    );
   } catch (e) {
     const err = e as Error;
-    log.debug(`Got an error '${err.message.trim()}' while getting the list of files in the cache. ` +
-      `Assuming the cache does not exist yet`);
+    log.debug(
+      `Got an error '${err.message.trim()}' while getting the list of files in the cache. ` +
+        `Assuming the cache does not exist yet`,
+    );
     await this.shell(['mkdir', '-p', REMOTE_CACHE_ROOT]);
   }
   log.debug(`The count of applications in the cache: ${remoteCachedFiles.length}`);
@@ -136,8 +161,10 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
     const timer = new timing.Timer().start();
     await this.push(apkPath, remotePath, {timeout: options.timeout});
     const {size} = await fs.stat(apkPath);
-    log.info(`The upload of '${path.basename(apkPath)}' (${util.toReadableSizeString(size)}) ` +
-      `took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+    log.info(
+      `The upload of '${path.basename(apkPath)}' (${util.toReadableSizeString(size)}) ` +
+        `took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
+    );
   }
   if (!this.remoteAppsCache) {
     this.remoteAppsCache = new LRUCache({
@@ -145,8 +172,9 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
     });
   }
   // Cleanup the invalid entries from the cache
-  _.difference([...this.remoteAppsCache.keys()], remoteCachedFiles.map(toHash))
-    .forEach((hash) => (this.remoteAppsCache as LRUCache<string, string>).delete(hash));
+  _.difference([...this.remoteAppsCache.keys()], remoteCachedFiles.map(toHash)).forEach((hash) =>
+    (this.remoteAppsCache as LRUCache<string, string>).delete(hash),
+  );
   // Bump the cache record for the recently cached item
   this.remoteAppsCache.set(appHash, remotePath);
   // If the remote cache exceeds this.remoteAppsCacheLimit, remove the least recently used entries
@@ -160,8 +188,10 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
       log.debug(`Deleted ${entriesToCleanup.length} expired application cache entries`);
     } catch (e) {
       const err = e as Error;
-      log.warn(`Cannot delete ${entriesToCleanup.length} expired application cache entries. ` +
-        `Original error: ${err.message}`);
+      log.warn(
+        `Cannot delete ${entriesToCleanup.length} expired application cache entries. ` +
+          `Original error: ${err.message}`,
+      );
     }
   }
   return remotePath;
@@ -174,7 +204,11 @@ export async function cacheApk (this: ADB, apkPath: string, options: CachingOpti
  * @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);
   }
@@ -182,12 +216,13 @@ export async function install (this: ADB, appPath: string, options: InstallOptio
   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',
   });
 
   const installArgs = buildInstallArgs(await this.getApiLevel(), options);
-  if (options.noIncremental && await this.isIncrementalInstallSupported()) {
+  if (options.noIncremental && (await this.isIncrementalInstallSupported())) {
     // Adb throws an error if it does not know about an arg,
     // which is the case here for older adb versions.
     installArgs.push('--no-incremental');
@@ -196,19 +231,17 @@ export async function install (this: ADB, appPath: string, options: InstallOptio
     timeout: options.timeout,
     timeoutCapName: options.timeoutCapName,
   };
-  const installCmd = [
-    'install',
-    ...installArgs,
-    appPath,
-  ];
+  const installCmd = ['install', ...installArgs, appPath];
   let performAppInstall = async () => await this.adbExec(installCmd, installOpts);
   // this.remoteAppsCacheLimit <= 0 means no caching should be applied
   let shouldCacheApp = (this.remoteAppsCacheLimit as number) > 0;
   if (shouldCacheApp) {
     shouldCacheApp = !(await this.isStreamedInstallSupported());
     if (!shouldCacheApp) {
-      log.info(`The application at '${appPath}' will not be cached, because the device under test has ` +
-        `confirmed the support of streamed installs`);
+      log.info(
+        `The application at '${appPath}' will not be cached, because the device under test has ` +
+          `confirmed the support of streamed installs`,
+      );
     }
   }
   if (shouldCacheApp) {
@@ -216,25 +249,31 @@ export async function install (this: ADB, appPath: string, options: InstallOptio
       log.info(`Clearing the cache at '${REMOTE_CACHE_ROOT}'`);
       await this.shell(['rm', '-rf', `${REMOTE_CACHE_ROOT}/*`]);
     };
-    const cacheApp = async () => await this.cacheApk(appPath, {
-      timeout: options.timeout,
-    });
+    const cacheApp = async () =>
+      await this.cacheApk(appPath, {
+        timeout: options.timeout,
+      });
     try {
       const cachedAppPath = await cacheApp();
       performAppInstall = async () => {
         const pmInstallCmdByRemotePath = (remotePath: string) => [
-          'pm', 'install',
+          'pm',
+          'install',
           ...installArgs,
           remotePath,
         ];
         const output = await this.shell(pmInstallCmdByRemotePath(cachedAppPath), installOpts);
         // https://github.com/appium/appium/issues/13970
         if (/\bINSTALL_FAILED_INSUFFICIENT_STORAGE\b/.test(output)) {
-          log.warn(`There was a failure while installing '${appPath}' ` +
-            `because of the insufficient device storage space`);
+          log.warn(
+            `There was a failure while installing '${appPath}' ` +
+              `because of the insufficient device storage space`,
+          );
           await clearCache();
-          log.info(`Consider decreasing the maximum amount of cached apps ` +
-            `(currently ${this.remoteAppsCacheLimit}) to avoid such issues in the future`);
+          log.info(
+            `Consider decreasing the maximum amount of cached apps ` +
+              `(currently ${this.remoteAppsCacheLimit}) to avoid such issues in the future`,
+          );
           const newCachedAppPath = await cacheApp();
           return await this.shell(pmInstallCmdByRemotePath(newCachedAppPath), installOpts);
         }
@@ -251,9 +290,13 @@ export async function install (this: ADB, appPath: string, options: InstallOptio
   try {
     const timer = new timing.Timer().start();
     const output = await performAppInstall();
-    log.info(`The installation of '${path.basename(appPath)}' took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
-    const truncatedOutput = (!_.isString(output) || output.length <= 300) ?
-      output : `${output.substring(0, 150)}...${output.substring(output.length - 150)}`;
+    log.info(
+      `The installation of '${path.basename(appPath)}' took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
+    );
+    const truncatedOutput =
+      !_.isString(output) || output.length <= 300
+        ? output
+        : `${output.substring(0, 150)}...${output.substring(output.length - 150)}`;
     log.debug(`Install command stdout: ${truncatedOutput}`);
     if (/\[INSTALL[A-Z_]+FAILED[A-Z_]+\]/.test(output)) {
       if (this.isTestPackageOnlyError(output)) {
@@ -282,7 +325,11 @@ export async function install (this: ADB, appPath: string, options: InstallOptio
  * try to extract it on its own
  * @returns One of `APP_INSTALL_STATE` constants
  */
-export async function getApplicationInstallState (this: ADB, appPath: string, pkg: string | null = null): Promise<InstallState> {
+export async function getApplicationInstallState(
+  this: ADB,
+  appPath: string,
+  pkg: string | null = null,
+): Promise<InstallState> {
   let apkInfo: AppInfo | null = null;
   if (!pkg) {
     apkInfo = (await this.getApkInfo(appPath)) as AppInfo;
@@ -319,30 +366,48 @@ export async function getApplicationInstallState (this: ADB, appPath: string, pk
   }
   if (_.isInteger(apkVersionCode) && _.isInteger(pkgVersionCode)) {
     if ((pkgVersionCode as number) > (apkVersionCode as number)) {
-      log.debug(`The version code of the installed '${pkg}' is greater than the application version code (${pkgVersionCode} > ${apkVersionCode})`);
+      log.debug(
+        `The version code of the installed '${pkg}' is greater than the application version code (${pkgVersionCode} > ${apkVersionCode})`,
+      );
       return this.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED;
     }
     // Version codes might not be maintained. Check version names.
     if (pkgVersionCode === apkVersionCode) {
-      if (_.isString(apkVersionName) && _.isString(pkgVersionName) && semver.satisfies(pkgVersionName, `>=${apkVersionName}`)) {
-        log.debug(`The version name of the installed '${pkg}' is greater or equal to the application version name ('${pkgVersionName}' >= '${apkVersionName}')`);
+      if (
+        _.isString(apkVersionName) &&
+        _.isString(pkgVersionName) &&
+        semver.satisfies(pkgVersionName, `>=${apkVersionName}`)
+      ) {
+        log.debug(
+          `The version name of the installed '${pkg}' is greater or equal to the application version name ('${pkgVersionName}' >= '${apkVersionName}')`,
+        );
         return semver.satisfies(pkgVersionName, `>${apkVersionName}`)
           ? this.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED
           : this.APP_INSTALL_STATE.SAME_VERSION_INSTALLED;
       }
       if (!_.isString(apkVersionName) || !_.isString(pkgVersionName)) {
-        log.debug(`The version name of the installed '${pkg}' is equal to application version name (${pkgVersionCode} === ${apkVersionCode})`);
+        log.debug(
+          `The version name of the installed '${pkg}' is equal to application version name (${pkgVersionCode} === ${apkVersionCode})`,
+        );
         return this.APP_INSTALL_STATE.SAME_VERSION_INSTALLED;
       }
     }
-  } else if (_.isString(apkVersionName) && _.isString(pkgVersionName) && semver.satisfies(pkgVersionName, `>=${apkVersionName}`)) {
-    log.debug(`The version name of the installed '${pkg}' is greater or equal to the application version name ('${pkgVersionName}' >= '${apkVersionName}')`);
+  } else if (
+    _.isString(apkVersionName) &&
+    _.isString(pkgVersionName) &&
+    semver.satisfies(pkgVersionName, `>=${apkVersionName}`)
+  ) {
+    log.debug(
+      `The version name of the installed '${pkg}' is greater or equal to the application version name ('${pkgVersionName}' >= '${apkVersionName}')`,
+    );
     return semver.satisfies(pkgVersionName, `>${apkVersionName}`)
       ? this.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED
       : this.APP_INSTALL_STATE.SAME_VERSION_INSTALLED;
   }
 
-  log.debug(`The installed '${pkg}' package is older than '${appPath}' (${pkgVersionCode} < ${apkVersionCode} or '${pkgVersionName}' < '${apkVersionName}')'`);
+  log.debug(
+    `The installed '${pkg}' package is older than '${appPath}' (${pkgVersionCode} < ${apkVersionCode} or '${pkgVersionName}' < '${apkVersionName}')'`,
+  );
   return this.APP_INSTALL_STATE.OLDER_VERSION_INSTALLED;
 }
 
@@ -356,7 +421,12 @@ export async function getApplicationInstallState (this: ADB, appPath: string, pk
  * @param options - Set of install options.
  * @throws If an unexpected error happens during install.
  */
-export async function installOrUpgrade (this: ADB, appPath: string, pkg: string | null = null, options: InstallOrUpgradeOptions = {}): Promise<InstallOrUpgradeResult> {
+export async function installOrUpgrade(
+  this: ADB,
+  appPath: string,
+  pkg: string | null = null,
+  options: InstallOrUpgradeOptions = {},
+): Promise<InstallOrUpgradeResult> {
   if (!pkg) {
     const apkInfo = await this.getApkInfo(appPath);
     if ('name' in apkInfo) {
@@ -364,18 +434,16 @@ export async function installOrUpgrade (this: ADB, appPath: string, pkg: string
     } else {
       log.warn(
         `Cannot determine the package name of '${appPath}'. ` +
-        `Continuing with the install anyway`
+          `Continuing with the install anyway`,
       );
     }
   }
 
-  const {
-    enforceCurrentBuild,
-  } = options;
+  const {enforceCurrentBuild} = options;
   const appState = await this.getApplicationInstallState(appPath, pkg);
   let wasUninstalled = false;
   const uninstallPackage = async () => {
-    if (!await this.uninstallApk(pkg as string, {skipInstallCheck: true})) {
+    if (!(await this.uninstallApk(pkg as string, {skipInstallCheck: true}))) {
       throw new Error(`'${pkg}' package cannot be uninstalled`);
     }
     wasUninstalled = true;
@@ -420,7 +488,9 @@ export async function installOrUpgrade (this: ADB, appPath: string, pkg: string
     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});
   }
@@ -440,11 +510,11 @@ export async function installOrUpgrade (this: ADB, appPath: string, pkg: string
  * store the extracted file to. If not provided then the `localPath` property in the returned object
  * will be undefined.
  */
-export async function extractStringsFromApk (
+export async function extractStringsFromApk(
   this: ADB,
   appPath: string,
   language: string | null = null,
-  outRoot: string | null = null
+  outRoot: string | null = null,
 ): Promise<ApkStrings> {
   log.debug(`Extracting strings from for language: ${language || 'default'}`);
   const originalAppPath = appPath;
@@ -457,49 +527,73 @@ export async function extractStringsFromApk (
   try {
     await this.initAapt();
 
-    configMarker = await formatConfigMarker(async () => {
-      const {stdout} = await exec((this.binaries as StringRecord).aapt as string, [
-        'd', 'configurations', appPath,
-      ]);
-      return _.uniq(stdout.split(os.EOL));
-    }, language, '(default)');
+    configMarker = await formatConfigMarker(
+      async () => {
+        const {stdout} = await exec((this.binaries as StringRecord).aapt as string, [
+          'd',
+          'configurations',
+          appPath,
+        ]);
+        return _.uniq(stdout.split(os.EOL));
+      },
+      language,
+      '(default)',
+    );
 
     const {stdout} = await exec((this.binaries as StringRecord).aapt as string, [
-      'd', '--values', 'resources', appPath,
+      'd',
+      '--values',
+      'resources',
+      appPath,
     ]);
     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,
-      ]);
-      return _.uniq(stdout.split(os.EOL));
-    }, language, '');
+    configMarker = await formatConfigMarker(
+      async () => {
+        const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, [
+          'd',
+          'configurations',
+          appPath,
+        ]);
+        return _.uniq(stdout.split(os.EOL));
+      },
+      language,
+      '',
+    );
 
     try {
       const {stdout} = await exec((this.binaries as StringRecord).aapt2 as string, [
-        'd', 'resources', appPath,
+        '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}`);
+      throw new Error(
+        `Cannot extract resources from '${originalAppPath}'. ` + `Original error: ${error.message}`,
+      );
     }
   }
 
   if (_.isEmpty(apkStrings)) {
-    log.warn(`No strings have been found in '${originalAppPath}' resources ` +
-      `for '${configMarker || 'default'}' configuration`);
+    log.warn(
+      `No strings have been found in '${originalAppPath}' resources ` +
+        `for '${configMarker || 'default'}' configuration`,
+    );
   } else {
-    log.info(`Successfully extracted ${_.keys(apkStrings).length} strings from ` +
-      `'${originalAppPath}' resources for '${configMarker || 'default'}' configuration`);
+    log.info(
+      `Successfully extracted ${_.keys(apkStrings).length} strings from ` +
+        `'${originalAppPath}' resources for '${configMarker || 'default'}' configuration`,
+    );
   }
 
   if (!outRoot) {
@@ -519,8 +613,8 @@ export async function extractStringsFromApk (
  *                           file system.
  * @returns The parsed application information.
  */
-export async function getApkInfo (this: ADB, appPath: string): Promise<AppInfo | {}> {
-  if (!await fs.exists(appPath)) {
+export async function getApkInfo(this: ADB, appPath: string): Promise<AppInfo | {}> {
+  if (!(await fs.exists(appPath))) {
     throw new Error(`The file at path ${appPath} does not exist or is not accessible`);
   }
 
@@ -554,7 +648,11 @@ export async function getApkInfo (this: ADB, appPath: string): Promise<AppInfo |
  * @param defaultMarker The default config marker value
  * @returns The formatted config marker
  */
-async function formatConfigMarker (configsGetter: () => Promise<string[]>, desiredMarker: string | null, defaultMarker: string): Promise<string> {
+async function formatConfigMarker(
+  configsGetter: () => Promise<string[]>,
+  desiredMarker: string | null,
+  defaultMarker: string,
+): Promise<string> {
   let configMarker = desiredMarker || defaultMarker;
   if (configMarker.includes('-') && !configMarker.includes('-r')) {
     configMarker = configMarker.replace('-', '-r');
@@ -562,10 +660,14 @@ async function formatConfigMarker (configsGetter: () => Promise<string[]>, desir
   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}'`);
@@ -583,9 +685,9 @@ async function formatConfigMarker (configsGetter: () => Promise<string[]>, desir
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
-export function parseAapt2Strings (rawOutput: string, configMarker: string): StringRecord {
+export function parseAapt2Strings(rawOutput: string, configMarker: string): StringRecord {
   const allLines = rawOutput.split(os.EOL);
-  function extractContent (startIdx: number): [string | null, number] {
+  function extractContent(startIdx: number): [string | null, number] {
     let idx = startIdx;
     const startCharPos = allLines[startIdx].indexOf('"');
     if (startCharPos < 0) {
@@ -597,15 +699,9 @@ export function parseAapt2Strings (rawOutput: string, configMarker: string): Str
       if (terminationCharMatch) {
         const terminationCharPos = terminationCharMatch.index;
         if (startIdx === idx) {
-          return [
-            allLines[idx].substring(startCharPos + 1, terminationCharPos),
-            idx
-          ];
+          return [allLines[idx].substring(startCharPos + 1, terminationCharPos), idx];
         }
-        return [
-          `${result}\\n${_.trimStart(allLines[idx].substring(0, terminationCharPos))}`,
-          idx,
-        ];
+        return [`${result}\\n${_.trimStart(allLines[idx].substring(0, terminationCharPos))}`, idx];
       }
       if (idx > startIdx) {
         result += `\\n${_.trimStart(allLines[idx])}`;
@@ -670,7 +766,9 @@ export function parseAapt2Strings (rawOutput: string, configMarker: string): Str
           lineIndex = idx;
           if (_.isString(content)) {
             apkStrings[currentResourceId] = [
-              ...(Array.isArray(apkStrings[currentResourceId]) ? apkStrings[currentResourceId] : []),
+              ...(Array.isArray(apkStrings[currentResourceId])
+                ? apkStrings[currentResourceId]
+                : []),
               content,
             ];
           }
@@ -699,7 +797,7 @@ export function parseAapt2Strings (rawOutput: string, configMarker: string): Str
  * values are represented as arrays. If no config found for the
  * given marker then an empty mapping is returned.
  */
-export function parseAaptStrings (rawOutput: string, configMarker: string): StringRecord {
+export function parseAaptStrings(rawOutput: string, configMarker: string): StringRecord {
   const normalizeStringMatch = function (s: string) {
     return s.replace(/"$/, '').replace(/^"/, '').replace(/\\"/g, '"');
   };
@@ -770,4 +868,3 @@ export function parseAaptStrings (rawOutput: string, configMarker: string): Stri
 }
 
 // #endregion
-