A video call can work perfectly on one Android phone and fail during the same user journey on another. The difference may appear when the screen locks, the device enters a power-saving state, a user disables the camera system-wide, or the browser negotiates a codec path your test device never exercised.
That is why Android Chrome WebRTC needs its own release plan. Video SDK on iOS Safari: Why the Camera Goes Black Without an Error covers the iOS side; a pass there cannot stand in for Android coverage. Test Android Chrome as a separate runtime with explicit cases for power state, screen state, sensor privacy, permission recovery, page lifecycle, and negotiated media performance.
Android Chrome WebRTC starts with the device state
Android can defer background CPU and network activity through Doze, while App Standby defers background network activity for apps that have had no recent user activity. Android documents these as platform power-management behaviors, rather than as browser-specific WebRTC failures. The Android Doze and App Standby documentation also provides ADB commands for forcing a device into and out of Doze.
That creates a clear test requirement. A call that passes while the device is active should also be observed while the screen is idle, the device enters Doze, and the device returns to normal operation. The test should record whether the camera and microphone tracks remain live, whether RTP packets continue, whether audio levels change, and how long recovery takes after the device becomes active again.
# Example test controls documented by Android
adb shell dumpsys deviceidle force-idle
adb shell dumpsys deviceidle unforceThe commands place the device into a platform power state; they do not define a pass or fail result for a browser call. Your product has to define that result. For a two-way call, a reasonable pass condition might require continued audio, an advancing remote video frame timestamp, and recovery within an agreed interval after the device exits the state.
Run the same case with the device connected to power and on battery. Record the Android version, Chrome version, device model, battery state, network type, and negotiated codec. Those fields turn an intermittent report into a reproducible test case.
Screen locking is a version-sensitive Android Chrome case
Screen locking deserves its own test because camera privacy behavior can change across Chrome and Android versions. Chromium documents a protection intended to prevent websites from recording video through the camera while the operating-system screen is locked. A Chromium issue records a vulnerability in that protection as fixed and associated with milestone 150. The Chromium issue for camera screen-lock protection is therefore useful evidence that this behavior is security-sensitive and version-dependent.
Do not turn that into a universal statement about what every active camera track does after locking the screen. Test the target Chrome and Android combinations directly.
For each combination, begin a call, confirm that the local camera is producing frames, lock the screen for a defined interval, unlock it, and observe:
- whether the local media track remains live;
- whether the remote peer receives new video frames during the lock;
- whether audio continues;
- whether the track ends, pauses, or resumes after unlock;
- whether the application receives a state change or error; and
- how long it takes for video to recover.
Test both directions. A local preview can look healthy while the remote peer receives no new frames, and a remote video element can remain visible while its last frame is frozen. Measure media continuity instead of relying on an icon or the presence of a live track object.
Sensor privacy controls can look like application failures
On supported Android 12 or later devices, users can disable camera or microphone access for all apps. Android documents that disabling camera access can give an app a blank camera feed, while disabling microphone access can produce silent audio. Android's documentation on sensitive-information access describes these device-wide controls and their effect on application sensor access.
These controls belong in the browser test matrix. Start with both sensors enabled. Then disable the camera before joining, disable it during an active call, repeat the sequence for the microphone, and restore access before testing recovery. Capture the browser-visible result on each target build instead of assuming it will always be a permission error.
Android 12 and later also show a status-bar icon when an app accesses the camera or microphone. The same Android documentation describes these privacy indicators. The indicator confirms sensor access at the device level; it does not prove that useful frames or audio samples are reaching the peer.
That distinction matters in support tooling. A product should expose media health separately from permission state. Useful signals include the local track state, audio level, frame arrival time, frames encoded, frames decoded, and the timestamp of the last remote frame. A green camera indicator should never be your only proof that the call is healthy.
Permission handling needs a recovery path
Permission testing should cover the full user journey rather than only the first successful prompt. Test first grant, denial, dismissal, a later grant through Android settings, camera-only permission, microphone-only permission, and a device-wide sensor toggle.
After each change, return to the call. Check whether the application can acquire the expected track, whether the existing peer connection remains usable, and whether the user receives an actionable state. A permission state that changes outside the page can leave the interface, local tracks, and remote media temporarily out of sync.
The recovery action should be explicit. Depending on the observed browser behavior, that may mean reacquiring a media track, replacing a sender's track, renegotiating, or asking the user to rejoin. The test should record which action restores media and whether the old track is correctly stopped.
Measure codec behavior on real Android devices
Android Chrome video testing should measure the codec that was actually negotiated rather than assuming that a browser-wide capability list predicts the call's behavior. Device hardware, OS build, Chrome version, camera format, resolution, thermal state, and network conditions can all affect the result you observe. Codec choice on the live path has its own constraints, set out in H.264 vs H.265 Over WebRTC. Use representative hardware and publish measured results.
At minimum, collect these values for every test run:
| Area | Record |
|---|---|
| Negotiation | Codec, packetization mode where relevant, resolution, frame rate, and direction |
| Encode and decode | Encode time, decode time, frames encoded, frames decoded, and dropped frames |
| Media health | Audio level, last local frame time, last remote frame time, RTP continuity, and track state |
| Device context | Android version, Chrome version, model, battery state, power connection, and thermal condition |
Run a short call at the product's lowest supported resolution, then at its normal target resolution. Repeat with the front and rear cameras where both are supported. A device can pass a low-resolution preview and fail at the resolution used in production because encode time rises or frames are dropped. Network-driven downgrades can look like a device limit; WebRTC Bandwidth Estimation explains why a call downgrades before it drops.
Also test the renegotiation path. Change camera, resolution, or mute state during a call and verify the selected codec and media statistics after the change. A reconnect that restores audio but leaves video stalled is a media-recovery defect even when the peer connection reports a connected state.
Test lifecycle recovery instead of assuming continuity
Android Chrome lifecycle behavior should be tested through user actions that occur in real sessions: switching applications, opening another browser tab, returning to the call, turning the screen off and on, rotating the device where supported, and leaving the page for a sustained interval.
The test result should describe what happened on the target build. Avoid treating background camera continuity, tab freezing, tab discarding, or survival under resource pressure as universal Chrome behavior.
Use a recovery state machine in the application. Video SDK Reconnection covers the network side of the same state machine. It should distinguish at least these conditions:
- the local track is live and media is flowing;
- the track exists but no recent frames or audio samples are arriving;
- the browser or device has interrupted access;
- the peer connection is connected while media is stalled; and
- the call needs a controlled rejoin.
For each state, define the observable signal, the user message, the automated recovery action, and the point at which the user can retry. This is more reliable than declaring success when the page returns to the foreground.
Build the Android Chrome WebRTC release matrix
A useful matrix combines browser and device state. It does not need every Android phone; it needs coverage of the environments your users actually bring to the product and the failure conditions most likely to affect them.
| Dimension | Required cases | Pass evidence |
|---|---|---|
| Power | Active, idle, forced Doze, exit from Doze, battery, and charging | Defined media continuity and recovery measurements |
| Screen | Unlocked, locked, unlocked after an active call | Observed local track, RTP, audio, and recovery behavior |
| Privacy | Camera and microphone enabled, denied, revoked, and device-wide disabled | Correct state, user guidance, and recovery path |
| Lifecycle | App switch, tab switch, return, rotation, and sustained absence | Media state remains accurate and recovery is bounded |
| Media | Front and rear camera, target resolutions, network changes, and renegotiation | Negotiated codec and frame/audio metrics meet the product threshold |
Run this matrix before release and again after Chrome, Android, or device firmware changes. Keep the raw results with the version fields. A failure attached only to “Android” is too broad to guide an engineer; a failure attached to a Chrome build, Android release, device, power state, and action can be fixed or deliberately supported. This matrix is a large part of the gap between a demo and production described in Add Video to Your App.
Bottom Line
Android Chrome WebRTC needs a separate test plan because the browser runs inside a device platform that can change sensor access, power state, screen-lock behavior, and media performance during a call. Make the release decision from measured track, RTP, audio, frame, recovery, and negotiated-codec results on representative devices.
Screen locking, Doze, sensor privacy controls, lifecycle changes, and codec renegotiation are test conditions. They are not reliable places for a universal product promise without a version-specific result.
What's Next
Mobile browser behavior is one part of a larger integration surface. When the calling layer itself is changing, sequencing the migration matters just as much as testing the client.
Read Migrating Off ACS: The Order to Do It In for a staged approach to moving the pieces that retire first while keeping the surviving parts stable long enough to migrate safely.
FAQs
Why does Android Chrome need a separate WebRTC test plan?
Android Chrome runs across different Android releases, device hardware, power states, privacy controls, and Chrome versions. Test those conditions directly because an iOS Safari result cannot establish how an Android device behaves when the screen locks, Doze activates, or sensor access changes.
Does Android Doze automatically stop a Chrome WebRTC call?
Android documents Doze as a state that defers background CPU and network activity, but that documentation does not establish a universal outcome for every Chrome WebRTC call. Force Doze with Android's documented ADB method and measure RTP continuity, audio level, frame arrival, and recovery time on the target device.
What should I test when an Android phone screen locks during a video call?
Test whether local video frames, remote frames, and audio continue during the lock, then measure recovery after unlock. Chromium documents screen-lock camera protection and a fixed vulnerability record, so the outcome must be checked against the Chrome and Android versions you support.
Can Android's camera privacy toggle produce a blank WebRTC camera?
On supported Android 12 or later devices, Android documents that disabling device-wide camera access can give an app a blank camera feed and disabling microphone access can give silent audio. Verify how the target Chrome build exposes that state, then provide a recovery action that matches the observed track and permission behavior.
How do I test Android Chrome codec support?
Measure the codec actually negotiated in the call on representative devices. Record resolution, frame rate, encode and decode timing, dropped frames, and thermal and battery context instead of publishing a market-wide claim about hardware codec support.
What media signals should an Android browser video product monitor?
Monitor local track state, remote frame arrival, audio level, RTP continuity, frames encoded and decoded, dropped frames, negotiated codec, and recovery time. These signals distinguish a permission problem, a stalled media path, a lifecycle interruption, and a peer connection that remains connected while video has stopped.
Can a video platform remove the need for Android Chrome testing?
No platform removes the need to test the browser and devices your users operate. A platform such as Samvyo can be evaluated as part of the media architecture, but your application still needs Android-specific tests for permissions, power states, screen locking, lifecycle recovery, and measured media performance.