Fix Android WebRTC stream startup

Author: DjDeveloperr

client/src/features/stream/streamTypes.ts

@@ -2,6 +2,7 @@ import type { Size } from "../viewport/types";
 
 export interface StreamConnectTarget {
   clientId?: string;
+  platform?: string;
   remote?: boolean;
   streamConfig?: StreamConfig;
   transport?: StreamTransport;

client/src/features/stream/streamWorkerClient.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildStreamTarget,
+  initialStreamBackend,
+  preferredStreamBackend,
+} from "./streamWorkerClient";
+
+describe("streamWorkerClient", () => {
+  it("forces Android emulator streams onto WebRTC even when H264 is requested", () => {
+    const target = buildStreamTarget("android:emulator-5554", {
+      platform: "android-emulator",
+      transport: "h264",
+    });
+
+    expect(preferredStreamBackend(target)).toBe("webrtc");
+    expect(initialStreamBackend(target)).toBe("webrtc");
+  });
+
+  it("treats Android UDID prefixes as WebRTC-only stream targets", () => {
+    const target = buildStreamTarget("android:Pixel_8", {
+      transport: "h264",
+    });
+
+    expect(preferredStreamBackend(target)).toBe("webrtc");
+    expect(initialStreamBackend(target)).toBe("webrtc");
+  });
+});

client/src/features/stream/streamWorkerClient.ts

@@ -224,13 +224,15 @@ export function buildStreamTarget(
   udid: string,
   options: {
     clientId?: string;
+    platform?: string;
     remote?: boolean;
     streamConfig?: StreamConfig;
     transport?: StreamTransport;
   } = {},
 ): StreamConnectTarget {
   return {
     clientId: options.clientId,
+    platform: options.platform,
     remote: options.remote,
     streamConfig: options.streamConfig,
     transport: options.transport,
@@ -2725,9 +2727,12 @@ export class StreamWorkerClient {
   };
 }
 
-function preferredStreamBackend(
+export function preferredStreamBackend(
   target?: StreamConnectTarget | null,
 ): "auto" | StreamBackend {
+  if (isAndroidStreamTarget(target)) {
+    return "webrtc";
+  }
   const value =
     target?.transport ??
     new URLSearchParams(window.location.search).get("stream");
@@ -2737,7 +2742,12 @@ function preferredStreamBackend(
   return value === "webrtc" ? "webrtc" : "auto";
 }
 
-function initialStreamBackend(target: StreamConnectTarget): StreamBackend {
+export function initialStreamBackend(
+  target: StreamConnectTarget,
+): StreamBackend {
+  if (isAndroidStreamTarget(target)) {
+    return "webrtc";
+  }
   const preferredBackend = preferredStreamBackend(target);
   if (preferredBackend === "h264-ws") {
     return canUseH264WebSocket() ? "h264-ws" : "webrtc";
@@ -2756,3 +2766,10 @@ function nextAutoFallbackBackend(
   }
   return null;
 }
+
+function isAndroidStreamTarget(target?: StreamConnectTarget | null): boolean {
+  return (
+    target?.platform === "android-emulator" ||
+    Boolean(target?.udid.startsWith("android:"))
+  );
+}

client/src/features/stream/useLiveStream.ts

@@ -301,6 +301,7 @@ export function useLiveStream({
 
     const targetKey = [
       simulator.udid,
+      simulator.platform ?? "",
       remote ? "remote" : "local",
       streamTransport,
     ].join("|");
@@ -316,6 +317,7 @@ export function useLiveStream({
     workerClient.connect(
       buildStreamTarget(simulator.udid, {
         clientId: clientTelemetryIdRef.current,
+        platform: simulator.platform,
         remote,
         streamConfig,
         transport: streamTransport,
@@ -324,6 +326,7 @@ export function useLiveStream({
   }, [
     canvasElement,
     simulator?.isBooted,
+    simulator?.platform,
     simulator?.udid,
     paused,
     remote,

server/src/transport/webrtc.rs

@@ -1181,6 +1181,9 @@ impl AndroidWebRtcSource {
                         let Some(frame) = frame else {
                             continue;
                         };
+                        if inner.latest_keyframe.read().unwrap().is_none() {
+                            inner.request_keyframe();
+                        }
                         let handle = inner.encoder_handle.load(Ordering::Acquire);
                         let udid = inner.udid.clone();
                         let encode_result = task::spawn_blocking(move || {
@@ -1238,15 +1241,7 @@ impl AndroidWebRtcSource {
     fn request_refresh(&self) {}
 
     fn request_keyframe(&self) {
-        self.inner
-            .metrics
-            .keyframe_requests
-            .fetch_add(1, Ordering::Relaxed);
-        unsafe {
-            ffi::xcw_native_h264_encoder_request_keyframe(
-                self.inner.encoder_handle.load(Ordering::Acquire) as *mut c_void,
-            );
-        }
+        self.inner.request_keyframe();
     }
 }
 
@@ -1284,6 +1279,19 @@ unsafe extern "C" fn android_h264_encoder_frame_callback(
 }
 
 impl AndroidWebRtcSourceInner {
+    fn request_keyframe(&self) {
+        self.metrics
+            .keyframe_requests
+            .fetch_add(1, Ordering::Relaxed);
+        let encoder_handle = self.encoder_handle.load(Ordering::Acquire);
+        if encoder_handle == 0 {
+            return;
+        }
+        unsafe {
+            ffi::xcw_native_h264_encoder_request_keyframe(encoder_handle as *mut c_void);
+        }
+    }
+
     fn handle_encoded_frame(&self, frame: &ffi::xcw_native_frame) {
         let description = unsafe { copy_native_shared_bytes(frame.description) };
         let Some(data) = (unsafe { copy_native_shared_bytes(frame.data) }) else {