appium-adb 14.1.2 → 14.1.4

package/lib/tools/{keyboard-commands.js → keyboard-commands.ts}

@@ -2,6 +2,8 @@ import {log} from '../logger.js';
 import _ from 'lodash';
 import {waitForCondition} from 'asyncbox';
 import B from 'bluebird';
+import type {ADB} from '../adb.js';
+import type {KeyboardState} from './types.js';
 
 const KEYCODE_ESC = 111;
 const KEYCODE_BACK = 4;
@@ -10,14 +12,15 @@ const KEYCODE_BACK = 4;
  * Hides software keyboard if it is visible.
  * Noop if the keyboard is already hidden.
  *
- * @this {import('../adb.js').ADB}
- * @param {number} [timeoutMs=1000] For how long to wait (in milliseconds)
+ * @param timeoutMs - For how long to wait (in milliseconds)
  * until the keyboard is actually hidden.
- * @returns {Promise<boolean>} `false` if the keyboard was already hidden
+ * @returns `false` if the keyboard was already hidden
  * @throws {Error} If the keyboard cannot be hidden.
  */
-export async function hideKeyboard(timeoutMs = 1000) {
-  let {isKeyboardShown, canCloseKeyboard} = await this.isSoftKeyboardPresent();
+export async function hideKeyboard(this: ADB, timeoutMs: number = 1000): Promise<boolean> {
+  const keyboardState = await this.isSoftKeyboardPresent();
+  let {isKeyboardShown} = keyboardState;
+  const {canCloseKeyboard} = keyboardState;
   if (!isKeyboardShown) {
     log.info('Keyboard has no UI; no closing necessary');
     return false;
@@ -43,10 +46,9 @@ export async function hideKeyboard(timeoutMs = 1000) {
 /**
  * Retrieve the state of the software keyboard on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').KeyboardState>} The keyboard state.
+ * @return The keyboard state.
  */
-export async function isSoftKeyboardPresent() {
+export async function isSoftKeyboardPresent(this: ADB): Promise<KeyboardState> {
   try {
     const stdout = await this.shell(['dumpsys', 'input_method']);
     const inputShownMatch = /mInputShown=(\w+)/.exec(stdout);
@@ -56,17 +58,16 @@ export async function isSoftKeyboardPresent() {
       canCloseKeyboard: !!(inputViewShownMatch && inputViewShownMatch[1] === 'true'),
     };
   } catch (e) {
-    throw new Error(`Error finding softkeyboard. Original error: ${e.message}`);
+    throw new Error(`Error finding softkeyboard. Original error: ${(e as Error).message}`);
   }
 }
 
 /**
  * Send the particular keycode to the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string|number} keycode - The actual key code to be sent.
+ * @param keycode - The actual key code to be sent.
  */
-export async function keyevent(keycode) {
+export async function keyevent(this: ADB, keycode: string | number): Promise<void> {
   // keycode must be an int.
   const code = parseInt(`${keycode}`, 10);
   await this.shell(['input', 'keyevent', `${code}`]);
@@ -75,14 +76,13 @@ export async function keyevent(keycode) {
 /**
  * Retrieve the list of available input methods (IMEs) for the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string[]>} The list of IME names or an empty list.
+ * @return The list of IME names or an empty list.
  */
-export async function availableIMEs() {
+export async function availableIMEs(this: ADB): Promise<string[]> {
   try {
     return getIMEListFromOutput(await this.shell(['ime', 'list', '-a']));
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     throw new Error(`Error getting available IME's. Original error: ${err.message}`);
   }
 }
@@ -90,14 +90,13 @@ export async function availableIMEs() {
 /**
  * Retrieve the list of enabled input methods (IMEs) for the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string[]>} The list of enabled IME names or an empty list.
+ * @return The list of enabled IME names or an empty list.
  */
-export async function enabledIMEs() {
+export async function enabledIMEs(this: ADB): Promise<string[]> {
   try {
     return getIMEListFromOutput(await this.shell(['ime', 'list']));
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     throw new Error(`Error getting enabled IME's. Original error: ${err.message}`);
   }
 }
@@ -105,48 +104,44 @@ export async function enabledIMEs() {
 /**
  * Enable the particular input method on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} imeId - One of existing IME ids.
+ * @param imeId - One of existing IME ids.
  */
-export async function enableIME(imeId) {
+export async function enableIME(this: ADB, imeId: string): Promise<void> {
   await this.shell(['ime', 'enable', imeId]);
 }
 
 /**
  * Disable the particular input method on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} imeId - One of existing IME ids.
+ * @param imeId - One of existing IME ids.
  */
-export async function disableIME(imeId) {
+export async function disableIME(this: ADB, imeId: string): Promise<void> {
   await this.shell(['ime', 'disable', imeId]);
 }
 
 /**
  * Set the particular input method on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} imeId - One of existing IME ids.
+ * @param imeId - One of existing IME ids.
  */
-export async function setIME(imeId) {
+export async function setIME(this: ADB, imeId: string): Promise<void> {
   await this.shell(['ime', 'set', imeId]);
 }
 
 /**
  * Get the default input method on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string|null>} The name of the default input method
+ * @return The name of the default input method
  */
-export async function defaultIME() {
+export async function defaultIME(this: ADB): Promise<string | null> {
   try {
-    let engine = await this.getSetting('secure', 'default_input_method');
+    const engine = await this.getSetting('secure', 'default_input_method');
     if (engine === 'null') {
       return null;
     }
     return engine.trim();
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     throw new Error(`Error getting default IME. Original error: ${err.message}`);
   }
 }
@@ -156,18 +151,17 @@ export async function defaultIME() {
  * The text gets properly escaped before being passed to ADB.
  * Noop if the text is empty.
  *
- * @this {import('../adb.js').ADB}
- * @param {string|number} text - The actual text to be sent.
+ * @param text - The actual text to be sent.
  * @throws {Error} If it is impossible to escape the given string
  */
-export async function inputText(text) {
+export async function inputText(this: ADB, text: string | number): Promise<void> {
   if (text === '') {
     return;
   }
 
   const originalStr = `${text}`;
   const escapedText = originalStr.replace(/\$/g, '\\$').replace(/ /g, '%s');
-  let args = ['input', 'text', originalStr];
+  let args: string[] = ['input', 'text', originalStr];
   // https://stackoverflow.com/questions/25791423/adb-shell-input-text-does-not-take-ampersand-character/25791498
   const adbInputEscapePattern = /[()<>|;&*\\~^"']/g;
   if (escapedText !== originalStr || adbInputEscapePattern.test(originalStr)) {
@@ -186,14 +180,13 @@ export async function inputText(text) {
  * Executes the given function with the given input method context
  * and then restores the IME to the original value
  *
- * @this {import('../adb.js').ADB}
- * @param {string} ime - Valid IME identifier
- * @param {Function} fn - Function to execute
- * @returns {Promise<any>} The result of the given function
+ * @param ime - Valid IME identifier
+ * @param fn - Function to execute
+ * @returns The result of the given function
  */
-export async function runInImeContext(ime, fn) {
+export async function runInImeContext<T>(this: ADB, ime: string, fn: () => Promise<T>): Promise<T> {
   // This is needed to properly apply new IME on some devices
-  const cycleImeState = async (/** @type {string} */ name) => {
+  const cycleImeState = async (name: string) => {
     try {
       await this.disableIME(name);
       await this.enableIME(name);
@@ -225,12 +218,11 @@ export async function runInImeContext(ime, fn) {
 // #region Private function
 
 /**
- * @param {string} stdout
- * @returns {string[]}
+ * @param stdout
+ * @returns
  */
-function getIMEListFromOutput(stdout) {
-  /** @type {string[]} */
-  const engines = [];
+function getIMEListFromOutput(stdout: string): string[] {
+  const engines: string[] = [];
   for (const line of stdout.split('\n')) {
     if (line.length > 0 && line[0] !== ' ') {
       // remove newline and trailing colon, and add to the list
@@ -241,3 +233,4 @@ function getIMEListFromOutput(stdout) {
 }
 
 // #endregion
+

package/lib/tools/{lockmgmt.js → lockmgmt.ts}

@@ -2,6 +2,7 @@ import {log} from '../logger.js';
 import _ from 'lodash';
 import B from 'bluebird';
 import {waitForCondition} from 'asyncbox';
+import type {ADB} from '../adb.js';
 
 const CREDENTIAL_CANNOT_BE_NULL_OR_EMPTY_ERROR = `Credential can't be null or empty`;
 const CREDENTIAL_DID_NOT_MATCH_ERROR = `didn't match`;
@@ -11,14 +12,14 @@ const KEYCODE_WAKEUP = 224; // works over API Level 20
 const HIDE_KEYBOARD_WAIT_TIME = 100;
 
 /**
- * @param {string} verb
- * @param {string?} [oldCredential=null]
- * @param {...string} args
+ * @param verb
+ * @param oldCredential
+ * @param args
  */
-function buildCommand(verb, oldCredential = null, ...args) {
+function buildCommand(verb: string, oldCredential: string | null = null, ...args: string[]): string[] {
   const cmd = ['locksettings', verb];
-  if (!_.isEmpty(oldCredential)) {
-    cmd.push('--old', /** @type {string} */ (oldCredential));
+  if (oldCredential && !_.isEmpty(oldCredential)) {
+    cmd.push('--old', oldCredential);
   }
   if (!_.isEmpty(args)) {
     cmd.push(...args);
@@ -29,11 +30,10 @@ function buildCommand(verb, oldCredential = null, ...args) {
 /**
  * Performs swipe up gesture on the screen
  *
- * @this {import('../adb.js').ADB}
- * @param {string} windowDumpsys The output of `adb shell dumpsys window` command
+ * @param windowDumpsys The output of `adb shell dumpsys window` command
  * @throws {Error} If the display size cannot be retrieved
  */
-async function swipeUp(windowDumpsys) {
+async function swipeUp(this: ADB, windowDumpsys: string): Promise<void> {
   const dimensionsMatch = /init=(\d+)x(\d+)/.exec(windowDumpsys);
   if (!dimensionsMatch) {
     throw new Error('Cannot retrieve the display size');
@@ -56,10 +56,9 @@ async function swipeUp(windowDumpsys) {
  * Check whether the device supports lock settings management with `locksettings`
  * command line tool. This tool has been added to Android toolset since  API 27 Oreo
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if the management is supported. The result is cached per ADB instance
+ * @return True if the management is supported. The result is cached per ADB instance
  */
-export async function isLockManagementSupported() {
+export async function isLockManagementSupported(this: ADB): Promise<boolean> {
   if (!_.isBoolean(this._isLockManagementSupported)) {
     const passFlag = '__PASS__';
     let output = '';
@@ -72,23 +71,25 @@ export async function isLockManagementSupported() {
         `${this._isLockManagementSupported ? '' : 'not '}supported`,
     );
   }
-  return this._isLockManagementSupported;
+  return this._isLockManagementSupported as boolean;
 }
 
 /**
  * Check whether the given credential is matches to the currently set one.
  *
- * @this {import('../adb.js').ADB}
- * @param {string?} [credential=null] The credential value. It could be either
+ * @param credential - The credential value. It could be either
  * pin, password or a pattern. A pattern is specified by a non-separated list
  * of numbers that index the cell on the pattern in a 1-based manner in left
  * to right and top to bottom order, i.e. the top-left cell is indexed with 1,
  * whereas the bottom-right cell is indexed with 9. Example: 1234.
  * null/empty value assumes the device has no lock currently set.
- * @return {Promise<boolean>} True if the given credential matches to the device's one
+ * @return True if the given credential matches to the device's one
  * @throws {Error} If the verification faces an unexpected error
  */
-export async function verifyLockCredential(credential = null) {
+export async function verifyLockCredential(
+  this: ADB,
+  credential: string | null = null,
+): Promise<boolean> {
   try {
     const {stdout, stderr} = await this.shell(buildCommand('verify', credential), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
@@ -107,7 +108,11 @@ export async function verifyLockCredential(credential = null) {
   } catch (e) {
     throw new Error(
       `Device lock credential verification failed. ` +
-        `Original error: ${e.stderr || e.stdout || e.message}`,
+        `Original error: ${
+          (e as Error & {stderr?: string; stdout?: string}).stderr
+          || (e as Error & {stderr?: string; stdout?: string}).stdout
+          || (e as Error).message
+        }`,
     );
   }
 }
@@ -116,8 +121,7 @@ export async function verifyLockCredential(credential = null) {
  * Clears current lock credentials. Usually it takes several seconds for a device to
  * sync the credential state after this method returns.
  *
- * @this {import('../adb.js').ADB}
- * @param {string?} [credential=null] The credential value. It could be either
+ * @param credential - The credential value. It could be either
  * pin, password or a pattern. A pattern is specified by a non-separated list
  * of numbers that index the cell on the pattern in a 1-based manner in left
  * to right and top to bottom order, i.e. the top-left cell is indexed with 1,
@@ -125,7 +129,10 @@ export async function verifyLockCredential(credential = null) {
  * null/empty value assumes the device has no lock currently set.
  * @throws {Error} If operation faces an unexpected error
  */
-export async function clearLockCredential(credential = null) {
+export async function clearLockCredential(
+  this: ADB,
+  credential: string | null = null,
+): Promise<void> {
   try {
     const {stdout, stderr} = await this.shell(buildCommand('clear', credential), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
@@ -140,7 +147,11 @@ export async function clearLockCredential(credential = null) {
   } catch (e) {
     throw new Error(
       `Cannot clear device lock credential. ` +
-        `Original error: ${e.stderr || e.stdout || e.message}`,
+        `Original error: ${
+          (e as Error & {stderr?: string; stdout?: string}).stderr
+          || (e as Error & {stderr?: string; stdout?: string}).stdout
+          || (e as Error).message
+        }`,
     );
   }
 }
@@ -149,11 +160,10 @@ export async function clearLockCredential(credential = null) {
  * Checks whether the device is locked with a credential (either pin or a password
  * or a pattern).
  *
- * @this {import('../adb.js').ADB}
- * @returns {Promise<boolean>} `true` if the device is locked
+ * @returns `true` if the device is locked
  * @throws {Error} If operation faces an unexpected error
  */
-export async function isLockEnabled() {
+export async function isLockEnabled(this: ADB): Promise<boolean> {
   try {
     const {stdout, stderr} = await this.shell(buildCommand('get-disabled'), {
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
@@ -171,29 +181,33 @@ export async function isLockEnabled() {
     }
     throw new Error(stderr || stdout);
   } catch (e) {
-    throw new Error(`Cannot check if device lock is enabled. Original error: ${e.message}`);
+    throw new Error(`Cannot check if device lock is enabled. Original error: ${(e as Error).message}`);
   }
 }
 
 /**
  * Sets the device lock.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} credentialType One of: password, pin, pattern.
- * @param {string} credential A non-empty credential value to be set.
+ * @param credentialType - One of: password, pin, pattern.
+ * @param credential - A non-empty credential value to be set.
  * Make sure your new credential matches to the actual system security requirements,
  * e.g. a minimum password length. A pattern is specified by a non-separated list
  * of numbers that index the cell on the pattern in a 1-based manner in left
  * to right and top to bottom order, i.e. the top-left cell is indexed with 1,
  * whereas the bottom-right cell is indexed with 9. Example: 1234.
- * @param {string?} [oldCredential=null] An old credential string.
+ * @param oldCredential - An old credential string.
  * It is only required to be set in case you need to change the current
  * credential rather than to set a new one. Setting it to a wrong value will
  * make this method to fail and throw an exception.
  * @throws {Error} If there was a failure while verifying input arguments or setting
  * the credential
  */
-export async function setLockCredential(credentialType, credential, oldCredential = null) {
+export async function setLockCredential(
+  this: ADB,
+  credentialType: string,
+  credential: string,
+  oldCredential: string | null = null,
+): Promise<void> {
   if (!SUPPORTED_LOCK_CREDENTIAL_TYPES.includes(credentialType)) {
     throw new Error(
       `Device lock credential type '${credentialType}' is unknown. ` +
@@ -214,7 +228,11 @@ export async function setLockCredential(credentialType, credential, oldCredentia
   } catch (e) {
     throw new Error(
       `Setting of device lock ${credentialType} credential failed. ` +
-        `Original error: ${e.stderr || e.stdout || e.message}`,
+        `Original error: ${
+          (e as Error & {stderr?: string; stdout?: string}).stderr
+          || (e as Error & {stderr?: string; stdout?: string}).stdout
+          || (e as Error).message
+        }`,
     );
   }
 }
@@ -222,10 +240,9 @@ export async function setLockCredential(credentialType, credential, oldCredentia
 /**
  * Retrieve the screen lock state of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if the device is locked.
+ * @return True if the device is locked.
  */
-export async function isScreenLocked() {
+export async function isScreenLocked(this: ADB): Promise<boolean> {
   const [windowOutput, powerOutput] = await B.all([
     this.shell(['dumpsys', 'window']),
     this.shell(['dumpsys', 'power']),
@@ -241,9 +258,8 @@ export async function isScreenLocked() {
 
 /**
  * Dismisses keyguard overlay.
- * @this {import('../adb.js').ADB}
  */
-export async function dismissKeyguard() {
+export async function dismissKeyguard(this: ADB): Promise<void> {
   log.info('Waking up the device to dismiss the keyguard');
   // Screen off once to force pre-inputted text field clean after wake-up
   // Just screen on if the screen defaults off
@@ -273,18 +289,16 @@ export async function dismissKeyguard() {
 /**
  * Presses the corresponding key combination to make sure the device's screen
  * is not turned off and is locked if the latter is enabled.
- * @this {import('../adb.js').ADB}
  */
-export async function cycleWakeUp() {
+export async function cycleWakeUp(this: ADB): Promise<void> {
   await this.keyevent(KEYCODE_POWER);
   await this.keyevent(KEYCODE_WAKEUP);
 }
 
 /**
  * Send the special keycode to the device under test in order to lock it.
- * @this {import('../adb.js').ADB}
  */
-export async function lock() {
+export async function lock(this: ADB): Promise<void> {
   if (await this.isScreenLocked()) {
     log.debug('Screen is already locked. Doing nothing.');
     return;
@@ -310,10 +324,10 @@ export async function lock() {
  * Default is true.
  * Note: this key
  *
- * @param {string} dumpsys
- * @returns {boolean}
+ * @param dumpsys
+ * @returns
  */
-function isScreenOnFully(dumpsys) {
+function isScreenOnFully(dumpsys: string): boolean {
   const m = /mScreenOnFully=\w+/gi.exec(dumpsys);
   return (
     !m || // if information is missing we assume screen is fully on
@@ -325,10 +339,10 @@ function isScreenOnFully(dumpsys) {
 /**
  * Checks mCurrentFocus in dumpsys output to determine if Keyguard is activated
  *
- * @param {string} dumpsys
- * @returns {boolean}
+ * @param dumpsys
+ * @returns
  */
-function isCurrentFocusOnKeyguard(dumpsys) {
+function isCurrentFocusOnKeyguard(dumpsys: string): boolean {
   const m = /mCurrentFocus.+Keyguard/gi.exec(dumpsys);
   return Boolean(m?.length && m[0]);
 }
@@ -336,10 +350,10 @@ function isCurrentFocusOnKeyguard(dumpsys) {
 /**
  * Check the current device power state to determine if it is locked
  *
- * @param {string} dumpsys The `adb shell dumpsys power` output
- * @returns {boolean} True if lock screen is shown
+ * @param dumpsys The `adb shell dumpsys power` output
+ * @returns True if lock screen is shown
  */
-function isInDozingMode(dumpsys) {
+function isInDozingMode(dumpsys: string): boolean {
   // On some phones/tablets we were observing mWakefulness=Dozing
   // while on others it was getWakefulnessLocked()=Dozing
   return /^[\s\w]+wakefulness[^=]*=Dozing$/im.test(dumpsys);
@@ -358,10 +372,10 @@ function isInDozingMode(dumpsys) {
  * Some devices such as Android TV do not have keyguard, so we should keep
  * screen condition as this primary method.
  *
- * @param {string} dumpsys - The output of dumpsys window command.
- * @return {boolean} True if lock screen is showing.
+ * @param dumpsys - The output of dumpsys window command.
+ * @return True if lock screen is showing.
  */
-export function isShowingLockscreen(dumpsys) {
+export function isShowingLockscreen(dumpsys: string): boolean {
   return (
     _.some(['mShowingLockscreen=true', 'mDreamingLockscreen=true'], (x) => dumpsys.includes(x)) ||
     // `mIsShowing` and `mInputRestricted` are `true` in lock condition. `false` is unlock condition.
@@ -375,11 +389,12 @@ export function isShowingLockscreen(dumpsys) {
  * Checks screenState has SCREEN_STATE_OFF in dumpsys output to determine
  * possible lock screen.
  *
- * @param {string} dumpsys - The output of dumpsys window command.
- * @return {boolean} True if lock screen is showing.
+ * @param dumpsys - The output of dumpsys window command.
+ * @return True if lock screen is showing.
  */
-export function isScreenStateOff(dumpsys) {
+export function isScreenStateOff(dumpsys: string): boolean {
   return /\s+screenState=SCREEN_STATE_OFF/i.test(dumpsys);
 }
 
 // #endregion
+

package/lib/tools/{logcat-commands.js → logcat-commands.ts}

@@ -1,14 +1,15 @@
 import _ from 'lodash';
 import {Logcat} from '../logcat';
+import type {ADB} from '../adb.js';
+import type {LogcatOpts, LogEntry, LogcatListener} from './types.js';
 
 /**
  * Start the logcat process to gather logs.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').LogcatOpts} [opts={}]
+ * @param opts - Logcat options
  * @throws {Error} If restart fails.
  */
-export async function startLogcat(opts = {}) {
+export async function startLogcat(this: ADB, opts: LogcatOpts = {}): Promise<void> {
   if (!_.isEmpty(this.logcat)) {
     throw new Error("Trying to start logcat capture but it's already started!");
   }
@@ -26,14 +27,14 @@ export async function startLogcat(opts = {}) {
 /**
  * Stop the active logcat process which gathers logs.
  * The call will be ignored if no logcat process is running.
- * @this {import('../adb.js').ADB}
  */
-export async function stopLogcat() {
-  if (_.isEmpty(this.logcat)) {
+export async function stopLogcat(this: ADB): Promise<void> {
+  const logcat = this.logcat;
+  if (!logcat || _.isEmpty(this.logcat)) {
     return;
   }
   try {
-    await this.logcat.stopCapture();
+    await logcat.stopCapture();
   } finally {
     this.logcat = undefined;
   }
@@ -43,43 +44,44 @@ export async function stopLogcat() {
  * Retrieve the output from the currently running logcat process.
  * The logcat process should be executed by {2link #startLogcat} method.
  *
- * @this {import('../adb.js').ADB}
- * @return {import('./types').LogEntry[]} The collected logcat output.
+ * @return The collected logcat output.
  * @throws {Error} If logcat process is not running.
  */
-export function getLogcatLogs() {
-  if (_.isEmpty(this.logcat)) {
+export function getLogcatLogs(this: ADB): LogEntry[] {
+  const logcat = this.logcat;
+  if (!logcat || _.isEmpty(this.logcat)) {
     throw new Error(`Can't get logcat logs since logcat hasn't started`);
   }
-  return this.logcat.getLogs();
+  return logcat.getLogs();
 }
 
 /**
  * Set the callback for the logcat output event.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').LogcatListener} listener - Listener function
+ * @param listener - Listener function
  * @throws {Error} If logcat process is not running.
  */
-export function setLogcatListener(listener) {
-  if (_.isEmpty(this.logcat)) {
+export function setLogcatListener(this: ADB, listener: LogcatListener): void {
+  const logcat = this.logcat;
+  if (!logcat || _.isEmpty(this.logcat)) {
     throw new Error("Logcat process hasn't been started");
   }
-  this.logcat.on('output', listener);
+  logcat.on('output', listener);
 }
 
 /**
  * Removes the previously set callback for the logcat output event.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').LogcatListener} listener
+ * @param listener
  * The listener function, which has been previously
  * passed to `setLogcatListener`
  * @throws {Error} If logcat process is not running.
  */
-export function removeLogcatListener(listener) {
-  if (_.isEmpty(this.logcat)) {
+export function removeLogcatListener(this: ADB, listener: LogcatListener): void {
+  const logcat = this.logcat;
+  if (!logcat || _.isEmpty(this.logcat)) {
     throw new Error("Logcat process hasn't been started");
   }
-  this.logcat.removeListener('output', listener);
+  logcat.removeListener('output', listener);
 }
+