appium-android-driver 5.14.7 → 6.0.0

package/build/lib/driver.d.ts

@@ -1,5 +1,19 @@
-export default AndroidDriver;
-export class AndroidDriver extends BaseDriver<any, import("@appium/types").StringRecord, import("@appium/types").StringRecord, import("@appium/types").DefaultCreateSessionResult<any>, void, import("@appium/types").StringRecord> {
+import type { DriverCaps, DriverData, DriverOpts, ExternalDriver, InitialOpts, RouteMatcher, StringRecord, W3CDriverCaps } from '@appium/types';
+import ADB from 'appium-adb';
+import type { default as AppiumChromedriver } from 'appium-chromedriver';
+import { BaseDriver } from 'appium/driver';
+import AndroidBootstrap from './bootstrap';
+import { AndroidDriverConstraints } from './constraints';
+import { helpers } from './helpers';
+export type AndroidDriverCaps = DriverCaps<AndroidDriverConstraints>;
+export type W3CAndroidDriverCaps = W3CDriverCaps<AndroidDriverConstraints>;
+export type AndroidDriverOpts = DriverOpts<AndroidDriverConstraints>;
+export interface AndroidSettings {
+    ignoreUnimportantViews: boolean;
+}
+export type AndroidDriverCreateResult = [string, AndroidDriverCaps];
+type AndroidExternalDriver = ExternalDriver<AndroidDriverConstraints>;
+declare class AndroidDriver<Settings extends AndroidSettings = AndroidSettings, CreateResult = AndroidDriverCreateResult> extends BaseDriver<AndroidDriverConstraints, StringRecord, Settings, CreateResult> implements ExternalDriver<AndroidDriverConstraints, string, StringRecord, Settings, CreateResult> {
     static newMethodMap: {
         readonly '/session/:sessionId/timeouts/implicit_wait': {
             readonly POST: {
@@ -355,14 +369,6 @@ export class AndroidDriver extends BaseDriver<any, import("@appium/types").Strin
                 };
             };
         };
-        readonly '/session/:sessionId/appium/app/end_test_coverage': {
-            readonly POST: {
-                readonly command: "endCoverage";
-                readonly payloadParams: {
-                    readonly required: readonly ["intent", "path"];
-                };
-            };
-        };
         readonly '/session/:sessionId/appium/app/strings': {
             readonly POST: {
                 readonly command: "getStrings";
@@ -388,43 +394,68 @@ export class AndroidDriver extends BaseDriver<any, import("@appium/types").Strin
             };
         };
     };
-    constructor(opts?: {}, shouldValidateCaps?: boolean);
-    desiredCapConstraints: {};
-    sessionChromedrivers: {};
+    jwpProxyAvoid: RouteMatcher[];
+    bootstrap?: AndroidBootstrap;
+    adb?: ADB;
+    unlocker: typeof helpers.unlocker;
+    apkStrings: StringRecord<StringRecord<string>>;
+    proxyReqRes?: (...args: any) => any;
+    contexts?: string[];
+    sessionChromedrivers: StringRecord<AppiumChromedriver>;
+    chromedriver?: AppiumChromedriver;
+    proxyCommand?: AndroidExternalDriver['proxyCommand'];
     jwpProxyActive: boolean;
-    jwpProxyAvoid: (string | RegExp)[][];
-    settings: DeviceSettings<{
-        ignoreUnimportantViews: boolean;
-    }>;
-    chromedriver: any;
-    apkStrings: {};
-    unlocker: typeof import("./unlock-helpers").helpers;
-    curContext: any;
-    createSession(...args: any[]): Promise<(string | import("@appium/types").DriverCaps<any>)[]>;
-    useUnlockHelperApp: boolean | undefined;
-    adb: any;
+    curContext: string;
+    useUnlockHelperApp?: boolean;
+    defaultIME?: string;
+    _wasWindowAnimationDisabled?: boolean;
+    opts: AndroidDriverOpts;
+    constructor(opts?: InitialOpts, shouldValidateCaps?: boolean);
+    createSession(w3cCaps1: W3CAndroidDriverCaps, w3cCaps2?: W3CAndroidDriverCaps, w3cCaps3?: W3CAndroidDriverCaps, driverData?: DriverData[]): Promise<CreateResult>;
     isEmulator(): boolean;
-    setAvdFromCapabilities(caps: any): void;
+    setAvdFromCapabilities(caps: AndroidDriverCaps): void;
     get appOnDevice(): boolean;
     get isChromeSession(): boolean;
-    onSettingsUpdate(key: any, value: any): Promise<void>;
-    startAndroidSession(): Promise<void>;
-    defaultIME: any;
-    _wasWindowAnimationDisabled: boolean | undefined;
-    bootstrap: import("./bootstrap").AndroidBootstrap | null | undefined;
+    onSettingsUpdate(key: keyof Settings, value: any): Promise<void>;
+    startAndroidSession(opts: AndroidDriverOpts): Promise<void>;
     initAutoWebview(): Promise<void>;
     initAUT(): Promise<void>;
     checkAppPresent(): Promise<void>;
     checkPackagePresent(): Promise<void>;
+    /**
+     * Set CompressedLayoutHierarchy on the device
+     * @privateRemarks FIXME: unknown param type
+     */
     setCompressedLayoutHierarchy(compress: any): Promise<void>;
     deleteSession(): Promise<void>;
-    setSharedPreferences(): Promise<boolean>;
+    /**
+     *
+     * @param {AndroidDriverOpts} [opts]
+     */
+    setSharedPreferences(opts: AndroidDriverOpts): Promise<boolean>;
     getPrefsBuilder(): any;
-    validateDesiredCaps(caps: any): boolean;
-    proxyActive(sessionId: any): boolean;
-    getProxyAvoidList(sessionId: any): (string | RegExp)[][];
-    canProxy(sessionId: any): boolean;
+    /**
+     *
+     * @param {any} caps
+     * @returns {caps is AndroidDriverCaps}
+     */
+    validateDesiredCaps(caps: any): caps is AndroidDriverCaps;
+    /**
+     *
+     * @param {string} sessionId
+     */
+    proxyActive(sessionId: string): boolean;
+    /**
+     *
+     * @param {string} sessionId
+     */
+    getProxyAvoidList(sessionId: string): RouteMatcher[];
+    /**
+     *
+     * @param {string} sessionId
+     */
+    canProxy(sessionId: string): boolean;
 }
-import { BaseDriver } from 'appium/driver';
-import { DeviceSettings } from 'appium/driver';
+export { commands as androidCommands } from './commands';
+export { AndroidDriver };
 //# sourceMappingURL=driver.d.ts.map

package/build/lib/driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../lib/driver.js"],"names":[],"mappings":";AAmCA;IAEE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmC;IAEnC,qDA0BC;IAhBC,0BAA+C;IAC/C,yBAA8B;IAC9B,wBAA2B;IAC3B,qCAAsC;IACtC;;OACoE;IACpE,kBAAwB;IACxB,eAAoB;IACpB,oDAAgC;IAOhC,gBAA2C;IAG7C,6FAkIC;IA/FG,wCAA6D;IA8B7D,SASE;IA0DN,sBAEC;IAED,wCAaC;IAED,2BAGC;IAED,+BAEC;IAED,sDAIC;IAED,qCA6EC;IA1EC,gBAA+D;IAoB3D,iDAAuC;IAU3C,qEAA8F;IA8ChG,iCAYC;IAED,yBAwDC;IAED,iCAKC;IAED,qCAKC;IAGD,2DAEC;IAED,+BAwDC;IAED,yCA4BC;IAED,uBAKC;IAED,wCAQC;IAED,qCAIC;IAED,yDAIC;IAED,kCAKC;CACF;2BA9gB0C,eAAe;+BAAf,eAAe"}
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../lib/driver.ts"],"names":[],"mappings":"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"}

package/build/lib/driver.js

@@ -1,24 +1,26 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndroidDriver = void 0;
-const driver_1 = require("appium/driver");
-const desired_caps_1 = __importDefault(require("./desired-caps"));
-const index_1 = __importDefault(require("./commands/index"));
-const method_map_1 = require("./method-map");
-const android_helpers_1 = require("./android-helpers");
-const lodash_1 = __importDefault(require("lodash"));
-const appium_adb_1 = require("appium-adb");
+exports.AndroidDriver = exports.androidCommands = void 0;
 const support_1 = require("@appium/support");
+const appium_adb_1 = require("appium-adb");
+const driver_1 = require("appium/driver");
 const asyncbox_1 = require("asyncbox");
-const shared_preferences_builder_1 = require("shared-preferences-builder");
 const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
+const shared_preferences_builder_1 = require("shared-preferences-builder");
+const constraints_1 = __importDefault(require("./constraints"));
+const helpers_1 = require("./helpers");
+const method_map_1 = require("./method-map");
 const APP_EXTENSION = '.apk';
 const DEVICE_PORT = 4724;
-// This is a set of methods and paths that we never want to proxy to
-// Chromedriver
+/**
+ * This is a set of methods and paths that we never want to proxy to
+ * Chromedriver
+ **/
 const NO_PROXY = [
     ['POST', new RegExp('^/session/[^/]+/context')],
     ['GET', new RegExp('^/session/[^/]+/context')],
@@ -41,29 +43,25 @@ class AndroidDriver extends driver_1.BaseDriver {
             'id',
             'class name',
             'accessibility id',
-            '-android uiautomator'
+            '-android uiautomator',
         ];
-        this.desiredCapConstraints = desired_caps_1.default;
+        this.desiredCapConstraints = lodash_1.default.cloneDeep(constraints_1.default);
         this.sessionChromedrivers = {};
         this.jwpProxyActive = false;
         this.jwpProxyAvoid = lodash_1.default.clone(NO_PROXY);
         this.settings = new driver_1.DeviceSettings({ ignoreUnimportantViews: false }, this.onSettingsUpdate.bind(this));
-        this.chromedriver = null;
         this.apkStrings = {};
-        this.unlocker = android_helpers_1.helpers.unlocker;
-        for (let [cmd, fn] of lodash_1.default.toPairs(index_1.default)) {
-            AndroidDriver.prototype[cmd] = fn;
-        }
-        // needs to be after the line which assigns commands to AndroidDriver.prototype, so that `this.defaultContextName` is defined.
+        this.unlocker = helpers_1.helpers.unlocker;
         this.curContext = this.defaultContextName();
+        this.opts = opts;
     }
-    async createSession(...args) {
+    async createSession(w3cCaps1, w3cCaps2, w3cCaps3, driverData) {
         // the whole createSession flow is surrounded in a try-catch statement
         // if creating a session fails at any point, we teardown everything we
         // set up before throwing the error.
         try {
-            let [sessionId, caps] = await super.createSession(...args);
-            let serverDetails = {
+            const [sessionId, caps] = (await super.createSession(w3cCaps1, w3cCaps2, w3cCaps3, driverData));
+            const serverDetails = {
                 platform: 'LINUX',
                 webStorageEnabled: false,
                 takesScreenshot: true,
@@ -72,11 +70,11 @@ class AndroidDriver extends driver_1.BaseDriver {
                 networkConnectionEnabled: true,
                 locationContextEnabled: false,
                 warnings: {},
-                desired: this.caps
+                desired: this.caps,
             };
             this.caps = Object.assign(serverDetails, this.caps);
             // assigning defaults
-            let defaultOpts = {
+            const defaultOpts = {
                 action: 'android.intent.action.MAIN',
                 category: 'android.intent.category.LAUNCHER',
                 flags: '0x10200000',
@@ -88,33 +86,27 @@ class AndroidDriver extends driver_1.BaseDriver {
                 bootstrapPort: DEVICE_PORT,
                 androidInstallTimeout: 90000,
             };
-            lodash_1.default.defaults(this.opts, defaultOpts);
+            this.opts = { ...defaultOpts, ...this.opts };
             this.useUnlockHelperApp = lodash_1.default.isUndefined(this.caps.unlockType);
-            // not user visible via caps
-            if (this.opts.noReset === true) {
-                this.opts.fullReset = false;
-            }
-            if (this.opts.fullReset === true) {
-                this.opts.noReset = false;
-            }
-            this.opts.fastReset = !this.opts.fullReset && !this.opts.noReset;
-            this.opts.skipUninstall = this.opts.fastReset || this.opts.noReset;
             if (this.isChromeSession) {
-                android_helpers_1.helpers.adjustBrowserSessionCaps(this.opts);
+                helpers_1.helpers.adjustBrowserSessionCaps(this.opts);
             }
             if (this.opts.nativeWebScreenshot) {
                 this.jwpProxyAvoid.push(['GET', new RegExp('^/session/[^/]+/screenshot')]);
             }
+            // @ts-expect-error do not put arbitrary properties on opts
             if (this.opts.reboot) {
                 this.setAvdFromCapabilities(caps);
             }
             // get device udid for this session
-            let { udid, emPort } = await android_helpers_1.helpers.getDeviceInfoFromCaps(this.opts);
+            const { udid, emPort } = await helpers_1.helpers.getDeviceInfoFromCaps(this.opts);
             this.opts.udid = udid;
+            // @ts-expect-error do not put arbitrary properties on opts
             this.opts.emPort = emPort;
             // set up an instance of ADB
-            this.adb = await android_helpers_1.helpers.createADB({
+            this.adb = await helpers_1.helpers.createADB({
                 udid: this.opts.udid,
+                // @ts-expect-error: unknown
                 emPort: this.opts.emPort,
                 adbPort: this.opts.adbPort,
                 suppressKillServer: this.opts.suppressKillServer,
@@ -123,14 +115,16 @@ class AndroidDriver extends driver_1.BaseDriver {
                 adbExecTimeout: this.opts.adbExecTimeout,
                 allowOfflineDevices: this.opts.allowOfflineDevices,
             });
-            if (await this.adb.getApiLevel() >= 23) {
+            if ((await this.adb.getApiLevel()) >= 23) {
                 this.log.warn("Consider setting 'automationName' capability to " +
                     "'uiautomator2' on Android >= 6, since UIAutomator framework " +
                     'is not maintained anymore by the OS vendor.');
             }
+            // @ts-expect-error no arbitrary props on opts
             if (this.helpers.isPackageOrBundle(this.opts.app)) {
                 // user provided package instead of app for 'app' capability, massage options
                 this.opts.appPackage = this.opts.app;
+                // @ts-expect-error no arbitrary props on opts
                 this.opts.app = null;
             }
             if (this.opts.app) {
@@ -152,7 +146,7 @@ class AndroidDriver extends driver_1.BaseDriver {
                     this.log.warn('Sorry, networkSpeed capability is only available for emulators');
                 }
                 else {
-                    const networkSpeed = (0, android_helpers_1.ensureNetworkSpeed)(this.adb, this.opts.networkSpeed);
+                    const networkSpeed = (0, helpers_1.ensureNetworkSpeed)(this.adb, this.opts.networkSpeed);
                     await this.adb.networkSpeed(networkSpeed);
                 }
             }
@@ -180,7 +174,7 @@ class AndroidDriver extends driver_1.BaseDriver {
         }
     }
     isEmulator() {
-        return android_helpers_1.helpers.isEmulator(this.adb, this.opts);
+        return helpers_1.helpers.isEmulator(this.adb, this.opts);
     }
     setAvdFromCapabilities(caps) {
         if (this.opts.avd) {
@@ -189,40 +183,51 @@ class AndroidDriver extends driver_1.BaseDriver {
         else {
             if (!caps.deviceName) {
                 this.log.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
+                throw new Error(); // unreachable
             }
             if (!caps.platformVersion) {
                 this.log.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
+                throw new Error(); // unreachable
             }
-            let avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');
+            const avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');
             this.opts.avd = `${avdDevice}__${caps.platformVersion}`;
         }
     }
     get appOnDevice() {
-        return this.helpers.isPackageOrBundle(this.opts.app) || (!this.opts.app &&
-            this.helpers.isPackageOrBundle(this.opts.appPackage));
+        return (
+        // @ts-expect-error no arbitrary props on opts
+        this.helpers.isPackageOrBundle(this.opts.app) ||
+            // @ts-expect-error no arbitrary props on opts
+            (!this.opts.app && this.helpers.isPackageOrBundle(this.opts.appPackage)));
     }
     get isChromeSession() {
-        return android_helpers_1.helpers.isChromeBrowser(this.opts.browserName);
+        return helpers_1.helpers.isChromeBrowser(String(this.opts.browserName));
     }
     async onSettingsUpdate(key, value) {
         if (key === 'ignoreUnimportantViews') {
             await this.setCompressedLayoutHierarchy(value);
         }
     }
-    async startAndroidSession() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async startAndroidSession(opts) {
         this.log.info(`Starting Android session`);
         // set up the device to run on (real or emulator, etc)
-        this.defaultIME = await android_helpers_1.helpers.initDevice(this.adb, this.opts);
+        this.defaultIME = (await helpers_1.helpers.initDevice(this.adb, this.opts));
         // set actual device name, udid, platform version, screen size, model and manufacturer details.
         this.caps.deviceName = this.adb.curDeviceId;
+        // @ts-expect-error do not put arbitrary properties on caps
         this.caps.deviceUDID = this.opts.udid;
         this.caps.platformVersion = await this.adb.getPlatformVersion();
+        // @ts-expect-error do not put arbitrary properties on caps
         this.caps.deviceScreenSize = await this.adb.getScreenSize();
+        // @ts-expect-error do not put arbitrary properties on caps
         this.caps.deviceModel = await this.adb.getModel();
+        // @ts-expect-error do not put arbitrary properties on caps
         this.caps.deviceManufacturer = await this.adb.getManufacturer();
         if (this.opts.disableWindowAnimation) {
             if (await this.adb.isAnimationOn()) {
-                if (await this.adb.getApiLevel() >= 28) { // API level 28 is Android P
+                if ((await this.adb.getApiLevel()) >= 28) {
+                    // API level 28 is Android P
                     // Don't forget to reset the relaxing in delete session
                     this.log.warn('Relaxing hidden api policy to manage animation scale');
                     await this.adb.setHiddenApiPolicy('1', !!this.opts.ignoreHiddenApiPolicyError);
@@ -238,15 +243,17 @@ class AndroidDriver extends driver_1.BaseDriver {
         // set up app under test
         await this.initAUT();
         // start UiAutomator
-        this.bootstrap = new android_helpers_1.helpers.bootstrap(this.adb, this.opts.bootstrapPort, this.opts.websocket);
-        await this.bootstrap.start(this.opts.appPackage, this.opts.disableAndroidWatchers, this.opts.acceptSslCerts);
+        const bootstrap = (this.bootstrap = new helpers_1.helpers.bootstrap(this.adb, this.opts.bootstrapPort, 
+        // @ts-expect-error do not put arbitrary properties on opts
+        this.opts.websocket));
+        await bootstrap.start(this.opts.appPackage, this.opts.disableAndroidWatchers, this.opts.acceptSslCerts);
         // handling unexpected shutdown
         (async () => {
             try {
-                await this.bootstrap.onUnexpectedShutdown;
+                await bootstrap.onUnexpectedShutdown;
             }
             catch (err) {
-                if (!this.bootstrap.ignoreUnexpectedShutdown) {
+                if (!bootstrap.ignoreUnexpectedShutdown) {
                     await this.startUnexpectedShutdown(err);
                 }
             }
@@ -257,12 +264,14 @@ class AndroidDriver extends driver_1.BaseDriver {
         else {
             this.log.info('Checking for lockscreen presence. ' +
                 `This could be skipped by setting the 'appium:skipUnlock' capability to true.`);
-            await android_helpers_1.helpers.unlock(this, this.adb, this.caps);
+            await helpers_1.helpers.unlock(this, this.adb, this.caps);
         }
         // Set CompressedLayoutHierarchy on the device based on current settings object
         // this has to happen _after_ bootstrap is initialized
         if (this.opts.ignoreUnimportantViews) {
-            await this.settings.update({ ignoreUnimportantViews: this.opts.ignoreUnimportantViews });
+            await this.settings.update({
+                ignoreUnimportantViews: this.opts.ignoreUnimportantViews,
+            });
         }
         if (this.isChromeSession) {
             // start a chromedriver session and proxy to it
@@ -276,14 +285,15 @@ class AndroidDriver extends driver_1.BaseDriver {
         }
         if (support_1.util.hasValue(this.opts.orientation)) {
             this.log.debug(`Setting initial orientation to '${this.opts.orientation}'`);
+            // @ts-expect-error no arbitrary props on opts
             await this.setOrientation(this.opts.orientation);
         }
         await this.initAutoWebview();
     }
     async initAutoWebview() {
         if (this.opts.autoWebview) {
-            let viewName = this.defaultWebviewName();
-            let timeout = (this.opts.autoWebviewTimeout) || 2000;
+            const viewName = this.defaultWebviewName();
+            const timeout = this.opts.autoWebviewTimeout || 2000;
             this.log.info(`Setting auto webview to context '${viewName}' with timeout ${timeout}ms`);
             // try every 500ms until timeout is over
             await (0, asyncbox_1.retryInterval)(timeout / 500, 500, async () => {
@@ -295,26 +305,28 @@ class AndroidDriver extends driver_1.BaseDriver {
         // populate appPackage, appActivity, appWaitPackage, appWaitActivity,
         // and the device being used
         // in the opts and caps (so it gets back to the user on session creation)
-        let launchInfo = await android_helpers_1.helpers.getLaunchInfo(this.adb, this.opts);
+        const launchInfo = await helpers_1.helpers.getLaunchInfo(this.adb, this.opts);
         Object.assign(this.opts, launchInfo);
         Object.assign(this.caps, launchInfo);
         // Uninstall any uninstallOtherPackages which were specified in caps
         if (this.opts.uninstallOtherPackages) {
-            android_helpers_1.helpers.validateDesiredCaps(this.opts);
+            helpers_1.helpers.validateDesiredCaps(this.opts);
             // Only SETTINGS_HELPER_PKG_ID package is used by UIA1
-            await android_helpers_1.helpers.uninstallOtherPackages(this.adb, android_helpers_1.helpers.parseArray(this.opts.uninstallOtherPackages), [android_helpers_1.SETTINGS_HELPER_PKG_ID]);
+            await helpers_1.helpers.uninstallOtherPackages(this.adb, helpers_1.helpers.parseArray(this.opts.uninstallOtherPackages), [helpers_1.SETTINGS_HELPER_PKG_ID]);
         }
         // Install any "otherApps" that were specified in caps
         if (this.opts.otherApps) {
+            /** @type {string[]} */
             let otherApps;
             try {
-                otherApps = android_helpers_1.helpers.parseArray(this.opts.otherApps);
+                otherApps = helpers_1.helpers.parseArray(this.opts.otherApps);
             }
             catch (e) {
                 this.log.errorAndThrow(`Could not parse "otherApps" capability: ${e.message}`);
+                return; // unreachable
             }
             otherApps = await bluebird_1.default.all(otherApps.map((app) => this.helpers.configureApp(app, APP_EXTENSION)));
-            await android_helpers_1.helpers.installOtherApks(otherApps, this.adb, this.opts);
+            await helpers_1.helpers.installOtherApks(otherApps, this.adb, this.opts);
         }
         // install app
         if (!this.opts.app) {
@@ -323,15 +335,15 @@ class AndroidDriver extends driver_1.BaseDriver {
             }
             this.log.debug('No app capability. Assuming it is already on the device');
             if (this.opts.fastReset) {
-                await android_helpers_1.helpers.resetApp(this.adb, this.opts);
+                await helpers_1.helpers.resetApp(this.adb, this.opts);
             }
             return;
         }
         if (!this.opts.skipUninstall) {
             await this.adb.uninstallApk(this.opts.appPackage);
         }
-        await android_helpers_1.helpers.installApk(this.adb, this.opts);
-        const apkStringsForLanguage = await android_helpers_1.helpers.pushStrings(this.opts.language, this.adb, this.opts);
+        await helpers_1.helpers.installApk(this.adb, this.opts);
+        const apkStringsForLanguage = await helpers_1.helpers.pushStrings(this.opts.language, this.adb, this.opts);
         if (this.opts.language) {
             this.apkStrings[this.opts.language] = apkStringsForLanguage;
         }
@@ -343,17 +355,21 @@ class AndroidDriver extends driver_1.BaseDriver {
     }
     async checkAppPresent() {
         this.log.debug('Checking whether app is actually present');
+        // @ts-expect-error do not put arbitrary properties on opts
         if (!(await support_1.fs.exists(this.opts.app))) {
             this.log.errorAndThrow(`Could not find app apk at ${this.opts.app}`);
         }
     }
     async checkPackagePresent() {
         this.log.debug('Checking whether package is present on the device');
-        if (!(await this.adb.shell(['pm', 'list', 'packages', this.opts.appPackage]))) {
+        if (!(await this.adb.shell(['pm', 'list', 'packages', String(this.opts.appPackage)]))) {
             this.log.errorAndThrow(`Could not find package ${this.opts.appPackage} on the device`);
         }
     }
-    // Set CompressedLayoutHierarchy on the device
+    /**
+     * Set CompressedLayoutHierarchy on the device
+     * @privateRemarks FIXME: unknown param type
+     */
     async setCompressedLayoutHierarchy(compress) {
         await this.bootstrap.sendAction('compressedLayoutHierarchy', { compressLayout: compress });
     }
@@ -365,7 +381,7 @@ class AndroidDriver extends driver_1.BaseDriver {
             }
         }
         catch (ign) { }
-        await android_helpers_1.helpers.removeAllSessionWebSocketHandlers(this.server, this.sessionId);
+        await helpers_1.helpers.removeAllSessionWebSocketHandlers(this.server, this.sessionId);
         await this.mobileStopScreenStreaming();
         await super.deleteSession();
         if (this.bootstrap) {
@@ -383,7 +399,7 @@ class AndroidDriver extends driver_1.BaseDriver {
                 await this.adb?.uninstallApk(this.opts.appPackage);
             }
             await this.bootstrap.shutdown();
-            this.bootstrap = null;
+            this.bootstrap = undefined;
         }
         else {
             this.log.debug("Called deleteSession but bootstrap wasn't active");
@@ -398,29 +414,36 @@ class AndroidDriver extends driver_1.BaseDriver {
             this.log.info('Restoring window animation state');
             await this.adb?.setAnimationState(true);
             // This was necessary to change animation scale over Android P. We must reset the policy for the security.
-            if (await this.adb?.getApiLevel() >= 28) {
+            if (this.adb && (await this.adb.getApiLevel()) >= 28) {
                 this.log.info('Restoring hidden api policy to the device default configuration');
                 await this.adb?.setDefaultHiddenApiPolicy(!!this.opts.ignoreHiddenApiPolicyError);
             }
         }
+        // @ts-expect-error do not put arbitrary properties on opts
         if (this.opts.reboot) {
-            let avdName = this.opts.avd.replace('@', '');
+            // @ts-expect-error do not put arbitrary properties on opts
+            const avdName = this.opts.avd.replace('@', '');
             this.log.debug(`closing emulator '${avdName}'`);
             await this.adb?.killEmulator(avdName);
         }
     }
-    async setSharedPreferences() {
-        let sharedPrefs = this.opts.sharedPreferences;
+    /**
+     *
+     * @param {AndroidDriverOpts} [opts]
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setSharedPreferences(opts) {
+        const sharedPrefs = this.opts.sharedPreferences;
         this.log.info('Trying to set shared preferences');
-        let name = sharedPrefs.name;
+        const name = sharedPrefs.name;
         if (lodash_1.default.isUndefined(name)) {
             this.log.warn(`Skipping setting Shared preferences, name is undefined: ${JSON.stringify(sharedPrefs)}`);
             return false;
         }
-        let remotePath = `/data/data/${this.opts.appPackage}/shared_prefs`;
-        let remoteFile = `${remotePath}/${name}.xml`;
-        let localPath = `/tmp/${name}.xml`;
-        let builder = this.getPrefsBuilder();
+        const remotePath = `/data/data/${this.opts.appPackage}/shared_prefs`;
+        const remoteFile = `${remotePath}/${name}.xml`;
+        const localPath = `/tmp/${name}.xml`;
+        const builder = this.getPrefsBuilder();
         builder.build(sharedPrefs.prefs);
         this.log.info(`Creating temporary shared preferences: ${localPath}`);
         builder.toFile(localPath);
@@ -442,26 +465,45 @@ class AndroidDriver extends driver_1.BaseDriver {
     getPrefsBuilder() {
         /* Add this method to create a new SharedPrefsBuilder instead of
          * directly creating the object on setSharedPreferences for testing purposes
-        */
+         */
         return new shared_preferences_builder_1.SharedPrefsBuilder();
     }
+    /**
+     *
+     * @param {any} caps
+     * @returns {caps is AndroidDriverCaps}
+     */
     validateDesiredCaps(caps) {
         if (!super.validateDesiredCaps(caps)) {
             return false;
         }
-        if ((!caps.browserName || !android_helpers_1.helpers.isChromeBrowser(caps.browserName)) && !caps.app && !caps.appPackage) {
+        if ((!caps.browserName || !helpers_1.helpers.isChromeBrowser(caps.browserName)) &&
+            !caps.app &&
+            !caps.appPackage) {
             this.log.errorAndThrow('The desired capabilities must include either an app, appPackage or browserName');
         }
-        return android_helpers_1.helpers.validateDesiredCaps(caps);
+        return helpers_1.helpers.validateDesiredCaps(caps);
     }
+    /**
+     *
+     * @param {string} sessionId
+     */
     proxyActive(sessionId) {
         super.proxyActive(sessionId);
         return this.jwpProxyActive;
     }
+    /**
+     *
+     * @param {string} sessionId
+     */
     getProxyAvoidList(sessionId) {
         super.getProxyAvoidList(sessionId);
         return this.jwpProxyAvoid;
     }
+    /**
+     *
+     * @param {string} sessionId
+     */
     canProxy(sessionId) {
         super.canProxy(sessionId);
         // this will change depending on ChromeDriver status
@@ -470,5 +512,6 @@ class AndroidDriver extends driver_1.BaseDriver {
 }
 exports.AndroidDriver = AndroidDriver;
 AndroidDriver.newMethodMap = method_map_1.newMethodMap;
-exports.default = AndroidDriver;
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "androidCommands", { enumerable: true, get: function () { return commands_1.commands; } });
 //# sourceMappingURL=driver.js.map