appium-remote-debugger 12.2.5 → 12.2.7

package/lib/rpc/rpc-client.js

@@ -10,10 +10,16 @@ import { ON_TARGET_PROVISIONED_EVENT } from './constants';
 
 const DATA_LOG_LENGTH = {length: 200};
 const WAIT_FOR_TARGET_TIMEOUT_MS = 10000;
-const WAIT_FOR_TARGET_INTERVAL_MS = 1000;
+const WAIT_FOR_TARGET_INTERVAL_MS = 100;
 const MIN_PLATFORM_FOR_TARGET_BASED = '12.2';
 // `Target.exists` protocol method was removed from WebKit in 13.4
 const MIN_PLATFORM_NO_TARGET_EXISTS = '13.4';
+const NO_TARGET_SUPPORTED_ERROR = `'target' domain was not found`;
+const NO_TARGET_PRESENT_YET_ERRORS = [
+  `domain was not found`,
+  `some arguments of method`,
+  `missing target`,
+];
 
 /**
  * @param {boolean} isSafari
@@ -257,17 +263,20 @@ export class RpcClient {
 
   /**
    *
-   * @param {string} appIdKey
-   * @param {string|number} pageIdKey
-   * @param {boolean} [force]
+   * @param {import('../types').AppIdKey} appIdKey
+   * @param {import('../types').PageIdKey} pageIdKey
    * @returns {Promise<void>}
    */
-  async waitForTarget (appIdKey, pageIdKey, force = false) {
-    if (!force && !this.needsTarget) {
+  async waitForTarget (appIdKey, pageIdKey) {
+    if (!this.needsTarget) {
+      log.debug(`Target-based communication is not needed, skipping wait for target`);
       return;
     }
-
-    if (this.getTarget(appIdKey, pageIdKey)) {
+    const target = this.getTarget(appIdKey, pageIdKey);
+    if (target) {
+      log.debug(
+        `The target '${target}' for app '${appIdKey}' and page '${pageIdKey}' already exists, no need to wait`
+      );
       return;
     }
 
@@ -289,34 +298,30 @@ export class RpcClient {
   /**
    *
    * @param {string} command
-   * @param {Record<string, any>} [opts]
+   * @param {import('../types').RemoteCommandOpts} opts
    * @param {boolean} [waitForResponse]
    * @returns {Promise<any>}
    */
-  async send (command, opts = {}, waitForResponse = true) {
+  async send (command, opts, waitForResponse = true) {
     const timer = new timing.Timer().start();
     const {
       appIdKey,
       pageIdKey
     } = opts;
     try {
-      if (!_.isEmpty(appIdKey) && !_.isEmpty(pageIdKey)) {
-        await this.waitForTarget(appIdKey, pageIdKey);
-      }
       return await this.sendToDevice(command, opts, waitForResponse);
     } catch (err) {
-      let { message = '' } = err;
-      message = message.toLowerCase();
-      if (message.includes(`'target' domain was not found`)) {
-        log.info('The target device does not support Target based communication. ' +
-          'Will follow non-target based communication.');
+      const messageLc = (err.message || '').toLowerCase();
+      if (messageLc.includes(NO_TARGET_SUPPORTED_ERROR)) {
+        log.info(
+          'The target device does not support Target based communication. ' +
+          'Will follow non-target based communication.'
+        );
         this.isTargetBased = false;
         return await this.sendToDevice(command, opts, waitForResponse);
-      } else if (message.includes(`domain was not found`) ||
-          message.includes(`some arguments of method`) ||
-          message.includes(`missing target`)) {
+      } else if (appIdKey && NO_TARGET_PRESENT_YET_ERRORS.some((error) => messageLc.includes(error))) {
         this.isTargetBased = true;
-        await this.waitForTarget(appIdKey, pageIdKey);
+        await this.waitForTarget(appIdKey, /** @type {import('../types').PageIdKey} */ (pageIdKey));
         return await this.sendToDevice(command, opts, waitForResponse);
       }
       throw err;
@@ -328,11 +333,11 @@ export class RpcClient {
   /**
    *
    * @param {string} command
-   * @param {Record<string, any>} opts
+   * @param {import('../types').RemoteCommandOpts} opts
    * @param {boolean} [waitForResponse]
    * @returns {Promise<any>}
    */
-  async sendToDevice (command, opts = {}, waitForResponse = true) {
+  async sendToDevice (command, opts, waitForResponse = true) {
     return await new B(async (resolve, reject) => {
       // promise to be resolved whenever remote debugger
       // replies to our request
@@ -444,7 +449,7 @@ export class RpcClient {
   }
 
   /**
-   * @param {string} command
+   * @param {import('../types').RemoteCommand} command
    * @returns {Promise<void>}
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -543,11 +548,10 @@ export class RpcClient {
           targets[page] = newTargetId;
           const opts = {appIdKey: app, pageIdKey: parseInt(page, 10)};
           (async () => {
-            try {
-              // This is needed to enable the broadcast of page lifecycle events
-              await this.sendToDevice('Page.enable', opts, true);
-            } catch (err) {
-              log.warn(err.message);
+            if (this.fullPageInitialization) {
+              await this.initializePageFull(opts.appIdKey, opts.pageIdKey);
+            } else {
+              await this.initializePage(opts.appIdKey, opts.pageIdKey);
             }
             this._targetSubscriptions.emit(ON_TARGET_PROVISIONED_EVENT, {
               ...opts,
@@ -574,21 +578,24 @@ export class RpcClient {
   }
 
   /**
-   * @param {string} appIdKey
-   * @param {string|number} pageIdKey
-   * @returns {any}
+   * @param {import('../types').AppIdKey} [appIdKey]
+   * @param {import('../types').PageIdKey} [pageIdKey]
+   * @returns {string | undefined}
    */
   getTarget (appIdKey, pageIdKey) {
+    if (!appIdKey || !pageIdKey) {
+      return;
+    }
     return (this.targets[appIdKey] || {})[pageIdKey];
   }
 
   /**
-   * @param {string} appIdKey
-   * @param {string|number} pageIdKey
+   * @param {import('../types').AppIdKey} appIdKey
+   * @param {import('../types').PageIdKey} pageIdKey
    * @returns {Promise<void>}
    */
   async selectPage (appIdKey, pageIdKey) {
-    /** @type {[string, string|number]} */
+    /** @type {[import('../types').AppIdKey, import('../types').PageIdKey]} */
     this.pendingTargetNotification = [appIdKey, pageIdKey];
     this.shouldCheckForTarget = false;
 
@@ -616,6 +623,7 @@ export class RpcClient {
 
     this.shouldCheckForTarget = true;
 
+    await this.waitForTarget(appIdKey, pageIdKey);
     if (this.fullPageInitialization) {
       await this.initializePageFull(appIdKey, pageIdKey);
     } else {
@@ -625,8 +633,8 @@ export class RpcClient {
 
   /**
    * Perform the minimal initialization to get the Web Inspector working
-   * @param {string} appIdKey
-   * @param {string|number} pageIdKey
+   * @param {import('../types').AppIdKey} appIdKey
+   * @param {import('../types').PageIdKey} pageIdKey
    * @returns {Promise<void>}
    */
   async initializePage (appIdKey, pageIdKey) {
@@ -635,24 +643,33 @@ export class RpcClient {
       pageIdKey,
     };
 
-    await this.send('Inspector.enable', sendOpts, false);
-    await this.send('Page.enable', sendOpts, false);
+    // The sequence of domains is important
+    for (const domain of [
+      'Inspector.enable',
+      'Page.enable',
+      'Runtime.enable',
+
+      'Network.enable',
+      'Heap.enable',
+      'Debugger.enable',
+      'Console.enable',
 
-    // go through the tasks to initialize
-    await this.send('Network.enable', sendOpts, false);
-    await this.send('Runtime.enable', sendOpts, false);
-    await this.send('Heap.enable', sendOpts, false);
-    await this.send('Debugger.enable', sendOpts, false);
-    await this.send('Console.enable', sendOpts, false);
-    await this.send('Inspector.initialized', sendOpts, false);
+      'Inspector.initialized',
+    ]) {
+      try {
+        await this.send(domain, sendOpts);
+      } catch (err) {
+        log.info(`Cannot enable domain '${domain}' during initialization: ${err.message}`);
+      }
+    }
   }
 
   /**
    * Mimic every step that Desktop Safari Develop tools uses to initialize a
    * Web Inspector session
    *
-   * @param {string} appIdKey
-   * @param {string|number} pageIdKey
+   * @param {import('../types').AppIdKey} appIdKey
+   * @param {import('../types').PageIdKey} pageIdKey
    * @returns {Promise<void>}
    */
   async initializePageFull (appIdKey, pageIdKey) {
@@ -661,66 +678,89 @@ export class RpcClient {
       pageIdKey,
     };
 
-    await this.send('Inspector.enable', sendOpts, false);
-    await this.send('Page.enable', sendOpts, false);
-
-    // go through the tasks to initialize
-    await this.send('Page.getResourceTree', sendOpts, false);
-    await this.send('Network.enable', sendOpts, false);
-    await this.send('Network.setResourceCachingDisabled', Object.assign({
-      disabled: false,
-    }, sendOpts), false);
-    await this.send('DOMStorage.enable', sendOpts, false);
-    await this.send('Database.enable', sendOpts, false);
-    await this.send('IndexedDB.enable', sendOpts, false);
-    await this.send('CSS.enable', sendOpts, false);
-    await this.send('Runtime.enable', sendOpts, false);
-    await this.send('Heap.enable', sendOpts, false);
-    await this.send('Memory.enable', sendOpts, false);
-    await this.send('ApplicationCache.enable', sendOpts, false);
-    await this.send('ApplicationCache.getFramesWithManifests', sendOpts, false);
-    await this.send('Timeline.setInstruments', Object.assign({
-      instruments: ['Timeline', 'ScriptProfiler', 'CPU'],
-    }, sendOpts), false);
-    await this.send('Timeline.setAutoCaptureEnabled', Object.assign({
-      enabled: false,
-    }, sendOpts), false);
-    await this.send('Debugger.enable', sendOpts, false);
-    await this.send('Debugger.setBreakpointsActive', Object.assign({
-      active: true,
-    }, sendOpts), false);
-    await this.send('Debugger.setPauseOnExceptions', Object.assign({
-      state: 'none',
-    }, sendOpts), false);
-    await this.send('Debugger.setPauseOnAssertions', Object.assign({
-      enabled: false,
-    }, sendOpts), false);
-    await this.send('Debugger.setAsyncStackTraceDepth', Object.assign({
-      depth: 200,
-    }, sendOpts), false);
-    await this.send('Debugger.setPauseForInternalScripts', Object.assign({
-      shouldPause: false,
-    }, sendOpts), false);
-
-    await this.send('LayerTree.enable', sendOpts, false);
-    await this.send('Worker.enable', sendOpts, false);
-    await this.send('Canvas.enable', sendOpts, false);
-    await this.send('Console.enable', sendOpts, false);
-    await this.send('DOM.getDocument', sendOpts, false);
-    const loggingChannels = await this.send('Console.getLoggingChannels', sendOpts);
-    for (const source of (loggingChannels.channels || []).map((entry) => entry.source)) {
-      await this.send('Console.setLoggingChannelLevel', Object.assign({
-        source,
-        level: 'verbose',
-      }, sendOpts), false);
-    }
+    // The sequence of commands here is important
+    const domainsToOptsMap = {
+      'Inspector.enable': sendOpts,
+      'Page.enable': sendOpts,
+      'Runtime.enable': sendOpts,
+
+      'Page.getResourceTree': sendOpts,
+      'Network.enable': sendOpts,
+      'Network.setResourceCachingDisabled': {
+        disabled: false,
+        ...sendOpts,
+      },
+      'DOMStorage.enable': sendOpts,
+      'Database.enable': sendOpts,
+      'IndexedDB.enable': sendOpts,
+      'CSS.enable': sendOpts,
+      'Heap.enable': sendOpts,
+      'Memory.enable': sendOpts,
+      'ApplicationCache.enable': sendOpts,
+      'ApplicationCache.getFramesWithManifests': sendOpts,
+      'Timeline.setInstruments': {
+        instruments: ['Timeline', 'ScriptProfiler', 'CPU'],
+        ...sendOpts,
+      },
+      'Timeline.setAutoCaptureEnabled': {
+        enabled: false,
+        ...sendOpts,
+      },
+      'Debugger.enable': sendOpts,
+      'Debugger.setBreakpointsActive': {
+        active: true,
+        ...sendOpts,
+      },
+      'Debugger.setPauseOnExceptions': {
+        state: 'none',
+        ...sendOpts,
+      },
+      'Debugger.setPauseOnAssertions': {
+        enabled: false,
+        ...sendOpts,
+      },
+      'Debugger.setAsyncStackTraceDepth': {
+        depth: 200,
+        ...sendOpts,
+      },
+      'Debugger.setPauseForInternalScripts': {
+        shouldPause: false,
+        ...sendOpts,
+      },
+      'LayerTree.enable': sendOpts,
+      'Worker.enable': sendOpts,
+      'Canvas.enable': sendOpts,
+      'Console.enable': sendOpts,
+      'DOM.getDocument': sendOpts,
+      'Console.getLoggingChannels': sendOpts,
+
+      'Inspector.initialized': sendOpts,
+    };
 
-    await this.send('Inspector.initialized', sendOpts, false);
+    for (const [domain, opts] of Object.entries(domainsToOptsMap)) {
+      try {
+        const res = await this.send(domain, opts);
+        if (domain === 'Console.getLoggingChannels') {
+          for (const source of (res?.channels || []).map((/** @type {{ source: any; }} */ entry) => entry.source)) {
+            try {
+              await this.send('Console.setLoggingChannelLevel', Object.assign({
+                source,
+                level: 'verbose',
+              }, sendOpts));
+            } catch (err) {
+              log.info(`Cannot set logging channel level for '${source}': ${err.message}`);
+            }
+          }
+        }
+      } catch (err) {
+        log.info(`Cannot enable domain '${domain}' during full initialization: ${err.message}`);
+      }
+    }
   }
 
   /**
    *
-   * @param {string} appIdKey
+   * @param {import('../types').AppIdKey} appIdKey
    * @returns {Promise<[string, Record<string, any>]>}
    */
   async selectApp (appIdKey) {

package/lib/types.ts

@@ -19,7 +19,7 @@ export interface AppInfo {
 }
 
 export interface AppPage {
-  appIdKey: string;
+  appIdKey: AppIdKey;
   pageDict: Page;
 }
 
@@ -80,3 +80,29 @@ interface RemoteDebuggerRealDeviceSpecificOptions {
 }
 
 export type RemoteDebuggerRealDeviceOptions = RemoteDebuggerRealDeviceSpecificOptions & RemoteDebuggerOptions;
+
+export type AppIdKey = string | number;
+export type PageIdKey = string | number;
+
+export interface RemoteCommandOpts {
+  appIdKey?: AppIdKey;
+  pageIdKey?: PageIdKey;
+  id?: string;
+  connId?: string;
+  senderId?: string;
+  targetId?: string;
+  bundleId?: string;
+  enabled?: boolean;
+  [key: string]: any;
+}
+
+export interface ProtocolCommandOpts {
+  id: string;
+  method: string;
+  params: StringRecord;
+}
+
+export interface RemoteCommand {
+  __argument: StringRecord;
+  __selector: string;
+}

package/package.json

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