From 1ebe29179ff9c268457e6aacd9e06eca69e8c85f Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Mon, 9 Nov 2026 05:39:19 -0500 Subject: [PATCH] fix(emulator): relay registered simulator controls through main --- .../vitest-node-runtime-files.mjs | 1 + src/main/emulator/emulator-bridge.ts | 5 +- .../emulator/emulator-session-registry.ts | 9 ++ src/main/ipc/emulator-control-stream.test.ts | 122 ++++++++++++++++++ src/main/ipc/emulator-control-stream.ts | 90 +++++++++++++ .../register-core-handlers.ts | 6 +- src/preload/api/emulator-api.ts | 10 ++ src/preload/api/emulator-bridge.ts | 13 ++ .../emulator-device-frame-visibility.test.tsx | 3 + .../emulator-device-frame.input.test.tsx | 119 ++++++++++------- .../use-emulator-control-stream.ts | 97 +++++++------- .../src/web/preload-api/web-browser-api.ts | 4 + 12 files changed, 382 insertions(+), 97 deletions(-) create mode 100644 src/main/ipc/emulator-control-stream.test.ts create mode 100644 src/main/ipc/emulator-control-stream.ts diff --git a/config/scripts/test-runtime/sqlite-admission/vitest-node-runtime-files.mjs b/config/scripts/test-runtime/sqlite-admission/vitest-node-runtime-files.mjs index 7ddb846c780b..fe89a807afb4 100644 --- a/config/scripts/test-runtime/sqlite-admission/vitest-node-runtime-files.mjs +++ b/config/scripts/test-runtime/sqlite-admission/vitest-node-runtime-files.mjs @@ -2,6 +2,7 @@ import { findSqliteRuntimeTests } from './vitest-sqlite-runtime-scan.mjs' // SQLite publication, native bindings, worker IPC, socket liveness, and V8 retention use Node. const NODE_RUNTIME_INCLUDE = [ + 'src/main/ipc/emulator-control-stream.test.ts', // Exercise the native fetch error and abort contracts used by the Linear SDK in Electron. 'tests/e2e/linear-cli-recovery.unit.test.ts', 'src/main/runtime/agent-session/lifecycle/structured-agent-cli-writers.test.ts', diff --git a/src/main/emulator/emulator-bridge.ts b/src/main/emulator/emulator-bridge.ts index 7b812880c362..5aaecd849f0d 100644 --- a/src/main/emulator/emulator-bridge.ts +++ b/src/main/emulator/emulator-bridge.ts @@ -71,6 +71,8 @@ export class EmulatorBridge { return this.sessionRegistry.getActiveForWorktree(worktreeId) } + hasControlStreamUrl = (url: string): boolean => this.sessionRegistry.hasControlStreamUrl(url) + // Keep slow-booting Android devices alive across switches for fast reattachment. async stopActiveForSwitch(worktreeId: string): Promise { const keepAlive = this.backendForActiveWorktree(worktreeId)?.kind === 'android' @@ -133,10 +135,9 @@ export class EmulatorBridge { if (!backend) { return null } - const sessionInfo = this.sessionRegistry.toSessionInfo(session) await this.startLeases.cleanupWhenIdle( backend, - sessionInfo, + this.sessionRegistry.toSessionInfo(session), (info) => this.sessionRegistry.hasActiveWorktreeForSession(info.deviceUdid), { includeOrphaned: !options.managedOnly, diff --git a/src/main/emulator/emulator-session-registry.ts b/src/main/emulator/emulator-session-registry.ts index 8e21ce3c8135..48acb99d7702 100644 --- a/src/main/emulator/emulator-session-registry.ts +++ b/src/main/emulator/emulator-session-registry.ts @@ -102,6 +102,15 @@ export class EmulatorSessionRegistry { return [...this.sessions.values()] } + hasControlStreamUrl(url: string): boolean { + for (const session of this.sessions.values()) { + if (session.wsUrl === url) { + return true + } + } + return false + } + clearSessionAndWorktrees(key: string): void { this.sessions.delete(key) for (const [worktreeId, activeKey] of this.activeByWorktree.entries()) { diff --git a/src/main/ipc/emulator-control-stream.test.ts b/src/main/ipc/emulator-control-stream.test.ts new file mode 100644 index 000000000000..bdce230e07f4 --- /dev/null +++ b/src/main/ipc/emulator-control-stream.test.ts @@ -0,0 +1,122 @@ +import { EventEmitter, once } from 'node:events' +import { afterEach, expect, it, vi } from 'vitest' +import WebSocket, { WebSocketServer } from 'ws' +import type * as WsModule from 'ws' +import { EmulatorBridge } from '../emulator/emulator-bridge' +import { registerEmulatorControlStreamHandlers } from './emulator-control-stream' + +const handlers = new Map unknown>() +vi.mock('electron', () => ({ + ipcMain: { + removeAllListeners: () => {}, + removeHandler: () => {}, + handle: (channel: string, handler: (event: unknown, args: unknown) => unknown) => + handlers.set(channel, handler), + on: (channel: string, handler: (event: unknown, args: unknown) => unknown) => + handlers.set(channel, handler) + }, + BrowserWindow: { fromWebContents: () => ({}) } +})) +vi.mock('ws', async (importOriginal) => { + const actual = await importOriginal() + return { + ...actual, + default: Object.assign( + vi.fn(function (url: string) { + return new actual.default(url) + }), + { OPEN: actual.default.OPEN } + ) + } +}) + +class Owner extends EventEmitter { + isDestroyed = (): boolean => false + send = (_channel: string, event: { type: string; data?: unknown }): void => { + this.emit(event.type, event.data) + } +} + +const owners: Owner[] = [] +let server: WebSocketServer | undefined + +afterEach(async () => { + for (const owner of owners.splice(0)) { + owner.emit('destroyed') + } + if (server) { + for (const socket of server.clients) { + socket.terminate() + } + const closed = once(server, 'close') + server.close() + await closed + server = undefined + } + vi.clearAllMocks() +}) + +function setup(wsUrl: string) { + const bridge = new EmulatorBridge() + bridge.registerActiveEmulator('worktree', { + deviceUdid: 'device', + streamUrl: 'http://127.0.0.1/stream.mjpeg', + wsUrl + }) + registerEmulatorControlStreamHandlers(() => bridge) + const sender = new Owner() + owners.push(sender) + return { + sender, + start: (url = wsUrl, streamId = 'control') => + handlers.get('emulator:controlStreamStart')?.({ sender }, { wsUrl: url, streamId }) + } +} + +it('never connects to URLs outside the registered session', () => { + const { start } = setup('ws://127.0.0.1:3100/ws') + for (const url of [ + 'ws://127.0.0.1:3101/ws', + 'ws://example.com/ws', + 'ws://127.0.0.1:3100/other' + ]) { + expect(() => start(url)).toThrow('registered emulator session') + } + expect(WebSocket).not.toHaveBeenCalled() +}) + +it('relays text and binary without Origin and releases the socket when the renderer goes away', async () => { + server = new WebSocketServer({ host: '127.0.0.1', port: 0 }) + await once(server, 'listening') + const address = server.address() + if (!address || typeof address === 'string') { + throw new Error('Expected TCP address') + } + const { sender, start } = setup(`ws://127.0.0.1:${address.port}/ws`) + const connection = once(server, 'connection') + const opened = once(sender, 'open') + start() + const [socket, request] = await connection + const otherRenderer = new Owner() + handlers.get('emulator:controlStreamSend')?.( + { sender: otherRenderer }, + { streamId: 'control', data: 'unowned' } + ) + handlers.get('emulator:controlStreamStop')?.({ sender: otherRenderer }, { streamId: 'control' }) + await opened + expect(request.headers.origin).toBeUndefined() + for (const data of ['text', new Uint8Array([130, 1, 2])]) { + const received = once(socket, 'message') + handlers.get('emulator:controlStreamSend')?.({ sender }, { streamId: 'control', data }) + const [bytes, binary] = await received + expect(binary).toBe(typeof data !== 'string') + expect(bytes.toString()).toBe(Buffer.from(data).toString()) + const relayed = once(sender, 'message') + socket.send(data) + const [frame] = await relayed + expect(frame instanceof ArrayBuffer ? new Uint8Array(frame) : frame).toEqual(data) + } + const closed = once(socket, 'close') + sender.emit('destroyed') + await closed +}) diff --git a/src/main/ipc/emulator-control-stream.ts b/src/main/ipc/emulator-control-stream.ts new file mode 100644 index 000000000000..d14b58a71627 --- /dev/null +++ b/src/main/ipc/emulator-control-stream.ts @@ -0,0 +1,90 @@ +import { BrowserWindow, ipcMain, type WebContents } from 'electron' +import WebSocket from 'ws' +import type { EmulatorBridge } from '../emulator/emulator-bridge' +import type { EmulatorControlStreamEvent } from '../../preload/api/emulator-api' +import { abortWhenRendererGone } from './renderer-lifetime-abort' +import { registerEmulatorScrcpyTouchHandler } from './emulator-scrcpy-touch' +import { registerEmulatorScrcpyKeyboardHandler } from './emulator-scrcpy-keyboard' + +export function registerEmulatorControlStreamHandlers( + getBridge: () => EmulatorBridge | null +): void { + registerEmulatorScrcpyTouchHandler() + registerEmulatorScrcpyKeyboardHandler() + const streams = new Map void }>() + const stop = (streamId: string, owner: WebContents): void => { + const stream = streams.get(streamId) + if (!stream || stream.owner !== owner) { + return + } + streams.delete(streamId) + stream.dispose() + // close() flushes queued release frames; terminate() would drop them. + if (stream.socket.readyState === WebSocket.OPEN) { + stream.socket.close() + } else { + stream.socket.terminate() + } + } + + ipcMain.handle( + 'emulator:controlStreamStart', + (event, args: { wsUrl: string; streamId: string }) => { + const owner = event.sender + if (!BrowserWindow.fromWebContents(owner) || !getBridge()?.hasControlStreamUrl(args?.wsUrl)) { + throw new Error('Control stream requires a registered emulator session.') + } + const { streamId } = args + if (typeof streamId !== 'string' || streams.has(streamId)) { + throw new Error('Control stream id is invalid or already in use.') + } + const socket = new WebSocket(args.wsUrl) + socket.binaryType = 'arraybuffer' + const lifetime = abortWhenRendererGone(owner) + const onGone = (): void => stop(streamId, owner) + streams.set(streamId, { + owner, + socket, + dispose: () => { + lifetime.signal.removeEventListener('abort', onGone) + lifetime.dispose() + } + }) + lifetime.signal.addEventListener('abort', onGone, { once: true }) + const send = ( + type: EmulatorControlStreamEvent['type'], + data?: ArrayBuffer | string + ): void => { + if (streams.has(streamId) && !owner.isDestroyed()) { + owner.send('emulator:controlStreamEvent', { streamId, type, data }) + } + } + socket.on('open', () => send('open')) + socket.on('message', (data) => + send('message', data instanceof ArrayBuffer ? data : data.toString()) + ) + socket.on('error', (error) => send('error', error.message)) + socket.on('close', () => { + send('close') + stop(streamId, owner) + }) + } + ) + ipcMain.on( + 'emulator:controlStreamSend', + (event, args: { streamId: string; data: string | Uint8Array } | null) => { + const stream = args && streams.get(args.streamId) + if ( + args && + stream?.owner === event.sender && + stream.socket.readyState === WebSocket.OPEN && + (typeof args.data === 'string' || args.data instanceof Uint8Array) + ) { + stream.socket.send(args.data) + } + } + ) + ipcMain.handle('emulator:controlStreamStop', (event, args: { streamId: string }) => { + stop(args.streamId, event.sender) + }) +} diff --git a/src/main/ipc/register-core-handlers/register-core-handlers.ts b/src/main/ipc/register-core-handlers/register-core-handlers.ts index 7bf4a77b0e8b..6a5295caf87e 100644 --- a/src/main/ipc/register-core-handlers/register-core-handlers.ts +++ b/src/main/ipc/register-core-handlers/register-core-handlers.ts @@ -62,9 +62,8 @@ import { registerPetHandlers } from '../pets/pet' import { registerPluginHandlers } from '../plugins' import { registerUIHandlers, setTrustedUIRendererWebContentsId } from '../ui' import { registerEmulatorFrameStreamHandlers } from '../emulator-frame-stream' +import { registerEmulatorControlStreamHandlers } from '../emulator-control-stream' import { registerEmulatorVideoStreamHandlers } from '../emulator-video-stream' -import { registerEmulatorScrcpyTouchHandler } from '../emulator-scrcpy-touch' -import { registerEmulatorScrcpyKeyboardHandler } from '../emulator-scrcpy-keyboard' import { registerSpeechHandlers } from '../speech' import { registerTerminalRenderDesyncEvidenceHandler } from '../terminal-render-desync-evidence' import { registerOrcaProfileHandlers } from '../profiles/orca-profiles' @@ -241,9 +240,8 @@ export function registerCoreHandlers( registerSessionHandlers(store, runtime) registerUIHandlers(store, { isDashboardPopoutRenderer }) registerEmulatorFrameStreamHandlers() + registerEmulatorControlStreamHandlers(() => runtime.getEmulatorBridge()) registerEmulatorVideoStreamHandlers((id) => runtime.getEmulatorBridge()?.getIosVideoStreamUrl(id)) - registerEmulatorScrcpyTouchHandler() - registerEmulatorScrcpyKeyboardHandler() registerWorkspaceSpaceHandlers(store) registerWorkspacePortHandlers(store) registerLinkPreviewHandlers() diff --git a/src/preload/api/emulator-api.ts b/src/preload/api/emulator-api.ts index 1638b4e4420c..75e4e9d22d9d 100644 --- a/src/preload/api/emulator-api.ts +++ b/src/preload/api/emulator-api.ts @@ -1,4 +1,14 @@ +export type EmulatorControlStreamEvent = { + streamId: string + type: 'open' | 'message' | 'error' | 'close' + data?: ArrayBuffer | string +} + export type EmulatorApi = { + startControlStream: (args: { wsUrl: string; streamId: string }) => Promise + stopControlStream: (args: { streamId: string }) => Promise + sendControlStream: (args: { streamId: string; data: string | Uint8Array }) => void + onControlStreamEvent: (callback: (event: EmulatorControlStreamEvent) => void) => () => void onPaneFocus: (callback: (data: { worktreeId: string }) => void) => () => void onAutoAttach: ( callback: (data: { diff --git a/src/preload/api/emulator-bridge.ts b/src/preload/api/emulator-bridge.ts index 50fb7c3c1664..97099ee6311b 100644 --- a/src/preload/api/emulator-bridge.ts +++ b/src/preload/api/emulator-bridge.ts @@ -1,7 +1,20 @@ import { ipcRenderer } from 'electron' import type { PreloadApi } from '../api-types' +import type { EmulatorControlStreamEvent } from './emulator-api' export const emulatorApi = { + startControlStream: (args: { wsUrl: string; streamId: string }): Promise => + ipcRenderer.invoke('emulator:controlStreamStart', args), + stopControlStream: (args: { streamId: string }): Promise => + ipcRenderer.invoke('emulator:controlStreamStop', args), + sendControlStream: (args: { streamId: string; data: string | Uint8Array }): void => + ipcRenderer.send('emulator:controlStreamSend', args), + onControlStreamEvent: (callback: (data: EmulatorControlStreamEvent) => void): (() => void) => { + const listener = (_event: Electron.IpcRendererEvent, data: EmulatorControlStreamEvent) => + callback(data) + ipcRenderer.on('emulator:controlStreamEvent', listener) + return () => ipcRenderer.removeListener('emulator:controlStreamEvent', listener) + }, startFrameStream: (args: { streamUrl: string streamKey?: string diff --git a/src/renderer/src/components/emulator-pane/emulator-device-frame-visibility.test.tsx b/src/renderer/src/components/emulator-pane/emulator-device-frame-visibility.test.tsx index 654b5905fba4..04922f884acf 100644 --- a/src/renderer/src/components/emulator-pane/emulator-device-frame-visibility.test.tsx +++ b/src/renderer/src/components/emulator-pane/emulator-device-frame-visibility.test.tsx @@ -34,6 +34,9 @@ beforeEach(() => { configurable: true, value: { emulator: { + startControlStream: () => Promise.resolve(), + stopControlStream: () => Promise.resolve(), + onControlStreamEvent: () => () => {}, startFrameStream, stopFrameStream, onFrameStreamFrame: (_listener: FrameListener) => () => {}, diff --git a/src/renderer/src/components/emulator-pane/emulator-device-frame.input.test.tsx b/src/renderer/src/components/emulator-pane/emulator-device-frame.input.test.tsx index 407f6ebbc7fe..df5b598e2de6 100644 --- a/src/renderer/src/components/emulator-pane/emulator-device-frame.input.test.tsx +++ b/src/renderer/src/components/emulator-pane/emulator-device-frame.input.test.tsx @@ -3,6 +3,8 @@ import { act } from 'react' import { createRoot, type Root } from 'react-dom/client' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import type { EmulatorControlStreamEvent } from '../../../../preload/api/emulator-api' +import { useEmulatorControlStream } from './use-emulator-control-stream' import { EmulatorDeviceFrame } from './emulator-device-frame' import type { EmulatorGesturePoint } from './emulator-screen-gesture' @@ -13,49 +15,25 @@ vi.mock('sonner', () => ({ } })) -class FakeWebSocket { - static CONNECTING = 0 - static OPEN = 1 - static CLOSED = 3 +const streams: { streamId: string; wsUrl: string; sent: Uint8Array[]; closed: boolean }[] = [] +const listeners = new Set<(event: EmulatorControlStreamEvent) => void>() - static instances: FakeWebSocket[] = [] - - binaryType: BinaryType = 'blob' - onclose: (() => void) | null = null - onerror: (() => void) | null = null - onopen: (() => void) | null = null - readyState = FakeWebSocket.CONNECTING - readonly sent: Uint8Array[] = [] - readonly url: string - - constructor(url: string) { - this.url = url - FakeWebSocket.instances.push(this) - } - - open(): void { - this.readyState = FakeWebSocket.OPEN - this.onopen?.() - } - - send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void { - if (data instanceof Uint8Array) { - this.sent.push(data) - return - } - if (ArrayBuffer.isView(data)) { - this.sent.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)) - return - } - if (data instanceof ArrayBuffer) { - this.sent.push(new Uint8Array(data)) +function emit(type: EmulatorControlStreamEvent['type'], data?: ArrayBuffer | string): void { + const streamId = streams.at(-1)?.streamId + if (streamId) { + for (const listener of listeners) { + listener({ streamId, type, data }) } } +} - close(): void { - this.readyState = FakeWebSocket.CLOSED - this.onclose?.() - } +function ControlStatus({ enabled = true }: { enabled?: boolean }) { + const stream = useEmulatorControlStream('ws://127.0.0.1:3100/ws', enabled) + return ( + + ) } let container: HTMLDivElement @@ -65,8 +43,31 @@ beforeEach(() => { ;( globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean } ).IS_REACT_ACT_ENVIRONMENT = true - vi.stubGlobal('WebSocket', FakeWebSocket as unknown as typeof WebSocket) - FakeWebSocket.instances = [] + streams.length = 0 + listeners.clear() + vi.stubGlobal('api', { + ...window.api, + emulator: { + ...window.api?.emulator, + startControlStream: ({ streamId, wsUrl }: { streamId: string; wsUrl: string }) => { + streams.push({ streamId, wsUrl, sent: [], closed: false }) + return Promise.resolve() + }, + stopControlStream: ({ streamId }: { streamId: string }) => { + const stream = streams.find((stream) => stream.streamId === streamId) + if (stream) { + stream.closed = true + } + return Promise.resolve() + }, + sendControlStream: ({ streamId, data }: { streamId: string; data: Uint8Array }) => + streams.find((stream) => stream.streamId === streamId)?.sent.push(data), + onControlStreamEvent: (listener: (event: EmulatorControlStreamEvent) => void) => { + listeners.add(listener) + return () => listeners.delete(listener) + } + } + }) container = document.createElement('div') document.body.appendChild(container) root = createRoot(container) @@ -131,8 +132,8 @@ function keyEvent( } function decodedSentMessages(tag: number): T[] { - return FakeWebSocket.instances - .flatMap((ws) => ws.sent) + return streams + .flatMap((stream) => stream.sent) .filter((frame) => frame[0] === tag) .map((frame) => JSON.parse(new TextDecoder().decode(frame.subarray(1)))) } @@ -179,7 +180,7 @@ describe('EmulatorDeviceFrame wheel scrolling', () => { beforeEach(() => { vi.useFakeTimers() renderFrame() - act(() => FakeWebSocket.instances[0]?.open()) + act(() => emit('open')) }) it('waits a frame after touch-down before moving an isolated notch, then travels its full distance', () => { @@ -245,7 +246,7 @@ describe('EmulatorDeviceFrame wheel scrolling', () => { const before = decodedSentMessages(0x03) expect(before.at(-1)?.type).toBe('move') if (mode === 'reconnect') { - act(() => FakeWebSocket.instances[0]?.close()) + act(() => emit('close')) act(() => vi.advanceTimersByTime(750)) } else { const wsUrl = mode === 'replace' ? 'ws://127.0.0.1:3101/ws' : undefined @@ -254,7 +255,7 @@ describe('EmulatorDeviceFrame wheel scrolling', () => { renderFrame({ onGesture }) } } - act(() => FakeWebSocket.instances.at(-1)?.open()) + act(() => emit('open')) finishWheel() act(() => root.render(
)) expect(decodedSentMessages(0x03).slice(before.length)).toEqual( @@ -281,7 +282,7 @@ describe('EmulatorDeviceFrame input', () => { vi.useFakeTimers() renderFrame() act(() => { - FakeWebSocket.instances[0]?.open() + emit('open') }) const screen = getScreen() @@ -300,5 +301,29 @@ describe('EmulatorDeviceFrame input', () => { { type: 'down', usage: 225 }, { type: 'up', usage: 225 } ]) + expect(streams[0]?.closed).toBe(true) + }) + + it('keeps helper orientation across reconnects and releases a disabled stream', () => { + vi.useFakeTimers() + act(() => root.render()) + expect(container.textContent).toBe('false:null') + act(() => emit('open')) + act(() => container.querySelector('button')?.click()) + expect(decodedSentMessages(0x03)).toEqual([{ type: 'begin', x: 0.25, y: 0.75 }]) + const config = new TextEncoder().encode(JSON.stringify({ orientation: 'landscape_left' })) + const message = new Uint8Array(config.length + 1) + message[0] = 130 + message.set(config, 1) + act(() => emit('message', message.buffer)) + expect(container.textContent).toBe('true:landscape_left') + act(() => emit('error', 'disconnected')) + expect(container.textContent).toBe('false:landscape_left') + act(() => vi.advanceTimersByTime(750)) + act(() => emit('open')) + expect(container.textContent).toBe('true:landscape_left') + act(() => root.render()) + expect(container.textContent).toBe('false:landscape_left') + expect(streams.at(-1)?.closed).toBe(true) }) }) diff --git a/src/renderer/src/components/emulator-pane/use-emulator-control-stream.ts b/src/renderer/src/components/emulator-pane/use-emulator-control-stream.ts index fb0aa73f1e77..22c87664e390 100644 --- a/src/renderer/src/components/emulator-pane/use-emulator-control-stream.ts +++ b/src/renderer/src/components/emulator-pane/use-emulator-control-stream.ts @@ -1,4 +1,5 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react' +import { createNonSecureContextUuid as createBrowserUuid } from '../../../../shared/non-secure-context-uuid' import { encodeServeSimKeyboardFrame, type ServeSimKeyboardFrame @@ -56,7 +57,7 @@ export function useEmulatorControlStream( enabled: boolean, scrcpyDeviceId: string | null = null ): EmulatorControlStream { - const wsRef = useRef(null) + const streamRef = useRef<{ streamId: string; open: boolean } | null>(null) const lastTouchRef = useRef(null) const keyboardTimerIdsRef = useRef>(new Set()) const pressedKeyboardUsagesRef = useRef>(new Set()) @@ -74,9 +75,9 @@ export function useEmulatorControlStream( keyboardTimerIdsRef.current.clear() }, []) - const getOpenSocket = useCallback((): WebSocket | null => { - const ws = wsRef.current - return ws?.readyState === WebSocket.OPEN ? ws : null + const getOpenSocket = useCallback(() => { + const ws = streamRef.current + return ws?.open ? ws : null }, []) const sendKeyboardFrameNow = useCallback( @@ -86,7 +87,10 @@ export function useEmulatorControlStream( return false } try { - ws.send(encodeServeSimKeyboardFrame(frame)) + window.api.emulator.sendControlStream({ + streamId: ws.streamId, + data: encodeServeSimKeyboardFrame(frame) + }) if (frame.type === 'down') { pressedKeyboardUsagesRef.current.add(frame.usage) } else { @@ -118,7 +122,6 @@ export function useEmulatorControlStream( releasePressedKeyboardUsages(true) }, [clearKeyboardTimers, releasePressedKeyboardUsages]) - // oxlint-disable-next-line react-doctor/effect-needs-cleanup -- cleanup closes the socket held in wsRef and stops reconnects. useEffect(() => { if (!enabled || !wsUrl) { setConnected(false) @@ -135,43 +138,42 @@ export function useEmulatorControlStream( } } - const connect = (): void => { - clearReconnectTimer() - const ws = new WebSocket(wsUrl) - ws.binaryType = 'arraybuffer' - wsRef.current = ws - - ws.onopen = () => { - if (!disposed && wsRef.current === ws) { - releasePressedKeyboardUsages() - setConnected(true) - } + const onClose = (streamId: string): void => { + if (disposed || streamRef.current?.streamId !== streamId) { + return } - - ws.onmessage = (event) => { + streamRef.current = null + lastTouchRef.current = null + clearKeyboardTimers() + setConnected(false) + reconnectTimerId = window.setTimeout(connect, RECONNECT_DELAY_MS) + } + const unsubscribe = window.api.emulator.onControlStreamEvent((event) => { + const ws = streamRef.current + if (disposed || ws?.streamId !== event.streamId) { + return + } + if (event.type === 'open') { + ws.open = true + releasePressedKeyboardUsages() + setConnected(true) + } else if (event.type === 'message') { const orientation = decodeServeSimOrientation(event.data) - if (orientation && !disposed && wsRef.current === ws) { + if (orientation) { setReportedConfig({ wsUrl, orientation }) } + } else { + onClose(event.streamId) + void window.api.emulator.stopControlStream({ streamId: event.streamId }).catch(() => {}) } - - ws.onerror = () => { - ws.close() - } - - ws.onclose = () => { - // A replaced socket can close after its successor opens; it must not reset the live one. - if (wsRef.current !== ws) { - return - } - wsRef.current = null - lastTouchRef.current = null - clearKeyboardTimers() - setConnected(false) - if (!disposed) { - reconnectTimerId = window.setTimeout(connect, RECONNECT_DELAY_MS) - } - } + }) + const connect = (): void => { + clearReconnectTimer() + const streamId = createBrowserUuid() + streamRef.current = { streamId, open: false } + void window.api.emulator + .startControlStream({ wsUrl, streamId }) + .catch(() => onClose(streamId)) } connect() @@ -179,19 +181,23 @@ export function useEmulatorControlStream( return () => { disposed = true clearReconnectTimer() + unsubscribe() // Interrupted HID input can stay pressed after disconnect, so release keys and touches first. cancelKeyboardFrames() - const ws = wsRef.current + const ws = streamRef.current const touch = lastTouchRef.current - if (ws?.readyState === WebSocket.OPEN && touch) { + if (ws?.open && touch) { try { - ws.send(encodeServeSimTouchFrame({ ...touch, type: 'end' })) + window.api.emulator.sendControlStream({ + streamId: ws.streamId, + data: encodeServeSimTouchFrame({ ...touch, type: 'end' }) + }) } catch {} } lastTouchRef.current = null if (ws) { - wsRef.current = null - ws.close() + streamRef.current = null + void window.api.emulator.stopControlStream({ streamId: ws.streamId }).catch(() => {}) } setConnected(false) } @@ -214,7 +220,10 @@ export function useEmulatorControlStream( return false } try { - ws.send(encodeServeSimTouchFrame(touch)) + window.api.emulator.sendControlStream({ + streamId: ws.streamId, + data: encodeServeSimTouchFrame(touch) + }) lastTouchRef.current = touch.type === 'end' ? null : touch return true } catch { diff --git a/src/renderer/src/web/preload-api/web-browser-api.ts b/src/renderer/src/web/preload-api/web-browser-api.ts index d96c34783f52..8e4e8b1fa800 100644 --- a/src/renderer/src/web/preload-api/web-browser-api.ts +++ b/src/renderer/src/web/preload-api/web-browser-api.ts @@ -145,6 +145,10 @@ export function createEmulatorApi(): NonNullable['emulator'] return { onPaneFocus: () => noopUnsubscribe, onAutoAttach: () => noopUnsubscribe, + startControlStream: () => Promise.reject(new Error('Mobile emulator is unavailable on web.')), + stopControlStream: () => Promise.resolve(), + sendControlStream: () => {}, + onControlStreamEvent: () => noopUnsubscribe, startFrameStream: () => Promise.reject(new Error('Mobile emulator is unavailable on web.')), stopFrameStream: () => Promise.resolve(), startVideoStream: () => Promise.reject(new Error('Mobile emulator is unavailable on web.')),