DEV Community: Lijiawei

Tackling Intermittent Android Bugs: Rolling Video Buffers and Automated Logcat Alignment in the Browser

Lijiawei — Wed, 09 Sep 2026 02:49:49 +0000

Tackling Intermittent Android Bugs: Rolling Video Buffers and Automated Logcat Alignment in the Browser

Every mobile QA engineer and Android developer has experienced this nightmare scenario:

You are testing a complex user flow—perhaps a multi-step checkout or a flaky gesture interaction. Suddenly, the app freezes with an Application Not Responding (ANR) dialog, or abruptly crashes back to the home screen.

You freeze.

Did I have screen recording turned on? No.

Was a terminal running adb logcat in the background? No.

Can you reproduce it on the next attempt? Of course not.

Even if you keep a desktop screen recorder running all day, you are left with a 45-minute, 2GB video file and a 200,000-line logcat dump. Handing those massive, disconnected files to an engineer is a guaranteed recipe for frustration.

In this article, we'll examine the engineering principles behind solving intermittent mobile bugs: implementing an in-browser rolling ring buffer that continuously captures screen video and streams logcat, automatically isolating the crash context the moment it occurs.

1. The Core Architecture: Dual-Stream Asynchronous Buffering

To capture unexpected bugs without blowing up browser memory, we need two decoupled, continuous streams running in a sliding window (e.g., the most recent 120–180 seconds):

                     +---------------------------------------+
                     |         Live Android Device           |
                     +-------------------+-------------------+
                                         |
                       [ WebUSB Transport Pipeline ]
                                         |
                 +-----------------------+-----------------------+
                 |                                               |
                 v                                               v
       [ Video Frame Stream ]                         [ Raw Logcat Stream ]
                 |                                               |
                 v                                               v
      +--------------------+                         +--------------------+
      | 1-Second GOP Chunk |                         | Regex Filter Engine|
      |   (WebCodecs API)  |                         | (Package & Crash)  |
      +----------+---------+                         +----------+---------+
                 |                                               |
                 v                                               v
      +--------------------+                         +--------------------+
      | Rolling RingBuffer |                         | Chrono Log Buffer  |
      | (Sliding 180s Max) |                         | (Keyed by WallTime)|
      +----------+---------+                         +----------+---------+
                 |                                               |
                 +-----------------------+-----------------------+
                                         |
                                         v  [ Trigger: Crash Detected or Manual Stop ]
                             +-----------------------+
                             | Sliced MP4 + Log Slice|
                             |   Timestamp Aligned   |
                             +-----------------------+

2. Implementing the High-Performance Rolling Ring Buffer

A circular ring buffer allows continuous pushing of streaming chunks with $O(1)$ amortized memory allocation, automatically overwriting expired slices.

Here is the TypeScript/JavaScript implementation used for managing video and log chunks:

export interface TimeStampedChunk {
  timestamp: number; // Monotonic performance.now()
  data: Uint8Array | Blob | string;
}

export class SlidingRingBuffer<T extends TimeStampedChunk> {
  private buffer: (T | null)[];
  private capacity: number;
  private head: number = 0;
  private currentSize: number = 0;

  constructor(maxItems: number) {
    this.capacity = maxItems;
    this.buffer = new Array(maxItems).fill(null);
  }

  public push(item: T): void {
    this.buffer[this.head] = item;
    this.head = (this.head + 1) % this.capacity;
    if (this.currentSize < this.capacity) {
      this.currentSize++;
    }
  }

  // Returns all items ordered chronologically from oldest to newest
  public dump(): T[] {
    const result: T[] = [];
    const startIndex = this.currentSize < this.capacity ? 0 : this.head;

    for (let i = 0; i < this.currentSize; i++) {
      const idx = (startIndex + i) % this.capacity;
      const item = this.buffer[idx];
      if (item !== null) {
        result.push(item);
      }
    }
    return result;
  }

  // Slices only the last N seconds prior to the trigger event
  public dumpRecent(durationMs: number): T[] {
    const all = this.dump();
    if (all.length === 0) return [];

    const latestTime = all[all.length - 1].timestamp;
    const cutoffTime = latestTime - durationMs;
    return all.filter(item => item.timestamp >= cutoffTime);
  }
}

3. Real-Time Logcat Filtering & Anomaly Detection

A continuous logcat stream outputs thousands of lines per second across the entire operating system. To make it actionable:

Target Package Isolation: We resolve the foreground PID and filter specifically for the application under test.
Signature Matching: We run regex state machines listening for FATAL EXCEPTION, ANR in <package>, and AndroidRuntime: E patterns.

// Stream parser and crash detector
const CRASH_SIGNATURES = [
  /FATAL EXCEPTION:\s*(.*)/i,
  /AndroidRuntime:\s*Process:\s*([a-zA-Z0-9._]+),\s*PID:\s*(\d+)/i,
  /ActivityManager:\s*ANR in\s*([a-zA-Z0-9._]+)/i
];

function processLogLine(rawLine, targetPackage, logBuffer, onCrashDetected) {
  const monotonicTime = performance.now();

  // Format: MM-DD HH:MM:SS.mmm PID TID Level Tag: Message
  const isRelevant = rawLine.includes(targetPackage) || 
                     CRASH_SIGNATURES.some(sig => sig.test(rawLine));

  if (!isRelevant) return;

  // Store structured log entry with synchronized monotonic timestamp
  logBuffer.push({
    timestamp: monotonicTime,
    data: rawLine
  });

  // Check for critical anomalies
  for (const regex of CRASH_SIGNATURES) {
    if (regex.test(rawLine)) {
      onCrashDetected({
        signature: rawLine,
        detectedAt: monotonicTime
      });
      break;
    }
  }
}

4. Aligning Video Frame Presentation with Log Timestamps

The most difficult challenge in mobile debugging is correlating what the user saw with what the operating system threw.

The Problem: Android's logcat timestamps reflect the device's internal Real-Time Clock (RTC), which may have clock drift relative to the host computer recording the video.
The Solution (Monotonic Anchor Sync):
1. When initiating the WebUSB session, the host queries the device uptime via SystemClock.elapsedRealtime();
2. Simultaneously, the browser records performance.now();
3. Every incoming H.264 video keyframe and every parsed log line is indexed against this common monotonic host timeline.

When a crash occurs, the exported package contains:

A trimmed MP4 video focusing specifically on the 30–60 seconds leading up to the issue;
A parsed Markdown file matching visual timestamps (00:23s - Screen tap) directly with corresponding error logs (00:23.412 - NullPointerException at MainActivity.java:84).

5. Architectural Comparison: Full Dump vs. Sliced Capture

Metric	Traditional Full Device Dump	Sliding Buffer Capture (TabQA Model)
File Footprint	500MB – 2GB (Full MP4 + Raw Logcat)	5MB – 25MB (Targeted Clip + Sliced Context)
Developer Triaging Time	15–30 minutes (Manual scrubbing & grepping)	< 2 minutes (Instant stack trace + visual repro)
Crash Discovery	Lost if not proactively recording	Retrospective capture ("Rewind" anytime)
Storage Impact	Rapidly fills disk with stale runs	Zero persistent bloat (Held in volatile RAM)
Host Toolchain Required	Desktop Screen Recorder + ADB Terminal	100% Browser Side Panel (No local install)

6. Open-Source Implementation

This sliding window architecture, combining WebUSB device streaming and retrospective evidence capture, is fully implemented in the open-source browser extension TabQA.

GitHub Repository: https://github.com/openutx/TabQA
Detailed Workflow Guide: https://tabqa.openutx.cn/en/guides/record-android-screen-and-logcat
Install Free on Chrome: Chrome Web Store Link

If your team struggles with capturing intermittent mobile crashes or aligning test evidence with bug trackers like Jira or Notion, feel free to give this browser-native approach a try!

How to Test Android Devices and Intercept WebView Traffic Directly in Chrome (Without Local ADB)

Lijiawei — Tue, 08 Sep 2026 04:23:08 +0000

How to Test Android Devices and Intercept WebView Traffic Directly in Chrome (Without Local ADB)

If you have ever tested mobile apps on Android, you are likely familiar with the friction of the traditional toolchain:

You plug in the phone and launch desktop mirroring tools like Scrcpy or Vysor;
You open a terminal to stream adb logcat and manually grep for errors;
If you need to inspect HTTPS traffic in an embedded WebView or hybrid app, you configure Charles or Fiddler, setup Wi-Fi proxies, and struggle with Android 7+ (API 24+) rejecting user-installed CA root certificates;
When an intermittent crash or ANR occurs, you scramble to take screenshots, clip screen recordings, align timestamps with logs, and assemble everything into Jira or Notion.

A recurring question arose in our engineering team:

Can we consolidate device mirroring, log filtering, network traffic interception, and bug evidence collection natively inside the browser—without requiring local ADB binaries, drivers, or desktop proxy software?

This article explores the technical implementation of such a workspace, leveraging the WebUSB API for hardware communication and the Chrome DevTools Protocol (CDP) for certificate-free network interception, based on our open-source project TabQA.

1. Direct Hardware Communication: Implementing ADB over WebUSB

Traditional Android debugging relies on an ADB server process listening on host port 5037. In multi-developer environments or non-technical QA machines, this often results in SDK configuration hurdles or adb server version doesn't match this client conflicts.

Modern Chromium browsers provide the WebUSB API, enabling secure user-authorized contexts to communicate directly with physical USB bulk endpoints.

1.1 Device Filtering and Interface Claiming

According to the Android Open Source Project (AOSP) specification, the ADB interface defines a fixed descriptor:

bInterfaceClass: 0xff (Vendor Specific)
bInterfaceSubClass: 0x42 (ADB)
bInterfaceProtocol: 0x01

In the browser, we request the device via permission prompts:

// Filter and request Android devices matching ADB interface descriptors
const device = await navigator.usb.requestDevice({
  filters: [{
    classCode: 0xff,
    subclassCode: 0x42,
    protocolCode: 0x01
  }]
});

await device.open();
await device.selectConfiguration(1);

// Locate and claim the ADB interface
const adbInterface = device.configuration.interfaces.find(iface =>
  iface.alternates.some(alt => alt.interfaceClass === 0xff && alt.interfaceSubclass === 0x42)
);
await device.claimInterface(adbInterface.interfaceNumber);

1.2 Framing ADB Packets & In-Memory RSA Authentication

Communication requires implementing the 24-byte binary ADB header directly in JavaScript:

// ADB message header format: command, arg0, arg1, data_length, data_checksum, magic
function createAdbPacket(command, arg0, arg1, payload = new Uint8Array(0)) {
  const header = new ArrayBuffer(24);
  const view = new DataView(header);

  view.setUint32(0, command, true);              // A_CNXN, A_OPEN, A_WRTE, etc.
  view.setUint32(4, arg0, true);
  view.setUint32(8, arg1, true);
  view.setUint32(12, payload.byteLength, true);  // Payload size
  view.setUint32(16, calculateChecksum(payload), true);
  view.setUint32(20, command ^ 0xffffffff, true);// Magic verification

  return concatBuffers(header, payload.buffer);
}

When connecting to an unauthorized device, Android replies with an A_AUTH challenge. The browser extension generates a 2048-bit RSA key pair in-memory (or loads a stored key from chrome.storage.local), encodes the public key in Android's expected token format, and sends it to the device. Once the user taps "Allow USB Debugging" on their screen, the transport channel is established.

No system adb process is invoked, eliminating port contention entirely.

2. Inspecting WebView Traffic Without CA Certificates (CDP)

Inspecting HTTPS network requests in mobile WebViews or hybrid apps is notoriously painful due to SSL Pinning and Android 7+ Network Security Config restrictions.

2.1 Forwarding DevTools Sockets

Android Chrome and debug-enabled WebViews (WebView.setWebContentsDebuggingEnabled(true)) expose an abstract Unix domain socket on the device (e.g., @webview_devtools_remote_<pid>).

By issuing an ADB port forward command across our WebUSB connection, the browser connects to the target WebView via a standard WebSocket.

2.2 Direct CDP Network Inspection

Once connected, we send Chrome DevTools Protocol commands directly to the engine:

// Enable network event streaming from the WebView
function startNetworkCapture(ws) {
  ws.send(JSON.stringify({
    id: 1,
    method: 'Network.enable',
    params: {
      maxPostDataSize: 65536 // Capture request bodies up to 64KB
    }
  }));
}

// Receive parsed network events
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);

  if (data.method === 'Network.responseReceived') {
    const { requestId, response } = data.params;
    console.log(`[Status ${response.status}] ${response.url}`);

    // Fetch response body on demand
    ws.send(JSON.stringify({
      id: generateUniqueId(),
      method: 'Network.getResponseBody',
      params: { requestId }
    }));
  }
};

Because telemetry is extracted directly from the Chromium rendering process:

No CA root certificates are required on the Android device;
No Wi-Fi proxy or DNS tampering is needed;
Requests, response headers, payloads, and timings are extracted cleanly, ready for export as cURL or sanitized HAR.

3. Rolling Ring Buffers for Video and Log Synchronization

Capturing intermittent bugs requires capturing evidence before you realize a crash happened. Storing hours of continuous high-definition recording and full device logcat quickly exhausts memory.

We implemented an in-memory Rolling Ring Buffer:

class RollingRingBuffer {
  constructor(capacity = 180) { // Holds 180 seconds of 1-second chunks
    this.buffer = new Array(capacity);
    this.capacity = capacity;
    this.head = 0;
    this.size = 0;
  }

  push(slice) {
    this.buffer[this.head] = slice;
    this.head = (this.head + 1) % this.capacity;
    if (this.size < this.capacity) this.size++;
  }

  dump() {
    const result = [];
    let start = this.size < this.capacity ? 0 : this.head;
    for (let i = 0; i < this.size; i++) {
      result.push(this.buffer[(start + i) % this.capacity]);
    }
    return result;
  }
}

Video Stream: Compressed via WebCodecs or MediaRecorder into 1-second GOPs and pushed to the buffer;
Logcat Stream: Read asynchronously over the ADB channel, with regex filters isolating the foreground package and flagging FATAL EXCEPTION or ANR signatures;
On-Demand Dump: When a bug occurs, clicking "Finish" dumps the synchronized video clip, structured Markdown summary, screenshots, and filtered logs into an all-in-one developer-ready package.

4. Architectural Comparison: Desktop vs. Browser

Architectural Dimension	Traditional Desktop Tools (e.g., Scrcpy + Charles)	Browser Native Workspace (TabQA)
Communication Layer	Host `adb` binary (`localhost:5037`)	Native WebUSB API (USB Bulk Transfer)
Setup & Dependencies	Requires platform tools, drivers, proxies	Zero host dependencies (Chrome 118+)
Frame Rates	High (60–120fps, ideal for gaming/long video)	Stable (Focus on UI testing and interaction)
Traffic Inspection	MITM Proxy (Requires installed CA Root Cert)	Built-in CDP (Zero certificates required)
Crash Extraction	Manual terminal grep / full system dump	Target app log filtering with ANR/Crash alerts
Bug Delivery	Dispersed files across folders	Integrated Markdown report + assets for Jira/Notion
Data Privacy	Local host	Local-first (Data never leaves browser sandbox)

5. Conclusion & Open Source Project

By combining WebUSB, WebCodecs, and Chrome DevTools Protocol, it is now entirely feasible to build a unified mobile testing workspace directly inside browser side panels.

We packaged this architecture into an open-source tool called TabQA:

GitHub Repository: openutx/TabQA
Official Documentation: tabqa.openutx.cn/en/
Chrome Web Store: Install TabQA for free

We welcome feedback, issues, and contributions from testing and mobile development teams!