Appium Screen Recording Solution Evaluation Report

1
2
3
4
# Works on Android / iOS; throws exception on Windows
driver.start_recording_screen()
# ... run tests ...
video = driver.stop_recording_screen()  # Returns base64, must decode to disk yourself

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import subprocess
import atexit

class FfmpegRecorder:
    def __init__(self, output_path):
        self.process = subprocess.Popen([
            "ffmpeg",
            "-f", "gdigrab",
            "-framerate", "10",
            "-i", "desktop",
            "-c:v", "h264_qsv",  # or libx264 / h264_nvenc
            "-preset", "fast",
            "-pix_fmt", "yuv420p",
            "-y",  # Overwrite existing file
            output_path
        ])
        atexit.register(self.stop)  # Ensure cleanup

    def stop(self):
        if self.process and self.process.poll() is None:
            self.process.terminate()  # Send SIGTERM; ffmpeg flushes gracefully
            self.process.wait(timeout=5)

# Start before tests
recorder = FfmpegRecorder("test_login.mp4")

# ... execute Appium tests (even if Appium crashes, ffmpeg keeps running) ...

# Stop after tests
recorder.stop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import threading
import time
from selenium.webdriver.common.by import By

class ScreenshotRecorder:
    def __init__(self, driver, output_dir, fps=5):
        self.driver = driver
        self.output_dir = output_dir
        self.fps = fps
        self.frames = []
        self.running = False
        self.thread = None

    def start(self):
        self.running = True
        self.thread = threading.Thread(target=self._loop)
        self.thread.start()

    def _loop(self):
        idx = 0
        interval = 1.0 / self.fps
        while self.running:
            start = time.time()
            try:
                # Full-page screenshot (works best for browsers)
                png = self.driver.get_screenshot_as_png()
                with open(f"{self.output_dir}/frame_{idx:05d}.png", "wb") as f:
                    f.write(png)
                idx += 1
            except Exception:
                # Exit loop when WebDriver connection drops
                break
            elapsed = time.time() - start
            sleep_time = interval - elapsed
            if sleep_time > 0:
                time.sleep(sleep_time)

    def stop(self):
        self.running = False
        if self.thread:
            self.thread.join(timeout=5)

    def encode(self, output_mp4):
        import subprocess
        subprocess.run([
            "ffmpeg", "-framerate", str(self.fps),
            "-i", f"{self.output_dir}/frame_%05d.png",
            "-c:v", "libx264", "-pix_fmt", "yuv420p",
            "-y", output_mp4
        ], check=True)

# Usage example
recorder = ScreenshotRecorder(driver, "/tmp/frames", fps=5)
recorder.start()
# ... run tests ...
recorder.stop()
recorder.encode("/tmp/test_output.mp4")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Obtain video frame stream via Chrome DevTools Protocol
# Doesn't rely on WebDriver or screen output
from selenium.webdriver.chrome.service import Service
from selenium.webdriver import Chrome

driver = Chrome()
# Enable CDP Screencast
driver.execute_cdp_cmd("Page.startScreencast", {
    "format": "jpeg",
    "quality": 80,
    "maxWidth": 1280,
    "maxHeight": 720,
    "everyNthFrame": 2  # Lower frame rate to reduce overhead
})

# Receive frame data in event listener and write to file
# (Event callback implementation omitted; can use websocket or selenium-devtools library)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import os
import platform
from enum import Enum

class RecordingBackend(Enum):
    FFMPEG_GDIGRAB = "ffmpeg_gdigrab"      # Windows desktop / headful browsers
    WEBDRIVER_SCREENSHOT = "webdriver_ss"   # Headless / no desktop session
    CDP_SCREENCAST = "cdp_screencast"       # Optimal for headless Chrome

class UnifiedRecorder:
    def __init__(self, driver, output_path, target_type="desktop"):
        self.output_path = output_path
        self.driver = driver
        self.target_type = target_type
        self.backend = self._select_backend()
        self.impl = self._create_impl()

    def _select_backend(self):
        system = platform.system()
        is_headless = os.environ.get("HEADLESS", "false").lower() == "true"
        has_display = os.environ.get("DISPLAY") or system == "Windows"

        if system == "Windows" and not is_headless:
            return RecordingBackend.FFMPEG_GDIGRAB
        elif is_headless or not has_display:
            return RecordingBackend.WEBDRIVER_SCREENSHOT
        else:
            return RecordingBackend.FFMPEG_GDIGRAB

    def _create_impl(self):
        if self.backend == RecordingBackend.FFMPEG_GDIGRAB:
            return FfmpegRecorder(self.output_path)
        else:
            return ScreenshotRecorder(self.driver, "/tmp/frames", output_mp4=self.output_path)

    def start(self):
        self.impl.start()

    def stop(self):
        self.impl.stop()

# Usage: one line automatically selects the optimal backend
recorder = UnifiedRecorder(driver, "output/test_login.mp4", target_type="browser")
recorder.start()
# ... run tests ...
recorder.stop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import atexit
import signal

recorder = UnifiedRecorder(driver, output_path)
recorder.start()

# Register multiple safeguards
atexit.register(recorder.stop)  # Normal exit / uncaught exception
signal.signal(signal.SIGTERM, lambda *_: recorder.stop())  # kill -15
signal.signal(signal.SIGINT, lambda *_: recorder.stop())   # Ctrl+C

# Extra protection for ffmpeg backend: ffmpeg itself is an independent process.
# Even if Python crashes, we only need to ensure ffmpeg is eventually terminated
# (can use a watchdog process for monitoring)