appium-android-driver 7.8.3 → 8.0.1

package/lib/commands/streamscreen.js

@@ -10,7 +10,6 @@ import net from 'node:net';
 import url from 'node:url';
 import {checkPortStatus} from 'portscanner';
 import {SubProcess, exec} from 'teen_process';
-import {mixin} from './mixins';
 
 const RECORDING_INTERVAL_SEC = 5;
 const STREAMING_STARTUP_TIMEOUT_MS = 5000;
@@ -34,6 +33,201 @@ const BOUNDARY_STRING = '--2ae9746887f170b8cf7c271047ce314c';
 
 const ADB_SCREEN_STREAMING_FEATURE = 'adb_screen_streaming';
 
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @param {import('./types').StartScreenStreamingOpts} [options={}]
+ * @returns {Promise<void>}
+ */
+export async function mobileStartScreenStreaming(options = {}) {
+  this.ensureFeatureEnabled(ADB_SCREEN_STREAMING_FEATURE);
+
+  const {
+    width,
+    height,
+    bitRate,
+    host = DEFAULT_HOST,
+    port = DEFAULT_PORT,
+    pathname,
+    tcpPort = DEFAULT_PORT + 1,
+    quality = DEFAULT_QUALITY,
+    considerRotation = false,
+    logPipelineDetails = false,
+  } = options;
+  if (_.isUndefined(this._screenStreamingProps)) {
+    await verifyStreamingRequirements(this.adb);
+  }
+  if (!_.isEmpty(this._screenStreamingProps)) {
+    this.log.info(
+      `The screen streaming session is already running. ` +
+        `Stop it first in order to start a new one.`,
+    );
+    return;
+  }
+  if ((await checkPortStatus(port, host)) === 'open') {
+    this.log.info(
+      `The port #${port} at ${host} is busy. ` + `Assuming the screen streaming is already running`,
+    );
+    return;
+  }
+  if ((await checkPortStatus(tcpPort, TCP_HOST)) === 'open') {
+    this.log.errorAndThrow(
+      `The port #${tcpPort} at ${TCP_HOST} is busy. ` +
+        `Make sure there are no leftovers from previous sessions.`,
+    );
+  }
+  this._screenStreamingProps = undefined;
+
+  const deviceInfo = await getDeviceInfo(this.adb, this.log);
+  const deviceStreamingProc = await initDeviceStreamingProc(this.adb, this.log, deviceInfo, {
+    width,
+    height,
+    bitRate,
+  });
+  let gstreamerPipeline;
+  try {
+    gstreamerPipeline = await initGstreamerPipeline(deviceStreamingProc, deviceInfo, this.log, {
+      width,
+      height,
+      quality,
+      tcpPort,
+      considerRotation,
+      logPipelineDetails,
+    });
+  } catch (e) {
+    if (deviceStreamingProc.kill(0)) {
+      deviceStreamingProc.kill();
+    }
+    throw e;
+  }
+
+  /** @type {import('node:net').Socket|undefined} */
+  let mjpegSocket;
+  /** @type {import('node:http').Server|undefined} */
+  let mjpegServer;
+  try {
+    await new B((resolve, reject) => {
+      mjpegSocket = net.createConnection(tcpPort, TCP_HOST, () => {
+        this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
+        mjpegServer = http.createServer((req, res) => {
+          const remoteAddress = extractRemoteAddress(req);
+          const currentPathname = url.parse(String(req.url)).pathname;
+          this.log.info(
+            `Got an incoming screen broadcasting request from ${remoteAddress} ` +
+              `(${req.headers['user-agent'] || 'User Agent unknown'}) at ${currentPathname}`,
+          );
+
+          if (pathname && currentPathname !== pathname) {
+            this.log.info(
+              'Rejecting the broadcast request since it does not match the given pathname',
+            );
+            res.writeHead(404, {
+              Connection: 'close',
+              'Content-Type': 'text/plain; charset=utf-8',
+            });
+            res.write(`'${currentPathname}' did not match any known endpoints`);
+            res.end();
+            return;
+          }
+
+          this.log.info('Starting MJPEG broadcast');
+          res.writeHead(200, {
+            'Cache-Control':
+              'no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0',
+            Pragma: 'no-cache',
+            Connection: 'close',
+            'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY_STRING}`,
+          });
+
+          /** @type {import('node:net').Socket} */ (mjpegSocket).pipe(res);
+        });
+        mjpegServer.on('error', (e) => {
+          this.log.warn(e);
+          reject(e);
+        });
+        mjpegServer.on('close', () => {
+          this.log.debug(`MJPEG server at http://${host}:${port} has been closed`);
+        });
+        mjpegServer.on('listening', () => {
+          this.log.info(`Successfully started MJPEG server at http://${host}:${port}`);
+          resolve();
+        });
+        mjpegServer.listen(port, host);
+      });
+      mjpegSocket.on('error', (e) => {
+        this.log.error(e);
+        reject(e);
+      });
+    }).timeout(
+      STREAMING_STARTUP_TIMEOUT_MS,
+      `Cannot connect to the streaming server within ${STREAMING_STARTUP_TIMEOUT_MS}ms`,
+    );
+  } catch (e) {
+    if (deviceStreamingProc.kill(0)) {
+      deviceStreamingProc.kill();
+    }
+    if (gstreamerPipeline.isRunning) {
+      await gstreamerPipeline.stop();
+    }
+    if (mjpegSocket) {
+      mjpegSocket.destroy();
+    }
+    if (mjpegServer && mjpegServer.listening) {
+      mjpegServer.close();
+    }
+    throw e;
+  }
+
+  this._screenStreamingProps = {
+    deviceStreamingProc,
+    gstreamerPipeline,
+    mjpegSocket,
+    mjpegServer,
+  };
+}
+
+/**
+ * @this {import('../driver').AndroidDriver}
+ * @returns {Promise<void>}
+ */
+export async function mobileStopScreenStreaming() {
+  if (_.isEmpty(this._screenStreamingProps)) {
+    if (!_.isUndefined(this._screenStreamingProps)) {
+      this.log.debug(`Screen streaming is not running. There is nothing to stop`);
+    }
+    return;
+  }
+
+  const {deviceStreamingProc, gstreamerPipeline, mjpegSocket, mjpegServer} =
+    this._screenStreamingProps;
+
+  try {
+    mjpegSocket.end();
+    if (mjpegServer.listening) {
+      mjpegServer.close();
+    }
+    if (deviceStreamingProc.kill(0)) {
+      deviceStreamingProc.kill('SIGINT');
+    }
+    if (gstreamerPipeline.isRunning) {
+      try {
+        await gstreamerPipeline.stop('SIGINT');
+      } catch (e) {
+        this.log.warn(e);
+        try {
+          await gstreamerPipeline.stop('SIGKILL');
+        } catch (e1) {
+          this.log.error(e1);
+        }
+      }
+    }
+    this.log.info(`Successfully terminated the screen streaming MJPEG server`);
+  } finally {
+    this._screenStreamingProps = undefined;
+  }
+}
+
+// #region Internal helpers
+
 /**
  *
  * @param {string} streamName
@@ -46,7 +240,7 @@ function createStreamingLogger(streamName, udid) {
       _.truncate(udid, {
         length: 8,
         omission: '',
-      })
+      }),
   );
 }
 
@@ -57,7 +251,7 @@ function createStreamingLogger(streamName, udid) {
 async function verifyStreamingRequirements(adb) {
   if (!_.trim(await adb.shell(['which', SCREENRECORD_BINARY]))) {
     throw new Error(
-      `The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`
+      `The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`,
     );
   }
 
@@ -70,10 +264,10 @@ async function verifyStreamingRequirements(adb) {
         } catch (e) {
           throw new Error(
             `The '${binaryName}' binary is not available in the PATH on the host system. ` +
-              `See ${GST_TUTORIAL_URL} for more details on how to install it.`
+              `See ${GST_TUTORIAL_URL} for more details on how to install it.`,
           );
         }
-      })()
+      })(),
     );
   }
   await B.all(gstreamerCheckPromises);
@@ -86,10 +280,10 @@ async function verifyStreamingRequirements(adb) {
         if (!_.includes(stdout, modName)) {
           throw new Error(
             `The required GStreamer plugin '${name}' from '${modName}' module is not installed. ` +
-              `See ${GST_TUTORIAL_URL} for more details on how to install it.`
+              `See ${GST_TUTORIAL_URL} for more details on how to install it.`,
           );
         }
-      })()
+      })(),
     );
   }
   await B.all(moduleCheckPromises);
@@ -118,7 +312,7 @@ async function getDeviceInfo(adb, log) {
       log?.debug(output);
       throw new Error(
         `Cannot parse the device ${key} from the adb command output. ` +
-          `Check the server log for more details.`
+          `Check the server log for more details.`,
       );
     }
     result[key] = parseInt(match[1], 10);
@@ -198,7 +392,7 @@ async function initDeviceStreamingProc(adb, log, deviceInfo, opts = {}) {
     log.errorAndThrow(
       `Cannot start the screen streaming process. Original error: ${
         /** @type {Error} */ (e).message
-      }`
+      }`,
     );
   } finally {
     deviceStreaming.stderr.removeListener('data', errorsListener);
@@ -253,7 +447,7 @@ async function initGstreamerPipeline(deviceStreamingProc, deviceInfo, log, opts)
     ],
     {
       stdio: [deviceStreamingProc.stdout, 'pipe', 'pipe'],
-    }
+    },
   );
   gstreamerPipeline.on('exit', (code, signal) => {
     log.debug(`Pipeline streaming process exited with code ${code}, signal ${signal}`);
@@ -285,14 +479,14 @@ async function initGstreamerPipeline(deviceStreamingProc, deviceInfo, log, opts)
       {
         waitMs: STREAMING_STARTUP_TIMEOUT_MS,
         intervalMs: 300,
-      }
+      },
     );
   } catch (e) {
     didFail = true;
     log.errorAndThrow(
       `Cannot start the screen streaming pipeline. Original error: ${
         /** @type {Error} */ (e).message
-      }`
+      }`,
     );
   } finally {
     if (!logPipelineDetails || didFail) {
@@ -316,200 +510,7 @@ function extractRemoteAddress(req) {
   );
 }
 
-/**
- * @type {import('./mixins').StreamScreenMixin & ThisType<import('../driver').AndroidDriver>}
- * @satisfies {import('@appium/types').ExternalDriver}
- */
-const StreamScreenMixin = {
-  async mobileStartScreenStreaming(options = {}) {
-    this.ensureFeatureEnabled(ADB_SCREEN_STREAMING_FEATURE);
-
-    const {
-      width,
-      height,
-      bitRate,
-      host = DEFAULT_HOST,
-      port = DEFAULT_PORT,
-      pathname,
-      tcpPort = DEFAULT_PORT + 1,
-      quality = DEFAULT_QUALITY,
-      considerRotation = false,
-      logPipelineDetails = false,
-    } = options;
-    if (_.isUndefined(this._screenStreamingProps)) {
-      await verifyStreamingRequirements(this.adb);
-    }
-    if (!_.isEmpty(this._screenStreamingProps)) {
-      this.log.info(
-        `The screen streaming session is already running. ` +
-          `Stop it first in order to start a new one.`
-      );
-      return;
-    }
-    if ((await checkPortStatus(port, host)) === 'open') {
-      this.log.info(
-        `The port #${port} at ${host} is busy. ` +
-          `Assuming the screen streaming is already running`
-      );
-      return;
-    }
-    if ((await checkPortStatus(tcpPort, TCP_HOST)) === 'open') {
-      this.log.errorAndThrow(
-        `The port #${tcpPort} at ${TCP_HOST} is busy. ` +
-          `Make sure there are no leftovers from previous sessions.`
-      );
-    }
-    this._screenStreamingProps = undefined;
-
-    const deviceInfo = await getDeviceInfo(this.adb, this.log);
-    const deviceStreamingProc = await initDeviceStreamingProc(this.adb, this.log, deviceInfo, {
-      width,
-      height,
-      bitRate,
-    });
-    let gstreamerPipeline;
-    try {
-      gstreamerPipeline = await initGstreamerPipeline(deviceStreamingProc, deviceInfo, this.log, {
-        width,
-        height,
-        quality,
-        tcpPort,
-        considerRotation,
-        logPipelineDetails,
-      });
-    } catch (e) {
-      if (deviceStreamingProc.kill(0)) {
-        deviceStreamingProc.kill();
-      }
-      throw e;
-    }
-
-    /** @type {import('node:net').Socket|undefined} */
-    let mjpegSocket;
-    /** @type {import('node:http').Server|undefined} */
-    let mjpegServer;
-    try {
-      await new B((resolve, reject) => {
-        mjpegSocket = net.createConnection(tcpPort, TCP_HOST, () => {
-          this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
-          mjpegServer = http.createServer((req, res) => {
-            const remoteAddress = extractRemoteAddress(req);
-            const currentPathname = url.parse(String(req.url)).pathname;
-            this.log.info(
-              `Got an incoming screen broadcasting request from ${remoteAddress} ` +
-                `(${req.headers['user-agent'] || 'User Agent unknown'}) at ${currentPathname}`
-            );
-
-            if (pathname && currentPathname !== pathname) {
-              this.log.info(
-                'Rejecting the broadcast request since it does not match the given pathname'
-              );
-              res.writeHead(404, {
-                Connection: 'close',
-                'Content-Type': 'text/plain; charset=utf-8',
-              });
-              res.write(`'${currentPathname}' did not match any known endpoints`);
-              res.end();
-              return;
-            }
-
-            this.log.info('Starting MJPEG broadcast');
-            res.writeHead(200, {
-              'Cache-Control':
-                'no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0',
-              Pragma: 'no-cache',
-              Connection: 'close',
-              'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY_STRING}`,
-            });
-
-            /** @type {import('node:net').Socket} */ (mjpegSocket).pipe(res);
-          });
-          mjpegServer.on('error', (e) => {
-            this.log.warn(e);
-            reject(e);
-          });
-          mjpegServer.on('close', () => {
-            this.log.debug(`MJPEG server at http://${host}:${port} has been closed`);
-          });
-          mjpegServer.on('listening', () => {
-            this.log.info(`Successfully started MJPEG server at http://${host}:${port}`);
-            resolve();
-          });
-          mjpegServer.listen(port, host);
-        });
-        mjpegSocket.on('error', (e) => {
-          this.log.error(e);
-          reject(e);
-        });
-      }).timeout(
-        STREAMING_STARTUP_TIMEOUT_MS,
-        `Cannot connect to the streaming server within ${STREAMING_STARTUP_TIMEOUT_MS}ms`
-      );
-    } catch (e) {
-      if (deviceStreamingProc.kill(0)) {
-        deviceStreamingProc.kill();
-      }
-      if (gstreamerPipeline.isRunning) {
-        await gstreamerPipeline.stop();
-      }
-      if (mjpegSocket) {
-        mjpegSocket.destroy();
-      }
-      if (mjpegServer && mjpegServer.listening) {
-        mjpegServer.close();
-      }
-      throw e;
-    }
-
-    this._screenStreamingProps = {
-      deviceStreamingProc,
-      gstreamerPipeline,
-      mjpegSocket,
-      mjpegServer,
-    };
-  },
-
-  async mobileStopScreenStreaming() {
-    if (_.isEmpty(this._screenStreamingProps)) {
-      if (!_.isUndefined(this._screenStreamingProps)) {
-        this.log.debug(`Screen streaming is not running. There is nothing to stop`);
-      }
-      return;
-    }
-
-    const {deviceStreamingProc, gstreamerPipeline, mjpegSocket, mjpegServer} =
-      this._screenStreamingProps;
-
-    try {
-      mjpegSocket.end();
-      if (mjpegServer.listening) {
-        mjpegServer.close();
-      }
-      if (deviceStreamingProc.kill(0)) {
-        deviceStreamingProc.kill('SIGINT');
-      }
-      if (gstreamerPipeline.isRunning) {
-        try {
-          await gstreamerPipeline.stop('SIGINT');
-        } catch (e) {
-          this.log.warn(e);
-          try {
-            await gstreamerPipeline.stop('SIGKILL');
-          } catch (e1) {
-            this.log.error(e1);
-          }
-        }
-      }
-      this.log.info(`Successfully terminated the screen streaming MJPEG server`);
-    } finally {
-      this._screenStreamingProps = undefined;
-    }
-  },
-};
-
-mixin(StreamScreenMixin);
-
-export default StreamScreenMixin;
+// #endregion
 
 /**
  * @typedef {import('appium-adb').ADB} ADB