appium-remote-debugger 15.0.0 → 15.0.2

package/lib/mixins/connect.js

@@ -173,11 +173,11 @@ export async function selectPage (appIdKey, pageIdKey, skipReadyCheck = false) {
 
   const timer = new timing.Timer().start();
 
-  await this.requireRpcClient().selectPage(fullAppIdKey, pageIdKey);
-
-  if (!skipReadyCheck) {
-    await this.waitForDom();
-  }
+  const pageReadinessDetector = skipReadyCheck ? undefined : {
+    timeoutMs: this.pageLoadMs,
+    readinessDetector: (/** @type {string} */ readyState) => this.isPageLoadingCompleted(readyState),
+  };
+  await this.requireRpcClient().selectPage(fullAppIdKey, pageIdKey, pageReadinessDetector);
 
   this.log.debug(`Selected page after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
 }

package/lib/mixins/execute.js

@@ -2,7 +2,7 @@ import { errors } from '@appium/base-driver';
 import {
   checkParams,
   simpleStringify,
-  convertResult,
+  convertJavascriptEvaluationResult,
   RESPONSE_LOG_LENGTH,
 } from '../utils';
 import { getScriptForAtom } from '../atoms';
@@ -123,7 +123,7 @@ export async function executeAtomAsync (atom, args = [], frames = []) {
       );
     } catch {}
   }
-  return convertResult(res);
+  return convertJavascriptEvaluationResult(res);
 }
 
 /**
@@ -144,7 +144,7 @@ export async function execute (command, override) {
   }
 
   const rpcClient = this.requireRpcClient(true);
-  await rpcClient.waitForPageInitialization(
+  await rpcClient.waitForPage(
     /** @type {import('../types').AppIdKey} */ (appIdKey),
     /** @type {import('../types').PageIdKey} */ (pageIdKey)
   );
@@ -155,7 +155,7 @@ export async function execute (command, override) {
     appIdKey,
     pageIdKey,
   });
-  return convertResult(res);
+  return convertJavascriptEvaluationResult(res);
 }
 
 /**
@@ -184,7 +184,7 @@ export async function callFunction (objectId, fn, args) {
     pageIdKey,
   });
 
-  return convertResult(res);
+  return convertJavascriptEvaluationResult(res);
 }
 
 /**

package/lib/mixins/navigate.js

@@ -20,11 +20,11 @@ const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
 /**
  * pageLoadStrategy in WebDriver definitions.
  */
-const PAGE_LOAD_STRATEGY = {
+const PAGE_LOAD_STRATEGY = Object.freeze({
   EAGER: 'eager',
   NONE: 'none',
   NORMAL: 'normal'
-};
+});
 
 /**
  * @this {RemoteDebugger}
@@ -53,18 +53,17 @@ export function cancelPageLoad () {
  * @returns {boolean}
  */
 export function isPageLoadingCompleted (readyState) {
-  const _pageLoadStrategy = _.toLower(getPageLoadStartegy(this));
-  if (_pageLoadStrategy === PAGE_LOAD_STRATEGY.NONE) {
-    return true;
+  const pageLoadStrategy = _.toLower(getPageLoadStartegy(this));
+  switch (pageLoadStrategy) {
+    case PAGE_LOAD_STRATEGY.EAGER:
+      // This could include 'interactive' or 'complete'
+      return readyState !== 'loading';
+    case PAGE_LOAD_STRATEGY.NONE:
+      return true;
+    case PAGE_LOAD_STRATEGY.NORMAL:
+    default:
+      return readyState === 'complete';
   }
-
-  if (_pageLoadStrategy === PAGE_LOAD_STRATEGY.EAGER) {
-    // This could include 'interactive' or 'complete'
-    return readyState !== 'loading';
-  }
-
-  // Default behavior. It includes pageLoadStrategy is 'normal' as well.
-  return readyState === 'complete';
 }
 
 /**
@@ -183,7 +182,7 @@ export async function navToUrl (url) {
 
   this.log.debug(`Navigating to new URL: '${url}'`);
   setNavigatingToPage(this, true);
-  await rpcClient.waitForPageInitialization(
+  await rpcClient.waitForPage(
     /** @type {import('../types').AppIdKey} */ (appIdKey),
     /** @type {import('../types').PageIdKey} */ (pageIdKey)
   );

package/lib/remote-debugger.ts

@@ -49,7 +49,6 @@ export class RemoteDebugger extends EventEmitter {
   protected readonly _platformVersion?: string;
   protected readonly _isSafari: boolean;
   protected readonly _includeSafari: boolean;
-  protected readonly _useNewSafari: boolean;
   protected readonly _garbageCollectOnExecute: boolean;
   protected readonly _host?: string;
   protected readonly _port?: number;
@@ -120,7 +119,6 @@ export class RemoteDebugger extends EventEmitter {
       platformVersion,
       isSafari = true,
       includeSafari = false,
-      useNewSafari = false,
       pageLoadMs,
       host,
       port = REMOTE_DEBUGGER_PORT,
@@ -142,10 +140,8 @@ export class RemoteDebugger extends EventEmitter {
     this._platformVersion = platformVersion;
     this._isSafari = isSafari;
     this._includeSafari = includeSafari;
-    this._useNewSafari = useNewSafari;
     this._pageLoadMs = pageLoadMs;
     this._allowNavigationWithoutReload = false;
-    this.log.debug(`useNewSafari --> ${this._useNewSafari}`);
 
     this._garbageCollectOnExecute = garbageCollectOnExecute;
 

package/lib/rpc/rpc-client.js

@@ -7,6 +7,7 @@ import RpcMessageHandler from './rpc-message-handler';
 import { util, timing } from '@appium/support';
 import { EventEmitter } from 'node:events';
 import AsyncLock from 'async-lock';
+import { convertJavascriptEvaluationResult } from '../utils';
 
 const DATA_LOG_LENGTH = {length: 200};
 const MIN_WAIT_FOR_TARGET_TIMEOUT_MS = 30000;
@@ -23,6 +24,7 @@ const NO_TARGET_PRESENT_YET_ERRORS = [
 ];
 export const NEW_APP_CONNECTED_ERROR = 'New application has connected';
 export const EMPTY_PAGE_DICTIONARY_ERROR = 'Empty page dictionary received';
+const ON_PAGE_INITIALIZED_EVENT = 'onPageInitialized';
 
 
 export class RpcClient {
@@ -83,7 +85,7 @@ export class RpcClient {
   /** @type {EventEmitter} */
   _targetSubscriptions;
 
-  /** @type {[import('../types').AppIdKey, import('../types').PageIdKey] | undefined} */
+  /** @type {PendingTargetNotification | undefined} */
   _pendingTargetNotification;
 
   /**
@@ -128,6 +130,8 @@ export class RpcClient {
     this._targets = {};
     this._targetSubscriptions = new EventEmitter();
     this._provisionedPages = new Set();
+    this._pageSelectionLock = new AsyncLock();
+    this._pageSelectionMonitor = new EventEmitter();
 
     this.remoteMessages = new RemoteMessages();
 
@@ -454,7 +458,7 @@ export class RpcClient {
       return;
     }
 
-    const [appIdKey, pageIdKey] = this._pendingTargetNotification;
+    const [appIdKey, pageIdKey, pageReadinessDetector] = this._pendingTargetNotification;
     if (appIdKey !== app) {
       log.info(
         `Received 'Target.targetCreated' event for app '${app}' with no pending request: ${JSON.stringify(targetInfo)}`
@@ -470,6 +474,24 @@ export class RpcClient {
     }
     const timer = new timing.Timer().start();
 
+    const adjustPageReadinessDetector = () => {
+      if (!pageReadinessDetector) {
+        return;
+      }
+
+      const elapsedMs = timer.getDuration().asMilliSeconds;
+      if (elapsedMs >= pageReadinessDetector.timeoutMs) {
+        log.warn(
+          `Page '${pageIdKey}' took too long to initialize, skipping readiness check`
+        );
+        return;
+      }
+      return {
+        timeoutMs: pageReadinessDetector.timeoutMs - elapsedMs,
+        readinessDetector: pageReadinessDetector.readinessDetector,
+      };
+    };
+
     if (targetInfo.isProvisional) {
       log.debug(
         `Provisional target created for app '${appIdKey}' and page '${pageIdKey}': '${JSON.stringify(targetInfo)}'`
@@ -478,8 +500,9 @@ export class RpcClient {
       this._provisionedPages.add(pageIdKey);
       try {
         await this.targets[appIdKey].lock.acquire(pageIdKey, async () => {
+          let wasInitialized = false;
           try {
-            await this._initializePage(appIdKey, pageIdKey, targetInfo.targetId);
+            wasInitialized = await this._initializePage(appIdKey, pageIdKey, targetInfo.targetId);
           } finally {
             if (targetInfo.isPaused) {
               await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
@@ -489,6 +512,11 @@ export class RpcClient {
               );
             }
           }
+          if (wasInitialized) {
+            await this._waitForPageReadiness(
+              appIdKey, pageIdKey, targetInfo.targetId, adjustPageReadinessDetector()
+            );
+          }
         });
       } catch (e) {
         log.warn(
@@ -522,21 +550,32 @@ export class RpcClient {
 
     try {
       await this.targets[appIdKey].lock.acquire(pageIdKey, async () => {
+        let wasInitialized = false;
         try {
           if (this._provisionedPages.has(pageIdKey)) {
             log.debug(`Page '${pageIdKey}' has been already provisioned`);
             this._provisionedPages.delete(pageIdKey);
           } else {
-            await this._initializePage(appIdKey, pageIdKey);
+            wasInitialized = await this._initializePage(appIdKey, pageIdKey);
           }
         } finally {
           if (targetInfo.isPaused) {
             await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
           }
         }
+        if (wasInitialized) {
+          await this._waitForPageReadiness(
+            appIdKey, pageIdKey, targetInfo.targetId, adjustPageReadinessDetector()
+          );
+        }
       });
     } catch (e) {
       log.warn(e.message);
+    } finally {
+      // Target creation is happening after provisioning,
+      // which means the above lock would be already released
+      // after provisioning is completed.
+      this._pageSelectionMonitor.emit(ON_PAGE_INITIALIZED_EVENT, appIdKey, pageIdKey);
     }
   }
 
@@ -633,32 +672,73 @@ export class RpcClient {
   /**
    * @param {import('../types').AppIdKey} appIdKey
    * @param {import('../types').PageIdKey} pageIdKey
+   * @param {PageReadinessDetector} [pageReadinessDetector]
    * @returns {Promise<void>}
    */
-  async selectPage (appIdKey, pageIdKey) {
-    this._pendingTargetNotification = [appIdKey, pageIdKey];
-    this._provisionedPages.clear();
+  async selectPage (appIdKey, pageIdKey, pageReadinessDetector) {
+    await this._pageSelectionLock.acquire(toPageSelectionKey(appIdKey, pageIdKey), async () => {
+      this._pendingTargetNotification = [appIdKey, pageIdKey, pageReadinessDetector];
+      this._provisionedPages.clear();
 
-    // go through the steps that the Desktop Safari system
-    // goes through to initialize the Web Inspector session
+      // go through the steps that the Desktop Safari system
+      // goes through to initialize the Web Inspector session
 
-    const sendOpts = {
-      appIdKey,
-      pageIdKey,
-    };
+      const sendOpts = {
+        appIdKey,
+        pageIdKey,
+      };
 
-    // highlight and then un-highlight the webview
-    for (const enabled of [true, false]) {
-      await this.send('indicateWebView', Object.assign({
-        enabled,
-      }, sendOpts), false);
-    }
+      const timeoutMs = Math.trunc(Math.max(this.pageLoadTimeoutMs ?? 0, PAGE_INIT_TIMEOUT_MS) * 1.2);
+      const timer = new timing.Timer().start();
 
-    await this.send('setSenderKey', sendOpts);
-    log.debug('Sender key set');
+      const setupWebview = async () => {
+        // highlight and then un-highlight the webview
+        for (const enabled of [true, false]) {
+          await this.send('indicateWebView', Object.assign({
+            enabled,
+          }, sendOpts), false);
+        }
+        await this.send('setSenderKey', sendOpts);
+      };
+      await B.resolve(setupWebview())
+        .timeout(timeoutMs, `Cannot set up page '${pageIdKey}' for app '${appIdKey}' within ${timeoutMs}ms`);
 
-    await this.waitForTarget(appIdKey, pageIdKey);
-    await this.waitForPageInitialization(appIdKey, pageIdKey);
+      const msLeft = Math.max(timeoutMs - Math.trunc(timer.getDuration().asMilliSeconds), 1000);
+      log.debug(
+        `Waiting up to ${msLeft}ms for page '${pageIdKey}' of app '${appIdKey}' to be selected`
+      );
+      await new Promise((resolve) => {
+        const onPageInitialized = (
+          /** @type {import("../types").AppIdKey} */ notifiedAppIdKey,
+          /** @type {import("../types").PageIdKey} */ notifiedPageIdKey
+        ) => {
+          const timeoutHandler = setTimeout(() => {
+            this._pageSelectionMonitor.off(ON_PAGE_INITIALIZED_EVENT, onPageInitialized);
+            log.warn(
+              `Page '${pageIdKey}' for app '${appIdKey}' has not been selected ` +
+              `within ${timer.getDuration().asMilliSeconds}ms. Continuing anyway`
+            );
+            resolve(false);
+          }, msLeft);
+
+          if (notifiedAppIdKey === appIdKey && notifiedPageIdKey === pageIdKey) {
+            clearTimeout(timeoutHandler);
+            this._pageSelectionMonitor.off(ON_PAGE_INITIALIZED_EVENT, onPageInitialized);
+            log.debug(
+              `Selected the page ${pageIdKey}@${appIdKey} after ${timer.getDuration().asMilliSeconds}ms`
+            );
+            resolve(true);
+          } else {
+            log.debug(
+              `Got notified that page ${notifiedPageIdKey}@${notifiedAppIdKey} is initialized, ` +
+              `but we are waiting for ${pageIdKey}@${appIdKey}. Continuing to wait`
+            );
+          }
+        };
+
+        this._pageSelectionMonitor.on(ON_PAGE_INITIALIZED_EVENT, onPageInitialized);
+      });
+    });
   }
 
   /**
@@ -904,15 +984,69 @@ export class RpcClient {
    *
    * @param {import('../types').AppIdKey} appIdKey
    * @param {import('../types').PageIdKey} pageIdKey
+   * @param {import('../types').TargetId} targetId
+   * @param {PageReadinessDetector} [pageReadinessDetector]
+   * @returns {Promise<void>}
    */
-  async waitForPageInitialization (appIdKey, pageIdKey) {
+  async _waitForPageReadiness(appIdKey, pageIdKey, targetId, pageReadinessDetector) {
+    if (!pageReadinessDetector) {
+      return;
+    }
+
+    log.debug(`Waiting up to ${pageReadinessDetector.timeoutMs}ms for page readiness`);
+    const timer = new timing.Timer().start();
+    while (pageReadinessDetector.timeoutMs - timer.getDuration().asMilliSeconds > 0) {
+      /** @type {string} */
+      let readyState;
+      try {
+        const commandTimeoutMs = Math.max(
+          100,
+          Math.trunc((pageReadinessDetector.timeoutMs - timer.getDuration().asMilliSeconds) * 0.8)
+        );
+        const rawResult = await B.resolve(this.send('Runtime.evaluate', {
+          expression: 'document.readyState;',
+          returnByValue: true,
+          appIdKey,
+          pageIdKey,
+          targetId,
+        })).timeout(commandTimeoutMs);
+        readyState = convertJavascriptEvaluationResult(rawResult);
+      } catch (e) {
+        log.debug(`Cannot determine page readiness: ${e.message}`);
+        continue;
+      }
+      if (pageReadinessDetector.readinessDetector(readyState)) {
+        log.info(
+          `Page '${pageIdKey}' for app '${appIdKey}' is ready after ` +
+          `${timer.getDuration().asMilliSeconds}ms`
+        );
+        return;
+      }
+      await B.delay(100);
+    }
+    log.warn(
+      `Page '${pageIdKey}' for app '${appIdKey}' is not ready after ` +
+      `${timer.getDuration().asMilliSeconds}ms. Continuing anyway`
+    );
+  }
+
+  /**
+   *
+   * @param {import('../types').AppIdKey} appIdKey
+   * @param {import('../types').PageIdKey} pageIdKey
+   * @returns {Promise<void>}
+   */
+  async waitForPage (appIdKey, pageIdKey) {
     const appTargetsMap = this.targets[appIdKey];
     if (!appTargetsMap) {
       throw new Error(`No targets found for app '${appIdKey}'`);
     }
     const lock = appTargetsMap.lock;
     const timer = new timing.Timer().start();
-    await lock.acquire(pageIdKey, async () => await B.delay(0));
+    await Promise.all([
+      lock.acquire(pageIdKey, async () => await B.delay(0)),
+      this._pageSelectionLock.acquire(toPageSelectionKey(appIdKey, pageIdKey), async () => await B.delay(0))
+    ]);
     const durationMs = timer.getDuration().asMilliSeconds;
     if (durationMs > 10) {
       log.debug(`Waited ${durationMs}ms until the page ${pageIdKey}@${appIdKey} is initialized`);
@@ -920,6 +1054,16 @@ export class RpcClient {
   }
 }
 
+/**
+ *
+ * @param {import('../types').AppIdKey} appIdKey
+ * @param {import('../types').PageIdKey} pageIdKey
+ * @returns {string}
+ */
+function toPageSelectionKey(appIdKey, pageIdKey) {
+  return `${appIdKey}:${pageIdKey}`;
+}
+
 export default RpcClient;
 
 /**
@@ -943,4 +1087,15 @@ export default RpcClient;
 /**
  * @typedef {PageDict & {provisional?: import('../types').ProvisionalTargetInfo, lock: AsyncLock}} PagesToTargets
  * @typedef {{[key: import('../types').AppIdKey]: PagesToTargets}} AppToTargetsMap
- */
+ */
+
+/**
+ * @typedef {Object} PageReadinessDetector
+ * @property {number} timeoutMs
+ * @property {(readyState: string) => boolean} readinessDetector
+ */
+
+/**
+ * @typedef {[import('../types').AppIdKey, import('../types').PageIdKey, PageReadinessDetector | undefined]} PendingTargetNotification
+ */
+

package/lib/types.ts

@@ -49,7 +49,7 @@ export interface RemoteDebuggerOptions {
   platformVersion?: string;
   isSafari?: boolean;
   includeSafari?: boolean;
-  /** for web inspector, whether this is a new Safari instance */
+  /** @deprecated - deprecated for removal, not used anywhere */
   useNewSafari?: boolean;
   /** the time, in ms, that should be waited for page loading */
   pageLoadMs?: number;

package/lib/utils.js

@@ -157,7 +157,7 @@ export function deferredPromise () {
  * @param {any} res
  * @returns {any}
  */
-export function convertResult (res) {
+export function convertJavascriptEvaluationResult (res) {
   if (_.isUndefined(res)) {
     throw new Error(`Did not get OK result from remote debugger. Result was: ${_.truncate(simpleStringify(res), {length: RESPONSE_LOG_LENGTH})}`);
   } else if (_.isString(res)) {

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "15.0.0",
+  "version": "15.0.2",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {