appium-remote-debugger 11.5.9 → 12.0.1

package/lib/mixins/misc.js

@@ -1,5 +1,9 @@
 import { checkParams } from '../utils';
 import B from 'bluebird';
+import {
+  getAppIdKey,
+  getPageIdKey,
+} from './property-accessors';
 
 const SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 const GARBAGE_COLLECT_TIMEOUT_MS = 5000;
@@ -16,15 +20,15 @@ export async function launchSafari () {
 
 /**
  * @this {RemoteDebugger}
- * @param {(event: import('@appium/types').StringRecord) => any} fn
+ * @param {import('../types').EventListener} fn
  * @returns {Promise<any>}
  */
 export async function startTimeline (fn) {
   this.log.debug('Starting to record the timeline');
   this.requireRpcClient().on('Timeline.eventRecorded', fn);
   return await this.requireRpcClient().send('Timeline.start', {
-    appIdKey: this.appIdKey,
-    pageIdKey: this.pageIdKey,
+    appIdKey: getAppIdKey(this),
+    pageIdKey: getPageIdKey(this),
   });
 }
 
@@ -35,51 +39,11 @@ export async function startTimeline (fn) {
 export async function stopTimeline () {
   this.log.debug('Stopping to record the timeline');
   await this.requireRpcClient().send('Timeline.stop', {
-    appIdKey: this.appIdKey,
-    pageIdKey: this.pageIdKey,
+    appIdKey: getAppIdKey(this),
+    pageIdKey: getPageIdKey(this),
   });
 }
 
-/**
- * @this {RemoteDebugger}
- * @param {(event: import('@appium/types').StringRecord) => any} listener
- * @returns {void}
- */
-export function startConsole (listener) {
-  this.log.debug('Starting to listen for JavaScript console');
-  this.addClientEventListener('Console.messageAdded', listener);
-  this.addClientEventListener('Console.messageRepeatCountUpdated', listener);
-}
-
-/**
- * @this {RemoteDebugger}
- * @returns {void}
- */
-export function stopConsole () {
-  this.log.debug('Stopping to listen for JavaScript console');
-  this.removeClientEventListener('Console.messageAdded');
-  this.removeClientEventListener('Console.messageRepeatCountUpdated');
-}
-
-/**
- * @this {RemoteDebugger}
- * @param {(event: import('@appium/types').StringRecord) => any} listener
- * @returns {void}
- */
-export function startNetwork (listener) {
-  this.log.debug('Starting to listen for network events');
-  this.addClientEventListener('NetworkEvent', listener);
-}
-
-/**
- * @this {RemoteDebugger}
- * @returns {void}
- */
-export function stopNetwork () {
-  this.log.debug('Stopping to listen for network events');
-  this.removeClientEventListener('NetworkEvent');
-}
-
 // Potentially this does not work for mobile safari
 /**
  * @this {RemoteDebugger}
@@ -89,9 +53,9 @@ export function stopNetwork () {
 export async function overrideUserAgent (value) {
   this.log.debug('Setting overrideUserAgent');
   return await this.requireRpcClient().send('Page.overrideUserAgent', {
-    appIdKey: this.appIdKey,
-    pageIdKey: this.pageIdKey,
-    value
+    appIdKey: getAppIdKey(this),
+    pageIdKey: getPageIdKey(this),
+    value,
   });
 }
 
@@ -104,7 +68,10 @@ export async function garbageCollect (timeoutMs = GARBAGE_COLLECT_TIMEOUT_MS) {
   this.log.debug(`Garbage collecting with ${timeoutMs}ms timeout`);
 
   try {
-    checkParams({appIdKey: this.appIdKey, pageIdKey: this.pageIdKey});
+    checkParams({
+      appIdKey: getAppIdKey(this),
+      pageIdKey: getPageIdKey(this),
+    });
   } catch (err) {
     this.log.debug(`Unable to collect garbage at this time`);
     return;
@@ -113,8 +80,8 @@ export async function garbageCollect (timeoutMs = GARBAGE_COLLECT_TIMEOUT_MS) {
   try {
     await B.resolve(this.requireRpcClient().send(
       'Heap.gc', {
-        appIdKey: this.appIdKey,
-        pageIdKey: this.pageIdKey,
+        appIdKey: getAppIdKey(this),
+        pageIdKey: getPageIdKey(this),
       })
     ).timeout(timeoutMs);
     this.log.debug(`Garbage collection successful`);

package/lib/mixins/navigate.js

@@ -5,8 +5,18 @@ import _ from 'lodash';
 import B from 'bluebird';
 import { errors } from '@appium/base-driver';
 import { rpcConstants } from '../rpc';
+import {
+  getAppIdKey,
+  setPageLoading,
+  getPageLoadDelay,
+  getPageLoadStartegy,
+  setPageLoadDelay,
+  getPageReadyTimeout,
+  getPageIdKey,
+  setNavigatingToPage,
+} from './property-accessors';
 
-const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 20 * 1000;
+export const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 20 * 1000;
 const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
 const PAGE_READINESS_JS_MIN_CHECK_INTERVAL_MS = 1000;
 const CONSOLE_ENABLEMENT_TIMEOUT_MS = 20 * 1000;
@@ -34,10 +44,8 @@ export function frameDetached () {
  */
 export function cancelPageLoad () {
   this.log.debug('Unregistering from page readiness notifications');
-  this.pageLoading = false;
-  if (this.pageLoadDelay) {
-    this.pageLoadDelay.cancel();
-  }
+  setPageLoading(this, false);
+  getPageLoadDelay(this)?.cancel();
 }
 
 /**
@@ -49,7 +57,7 @@ export function cancelPageLoad () {
  * @returns {boolean}
  */
 export function isPageLoadingCompleted (readyState) {
-  const _pageLoadStrategy = _.toLower(this.pageLoadStrategy);
+  const _pageLoadStrategy = _.toLower(getPageLoadStartegy(this));
   if (_pageLoadStrategy === PAGE_LOAD_STRATEGY.NONE) {
     return true;
   }
@@ -70,15 +78,15 @@ export function isPageLoadingCompleted (readyState) {
  */
 export async function waitForDom (startPageLoadTimer) {
   this.log.debug('Waiting for page readiness');
-  const readinessTimeoutMs = this.pageLoadMs || DEFAULT_PAGE_READINESS_TIMEOUT_MS;
+  const readinessTimeoutMs = this.pageLoadMs;
   if (!_.isFunction(startPageLoadTimer?.getDuration)) {
     this.log.debug(`Page load timer not a timer. Creating new timer`);
     startPageLoadTimer = new timing.Timer().start();
   }
 
   let isPageLoading = true;
-  this.pageLoading = true;
-  this.pageLoadDelay = util.cancellableDelay(readinessTimeoutMs);
+  setPageLoading(this, true);
+  setPageLoadDelay(this, util.cancellableDelay(readinessTimeoutMs));
   /** @type {B<void>} */
   const pageReadinessPromise = B.resolve((async () => {
     let retry = 0;
@@ -93,7 +101,7 @@ export async function waitForDom (startPageLoadTimer) {
       );
       await B.delay(intervalMs);
       // we can get this called in the middle of trying to find a new app
-      if (!this.appIdKey) {
+      if (!getAppIdKey(this)) {
         this.log.debug('Not connected to an application. Ignoring page readiess check');
         return;
       }
@@ -119,7 +127,7 @@ export async function waitForDom (startPageLoadTimer) {
   /** @type {B<void>} */
   const cancellationPromise = B.resolve((async () => {
     try {
-      await this.pageLoadDelay;
+      await getPageLoadDelay(this);
     } catch (ign) {}
   })());
 
@@ -127,8 +135,8 @@ export async function waitForDom (startPageLoadTimer) {
     await B.any([cancellationPromise, pageReadinessPromise]);
   } finally {
     isPageLoading = false;
-    this.pageLoading = false;
-    this.pageLoadDelay = B.resolve();
+    setPageLoading(this, false);
+    setPageLoadDelay(this, B.resolve());
   }
 }
 
@@ -138,20 +146,23 @@ export async function waitForDom (startPageLoadTimer) {
  * @returns {Promise<boolean>}
  */
 export async function checkPageIsReady (timeoutMs) {
-  checkParams({appIdKey: this.appIdKey});
+  checkParams({
+    appIdKey: getAppIdKey(this),
+  });
 
   const readyCmd = 'document.readyState;';
+  const actualTimeoutMs = timeoutMs ?? getPageReadyTimeout(this);
   try {
     const readyState = await B.resolve(this.execute(readyCmd, true))
-      .timeout(timeoutMs ?? this.pageReadyTimeout);
+      .timeout(actualTimeoutMs);
     this.log.debug(`Document readyState is '${readyState}'. ` +
-      `The pageLoadStrategy is '${this.pageLoadStrategy || PAGE_LOAD_STRATEGY.NORMAL}'`);
+      `The pageLoadStrategy is '${getPageLoadStartegy(this) ?? PAGE_LOAD_STRATEGY.NORMAL}'`);
     return this.isPageLoadingCompleted(readyState);
   } catch (err) {
     if (!(err instanceof B.TimeoutError)) {
       throw err;
     }
-    this.log.debug(`Page readiness check timed out after ${this.pageReadyTimeout}ms`);
+    this.log.debug(`Page readiness check timed out after ${actualTimeoutMs}ms`);
     return false;
   }
 }
@@ -162,7 +173,10 @@ export async function checkPageIsReady (timeoutMs) {
  * @returns {Promise<void>}
  */
 export async function navToUrl (url) {
-  checkParams({appIdKey: this.appIdKey, pageIdKey: this.pageIdKey});
+  checkParams({
+    appIdKey: getAppIdKey(this),
+    pageIdKey: getPageIdKey(this),
+  });
   const rpcClient = this.requireRpcClient();
 
   try {
@@ -171,17 +185,17 @@ export async function navToUrl (url) {
     throw new TypeError(`'${url}' is not a valid URL`);
   }
 
-  this._navigatingToPage = true;
+  setNavigatingToPage(this, true);
   this.log.debug(`Navigating to new URL: '${url}'`);
-  const readinessTimeoutMs = this.pageLoadMs || DEFAULT_PAGE_READINESS_TIMEOUT_MS;
+  const readinessTimeoutMs = this.pageLoadMs;
   /** @type {(() => void)|undefined} */
   let onPageLoaded;
   /** @type {(() => void)|undefined} */
   let onTargetProvisioned;
   /** @type {NodeJS.Timeout|undefined|null} */
   let onPageLoadedTimeout;
-  this.pageLoadDelay = util.cancellableDelay(readinessTimeoutMs);
-  this.pageLoading = true;
+  setPageLoadDelay(this, util.cancellableDelay(readinessTimeoutMs));
+  setPageLoading(this, true);
   let isPageLoading = true;
   let didPageFinishLoad = false;
   const start = new timing.Timer().start();
@@ -236,24 +250,24 @@ export async function navToUrl (url) {
 
     rpcClient.send('Page.navigate', {
       url,
-      appIdKey: this.appIdKey,
-      pageIdKey: this.pageIdKey,
+      appIdKey: getAppIdKey(this),
+      pageIdKey: getPageIdKey(this),
     });
   });
   /** @type {B<void>} */
   const cancellationPromise = B.resolve((async () => {
     try {
-      await this.pageLoadDelay;
+      await getPageLoadDelay(this);
     } catch (ign) {}
   })());
 
   try {
     await B.any([cancellationPromise, pageReadinessPromise]);
   } finally {
-    this.pageLoading = false;
+    setPageLoading(this, false);
     isPageLoading = false;
-    this._navigatingToPage = false;
-    this.pageLoadDelay = B.resolve();
+    setNavigatingToPage(this, false);
+    setPageLoadDelay(this, B.resolve());
     if (onPageLoadedTimeout && pageReadinessPromise.isFulfilled()) {
       clearTimeout(onPageLoadedTimeout);
       onPageLoadedTimeout = null;
@@ -270,8 +284,8 @@ export async function navToUrl (url) {
   // get notified when navigating to a local page
   try {
     await B.resolve(rpcClient.send('Console.enable', {
-      appIdKey: this.appIdKey,
-      pageIdKey: this.pageIdKey,
+      appIdKey: getAppIdKey(this),
+      pageIdKey: getPageIdKey(this),
     }, didPageFinishLoad)).timeout(CONSOLE_ENABLEMENT_TIMEOUT_MS);
   } catch (err) {
     if (err instanceof B.TimeoutError) {

package/lib/mixins/property-accessors.ts

@@ -0,0 +1,96 @@
+/* eslint-disable dot-notation */
+import type { StringRecord } from '@appium/types';
+import type { RemoteDebugger } from '../remote-debugger';
+import type { EventListener } from '../types';
+
+export function getAppDict(instance: RemoteDebugger): typeof instance['_appDict'] {
+  return instance['_appDict'];
+}
+
+export function getAppIdKey(instance: RemoteDebugger): typeof instance['_appIdKey'] {
+  return instance['_appIdKey'];
+}
+
+export function setAppIdKey(instance: RemoteDebugger, value: typeof instance['_appIdKey']): void {
+  instance['_appIdKey'] = value;
+}
+
+export function getRcpClient(instance: RemoteDebugger): typeof instance['_rpcClient'] {
+  return instance['_rpcClient'];
+}
+
+export function getPageIdKey(instance: RemoteDebugger): typeof instance['_pageIdKey'] {
+  return instance['_pageIdKey'];
+}
+
+export function setPageIdKey(instance: RemoteDebugger, value: typeof instance['_pageIdKey']): void {
+  instance['_pageIdKey'] = value;
+}
+
+export function getIsSafari(instance: RemoteDebugger): typeof instance['_isSafari'] {
+  return instance['_isSafari'];
+}
+
+export function getIncludeSafari(instance: RemoteDebugger): typeof instance['_includeSafari'] {
+  return instance['_includeSafari'];
+}
+
+export function getBundleId(instance: RemoteDebugger): typeof instance['_bundleId'] {
+  return instance['_bundleId'];
+}
+
+export function getAdditionalBundleIds(instance: RemoteDebugger): typeof instance['_additionalBundleIds'] {
+  return instance['_additionalBundleIds'];
+}
+
+export function getSkippedApps(instance: RemoteDebugger): typeof instance['_skippedApps'] {
+  return instance['_skippedApps'];
+}
+
+export function getClientEventListeners(instance: RemoteDebugger): StringRecord<EventListener[]> {
+  return instance['_clientEventListeners'];
+}
+
+export function getPageLoading(instance: RemoteDebugger): boolean {
+  return instance['_pageLoading'];
+}
+
+export function setPageLoading(instance: RemoteDebugger, value: boolean): void {
+  instance['_pageLoading'] = value;
+}
+
+export function getGarbageCollectOnExecute(instance: RemoteDebugger): typeof instance['_garbageCollectOnExecute'] {
+  return instance['_garbageCollectOnExecute'];
+}
+
+export function getNavigatingToPage(instance: RemoteDebugger): typeof instance['_navigatingToPage'] {
+  return instance['_navigatingToPage'];
+}
+
+export function setNavigatingToPage(instance: RemoteDebugger, value: typeof instance['_navigatingToPage']): void {
+  instance['_navigatingToPage'] = value;
+}
+
+export function setCurrentState(instance: RemoteDebugger, value: typeof instance['_currentState']): void {
+  instance['_currentState'] = value;
+}
+
+export function setConnectedDrivers(instance: RemoteDebugger, value: typeof instance['_connectedDrivers']): void {
+  instance['_connectedDrivers'] = value;
+}
+
+export function getPageLoadDelay(instance: RemoteDebugger): typeof instance['_pageLoadDelay'] {
+  return instance['_pageLoadDelay'];
+}
+
+export function setPageLoadDelay(instance: RemoteDebugger, value: typeof instance['_pageLoadDelay']): void {
+  instance['_pageLoadDelay'] = value;
+}
+
+export function getPageLoadStartegy(instance: RemoteDebugger): typeof instance['_pageLoadStrategy'] {
+  return instance['_pageLoadStrategy'];
+}
+
+export function getPageReadyTimeout(instance: RemoteDebugger): typeof instance['_pageReadyTimeout'] {
+  return instance['_pageReadyTimeout'];
+}

package/lib/mixins/screenshot.js

@@ -1,3 +1,8 @@
+import {
+  getAppIdKey,
+  getPageIdKey,
+} from './property-accessors';
+
 /**
  * Capture a rect of the page or by default the viewport
  * @this {RemoteDebugger}
@@ -15,8 +20,8 @@ export async function captureScreenshot(opts = {}) {
   ));
   const response = await this.requireRpcClient().send('Page.snapshotRect', {
     ...arect,
-    appIdKey: this.appIdKey,
-    pageIdKey: this.pageIdKey,
+    appIdKey: getAppIdKey(this),
+    pageIdKey: getPageIdKey(this),
     coordinateSystem,
   });
 

package/lib/remote-debugger-real-device.ts

@@ -0,0 +1,28 @@
+import RemoteDebugger from './remote-debugger';
+import { RpcClientRealDevice } from './rpc';
+import type { RemoteDebuggerRealDeviceOptions } from './types';
+
+export class RemoteDebuggerRealDevice extends RemoteDebugger {
+  private readonly _udid: string;
+
+  constructor (opts: RemoteDebuggerRealDeviceOptions) {
+    super(opts);
+    this._udid = opts.udid;
+    this._skippedApps = ['lockdownd'];
+  }
+
+  override initRpcClient (): void {
+    this._rpcClient = new RpcClientRealDevice({
+      bundleId: this._bundleId,
+      platformVersion: this._platformVersion,
+      isSafari: this._isSafari,
+      logAllCommunication: this._logAllCommunication,
+      logAllCommunicationHexDump: this._logAllCommunicationHexDump,
+      socketChunkSize: this._socketChunkSize,
+      webInspectorMaxFrameLength: this._webInspectorMaxFrameLength,
+      udid: this._udid,
+    });
+  }
+}
+
+export default RemoteDebuggerRealDevice;