appium-android-driver 5.13.0 → 5.13.2

package/build/lib/commands/recordscreen.js

@@ -1,16 +1,14 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.commands = void 0;
-require("source-map-support/register");
-var _lodash = _interopRequireDefault(require("lodash"));
-var _asyncbox = require("asyncbox");
-var _support = require("@appium/support");
-var _teen_process = require("teen_process");
-var _path = _interopRequireDefault(require("path"));
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const asyncbox_1 = require("asyncbox");
+const support_1 = require("@appium/support");
+const teen_process_1 = require("teen_process");
+const path_1 = __importDefault(require("path"));
 const commands = {};
 exports.commands = commands;
 const RETRY_PAUSE = 300;
@@ -22,232 +20,303 @@ const PROCESS_SHUTDOWN_TIMEOUT = 10 * 1000;
 const SCREENRECORD_BINARY = 'screenrecord';
 const DEFAULT_EXT = '.mp4';
 const MIN_EMULATOR_API_LEVEL = 27;
-const FFMPEG_BINARY = `ffmpeg${_support.system.isWindows() ? '.exe' : ''}`;
+const FFMPEG_BINARY = `ffmpeg${support_1.system.isWindows() ? '.exe' : ''}`;
 async function uploadRecordedMedia(localFile, remotePath = null, uploadOptions = {}) {
-  if (_lodash.default.isEmpty(remotePath)) {
-    return (await _support.util.toInMemoryBase64(localFile)).toString();
-  }
-  const {
-    user,
-    pass,
-    method,
-    headers,
-    fileFieldName,
-    formFields
-  } = uploadOptions;
-  const options = {
-    method: method || 'PUT',
-    headers,
-    fileFieldName,
-    formFields
-  };
-  if (user && pass) {
-    options.auth = {
-      user,
-      pass
+    if (lodash_1.default.isEmpty(remotePath)) {
+        return (await support_1.util.toInMemoryBase64(localFile)).toString();
+    }
+    const { user, pass, method, headers, fileFieldName, formFields } = uploadOptions;
+    const options = {
+        method: method || 'PUT',
+        headers,
+        fileFieldName,
+        formFields,
     };
-  }
-  await _support.net.uploadFile(localFile, remotePath, options);
-  return '';
+    if (user && pass) {
+        options.auth = { user, pass };
+    }
+    await support_1.net.uploadFile(localFile, remotePath, options);
+    return '';
 }
 async function verifyScreenRecordIsSupported(adb, isEmulator) {
-  const apiLevel = await adb.getApiLevel();
-  if (isEmulator && apiLevel < MIN_EMULATOR_API_LEVEL) {
-    throw new Error(`Screen recording does not work on emulators running Android API level less than ${MIN_EMULATOR_API_LEVEL}`);
-  }
-  if (apiLevel < 19) {
-    throw new Error(`Screen recording not available on API Level ${apiLevel}. Minimum API Level is 19.`);
-  }
+    const apiLevel = await adb.getApiLevel();
+    if (isEmulator && apiLevel < MIN_EMULATOR_API_LEVEL) {
+        throw new Error(`Screen recording does not work on emulators running Android API level less than ${MIN_EMULATOR_API_LEVEL}`);
+    }
+    if (apiLevel < 19) {
+        throw new Error(`Screen recording not available on API Level ${apiLevel}. Minimum API Level is 19.`);
+    }
 }
 async function scheduleScreenRecord(adb, recordingProperties, log = null) {
-  if (recordingProperties.stopped) {
-    return;
-  }
-  const {
-    timer,
-    videoSize,
-    bitRate,
-    timeLimit,
-    bugReport
-  } = recordingProperties;
-  let currentTimeLimit = MAX_RECORDING_TIME_SEC;
-  if (_support.util.hasValue(recordingProperties.currentTimeLimit)) {
-    const currentTimeLimitInt = parseInt(recordingProperties.currentTimeLimit, 10);
-    if (!isNaN(currentTimeLimitInt) && currentTimeLimitInt < MAX_RECORDING_TIME_SEC) {
-      currentTimeLimit = currentTimeLimitInt;
-    }
-  }
-  const pathOnDevice = `/sdcard/${_support.util.uuidV4().substring(0, 8)}${DEFAULT_EXT}`;
-  const recordingProc = adb.screenrecord(pathOnDevice, {
-    videoSize,
-    bitRate,
-    timeLimit: currentTimeLimit,
-    bugReport
-  });
-  recordingProc.on('end', () => {
-    if (recordingProperties.stopped || !_support.util.hasValue(timeLimit)) {
-      return;
-    }
-    const currentDuration = timer.getDuration().asSeconds.toFixed(0);
-    log === null || log === void 0 ? void 0 : log.debug(`The overall screen recording duration is ${currentDuration}s so far`);
-    const timeLimitInt = parseInt(timeLimit, 10);
-    if (isNaN(timeLimitInt) || currentDuration >= timeLimitInt) {
-      log === null || log === void 0 ? void 0 : log.debug('There is no need to start the next recording chunk');
-      return;
-    }
-    recordingProperties.currentTimeLimit = timeLimitInt - currentDuration;
-    const chunkDuration = recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC ? recordingProperties.currentTimeLimit : MAX_RECORDING_TIME_SEC;
-    log === null || log === void 0 ? void 0 : log.debug(`Starting the next ${chunkDuration}s-chunk ` + `of screen recording in order to achieve ${timeLimitInt}s total duration`);
-    (async () => {
-      try {
-        await scheduleScreenRecord(adb, recordingProperties, log);
-      } catch (e) {
-        log === null || log === void 0 ? void 0 : log.error(e.stack);
-        recordingProperties.stopped = true;
-      }
-    })();
-  });
-  await recordingProc.start(0);
-  try {
-    await (0, _asyncbox.waitForCondition)(async () => await adb.fileExists(pathOnDevice), {
-      waitMs: RETRY_TIMEOUT,
-      intervalMs: RETRY_PAUSE
+    if (recordingProperties.stopped) {
+        return;
+    }
+    const { timer, videoSize, bitRate, timeLimit, bugReport, } = recordingProperties;
+    let currentTimeLimit = MAX_RECORDING_TIME_SEC;
+    if (support_1.util.hasValue(recordingProperties.currentTimeLimit)) {
+        const currentTimeLimitInt = parseInt(recordingProperties.currentTimeLimit, 10);
+        if (!isNaN(currentTimeLimitInt) && currentTimeLimitInt < MAX_RECORDING_TIME_SEC) {
+            currentTimeLimit = currentTimeLimitInt;
+        }
+    }
+    const pathOnDevice = `/sdcard/${support_1.util.uuidV4().substring(0, 8)}${DEFAULT_EXT}`;
+    const recordingProc = adb.screenrecord(pathOnDevice, {
+        videoSize,
+        bitRate,
+        timeLimit: currentTimeLimit,
+        bugReport,
+    });
+    recordingProc.on('end', () => {
+        if (recordingProperties.stopped || !support_1.util.hasValue(timeLimit)) {
+            return;
+        }
+        const currentDuration = timer.getDuration().asSeconds.toFixed(0);
+        log?.debug(`The overall screen recording duration is ${currentDuration}s so far`);
+        const timeLimitInt = parseInt(timeLimit, 10);
+        if (isNaN(timeLimitInt) || currentDuration >= timeLimitInt) {
+            log?.debug('There is no need to start the next recording chunk');
+            return;
+        }
+        recordingProperties.currentTimeLimit = timeLimitInt - currentDuration;
+        const chunkDuration = recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC
+            ? recordingProperties.currentTimeLimit
+            : MAX_RECORDING_TIME_SEC;
+        log?.debug(`Starting the next ${chunkDuration}s-chunk ` +
+            `of screen recording in order to achieve ${timeLimitInt}s total duration`);
+        (async () => {
+            try {
+                await scheduleScreenRecord(adb, recordingProperties, log);
+            }
+            catch (e) {
+                log?.error(e.stack);
+                recordingProperties.stopped = true;
+            }
+        })();
     });
-  } catch (e) {
-    throw new Error(`The expected screen record file '${pathOnDevice}' does not exist after ${RETRY_TIMEOUT}ms. ` + `Is ${SCREENRECORD_BINARY} utility available and operational on the device under test?`);
-  }
-  recordingProperties.records.push(pathOnDevice);
-  recordingProperties.recordingProcess = recordingProc;
+    await recordingProc.start(0);
+    try {
+        await (0, asyncbox_1.waitForCondition)(async () => await adb.fileExists(pathOnDevice), { waitMs: RETRY_TIMEOUT, intervalMs: RETRY_PAUSE });
+    }
+    catch (e) {
+        throw new Error(`The expected screen record file '${pathOnDevice}' does not exist after ${RETRY_TIMEOUT}ms. ` +
+            `Is ${SCREENRECORD_BINARY} utility available and operational on the device under test?`);
+    }
+    recordingProperties.records.push(pathOnDevice);
+    recordingProperties.recordingProcess = recordingProc;
 }
 async function mergeScreenRecords(mediaFiles, log = null) {
-  try {
-    await _support.fs.which(FFMPEG_BINARY);
-  } catch (e) {
-    throw new Error(`${FFMPEG_BINARY} utility is not available in PATH. Please install it from https://www.ffmpeg.org/`);
-  }
-  const configContent = mediaFiles.map(x => `file '${x}'`).join('\n');
-  const configFile = _path.default.resolve(_path.default.dirname(mediaFiles[0]), 'config.txt');
-  await _support.fs.writeFile(configFile, configContent, 'utf8');
-  log === null || log === void 0 ? void 0 : log.debug(`Generated ffmpeg merging config '${configFile}' with items:\n${configContent}`);
-  const result = _path.default.resolve(_path.default.dirname(mediaFiles[0]), `merge_${Math.floor(new Date())}${DEFAULT_EXT}`);
-  const args = ['-safe', '0', '-f', 'concat', '-i', configFile, '-c', 'copy', result];
-  log === null || log === void 0 ? void 0 : log.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);
-  await (0, _teen_process.exec)(FFMPEG_BINARY, args);
-  return result;
+    try {
+        await support_1.fs.which(FFMPEG_BINARY);
+    }
+    catch (e) {
+        throw new Error(`${FFMPEG_BINARY} utility is not available in PATH. Please install it from https://www.ffmpeg.org/`);
+    }
+    const configContent = mediaFiles
+        .map((x) => `file '${x}'`)
+        .join('\n');
+    const configFile = path_1.default.resolve(path_1.default.dirname(mediaFiles[0]), 'config.txt');
+    await support_1.fs.writeFile(configFile, configContent, 'utf8');
+    log?.debug(`Generated ffmpeg merging config '${configFile}' with items:\n${configContent}`);
+    const result = path_1.default.resolve(path_1.default.dirname(mediaFiles[0]), `merge_${Math.floor(new Date())}${DEFAULT_EXT}`);
+    const args = ['-safe', '0', '-f', 'concat', '-i', configFile, '-c', 'copy', result];
+    log?.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);
+    await (0, teen_process_1.exec)(FFMPEG_BINARY, args);
+    return result;
 }
 async function terminateBackgroundScreenRecording(adb, force = true) {
-  const pids = (await adb.getPIDsByName(SCREENRECORD_BINARY)).map(p => `${p}`);
-  if (_lodash.default.isEmpty(pids)) {
-    return false;
-  }
-  try {
-    await adb.shell(['kill', force ? '-15' : '-2', ...pids]);
-    await (0, _asyncbox.waitForCondition)(async () => _lodash.default.isEmpty(await adb.getPIDsByName(SCREENRECORD_BINARY)), {
-      waitMs: PROCESS_SHUTDOWN_TIMEOUT,
-      intervalMs: 500
-    });
-    return true;
-  } catch (err) {
-    throw new Error(`Unable to stop the background screen recording: ${err.message}`);
-  }
+    const pids = (await adb.getPIDsByName(SCREENRECORD_BINARY))
+        .map((p) => `${p}`);
+    if (lodash_1.default.isEmpty(pids)) {
+        return false;
+    }
+    try {
+        await adb.shell(['kill', force ? '-15' : '-2', ...pids]);
+        await (0, asyncbox_1.waitForCondition)(async () => lodash_1.default.isEmpty(await adb.getPIDsByName(SCREENRECORD_BINARY)), {
+            waitMs: PROCESS_SHUTDOWN_TIMEOUT,
+            intervalMs: 500,
+        });
+        return true;
+    }
+    catch (err) {
+        throw new Error(`Unable to stop the background screen recording: ${err.message}`);
+    }
 }
+/**
+ * @typedef {Object} StartRecordingOptions
+ *
+ * @property {?string} remotePath - The path to the remote location, where the captured video should be uploaded.
+ *                                  The following protocols are supported: http/https, ftp.
+ *                                  Null or empty string value (the default setting) means the content of resulting
+ *                                  file should be encoded as Base64 and passed as the endpount response value.
+ *                                  An exception will be thrown if the generated media file is too big to
+ *                                  fit into the available process memory.
+ *                                  This option only has an effect if there is screen recording process in progreess
+ *                                  and `forceRestart` parameter is not set to `true`.
+ * @property {?string} user - The name of the user for the remote authentication. Only works if `remotePath` is provided.
+ * @property {?string} pass - The password for the remote authentication. Only works if `remotePath` is provided.
+ * @property {?string} method [PUT] - The http multipart upload method name. Only works if `remotePath` is provided.
+ * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads
+ * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for
+ *                                            http(s) uploads
+ * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads
+ * @property {?string} videoSize - The format is widthxheight.
+ *                  The default value is the device's native display resolution (if supported),
+ *                  1280x720 if not. For best results,
+ *                  use a size supported by your device's Advanced Video Coding (AVC) encoder.
+ *                  For example, "1280x720"
+ * @property {?boolean} bugReport - Set it to `true` in order to display additional information on the video overlay,
+ *                                  such as a timestamp, that is helpful in videos captured to illustrate bugs.
+ *                                  This option is only supported since API level 27 (Android P).
+ * @property {?string|number} timeLimit - The maximum recording time, in seconds. The default value is 180 (3 minutes).
+ *                                        The maximum value is 1800 (30 minutes). If the passed value is greater than 180 then
+ *                                        the algorithm will try to schedule multiple screen recording chunks and merge the
+ *                                        resulting videos into a single media file using `ffmpeg` utility.
+ *                                        If the utility is not available in PATH then the most recent screen recording chunk is
+ *                                        going to be returned.
+ * @property {?string|number} bitRate - The video bit rate for the video, in bits per second.
+ *                The default value is 4000000 (4 Mbit/s). You can increase the bit rate to improve video quality,
+ *                but doing so results in larger movie files.
+ * @property {?boolean} forceRestart - Whether to try to catch and upload/return the currently running screen recording
+ *                                     (`false`, the default setting) or ignore the result of it and start a new recording
+ *                                     immediately (`true`).
+ */
+/**
+ * Record the display of a real devices running Android 4.4 (API level 19) and higher.
+ * Emulators are supported since API level 27 (Android P).
+ * It records screen activity to an MPEG-4 file. Audio is not recorded with the video file.
+ * If screen recording has been already started then the command will stop it forcefully and start a new one.
+ * The previously recorded video file will be deleted.
+ *
+ * @param {?StartRecordingOptions} options - The available options.
+ * @returns {string} Base64-encoded content of the recorded media file if
+ *                   any screen recording is currently running or an empty string.
+ * @throws {Error} If screen recording has failed to start or is not supported on the device under test.
+ */
 commands.startRecordingScreen = async function startRecordingScreen(options = {}) {
-  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
-  let result = '';
-  const {
-    videoSize,
-    timeLimit = DEFAULT_RECORDING_TIME_SEC,
-    bugReport,
-    bitRate,
-    forceRestart
-  } = options;
-  if (!forceRestart) {
-    result = await this.stopRecordingScreen(options);
-  }
-  if (await terminateBackgroundScreenRecording(this.adb, true)) {
-    this.log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` + `in the background. Make sure you stop screen recording each time after it is started, ` + `otherwise the recorded media might quickly exceed all the free space on the device under test.`);
-  }
-  if (!_lodash.default.isEmpty(this._screenRecordingProperties)) {
-    for (const record of this._screenRecordingProperties.records || []) {
-      await this.adb.rimraf(record);
-    }
-    this._screenRecordingProperties = null;
-  }
-  const timeout = parseFloat(timeLimit);
-  if (isNaN(timeout) || timeout > MAX_TIME_SEC || timeout <= 0) {
-    throw new Error(`The timeLimit value must be in range [1, ${MAX_TIME_SEC}] seconds. ` + `The value of '${timeLimit}' has been passed instead.`);
-  }
-  this._screenRecordingProperties = {
-    timer: new _support.timing.Timer().start(),
-    videoSize,
-    timeLimit,
-    currentTimeLimit: timeLimit,
-    bitRate,
-    bugReport,
-    records: [],
-    recordingProcess: null,
-    stopped: false
-  };
-  await scheduleScreenRecord(this.adb, this._screenRecordingProperties, this.log);
-  return result;
+    await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
+    let result = '';
+    const { videoSize, timeLimit = DEFAULT_RECORDING_TIME_SEC, bugReport, bitRate, forceRestart } = options;
+    if (!forceRestart) {
+        result = await this.stopRecordingScreen(options);
+    }
+    if (await terminateBackgroundScreenRecording(this.adb, true)) {
+        this.log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` +
+            `in the background. Make sure you stop screen recording each time after it is started, ` +
+            `otherwise the recorded media might quickly exceed all the free space on the device under test.`);
+    }
+    if (!lodash_1.default.isEmpty(this._screenRecordingProperties)) {
+        for (const record of (this._screenRecordingProperties.records || [])) {
+            await this.adb.rimraf(record);
+        }
+        this._screenRecordingProperties = null;
+    }
+    const timeout = parseFloat(timeLimit);
+    if (isNaN(timeout) || timeout > MAX_TIME_SEC || timeout <= 0) {
+        throw new Error(`The timeLimit value must be in range [1, ${MAX_TIME_SEC}] seconds. ` +
+            `The value of '${timeLimit}' has been passed instead.`);
+    }
+    this._screenRecordingProperties = {
+        timer: new support_1.timing.Timer().start(),
+        videoSize,
+        timeLimit,
+        currentTimeLimit: timeLimit,
+        bitRate,
+        bugReport,
+        records: [],
+        recordingProcess: null,
+        stopped: false,
+    };
+    await scheduleScreenRecord(this.adb, this._screenRecordingProperties, this.log);
+    return result;
 };
+/**
+ * @typedef {Object} StopRecordingOptions
+ *
+ * @property {?string} remotePath - The path to the remote location, where the resulting video should be uploaded.
+ *                                  The following protocols are supported: http/https, ftp.
+ *                                  Null or empty string value (the default setting) means the content of resulting
+ *                                  file should be encoded as Base64 and passed as the endpount response value.
+ *                                  An exception will be thrown if the generated media file is too big to
+ *                                  fit into the available process memory.
+ * @property {?string} user - The name of the user for the remote authentication.
+ * @property {?string} pass - The password for the remote authentication.
+ * @property {?string} method - The http multipart upload method name. The 'PUT' one is used by default.
+ * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads
+ * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for
+ *                                            http(s) uploads
+ * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads
+ */
+/**
+ * Stop recording the screen.
+ * If no screen recording has been started before then the method returns an empty string.
+ *
+ * @param {?StopRecordingOptions} options - The available options.
+ * @returns {string} Base64-encoded content of the recorded media file if 'remotePath'
+ *                   parameter is falsy or an empty string.
+ * @throws {Error} If there was an error while getting the name of a media file
+ *                 or the file content cannot be uploaded to the remote location
+ *                 or screen recording is not supported on the device under test.
+ */
 commands.stopRecordingScreen = async function stopRecordingScreen(options = {}) {
-  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
-  if (!_lodash.default.isEmpty(this._screenRecordingProperties)) {
-    this._screenRecordingProperties.stopped = true;
-  }
-  try {
-    await terminateBackgroundScreenRecording(this.adb, false);
-  } catch (err) {
-    this.log.warn(err.message);
-    if (!_lodash.default.isEmpty(this._screenRecordingProperties)) {
-      this.log.warn('The resulting video might be corrupted');
-    }
-  }
-  if (_lodash.default.isEmpty(this._screenRecordingProperties)) {
-    this.log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);
-    return '';
-  }
-  if (this._screenRecordingProperties.recordingProcess && this._screenRecordingProperties.recordingProcess.isRunning) {
+    await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
+    if (!lodash_1.default.isEmpty(this._screenRecordingProperties)) {
+        this._screenRecordingProperties.stopped = true;
+    }
     try {
-      await this._screenRecordingProperties.recordingProcess.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT);
-    } catch (e) {
-      this.log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);
-    }
-    this._screenRecordingProperties.recordingProcess = null;
-  }
-  if (_lodash.default.isEmpty(this._screenRecordingProperties.records)) {
-    this.log.errorAndThrow(`No screen recordings have been stored on the device so far. ` + `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`);
-  }
-  const tmpRoot = await _support.tempDir.openDir();
-  try {
-    const localRecords = [];
-    for (const pathOnDevice of this._screenRecordingProperties.records) {
-      localRecords.push(_path.default.resolve(tmpRoot, _path.default.posix.basename(pathOnDevice)));
-      await this.adb.pull(pathOnDevice, _lodash.default.last(localRecords));
-      await this.adb.rimraf(pathOnDevice);
-    }
-    let resultFilePath = _lodash.default.last(localRecords);
-    if (localRecords.length > 1) {
-      this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
-      try {
-        resultFilePath = await mergeScreenRecords(localRecords, this.log);
-      } catch (e) {
-        this.log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` + `Original error: ${e.message}`);
-      }
-    }
-    if (_lodash.default.isEmpty(options.remotePath)) {
-      const {
-        size
-      } = await _support.fs.stat(resultFilePath);
-      this.log.debug(`The size of the resulting screen recording is ${_support.util.toReadableSizeString(size)}`);
-    }
-    return await uploadRecordedMedia(resultFilePath, options.remotePath, options);
-  } finally {
-    await _support.fs.rimraf(tmpRoot);
-    this._screenRecordingProperties = null;
-  }
+        await terminateBackgroundScreenRecording(this.adb, false);
+    }
+    catch (err) {
+        this.log.warn(err.message);
+        if (!lodash_1.default.isEmpty(this._screenRecordingProperties)) {
+            this.log.warn('The resulting video might be corrupted');
+        }
+    }
+    if (lodash_1.default.isEmpty(this._screenRecordingProperties)) {
+        this.log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);
+        return '';
+    }
+    if (this._screenRecordingProperties.recordingProcess && this._screenRecordingProperties.recordingProcess.isRunning) {
+        try {
+            await this._screenRecordingProperties.recordingProcess.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT);
+        }
+        catch (e) {
+            this.log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);
+        }
+        this._screenRecordingProperties.recordingProcess = null;
+    }
+    if (lodash_1.default.isEmpty(this._screenRecordingProperties.records)) {
+        this.log.errorAndThrow(`No screen recordings have been stored on the device so far. ` +
+            `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`);
+    }
+    const tmpRoot = await support_1.tempDir.openDir();
+    try {
+        const localRecords = [];
+        for (const pathOnDevice of this._screenRecordingProperties.records) {
+            localRecords.push(path_1.default.resolve(tmpRoot, path_1.default.posix.basename(pathOnDevice)));
+            await this.adb.pull(pathOnDevice, lodash_1.default.last(localRecords));
+            await this.adb.rimraf(pathOnDevice);
+        }
+        let resultFilePath = lodash_1.default.last(localRecords);
+        if (localRecords.length > 1) {
+            this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
+            try {
+                resultFilePath = await mergeScreenRecords(localRecords, this.log);
+            }
+            catch (e) {
+                this.log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +
+                    `Original error: ${e.message}`);
+            }
+        }
+        if (lodash_1.default.isEmpty(options.remotePath)) {
+            const { size } = await support_1.fs.stat(resultFilePath);
+            this.log.debug(`The size of the resulting screen recording is ${support_1.util.toReadableSizeString(size)}`);
+        }
+        return await uploadRecordedMedia(resultFilePath, options.remotePath, options);
+    }
+    finally {
+        await support_1.fs.rimraf(tmpRoot);
+        this._screenRecordingProperties = null;
+    }
 };
-var _default = commands;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_asyncbox","_support","_teen_process","_path","commands","exports","RETRY_PAUSE","RETRY_TIMEOUT","MAX_RECORDING_TIME_SEC","MAX_TIME_SEC","DEFAULT_RECORDING_TIME_SEC","PROCESS_SHUTDOWN_TIMEOUT","SCREENRECORD_BINARY","DEFAULT_EXT","MIN_EMULATOR_API_LEVEL","FFMPEG_BINARY","system","isWindows","uploadRecordedMedia","localFile","remotePath","uploadOptions","_","isEmpty","util","toInMemoryBase64","toString","user","pass","method","headers","fileFieldName","formFields","options","auth","net","uploadFile","verifyScreenRecordIsSupported","adb","isEmulator","apiLevel","getApiLevel","Error","scheduleScreenRecord","recordingProperties","log","stopped","timer","videoSize","bitRate","timeLimit","bugReport","currentTimeLimit","hasValue","currentTimeLimitInt","parseInt","isNaN","pathOnDevice","uuidV4","substring","recordingProc","screenrecord","on","currentDuration","getDuration","asSeconds","toFixed","debug","timeLimitInt","chunkDuration","e","error","stack","start","waitForCondition","fileExists","waitMs","intervalMs","records","push","recordingProcess","mergeScreenRecords","mediaFiles","fs","which","configContent","map","x","join","configFile","path","resolve","dirname","writeFile","result","Math","floor","Date","args","info","exec","terminateBackgroundScreenRecording","force","pids","getPIDsByName","p","shell","err","message","startRecordingScreen","forceRestart","stopRecordingScreen","warn","_screenRecordingProperties","record","rimraf","timeout","parseFloat","timing","Timer","isRunning","stop","errorAndThrow","tmpRoot","tempDir","openDir","localRecords","posix","basename","pull","last","resultFilePath","length","size","stat","toReadableSizeString","_default","default"],"sources":["../../../lib/commands/recordscreen.js"],"sourcesContent":["import _ from 'lodash';\nimport { waitForCondition } from 'asyncbox';\nimport { util, fs, net, tempDir, system, timing } from '@appium/support';\nimport { exec } from 'teen_process';\nimport path from 'path';\n\n\nconst commands = {};\n\nconst RETRY_PAUSE = 300;\nconst RETRY_TIMEOUT = 5000;\nconst MAX_RECORDING_TIME_SEC = 60 * 3;\nconst MAX_TIME_SEC = 60 * 30;\nconst DEFAULT_RECORDING_TIME_SEC = MAX_RECORDING_TIME_SEC;\nconst PROCESS_SHUTDOWN_TIMEOUT = 10 * 1000;\nconst SCREENRECORD_BINARY = 'screenrecord';\nconst DEFAULT_EXT = '.mp4';\nconst MIN_EMULATOR_API_LEVEL = 27;\nconst FFMPEG_BINARY = `ffmpeg${system.isWindows() ? '.exe' : ''}`;\n\nasync function uploadRecordedMedia (localFile, remotePath = null, uploadOptions = {}) {\n  if (_.isEmpty(remotePath)) {\n    return (await util.toInMemoryBase64(localFile)).toString();\n  }\n\n  const {user, pass, method, headers, fileFieldName, formFields} = uploadOptions;\n  const options = {\n    method: method || 'PUT',\n    headers,\n    fileFieldName,\n    formFields,\n  };\n  if (user && pass) {\n    options.auth = {user, pass};\n  }\n  await net.uploadFile(localFile, remotePath, options);\n  return '';\n}\n\nasync function verifyScreenRecordIsSupported (adb, isEmulator) {\n  const apiLevel = await adb.getApiLevel();\n  if (isEmulator && apiLevel < MIN_EMULATOR_API_LEVEL) {\n    throw new Error(`Screen recording does not work on emulators running Android API level less than ${MIN_EMULATOR_API_LEVEL}`);\n  }\n  if (apiLevel < 19) {\n    throw new Error(`Screen recording not available on API Level ${apiLevel}. Minimum API Level is 19.`);\n  }\n}\n\nasync function scheduleScreenRecord (adb, recordingProperties, log = null) {\n  if (recordingProperties.stopped) {\n    return;\n  }\n\n  const {\n    timer,\n    videoSize,\n    bitRate,\n    timeLimit,\n    bugReport,\n  } = recordingProperties;\n\n  let currentTimeLimit = MAX_RECORDING_TIME_SEC;\n  if (util.hasValue(recordingProperties.currentTimeLimit)) {\n    const currentTimeLimitInt = parseInt(recordingProperties.currentTimeLimit, 10);\n    if (!isNaN(currentTimeLimitInt) && currentTimeLimitInt < MAX_RECORDING_TIME_SEC) {\n      currentTimeLimit = currentTimeLimitInt;\n    }\n  }\n  const pathOnDevice = `/sdcard/${util.uuidV4().substring(0, 8)}${DEFAULT_EXT}`;\n  const recordingProc = adb.screenrecord(pathOnDevice, {\n    videoSize,\n    bitRate,\n    timeLimit: currentTimeLimit,\n    bugReport,\n  });\n\n  recordingProc.on('end', () => {\n    if (recordingProperties.stopped || !util.hasValue(timeLimit)) {\n      return;\n    }\n    const currentDuration = timer.getDuration().asSeconds.toFixed(0);\n    log?.debug(`The overall screen recording duration is ${currentDuration}s so far`);\n    const timeLimitInt = parseInt(timeLimit, 10);\n    if (isNaN(timeLimitInt) || currentDuration >= timeLimitInt) {\n      log?.debug('There is no need to start the next recording chunk');\n      return;\n    }\n\n    recordingProperties.currentTimeLimit = timeLimitInt - currentDuration;\n    const chunkDuration = recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC\n      ? recordingProperties.currentTimeLimit\n      : MAX_RECORDING_TIME_SEC;\n    log?.debug(`Starting the next ${chunkDuration}s-chunk ` +\n      `of screen recording in order to achieve ${timeLimitInt}s total duration`);\n    (async () => {\n      try {\n        await scheduleScreenRecord(adb, recordingProperties, log);\n      } catch (e) {\n        log?.error(e.stack);\n        recordingProperties.stopped = true;\n      }\n    })();\n  });\n\n  await recordingProc.start(0);\n  try {\n    await waitForCondition(async () => await adb.fileExists(pathOnDevice),\n      {waitMs: RETRY_TIMEOUT, intervalMs: RETRY_PAUSE});\n  } catch (e) {\n    throw new Error(`The expected screen record file '${pathOnDevice}' does not exist after ${RETRY_TIMEOUT}ms. ` +\n      `Is ${SCREENRECORD_BINARY} utility available and operational on the device under test?`);\n  }\n\n  recordingProperties.records.push(pathOnDevice);\n  recordingProperties.recordingProcess = recordingProc;\n}\n\nasync function mergeScreenRecords (mediaFiles, log = null) {\n  try {\n    await fs.which(FFMPEG_BINARY);\n  } catch (e) {\n    throw new Error(`${FFMPEG_BINARY} utility is not available in PATH. Please install it from https://www.ffmpeg.org/`);\n  }\n  const configContent = mediaFiles\n    .map((x) => `file '${x}'`)\n    .join('\\n');\n  const configFile = path.resolve(path.dirname(mediaFiles[0]), 'config.txt');\n  await fs.writeFile(configFile, configContent, 'utf8');\n  log?.debug(`Generated ffmpeg merging config '${configFile}' with items:\\n${configContent}`);\n  const result = path.resolve(path.dirname(mediaFiles[0]), `merge_${Math.floor(new Date())}${DEFAULT_EXT}`);\n  const args = ['-safe', '0', '-f', 'concat', '-i', configFile, '-c', 'copy', result];\n  log?.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);\n  await exec(FFMPEG_BINARY, args);\n  return result;\n}\n\nasync function terminateBackgroundScreenRecording (adb, force = true) {\n  const pids = (await adb.getPIDsByName(SCREENRECORD_BINARY))\n    .map((p) => `${p}`);\n  if (_.isEmpty(pids)) {\n    return false;\n  }\n\n  try {\n    await adb.shell(['kill', force ? '-15' : '-2', ...pids]);\n    await waitForCondition(async () => _.isEmpty(await adb.getPIDsByName(SCREENRECORD_BINARY)), {\n      waitMs: PROCESS_SHUTDOWN_TIMEOUT,\n      intervalMs: 500,\n    });\n    return true;\n  } catch (err) {\n    throw new Error(`Unable to stop the background screen recording: ${err.message}`);\n  }\n}\n\n\n/**\n * @typedef {Object} StartRecordingOptions\n *\n * @property {?string} remotePath - The path to the remote location, where the captured video should be uploaded.\n *                                  The following protocols are supported: http/https, ftp.\n *                                  Null or empty string value (the default setting) means the content of resulting\n *                                  file should be encoded as Base64 and passed as the endpount response value.\n *                                  An exception will be thrown if the generated media file is too big to\n *                                  fit into the available process memory.\n *                                  This option only has an effect if there is screen recording process in progreess\n *                                  and `forceRestart` parameter is not set to `true`.\n * @property {?string} user - The name of the user for the remote authentication. Only works if `remotePath` is provided.\n * @property {?string} pass - The password for the remote authentication. Only works if `remotePath` is provided.\n * @property {?string} method [PUT] - The http multipart upload method name. Only works if `remotePath` is provided.\n * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads\n * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for\n *                                            http(s) uploads\n * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads\n * @property {?string} videoSize - The format is widthxheight.\n *                  The default value is the device's native display resolution (if supported),\n *                  1280x720 if not. For best results,\n *                  use a size supported by your device's Advanced Video Coding (AVC) encoder.\n *                  For example, \"1280x720\"\n * @property {?boolean} bugReport - Set it to `true` in order to display additional information on the video overlay,\n *                                  such as a timestamp, that is helpful in videos captured to illustrate bugs.\n *                                  This option is only supported since API level 27 (Android P).\n * @property {?string|number} timeLimit - The maximum recording time, in seconds. The default value is 180 (3 minutes).\n *                                        The maximum value is 1800 (30 minutes). If the passed value is greater than 180 then\n *                                        the algorithm will try to schedule multiple screen recording chunks and merge the\n *                                        resulting videos into a single media file using `ffmpeg` utility.\n *                                        If the utility is not available in PATH then the most recent screen recording chunk is\n *                                        going to be returned.\n * @property {?string|number} bitRate - The video bit rate for the video, in bits per second.\n *                The default value is 4000000 (4 Mbit/s). You can increase the bit rate to improve video quality,\n *                but doing so results in larger movie files.\n * @property {?boolean} forceRestart - Whether to try to catch and upload/return the currently running screen recording\n *                                     (`false`, the default setting) or ignore the result of it and start a new recording\n *                                     immediately (`true`).\n */\n\n/**\n * Record the display of a real devices running Android 4.4 (API level 19) and higher.\n * Emulators are supported since API level 27 (Android P).\n * It records screen activity to an MPEG-4 file. Audio is not recorded with the video file.\n * If screen recording has been already started then the command will stop it forcefully and start a new one.\n * The previously recorded video file will be deleted.\n *\n * @param {?StartRecordingOptions} options - The available options.\n * @returns {string} Base64-encoded content of the recorded media file if\n *                   any screen recording is currently running or an empty string.\n * @throws {Error} If screen recording has failed to start or is not supported on the device under test.\n */\ncommands.startRecordingScreen = async function startRecordingScreen (options = {}) {\n  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());\n\n  let result = '';\n  const {videoSize, timeLimit = DEFAULT_RECORDING_TIME_SEC, bugReport, bitRate, forceRestart} = options;\n  if (!forceRestart) {\n    result = await this.stopRecordingScreen(options);\n  }\n\n  if (await terminateBackgroundScreenRecording(this.adb, true)) {\n    this.log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` +\n      `in the background. Make sure you stop screen recording each time after it is started, ` +\n      `otherwise the recorded media might quickly exceed all the free space on the device under test.`);\n  }\n\n  if (!_.isEmpty(this._screenRecordingProperties)) {\n    for (const record of (this._screenRecordingProperties.records || [])) {\n      await this.adb.rimraf(record);\n    }\n    this._screenRecordingProperties = null;\n  }\n\n  const timeout = parseFloat(timeLimit);\n  if (isNaN(timeout) || timeout > MAX_TIME_SEC || timeout <= 0) {\n    throw new Error(`The timeLimit value must be in range [1, ${MAX_TIME_SEC}] seconds. ` +\n      `The value of '${timeLimit}' has been passed instead.`);\n  }\n\n  this._screenRecordingProperties = {\n    timer: new timing.Timer().start(),\n    videoSize,\n    timeLimit,\n    currentTimeLimit: timeLimit,\n    bitRate,\n    bugReport,\n    records: [],\n    recordingProcess: null,\n    stopped: false,\n  };\n  await scheduleScreenRecord(this.adb, this._screenRecordingProperties, this.log);\n  return result;\n};\n\n/**\n * @typedef {Object} StopRecordingOptions\n *\n * @property {?string} remotePath - The path to the remote location, where the resulting video should be uploaded.\n *                                  The following protocols are supported: http/https, ftp.\n *                                  Null or empty string value (the default setting) means the content of resulting\n *                                  file should be encoded as Base64 and passed as the endpount response value.\n *                                  An exception will be thrown if the generated media file is too big to\n *                                  fit into the available process memory.\n * @property {?string} user - The name of the user for the remote authentication.\n * @property {?string} pass - The password for the remote authentication.\n * @property {?string} method - The http multipart upload method name. The 'PUT' one is used by default.\n * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads\n * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for\n *                                            http(s) uploads\n * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads\n */\n\n/**\n * Stop recording the screen.\n * If no screen recording has been started before then the method returns an empty string.\n *\n * @param {?StopRecordingOptions} options - The available options.\n * @returns {string} Base64-encoded content of the recorded media file if 'remotePath'\n *                   parameter is falsy or an empty string.\n * @throws {Error} If there was an error while getting the name of a media file\n *                 or the file content cannot be uploaded to the remote location\n *                 or screen recording is not supported on the device under test.\n */\ncommands.stopRecordingScreen = async function stopRecordingScreen (options = {}) {\n  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());\n\n  if (!_.isEmpty(this._screenRecordingProperties)) {\n    this._screenRecordingProperties.stopped = true;\n  }\n\n  try {\n    await terminateBackgroundScreenRecording(this.adb, false);\n  } catch (err) {\n    this.log.warn(err.message);\n    if (!_.isEmpty(this._screenRecordingProperties)) {\n      this.log.warn('The resulting video might be corrupted');\n    }\n  }\n\n  if (_.isEmpty(this._screenRecordingProperties)) {\n    this.log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);\n    return '';\n  }\n\n  if (this._screenRecordingProperties.recordingProcess && this._screenRecordingProperties.recordingProcess.isRunning) {\n    try {\n      await this._screenRecordingProperties.recordingProcess.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT);\n    } catch (e) {\n      this.log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);\n    }\n    this._screenRecordingProperties.recordingProcess = null;\n  }\n\n  if (_.isEmpty(this._screenRecordingProperties.records)) {\n    this.log.errorAndThrow(`No screen recordings have been stored on the device so far. ` +\n      `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`);\n  }\n\n  const tmpRoot = await tempDir.openDir();\n  try {\n    const localRecords = [];\n    for (const pathOnDevice of this._screenRecordingProperties.records) {\n      localRecords.push(path.resolve(tmpRoot, path.posix.basename(pathOnDevice)));\n      await this.adb.pull(pathOnDevice, _.last(localRecords));\n      await this.adb.rimraf(pathOnDevice);\n    }\n    let resultFilePath = _.last(localRecords);\n    if (localRecords.length > 1) {\n      this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);\n      try {\n        resultFilePath = await mergeScreenRecords(localRecords, this.log);\n      } catch (e) {\n        this.log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +\n          `Original error: ${e.message}`);\n      }\n    }\n    if (_.isEmpty(options.remotePath)) {\n      const {size} = await fs.stat(resultFilePath);\n      this.log.debug(`The size of the resulting screen recording is ${util.toReadableSizeString(size)}`);\n    }\n    return await uploadRecordedMedia(resultFilePath, options.remotePath, options);\n  } finally {\n    await fs.rimraf(tmpRoot);\n    this._screenRecordingProperties = null;\n  }\n};\n\n\nexport { commands };\nexport default commands;\n"],"mappings":"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"}
+exports.default = commands;
+//# sourceMappingURL=recordscreen.js.map