appium-android-driver 5.13.1 → 5.13.2

package/build/lib/commands/streamscreen.js

@@ -1,32 +1,29 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-require("source-map-support/register");
-var _lodash = _interopRequireDefault(require("lodash"));
-var _support = require("@appium/support");
-var _teen_process = require("teen_process");
-var _portscanner = require("portscanner");
-var _http = _interopRequireDefault(require("http"));
-var _net = _interopRequireDefault(require("net"));
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _asyncbox = require("asyncbox");
-var _child_process = require("child_process");
-var _url = _interopRequireDefault(require("url"));
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const support_1 = require("@appium/support");
+const teen_process_1 = require("teen_process");
+const portscanner_1 = require("portscanner");
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const asyncbox_1 = require("asyncbox");
+const child_process_1 = require("child_process");
+const url_1 = __importDefault(require("url"));
 const commands = {};
 const RECORDING_INTERVAL_SEC = 5;
 const STREAMING_STARTUP_TIMEOUT_MS = 5000;
-const GSTREAMER_BINARY = `gst-launch-1.0${_support.system.isWindows() ? '.exe' : ''}`;
-const GST_INSPECT_BINARY = `gst-inspect-1.0${_support.system.isWindows() ? '.exe' : ''}`;
+const GSTREAMER_BINARY = `gst-launch-1.0${support_1.system.isWindows() ? '.exe' : ''}`;
+const GST_INSPECT_BINARY = `gst-inspect-1.0${support_1.system.isWindows() ? '.exe' : ''}`;
 const REQUIRED_GST_PLUGINS = {
-  avdec_h264: 'gst-libav',
-  h264parse: 'gst-plugins-bad',
-  jpegenc: 'gst-plugins-good',
-  tcpserversink: 'gst-plugins-base',
-  multipartmux: 'gst-plugins-good'
+    avdec_h264: 'gst-libav',
+    h264parse: 'gst-plugins-bad',
+    jpegenc: 'gst-plugins-good',
+    tcpserversink: 'gst-plugins-base',
+    multipartmux: 'gst-plugins-good',
 };
 const SCREENRECORD_BINARY = 'screenrecord';
 const GST_TUTORIAL_URL = 'https://gstreamer.freedesktop.org/documentation/installing/index.html';
@@ -34,316 +31,378 @@ const DEFAULT_HOST = '127.0.0.1';
 const TCP_HOST = '127.0.0.1';
 const DEFAULT_PORT = 8093;
 const DEFAULT_QUALITY = 70;
-const DEFAULT_BITRATE = 4000000;
+const DEFAULT_BITRATE = 4000000; // 4 Mbps
 const BOUNDARY_STRING = '--2ae9746887f170b8cf7c271047ce314c';
 const ADB_SCREEN_STREAMING_FEATURE = 'adb_screen_streaming';
 function createStreamingLogger(streamName, udid) {
-  return _support.logger.getLogger(`${streamName}@` + _lodash.default.truncate(udid, {
-    length: 8,
-    omission: ''
-  }));
+    return support_1.logger.getLogger(`${streamName}@` + lodash_1.default.truncate(udid, {
+        length: 8,
+        omission: '',
+    }));
 }
 async function verifyStreamingRequirements(adb) {
-  if (!_lodash.default.trim(await adb.shell(['which', SCREENRECORD_BINARY]))) {
-    throw new Error(`The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`);
-  }
-  const gstreamerCheckPromises = [];
-  for (const binaryName of [GSTREAMER_BINARY, GST_INSPECT_BINARY]) {
-    gstreamerCheckPromises.push((async () => {
-      try {
-        await _support.fs.which(binaryName);
-      } 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.`);
-      }
-    })());
-  }
-  await _bluebird.default.all(gstreamerCheckPromises);
-  const moduleCheckPromises = [];
-  for (const [name, modName] of _lodash.default.toPairs(REQUIRED_GST_PLUGINS)) {
-    moduleCheckPromises.push((async () => {
-      const {
-        stdout
-      } = await (0, _teen_process.exec)(GST_INSPECT_BINARY, [name]);
-      if (!_lodash.default.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.`);
-      }
-    })());
-  }
-  await _bluebird.default.all(moduleCheckPromises);
+    if (!lodash_1.default.trim(await adb.shell(['which', SCREENRECORD_BINARY]))) {
+        throw new Error(`The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`);
+    }
+    const gstreamerCheckPromises = [];
+    for (const binaryName of [GSTREAMER_BINARY, GST_INSPECT_BINARY]) {
+        gstreamerCheckPromises.push((async () => {
+            try {
+                await support_1.fs.which(binaryName);
+            }
+            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.`);
+            }
+        })());
+    }
+    await bluebird_1.default.all(gstreamerCheckPromises);
+    const moduleCheckPromises = [];
+    for (const [name, modName] of lodash_1.default.toPairs(REQUIRED_GST_PLUGINS)) {
+        moduleCheckPromises.push((async () => {
+            const { stdout } = await (0, teen_process_1.exec)(GST_INSPECT_BINARY, [name]);
+            if (!lodash_1.default.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.`);
+            }
+        })());
+    }
+    await bluebird_1.default.all(moduleCheckPromises);
 }
 async function getDeviceInfo(adb, log = null) {
-  const output = await adb.shell(['dumpsys', 'display']);
-  const result = {};
-  for (const [key, pattern] of [['width', /\bdeviceWidth=(\d+)/], ['height', /\bdeviceHeight=(\d+)/], ['fps', /\bfps=(\d+)/]]) {
-    const match = pattern.exec(output);
-    if (!match) {
-      log === null || log === void 0 ? void 0 : log.debug(output);
-      throw new Error(`Cannot parse the device ${key} from the adb command output. ` + `Check the server log for more details.`);
+    const output = await adb.shell(['dumpsys', 'display']);
+    const result = {};
+    for (const [key, pattern] of [
+        ['width', /\bdeviceWidth=(\d+)/],
+        ['height', /\bdeviceHeight=(\d+)/],
+        ['fps', /\bfps=(\d+)/],
+    ]) {
+        const match = pattern.exec(output);
+        if (!match) {
+            log?.debug(output);
+            throw new Error(`Cannot parse the device ${key} from the adb command output. ` +
+                `Check the server log for more details.`);
+        }
+        result[key] = parseInt(match[1], 10);
     }
-    result[key] = parseInt(match[1], 10);
-  }
-  result.udid = adb.curDeviceId;
-  return result;
+    result.udid = adb.curDeviceId;
+    return result;
 }
 async function initDeviceStreamingProc(adb, log, deviceInfo, opts = {}) {
-  const {
-    width,
-    height,
-    bitRate
-  } = opts;
-  const adjustedWidth = parseInt(width, 10) || deviceInfo.width;
-  const adjustedHeight = parseInt(height, 10) || deviceInfo.height;
-  const adjustedBitrate = parseInt(bitRate, 10) || DEFAULT_BITRATE;
-  let screenRecordCmd = SCREENRECORD_BINARY + ` --output-format=h264` + ` --time-limit=${RECORDING_INTERVAL_SEC}`;
-  if (width || height) {
-    screenRecordCmd += ` --size=${adjustedWidth}x${adjustedHeight}`;
-  }
-  if (bitRate) {
-    screenRecordCmd += ` --bit-rate=${adjustedBitrate}`;
-  }
-  const adbArgs = [...adb.executable.defaultArgs, 'exec-out', `while true; do ${screenRecordCmd} -; done`];
-  const deviceStreaming = (0, _child_process.spawn)(adb.executable.path, adbArgs);
-  deviceStreaming.on('exit', (code, signal) => {
-    log.debug(`Device streaming process exited with code ${code}, signal ${signal}`);
-  });
-  let isStarted = false;
-  const deviceStreamingLogger = createStreamingLogger(SCREENRECORD_BINARY, deviceInfo.udid);
-  const errorsListener = chunk => {
-    const stderr = chunk.toString();
-    if (_lodash.default.trim(stderr)) {
-      deviceStreamingLogger.debug(stderr);
+    const { width, height, bitRate, } = opts;
+    const adjustedWidth = parseInt(width, 10) || deviceInfo.width;
+    const adjustedHeight = parseInt(height, 10) || deviceInfo.height;
+    const adjustedBitrate = parseInt(bitRate, 10) || DEFAULT_BITRATE;
+    let screenRecordCmd = SCREENRECORD_BINARY +
+        ` --output-format=h264` +
+        // 5 seconds is fine to detect rotation changes
+        ` --time-limit=${RECORDING_INTERVAL_SEC}`;
+    if (width || height) {
+        screenRecordCmd += ` --size=${adjustedWidth}x${adjustedHeight}`;
     }
-  };
-  deviceStreaming.stderr.on('data', errorsListener);
-  const startupListener = chunk => {
-    if (!isStarted) {
-      isStarted = !_lodash.default.isEmpty(chunk);
+    if (bitRate) {
+        screenRecordCmd += ` --bit-rate=${adjustedBitrate}`;
     }
-  };
-  deviceStreaming.stdout.on('data', startupListener);
-  try {
-    log.info(`Starting device streaming: ${_support.util.quote([adb.executable.path, ...adbArgs])}`);
-    await (0, _asyncbox.waitForCondition)(() => isStarted, {
-      waitMs: STREAMING_STARTUP_TIMEOUT_MS,
-      intervalMs: 300
+    const adbArgs = [
+        ...adb.executable.defaultArgs,
+        'exec-out',
+        // The loop is required, because by default the maximum record duration
+        // for screenrecord is always limited
+        `while true; do ${screenRecordCmd} -; done`,
+    ];
+    const deviceStreaming = (0, child_process_1.spawn)(adb.executable.path, adbArgs);
+    deviceStreaming.on('exit', (code, signal) => {
+        log.debug(`Device streaming process exited with code ${code}, signal ${signal}`);
     });
-  } catch (e) {
-    log.errorAndThrow(`Cannot start the screen streaming process. Original error: ${e.message}`);
-  } finally {
-    deviceStreaming.stderr.removeListener('data', errorsListener);
-    deviceStreaming.stdout.removeListener('data', startupListener);
-  }
-  return deviceStreaming;
+    let isStarted = false;
+    const deviceStreamingLogger = createStreamingLogger(SCREENRECORD_BINARY, deviceInfo.udid);
+    const errorsListener = (chunk) => {
+        const stderr = chunk.toString();
+        if (lodash_1.default.trim(stderr)) {
+            deviceStreamingLogger.debug(stderr);
+        }
+    };
+    deviceStreaming.stderr.on('data', errorsListener);
+    const startupListener = (chunk) => {
+        if (!isStarted) {
+            isStarted = !lodash_1.default.isEmpty(chunk);
+        }
+    };
+    deviceStreaming.stdout.on('data', startupListener);
+    try {
+        log.info(`Starting device streaming: ${support_1.util.quote([adb.executable.path, ...adbArgs])}`);
+        await (0, asyncbox_1.waitForCondition)(() => isStarted, {
+            waitMs: STREAMING_STARTUP_TIMEOUT_MS,
+            intervalMs: 300,
+        });
+    }
+    catch (e) {
+        log.errorAndThrow(`Cannot start the screen streaming process. Original error: ${e.message}`);
+    }
+    finally {
+        deviceStreaming.stderr.removeListener('data', errorsListener);
+        deviceStreaming.stdout.removeListener('data', startupListener);
+    }
+    return deviceStreaming;
 }
 async function initGstreamerPipeline(deviceStreamingProc, deviceInfo, log, opts = {}) {
-  const {
-    width,
-    height,
-    quality,
-    tcpPort,
-    considerRotation,
-    logPipelineDetails
-  } = opts;
-  const adjustedWidth = parseInt(width, 10) || deviceInfo.width;
-  const adjustedHeight = parseInt(height, 10) || deviceInfo.height;
-  const gstreamerPipeline = new _teen_process.SubProcess(GSTREAMER_BINARY, ['-v', 'fdsrc', 'fd=0', '!', 'video/x-h264,' + `width=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedWidth},` + `height=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedHeight},` + `framerate=${deviceInfo.fps}/1,` + 'byte-stream=true', '!', 'h264parse', '!', 'queue', 'leaky=downstream', '!', 'avdec_h264', '!', 'queue', 'leaky=downstream', '!', 'jpegenc', `quality=${quality}`, '!', 'multipartmux', `boundary=${BOUNDARY_STRING}`, '!', 'tcpserversink', `host=${TCP_HOST}`, `port=${tcpPort}`], {
-    stdio: [deviceStreamingProc.stdout, 'pipe', 'pipe']
-  });
-  gstreamerPipeline.on('exit', (code, signal) => {
-    log.debug(`Pipeline streaming process exited with code ${code}, signal ${signal}`);
-  });
-  const gstreamerLogger = createStreamingLogger('gst', deviceInfo.udid);
-  const gstOutputListener = (stdout, stderr) => {
-    if (_lodash.default.trim(stderr || stdout)) {
-      gstreamerLogger.debug(stderr || stdout);
-    }
-  };
-  gstreamerPipeline.on('output', gstOutputListener);
-  let didFail = false;
-  try {
-    log.info(`Starting GStreamer pipeline: ${gstreamerPipeline.rep}`);
-    await gstreamerPipeline.start(0);
-    await (0, _asyncbox.waitForCondition)(async () => {
-      try {
-        return (await (0, _portscanner.checkPortStatus)(tcpPort, TCP_HOST)) === 'open';
-      } catch (ign) {
-        return false;
-      }
-    }, {
-      waitMs: STREAMING_STARTUP_TIMEOUT_MS,
-      intervalMs: 300
+    const { width, height, quality, tcpPort, considerRotation, logPipelineDetails, } = opts;
+    const adjustedWidth = parseInt(width, 10) || deviceInfo.width;
+    const adjustedHeight = parseInt(height, 10) || deviceInfo.height;
+    const gstreamerPipeline = new teen_process_1.SubProcess(GSTREAMER_BINARY, [
+        '-v',
+        'fdsrc', 'fd=0',
+        '!', 'video/x-h264,' +
+            `width=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedWidth},` +
+            `height=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedHeight},` +
+            `framerate=${deviceInfo.fps}/1,` +
+            'byte-stream=true',
+        '!', 'h264parse',
+        '!', 'queue', 'leaky=downstream',
+        '!', 'avdec_h264',
+        '!', 'queue', 'leaky=downstream',
+        '!', 'jpegenc', `quality=${quality}`,
+        '!', 'multipartmux', `boundary=${BOUNDARY_STRING}`,
+        '!', 'tcpserversink', `host=${TCP_HOST}`, `port=${tcpPort}`,
+    ], {
+        stdio: [deviceStreamingProc.stdout, 'pipe', 'pipe']
+    });
+    gstreamerPipeline.on('exit', (code, signal) => {
+        log.debug(`Pipeline streaming process exited with code ${code}, signal ${signal}`);
     });
-  } catch (e) {
-    didFail = true;
-    log.errorAndThrow(`Cannot start the screen streaming pipeline. Original error: ${e.message}`);
-  } finally {
-    if (!logPipelineDetails || didFail) {
-      gstreamerPipeline.removeListener('output', gstOutputListener);
+    const gstreamerLogger = createStreamingLogger('gst', deviceInfo.udid);
+    const gstOutputListener = (stdout, stderr) => {
+        if (lodash_1.default.trim(stderr || stdout)) {
+            gstreamerLogger.debug(stderr || stdout);
+        }
+    };
+    gstreamerPipeline.on('output', gstOutputListener);
+    let didFail = false;
+    try {
+        log.info(`Starting GStreamer pipeline: ${gstreamerPipeline.rep}`);
+        await gstreamerPipeline.start(0);
+        await (0, asyncbox_1.waitForCondition)(async () => {
+            try {
+                return (await (0, portscanner_1.checkPortStatus)(tcpPort, TCP_HOST)) === 'open';
+            }
+            catch (ign) {
+                return false;
+            }
+        }, {
+            waitMs: STREAMING_STARTUP_TIMEOUT_MS,
+            intervalMs: 300,
+        });
+    }
+    catch (e) {
+        didFail = true;
+        log.errorAndThrow(`Cannot start the screen streaming pipeline. Original error: ${e.message}`);
     }
-  }
-  return gstreamerPipeline;
+    finally {
+        if (!logPipelineDetails || didFail) {
+            gstreamerPipeline.removeListener('output', gstOutputListener);
+        }
+    }
+    return gstreamerPipeline;
 }
 function extractRemoteAddress(req) {
-  return req.headers['x-forwarded-for'] || req.socket.remoteAddress || req.connection.remoteAddress || req.connection.socket.remoteAddress;
+    return req.headers['x-forwarded-for']
+        || req.socket.remoteAddress
+        || req.connection.remoteAddress
+        || req.connection.socket.remoteAddress;
 }
+/**
+ * @typedef {Object} StartScreenStreamingOptions
+ *
+ * @property {?number} width - The scaled width of the device's screen. If unset then the script will assign it
+ * to the actual screen width measured in pixels.
+ * @property {?number} height - The scaled height of the device's screen. If unset then the script will assign it
+ * to the actual screen height measured in pixels.
+ * @property {?number} bitRate - The video bit rate for the video, in bits per second.
+ * The default value is 4000000 (4 Mb/s). You can increase the bit rate to improve video quality,
+ * but doing so results in larger movie files.
+ * @property {?string} host [127.0.0.1] - The IP address/host name to start the MJPEG server on.
+ * You can set it to `0.0.0.0` to trigger the broadcast on all available network interfaces.
+ * @property {?string} pathname - The HTTP request path the MJPEG server should be available on.
+ * If unset then any pathname on the given `host`/`port` combination will work. Note that the value
+ * should always start with a single slash: `/`
+ * @property {?number} tcpPort [8094] - The port number to start the internal TCP MJPEG broadcast on.
+ * This type of broadcast always starts on the loopback interface (`127.0.0.1`).
+ * @property {?number} port [8093] - The port number to start the MJPEG server on.
+ * @property {?number} quality [70] - The quality value for the streamed JPEG images.
+ * This number should be in range [1, 100], where 100 is the best quality.
+ * @property {?boolean} considerRotation [false] - If set to `true` then GStreamer pipeline will
+ * increase the dimensions of the resulting images to properly fit images in both landscape and
+ * portrait orientations. Set it to `true` if the device rotation is not going to be the same during the
+ * broadcasting session.
+ * @property {?boolean} logPipelineDetails [false] - Whether to log GStreamer pipeline events into
+ * the standard log output. Might be useful for debugging purposes.
+ */
+/**
+ * Starts device screen broadcast by creating MJPEG server.
+ * Multiple calls to this method have no effect unless the previous streaming
+ * session is stopped.
+ * This method only works if the `adb_screen_streaming` feature is
+ * enabled on the server side.
+ *
+ * @param {?StartScreenStreamingOptions} options - The available options.
+ * @throws {Error} If screen streaming has failed to start or
+ * is not supported on the host system or
+ * the corresponding server feature is not enabled.
+ */
 commands.mobileStartScreenStreaming = 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 (_lodash.default.isUndefined(this._screenStreamingProps)) {
-    await verifyStreamingRequirements(this.adb);
-  }
-  if (!_lodash.default.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 (0, _portscanner.checkPortStatus)(port, host)) === 'open') {
-    this.log.info(`The port #${port} at ${host} is busy. ` + `Assuming the screen streaming is already running`);
-    return;
-  }
-  if ((await (0, _portscanner.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 = null;
-  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();
+    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 (lodash_1.default.isUndefined(this._screenStreamingProps)) {
+        await verifyStreamingRequirements(this.adb);
     }
-    throw e;
-  }
-  let mjpegSocket;
-  let mjpegServer;
-  try {
-    await new _bluebird.default((resolve, reject) => {
-      mjpegSocket = _net.default.createConnection(tcpPort, TCP_HOST, () => {
-        this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
-        mjpegServer = _http.default.createServer((req, res) => {
-          const remoteAddress = extractRemoteAddress(req);
-          const currentPathname = _url.default.parse(req.url).pathname;
-          this.log.info(`Got an incoming screen bradcasting 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}`
-          });
-          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 (!lodash_1.default.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 (gstreamerPipeline.isRunning) {
-      await gstreamerPipeline.stop();
+    if ((await (0, portscanner_1.checkPortStatus)(port, host)) === 'open') {
+        this.log.info(`The port #${port} at ${host} is busy. ` +
+            `Assuming the screen streaming is already running`);
+        return;
     }
-    if (mjpegSocket) {
-      mjpegSocket.destroy();
+    if ((await (0, portscanner_1.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.`);
     }
-    if (mjpegServer && mjpegServer.listening) {
-      mjpegServer.close();
+    this._screenStreamingProps = null;
+    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,
+        });
     }
-    throw e;
-  }
-  this._screenStreamingProps = {
-    deviceStreamingProc,
-    gstreamerPipeline,
-    mjpegSocket,
-    mjpegServer
-  };
-};
-commands.mobileStopScreenStreaming = async function mobileStopScreenStreaming() {
-  if (_lodash.default.isEmpty(this._screenStreamingProps)) {
-    if (!_lodash.default.isUndefined(this._screenStreamingProps)) {
-      this.log.debug(`Screen streaming is not running. There is nothing to stop`);
+    catch (e) {
+        if (deviceStreamingProc.kill(0)) {
+            deviceStreamingProc.kill();
+        }
+        throw e;
     }
-    return;
-  }
-  const {
-    deviceStreamingProc,
-    gstreamerPipeline,
-    mjpegSocket,
-    mjpegServer
-  } = this._screenStreamingProps;
-  try {
-    mjpegSocket.end();
-    if (mjpegServer.listening) {
-      mjpegServer.close();
+    let mjpegSocket;
+    let mjpegServer;
+    try {
+        await new bluebird_1.default((resolve, reject) => {
+            mjpegSocket = net_1.default.createConnection(tcpPort, TCP_HOST, () => {
+                this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);
+                mjpegServer = http_1.default.createServer((req, res) => {
+                    const remoteAddress = extractRemoteAddress(req);
+                    const currentPathname = url_1.default.parse(req.url).pathname;
+                    this.log.info(`Got an incoming screen bradcasting 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}`
+                    });
+                    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`);
     }
-    if (deviceStreamingProc.kill(0)) {
-      deviceStreamingProc.kill('SIGINT');
+    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;
     }
-    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._screenStreamingProps = {
+        deviceStreamingProc,
+        gstreamerPipeline,
+        mjpegSocket,
+        mjpegServer,
+    };
+};
+/**
+ * Stop screen streaming.
+ * If no screen streaming server has been started then nothing is done.
+ */
+commands.mobileStopScreenStreaming = async function mobileStopScreenStreaming( /* options = {} */) {
+    if (lodash_1.default.isEmpty(this._screenStreamingProps)) {
+        if (!lodash_1.default.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 = null;
     }
-    this.log.info(`Successfully terminated the screen streaming MJPEG server`);
-  } finally {
-    this._screenStreamingProps = null;
-  }
 };
-var _default = commands;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_support","_teen_process","_portscanner","_http","_net","_bluebird","_asyncbox","_child_process","_url","commands","RECORDING_INTERVAL_SEC","STREAMING_STARTUP_TIMEOUT_MS","GSTREAMER_BINARY","system","isWindows","GST_INSPECT_BINARY","REQUIRED_GST_PLUGINS","avdec_h264","h264parse","jpegenc","tcpserversink","multipartmux","SCREENRECORD_BINARY","GST_TUTORIAL_URL","DEFAULT_HOST","TCP_HOST","DEFAULT_PORT","DEFAULT_QUALITY","DEFAULT_BITRATE","BOUNDARY_STRING","ADB_SCREEN_STREAMING_FEATURE","createStreamingLogger","streamName","udid","logger","getLogger","_","truncate","length","omission","verifyStreamingRequirements","adb","trim","shell","Error","gstreamerCheckPromises","binaryName","push","fs","which","e","B","all","moduleCheckPromises","name","modName","toPairs","stdout","exec","includes","getDeviceInfo","log","output","result","key","pattern","match","debug","parseInt","curDeviceId","initDeviceStreamingProc","deviceInfo","opts","width","height","bitRate","adjustedWidth","adjustedHeight","adjustedBitrate","screenRecordCmd","adbArgs","executable","defaultArgs","deviceStreaming","spawn","path","on","code","signal","isStarted","deviceStreamingLogger","errorsListener","chunk","stderr","toString","startupListener","isEmpty","info","util","quote","waitForCondition","waitMs","intervalMs","errorAndThrow","message","removeListener","initGstreamerPipeline","deviceStreamingProc","quality","tcpPort","considerRotation","logPipelineDetails","gstreamerPipeline","SubProcess","Math","max","fps","stdio","gstreamerLogger","gstOutputListener","didFail","rep","start","checkPortStatus","ign","extractRemoteAddress","req","headers","socket","remoteAddress","connection","mobileStartScreenStreaming","options","ensureFeatureEnabled","host","port","pathname","isUndefined","_screenStreamingProps","kill","mjpegSocket","mjpegServer","resolve","reject","net","createConnection","http","createServer","res","currentPathname","url","parse","writeHead","Connection","write","end","Pragma","pipe","warn","listen","error","timeout","isRunning","stop","destroy","listening","close","mobileStopScreenStreaming","e1","_default","exports","default"],"sources":["../../../lib/commands/streamscreen.js"],"sourcesContent":["import _ from 'lodash';\nimport { fs, system, logger, util } from '@appium/support';\nimport { exec, SubProcess } from 'teen_process';\nimport { checkPortStatus } from 'portscanner';\nimport http from 'http';\nimport net from 'net';\nimport B from 'bluebird';\nimport { waitForCondition } from 'asyncbox';\nimport { spawn } from 'child_process';\nimport url from 'url';\n\nconst commands = {};\n\nconst RECORDING_INTERVAL_SEC = 5;\nconst STREAMING_STARTUP_TIMEOUT_MS = 5000;\nconst GSTREAMER_BINARY = `gst-launch-1.0${system.isWindows() ? '.exe' : ''}`;\nconst GST_INSPECT_BINARY = `gst-inspect-1.0${system.isWindows() ? '.exe' : ''}`;\nconst REQUIRED_GST_PLUGINS = {\n  avdec_h264: 'gst-libav',\n  h264parse: 'gst-plugins-bad',\n  jpegenc: 'gst-plugins-good',\n  tcpserversink: 'gst-plugins-base',\n  multipartmux: 'gst-plugins-good',\n};\nconst SCREENRECORD_BINARY = 'screenrecord';\nconst GST_TUTORIAL_URL = 'https://gstreamer.freedesktop.org/documentation/installing/index.html';\nconst DEFAULT_HOST = '127.0.0.1';\nconst TCP_HOST = '127.0.0.1';\nconst DEFAULT_PORT = 8093;\nconst DEFAULT_QUALITY = 70;\nconst DEFAULT_BITRATE = 4000000; // 4 Mbps\nconst BOUNDARY_STRING = '--2ae9746887f170b8cf7c271047ce314c';\n\nconst ADB_SCREEN_STREAMING_FEATURE = 'adb_screen_streaming';\n\nfunction createStreamingLogger (streamName, udid) {\n  return logger.getLogger(`${streamName}@` + _.truncate(udid, {\n    length: 8,\n    omission: '',\n  }));\n}\n\nasync function verifyStreamingRequirements (adb) {\n  if (!_.trim(await adb.shell(['which', SCREENRECORD_BINARY]))) {\n    throw new Error(\n      `The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`);\n  }\n\n  const gstreamerCheckPromises = [];\n  for (const binaryName of [GSTREAMER_BINARY, GST_INSPECT_BINARY]) {\n    gstreamerCheckPromises.push((async () => {\n      try {\n        await fs.which(binaryName);\n      } catch (e) {\n        throw new Error(`The '${binaryName}' binary is not available in the PATH on the host system. ` +\n          `See ${GST_TUTORIAL_URL} for more details on how to install it.`);\n      }\n    })());\n  }\n  await B.all(gstreamerCheckPromises);\n\n  const moduleCheckPromises = [];\n  for (const [name, modName] of _.toPairs(REQUIRED_GST_PLUGINS)) {\n    moduleCheckPromises.push((async () => {\n      const {stdout} = await exec(GST_INSPECT_BINARY, [name]);\n      if (!_.includes(stdout, modName)) {\n        throw new Error(\n          `The required GStreamer plugin '${name}' from '${modName}' module is not installed. ` +\n          `See ${GST_TUTORIAL_URL} for more details on how to install it.`);\n      }\n    })());\n  }\n  await B.all(moduleCheckPromises);\n}\n\nasync function getDeviceInfo (adb, log = null) {\n  const output = await adb.shell(['dumpsys', 'display']);\n  const result = {};\n  for (const [key, pattern] of [\n    ['width', /\\bdeviceWidth=(\\d+)/],\n    ['height', /\\bdeviceHeight=(\\d+)/],\n    ['fps', /\\bfps=(\\d+)/],\n  ]) {\n    const match = pattern.exec(output);\n    if (!match) {\n      log?.debug(output);\n      throw new Error(`Cannot parse the device ${key} from the adb command output. ` +\n        `Check the server log for more details.`);\n    }\n    result[key] = parseInt(match[1], 10);\n  }\n  result.udid = adb.curDeviceId;\n  return result;\n}\n\nasync function initDeviceStreamingProc (adb, log, deviceInfo, opts = {}) {\n  const {\n    width,\n    height,\n    bitRate,\n  } = opts;\n  const adjustedWidth = parseInt(width, 10) || deviceInfo.width;\n  const adjustedHeight = parseInt(height, 10) || deviceInfo.height;\n  const adjustedBitrate = parseInt(bitRate, 10) || DEFAULT_BITRATE;\n  let screenRecordCmd = SCREENRECORD_BINARY +\n    ` --output-format=h264` +\n    // 5 seconds is fine to detect rotation changes\n    ` --time-limit=${RECORDING_INTERVAL_SEC}`;\n  if (width || height) {\n    screenRecordCmd += ` --size=${adjustedWidth}x${adjustedHeight}`;\n  }\n  if (bitRate) {\n    screenRecordCmd += ` --bit-rate=${adjustedBitrate}`;\n  }\n  const adbArgs = [\n    ...adb.executable.defaultArgs,\n    'exec-out',\n    // The loop is required, because by default the maximum record duration\n    // for screenrecord is always limited\n    `while true; do ${screenRecordCmd} -; done`,\n  ];\n  const deviceStreaming = spawn(adb.executable.path, adbArgs);\n  deviceStreaming.on('exit', (code, signal) => {\n    log.debug(`Device streaming process exited with code ${code}, signal ${signal}`);\n  });\n\n  let isStarted = false;\n  const deviceStreamingLogger = createStreamingLogger(SCREENRECORD_BINARY, deviceInfo.udid);\n  const errorsListener = (chunk) => {\n    const stderr = chunk.toString();\n    if (_.trim(stderr)) {\n      deviceStreamingLogger.debug(stderr);\n    }\n  };\n  deviceStreaming.stderr.on('data', errorsListener);\n\n  const startupListener = (chunk) => {\n    if (!isStarted) {\n      isStarted = !_.isEmpty(chunk);\n    }\n  };\n  deviceStreaming.stdout.on('data', startupListener);\n\n  try {\n    log.info(`Starting device streaming: ${util.quote([adb.executable.path, ...adbArgs])}`);\n    await waitForCondition(() => isStarted, {\n      waitMs: STREAMING_STARTUP_TIMEOUT_MS,\n      intervalMs: 300,\n    });\n  } catch (e) {\n    log.errorAndThrow(\n      `Cannot start the screen streaming process. Original error: ${e.message}`);\n  } finally {\n    deviceStreaming.stderr.removeListener('data', errorsListener);\n    deviceStreaming.stdout.removeListener('data', startupListener);\n  }\n  return deviceStreaming;\n}\n\nasync function initGstreamerPipeline (deviceStreamingProc, deviceInfo, log, opts = {}) {\n  const {\n    width,\n    height,\n    quality,\n    tcpPort,\n    considerRotation,\n    logPipelineDetails,\n  } = opts;\n  const adjustedWidth = parseInt(width, 10) || deviceInfo.width;\n  const adjustedHeight = parseInt(height, 10) || deviceInfo.height;\n  const gstreamerPipeline = new SubProcess(GSTREAMER_BINARY, [\n    '-v',\n    'fdsrc', 'fd=0',\n    '!', 'video/x-h264,' +\n      `width=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedWidth},` +\n      `height=${considerRotation ? Math.max(adjustedWidth, adjustedHeight) : adjustedHeight},` +\n      `framerate=${deviceInfo.fps}/1,` +\n      'byte-stream=true',\n    '!', 'h264parse',\n    '!', 'queue', 'leaky=downstream',\n    '!', 'avdec_h264',\n    '!', 'queue', 'leaky=downstream',\n    '!', 'jpegenc', `quality=${quality}`,\n    '!', 'multipartmux', `boundary=${BOUNDARY_STRING}`,\n    '!', 'tcpserversink', `host=${TCP_HOST}`, `port=${tcpPort}`,\n  ], {\n    stdio: [deviceStreamingProc.stdout, 'pipe', 'pipe']\n  });\n  gstreamerPipeline.on('exit', (code, signal) => {\n    log.debug(`Pipeline streaming process exited with code ${code}, signal ${signal}`);\n  });\n  const gstreamerLogger = createStreamingLogger('gst', deviceInfo.udid);\n  const gstOutputListener = (stdout, stderr) => {\n    if (_.trim(stderr || stdout)) {\n      gstreamerLogger.debug(stderr || stdout);\n    }\n  };\n  gstreamerPipeline.on('output', gstOutputListener);\n  let didFail = false;\n  try {\n    log.info(`Starting GStreamer pipeline: ${gstreamerPipeline.rep}`);\n    await gstreamerPipeline.start(0);\n    await waitForCondition(async () => {\n      try {\n        return (await checkPortStatus(tcpPort, TCP_HOST)) === 'open';\n      } catch (ign) {\n        return false;\n      }\n    }, {\n      waitMs: STREAMING_STARTUP_TIMEOUT_MS,\n      intervalMs: 300,\n    });\n  } catch (e) {\n    didFail = true;\n    log.errorAndThrow(\n      `Cannot start the screen streaming pipeline. Original error: ${e.message}`);\n  } finally {\n    if (!logPipelineDetails || didFail) {\n      gstreamerPipeline.removeListener('output', gstOutputListener);\n    }\n  }\n  return gstreamerPipeline;\n}\n\nfunction extractRemoteAddress (req) {\n  return req.headers['x-forwarded-for']\n    || req.socket.remoteAddress\n    || req.connection.remoteAddress\n    || req.connection.socket.remoteAddress;\n}\n\n\n/**\n * @typedef {Object} StartScreenStreamingOptions\n *\n * @property {?number} width - The scaled width of the device's screen. If unset then the script will assign it\n * to the actual screen width measured in pixels.\n * @property {?number} height - The scaled height of the device's screen. If unset then the script will assign it\n * to the actual screen height measured in pixels.\n * @property {?number} bitRate - The video bit rate for the video, in bits per second.\n * The default value is 4000000 (4 Mb/s). You can increase the bit rate to improve video quality,\n * but doing so results in larger movie files.\n * @property {?string} host [127.0.0.1] - The IP address/host name to start the MJPEG server on.\n * You can set it to `0.0.0.0` to trigger the broadcast on all available network interfaces.\n * @property {?string} pathname - The HTTP request path the MJPEG server should be available on.\n * If unset then any pathname on the given `host`/`port` combination will work. Note that the value\n * should always start with a single slash: `/`\n * @property {?number} tcpPort [8094] - The port number to start the internal TCP MJPEG broadcast on.\n * This type of broadcast always starts on the loopback interface (`127.0.0.1`).\n * @property {?number} port [8093] - The port number to start the MJPEG server on.\n * @property {?number} quality [70] - The quality value for the streamed JPEG images.\n * This number should be in range [1, 100], where 100 is the best quality.\n * @property {?boolean} considerRotation [false] - If set to `true` then GStreamer pipeline will\n * increase the dimensions of the resulting images to properly fit images in both landscape and\n * portrait orientations. Set it to `true` if the device rotation is not going to be the same during the\n * broadcasting session.\n * @property {?boolean} logPipelineDetails [false] - Whether to log GStreamer pipeline events into\n * the standard log output. Might be useful for debugging purposes.\n */\n\n/**\n * Starts device screen broadcast by creating MJPEG server.\n * Multiple calls to this method have no effect unless the previous streaming\n * session is stopped.\n * This method only works if the `adb_screen_streaming` feature is\n * enabled on the server side.\n *\n * @param {?StartScreenStreamingOptions} options - The available options.\n * @throws {Error} If screen streaming has failed to start or\n * is not supported on the host system or\n * the corresponding server feature is not enabled.\n */\ncommands.mobileStartScreenStreaming = async function mobileStartScreenStreaming (options = {}) {\n  this.ensureFeatureEnabled(ADB_SCREEN_STREAMING_FEATURE);\n\n  const {\n    width,\n    height,\n    bitRate,\n    host = DEFAULT_HOST,\n    port = DEFAULT_PORT,\n    pathname,\n    tcpPort = DEFAULT_PORT + 1,\n    quality = DEFAULT_QUALITY,\n    considerRotation = false,\n    logPipelineDetails = false,\n  } = options;\n\n  if (_.isUndefined(this._screenStreamingProps)) {\n    await verifyStreamingRequirements(this.adb);\n  }\n  if (!_.isEmpty(this._screenStreamingProps)) {\n    this.log.info(`The screen streaming session is already running. ` +\n      `Stop it first in order to start a new one.`);\n    return;\n  }\n  if ((await checkPortStatus(port, host)) === 'open') {\n    this.log.info(`The port #${port} at ${host} is busy. ` +\n      `Assuming the screen streaming is already running`);\n    return;\n  }\n  if ((await checkPortStatus(tcpPort, TCP_HOST)) === 'open') {\n    this.log.errorAndThrow(`The port #${tcpPort} at ${TCP_HOST} is busy. ` +\n      `Make sure there are no leftovers from previous sessions.`);\n  }\n  this._screenStreamingProps = null;\n\n  const deviceInfo = await getDeviceInfo(this.adb, this.log);\n  const deviceStreamingProc = await initDeviceStreamingProc(this.adb, this.log, deviceInfo, {\n    width,\n    height,\n    bitRate,\n  });\n  let gstreamerPipeline;\n  try {\n    gstreamerPipeline = await initGstreamerPipeline(deviceStreamingProc, deviceInfo, this.log, {\n      width,\n      height,\n      quality,\n      tcpPort,\n      considerRotation,\n      logPipelineDetails,\n    });\n  } catch (e) {\n    if (deviceStreamingProc.kill(0)) {\n      deviceStreamingProc.kill();\n    }\n    throw e;\n  }\n\n  let mjpegSocket;\n  let mjpegServer;\n  try {\n    await new B((resolve, reject) => {\n      mjpegSocket = net.createConnection(tcpPort, TCP_HOST, () => {\n        this.log.info(`Successfully connected to MJPEG stream at tcp://${TCP_HOST}:${tcpPort}`);\n        mjpegServer = http.createServer((req, res) => {\n          const remoteAddress = extractRemoteAddress(req);\n          const currentPathname = url.parse(req.url).pathname;\n          this.log.info(`Got an incoming screen bradcasting request from ${remoteAddress} ` +\n            `(${req.headers['user-agent'] || 'User Agent unknown'}) at ${currentPathname}`);\n\n          if (pathname && currentPathname !== pathname) {\n            this.log.info('Rejecting the broadcast request since it does not match the given pathname');\n            res.writeHead(404, {\n              Connection: 'close',\n              'Content-Type': 'text/plain; charset=utf-8',\n            });\n            res.write(`'${currentPathname}' did not match any known endpoints`);\n            res.end();\n            return;\n          }\n\n          this.log.info('Starting MJPEG broadcast');\n          res.writeHead(200, {\n            'Cache-Control': 'no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0',\n            Pragma: 'no-cache',\n            Connection: 'close',\n            'Content-Type': `multipart/x-mixed-replace; boundary=${BOUNDARY_STRING}`\n          });\n\n          mjpegSocket.pipe(res);\n        });\n        mjpegServer.on('error', (e) => {\n          this.log.warn(e);\n          reject(e);\n        });\n        mjpegServer.on('close', () => {\n          this.log.debug(`MJPEG server at http://${host}:${port} has been closed`);\n        });\n        mjpegServer.on('listening', () => {\n          this.log.info(`Successfully started MJPEG server at http://${host}:${port}`);\n          resolve();\n        });\n        mjpegServer.listen(port, host);\n      });\n      mjpegSocket.on('error', (e) => {\n        this.log.error(e);\n        reject(e);\n      });\n    }).timeout(STREAMING_STARTUP_TIMEOUT_MS,\n      `Cannot connect to the streaming server within ${STREAMING_STARTUP_TIMEOUT_MS}ms`);\n  } catch (e) {\n    if (deviceStreamingProc.kill(0)) {\n      deviceStreamingProc.kill();\n    }\n    if (gstreamerPipeline.isRunning) {\n      await gstreamerPipeline.stop();\n    }\n    if (mjpegSocket) {\n      mjpegSocket.destroy();\n    }\n    if (mjpegServer && mjpegServer.listening) {\n      mjpegServer.close();\n    }\n    throw e;\n  }\n\n  this._screenStreamingProps = {\n    deviceStreamingProc,\n    gstreamerPipeline,\n    mjpegSocket,\n    mjpegServer,\n  };\n};\n\n/**\n * Stop screen streaming.\n * If no screen streaming server has been started then nothing is done.\n */\ncommands.mobileStopScreenStreaming = async function mobileStopScreenStreaming (/* options = {} */) {\n  if (_.isEmpty(this._screenStreamingProps)) {\n    if (!_.isUndefined(this._screenStreamingProps)) {\n      this.log.debug(`Screen streaming is not running. There is nothing to stop`);\n    }\n    return;\n  }\n\n  const {\n    deviceStreamingProc,\n    gstreamerPipeline,\n    mjpegSocket,\n    mjpegServer,\n  } = this._screenStreamingProps;\n\n  try {\n    mjpegSocket.end();\n    if (mjpegServer.listening) {\n      mjpegServer.close();\n    }\n    if (deviceStreamingProc.kill(0)) {\n      deviceStreamingProc.kill('SIGINT');\n    }\n    if (gstreamerPipeline.isRunning) {\n      try {\n        await gstreamerPipeline.stop('SIGINT');\n      } catch (e) {\n        this.log.warn(e);\n        try {\n          await gstreamerPipeline.stop('SIGKILL');\n        } catch (e1) {\n          this.log.error(e1);\n        }\n      }\n    }\n    this.log.info(`Successfully terminated the screen streaming MJPEG server`);\n  } finally {\n    this._screenStreamingProps = null;\n  }\n};\n\n\nexport default commands;\n"],"mappings":"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"}
+exports.default = commands;
+//# sourceMappingURL=streamscreen.js.map