@aiscene/aiserver 1.5.9 → 1.6.0

package/dist/scrcpy/server.js

@@ -0,0 +1,739 @@
+/**
+ * Scrcpy preview service for AIServer
+ *
+ * 仿照 midscene/packages/android-playground/src/scrcpy-server.ts 实现，
+ * 通过 socket.io 提供稳定的 Android 投屏服务。
+ *
+ * 前端约定（与 nethp-docs-static 对齐）：
+ *   - 连接后 emit 'connect-device' { deviceId?, maxSize? }
+ *   - 服务端推送：
+ *       'devices-list'      { devices, currentDeviceId }
+ *       'preview-status'    { phase, message }
+ *       'video-metadata'    { codec, width, height }
+ *       'video-data'        { data: Uint8Array, type: 'configuration'|'data', keyFrame, timestamp }
+ *       'control-ready'
+ *       'error'             { message }
+ *       'device-switched'   { deviceId }
+ *       'global-device-switched' { deviceId, timestamp }
+ */
+import { exec } from 'node:child_process';
+import { createReadStream, existsSync } from 'node:fs';
+import { createServer } from 'node:http';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { createRequire } from 'node:module';
+import cors from 'cors';
+import express from 'express';
+import { Server as SocketIoServer } from 'socket.io';
+import { createLogger } from '../core/logger.js';
+import { buildScrcpyPreviewStatusEvent, } from './preview-status.js';
+import { withTimeout } from './timeout.js';
+const logger = createLogger('ScrcpyServer');
+const promiseExec = promisify(exec);
+const requireCjs = createRequire(import.meta.url);
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+function isPrivateIP(hostname) {
+    return (LOOPBACK_HOSTS.has(hostname) ||
+        /^10\./.test(hostname) ||
+        /^172\.(1[6-9]|2\d|3[01])\./.test(hostname) ||
+        /^192\.168\./.test(hostname) ||
+        /^100\.(6[4-9]|[7-9]\d|1[0-2]\d)\./.test(hostname));
+}
+function isAllowedOrigin(origin) {
+    if (!origin)
+        return true;
+    try {
+        const url = new URL(origin);
+        return isPrivateIP(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveRequestedDeviceId(options, currentDeviceId) {
+    const requestedDeviceId = typeof options?.deviceId === 'string' ? options.deviceId.trim() : '';
+    return requestedDeviceId || currentDeviceId || undefined;
+}
+/**
+ * 自动解析 scrcpy-server 二进制文件路径，
+ * 优先使用 config.serverBinPath，回退到 @aiscene/android/bin/scrcpy-server。
+ */
+function resolveServerBinPath(configured) {
+    if (configured && existsSync(configured)) {
+        return configured;
+    }
+    try {
+        // require.resolve 找到 package.json，从而得到包根
+        const pkgPath = requireCjs.resolve('@aiscene/android/package.json');
+        const candidate = path.resolve(path.dirname(pkgPath), 'bin/scrcpy-server');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    catch {
+        // ignore
+    }
+    // 最后退路：相对 cwd 的默认 node_modules 路径
+    const fallback = path.resolve(process.cwd(), 'node_modules/@aiscene/android/bin/scrcpy-server');
+    return fallback;
+}
+export class ScrcpyServer {
+    app;
+    httpServer;
+    io;
+    config;
+    adbClient = null;
+    currentDeviceId = null;
+    devicePollInterval = null;
+    lastDeviceListJson = '';
+    serverBinPath;
+    started = false;
+    constructor(config) {
+        this.config = config;
+        this.serverBinPath = resolveServerBinPath(config.serverBinPath);
+        this.app = express();
+        this.httpServer = createServer(this.app);
+        this.io = new SocketIoServer(this.httpServer, {
+            cors: {
+                origin(origin, callback) {
+                    callback(null, isAllowedOrigin(origin));
+                },
+                methods: ['GET', 'POST'],
+                credentials: true,
+            },
+            // 视频帧二进制大小较大，提升允许的载荷上限
+            maxHttpBufferSize: 1e8,
+        });
+        this.app.use(cors({
+            origin(origin, callback) {
+                callback(null, isAllowedOrigin(origin));
+            },
+            credentials: true,
+        }));
+        this.setupApiRoutes();
+        this.setupSocketHandlers();
+    }
+    // ============================================================
+    // REST API
+    // ============================================================
+    setupApiRoutes() {
+        this.app.get('/api/health', (_req, res) => {
+            res.json({ ok: true, currentDeviceId: this.currentDeviceId });
+        });
+        this.app.get('/api/devices', async (_req, res) => {
+            try {
+                const devices = await this.getDevicesList();
+                res.json({ devices, currentDeviceId: this.currentDeviceId });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: error.message || 'Failed to get devices list',
+                });
+            }
+        });
+    }
+    // ============================================================
+    // ADB helpers
+    // ============================================================
+    async getAdbClient() {
+        if (this.adbClient)
+            return this.adbClient;
+        const { AdbServerClient } = await import('@yume-chan/adb');
+        const { AdbServerNodeTcpConnector } = await import('@yume-chan/adb-server-node-tcp');
+        try {
+            await withTimeout(promiseExec('adb start-server'), this.config.adbConnectTimeoutMs, `Timed out starting adb server after ${Math.round(this.config.adbConnectTimeoutMs / 1000)}s`);
+            logger.debug('adb server started');
+        }
+        catch (error) {
+            logger.warn(`adb start-server failed: ${error.message}`);
+        }
+        this.adbClient = new AdbServerClient(new AdbServerNodeTcpConnector({ host: '127.0.0.1', port: 5037 }));
+        return this.adbClient;
+    }
+    async getDevicesList() {
+        try {
+            const client = await this.getAdbClient();
+            const devices = (await withTimeout(client.getDevices(), this.config.adbConnectTimeoutMs, `Timed out listing devices after ${Math.round(this.config.adbConnectTimeoutMs / 1000)}s`));
+            if (!devices || devices.length === 0)
+                return [];
+            return devices.map((d) => ({
+                id: d.serial,
+                name: d.product || d.model || d.serial,
+                status: d.state || 'device',
+            }));
+        }
+        catch (error) {
+            logger.warn(`Failed to get devices: ${error.message}`);
+            return [];
+        }
+    }
+    async getAdb(deviceId) {
+        const { Adb } = await import('@yume-chan/adb');
+        const client = await this.getAdbClient();
+        const targetDeviceId = deviceId || this.currentDeviceId;
+        if (targetDeviceId) {
+            this.currentDeviceId = targetDeviceId;
+            return new Adb(await withTimeout(client.createTransport({ serial: targetDeviceId }), this.config.adbConnectTimeoutMs, `Timed out connecting to Android device ${targetDeviceId} via ADB after ${Math.round(this.config.adbConnectTimeoutMs / 1000)}s`));
+        }
+        const devices = (await withTimeout(client.getDevices(), this.config.adbConnectTimeoutMs, `Timed out listing Android devices via ADB after ${Math.round(this.config.adbConnectTimeoutMs / 1000)}s`));
+        if (!devices || devices.length === 0)
+            return null;
+        this.currentDeviceId = devices[0].serial;
+        return new Adb(await withTimeout(client.createTransport(devices[0]), this.config.adbConnectTimeoutMs, `Timed out connecting to ${devices[0].serial} via ADB`));
+    }
+    // ============================================================
+    // Scrcpy lifecycle
+    // ============================================================
+    async startScrcpy(adb, options = {}, onProgress) {
+        const { AdbScrcpyClient, AdbScrcpyOptions3_3_3 } = await import('@yume-chan/adb-scrcpy');
+        const { ReadableStream } = await import('@yume-chan/stream-extra');
+        const { DefaultServerPath } = await import('@yume-chan/scrcpy');
+        if (!existsSync(this.serverBinPath)) {
+            throw new Error(`scrcpy-server binary not found at: ${this.serverBinPath}. ` +
+                `Please install @aiscene/android or set scrcpy.serverBinPath.`);
+        }
+        onProgress?.('pushing-server');
+        await withTimeout(AdbScrcpyClient.pushServer(adb, ReadableStream.from(createReadStream(this.serverBinPath))), this.config.pushTimeoutMs, `Timed out pushing scrcpy server to device after ${Math.round(this.config.pushTimeoutMs / 1000)}s`);
+        const scrcpyOptions = new AdbScrcpyOptions3_3_3({
+            audio: false,
+            control: true,
+            maxSize: options.maxSize ?? this.config.maxSize,
+            // 让 web decoder 能区分 configuration 帧
+            sendFrameMeta: true,
+            videoBitRate: options.videoBitRate ?? this.config.videoBitRate,
+            // 降低端到端延迟与提升首帧速度
+            maxFps: 60,
+            // 让设备更频繁地发关键帧，掉帧/花屏可更快恢复（单位：秒）
+            // 注意：scrcpy 3.x 接受字符串 "1" 也可以是 number；保险用字符串
+            // 由 scrcpy server 用 ffmpeg/ MediaCodec 解释
+            // 如果你的 scrcpy 版本不支持此选项，会被忽略，无副作用
+        });
+        onProgress?.('starting-service');
+        const startPromise = AdbScrcpyClient.start(adb, DefaultServerPath, scrcpyOptions);
+        return withTimeout(startPromise, this.config.startTimeoutMs, `Timed out starting scrcpy service after ${Math.round(this.config.startTimeoutMs / 1000)}s`, {
+            onSettledAfterTimeout: async (lateClient) => {
+                try {
+                    await lateClient?.close?.();
+                }
+                catch (e) {
+                    logger.warn(`Failed to close late scrcpy client: ${e.message}`);
+                }
+            },
+        });
+    }
+    // ============================================================
+    // Socket handlers
+    // ============================================================
+    broadcastDevicesList(devices) {
+        const currentJson = JSON.stringify(devices);
+        if (this.lastDeviceListJson === currentJson)
+            return;
+        this.lastDeviceListJson = currentJson;
+        if (this.currentDeviceId &&
+            !devices.some((d) => d.id === this.currentDeviceId)) {
+            this.currentDeviceId = null;
+        }
+        if (!this.currentDeviceId && devices.length > 0) {
+            const online = devices.filter((d) => d.status.toLowerCase() === 'device');
+            if (online.length > 0) {
+                this.currentDeviceId = online[0].id;
+                logger.info(`Auto-selected online device: ${this.currentDeviceId}`);
+            }
+        }
+        this.io.emit('devices-list', {
+            devices,
+            currentDeviceId: this.currentDeviceId,
+        });
+    }
+    setupSocketHandlers() {
+        this.io.on('connection', (socket) => {
+            logger.info(`Client connected: id=${socket.id}, address=${socket.handshake.address}`);
+            const state = {
+                scrcpyClient: null,
+                adb: null,
+                videoWidth: 0,
+                videoHeight: 0,
+            };
+            const emitStatus = (phase) => {
+                socket.emit('preview-status', buildScrcpyPreviewStatusEvent(phase));
+            };
+            const sendDevicesList = async () => {
+                try {
+                    const devices = await this.getDevicesList();
+                    socket.emit('devices-list', {
+                        devices,
+                        currentDeviceId: this.currentDeviceId,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`sendDevicesList failed: ${error.message}`);
+                    socket.emit('error', { message: 'failed to get devices list' });
+                }
+            };
+            socket.on('get-devices', () => {
+                void sendDevicesList();
+            });
+            socket.on('switch-device', async (deviceId) => {
+                try {
+                    if (state.scrcpyClient) {
+                        await state.scrcpyClient.close().catch(() => { });
+                        state.scrcpyClient = null;
+                    }
+                    this.currentDeviceId = deviceId;
+                    socket.emit('device-switched', { deviceId });
+                    this.io.emit('global-device-switched', {
+                        deviceId,
+                        timestamp: Date.now(),
+                    });
+                }
+                catch (error) {
+                    socket.emit('error', {
+                        message: `Failed to switch device: ${error?.message || 'Unknown error'}`,
+                    });
+                }
+            });
+            socket.on('connect-device', async (options = {}) => {
+                const { ScrcpyVideoCodecId } = await import('@yume-chan/scrcpy');
+                try {
+                    emitStatus('connecting-device');
+                    const requestedDeviceId = resolveRequestedDeviceId(options, this.currentDeviceId);
+                    if (requestedDeviceId) {
+                        this.currentDeviceId = requestedDeviceId;
+                    }
+                    state.adb = await this.getAdb(requestedDeviceId);
+                    if (!state.adb) {
+                        socket.emit('error', { message: 'No device found' });
+                        return;
+                    }
+                    state.scrcpyClient = await this.startScrcpy(state.adb, options, emitStatus);
+                    logger.info(`Scrcpy started for device=${this.currentDeviceId}, client=${socket.id}`);
+                    const videoStreamRaw = state.scrcpyClient?.videoStream;
+                    if (!videoStreamRaw) {
+                        socket.emit('error', {
+                            message: 'Video stream not available in scrcpy client',
+                        });
+                        return;
+                    }
+                    emitStatus('waiting-for-video');
+                    const videoStream = typeof videoStreamRaw?.then === 'function'
+                        ? await withTimeout(videoStreamRaw, this.config.videoStreamTimeoutMs, `Timed out waiting for scrcpy video stream metadata after ${Math.round(this.config.videoStreamTimeoutMs / 1000)}s`)
+                        : videoStreamRaw;
+                    const metadata = videoStream.metadata || {};
+                    if (!metadata.codec)
+                        metadata.codec = ScrcpyVideoCodecId.H264;
+                    if (!metadata.width)
+                        metadata.width = 1080;
+                    if (!metadata.height)
+                        metadata.height = 1920;
+                    socket.emit('video-metadata', metadata);
+                    state.videoWidth = metadata.width;
+                    state.videoHeight = metadata.height;
+                    const { stream } = videoStream;
+                    const reader = stream.getReader();
+                    const processStream = async () => {
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                const frameType = value.type || 'data';
+                                // scrcpy 包属性是 `keyframe`（小写 f），兼容两种命名后强制布尔
+                                const isKey = !!(value.keyframe ?? value.keyFrame);
+                                // 二进制 Uint8Array 直发，避免 Array.from 内存爆炸
+                                socket.emit('video-data', {
+                                    data: value.data,
+                                    type: frameType,
+                                    timestamp: Date.now(),
+                                    keyFrame: isKey,
+                                });
+                            }
+                        }
+                        catch (error) {
+                            logger.error(`Video stream error: ${error.message}`);
+                            if (socket.connected) {
+                                socket.emit('error', {
+                                    message: 'video stream processing error',
+                                });
+                            }
+                            return;
+                        }
+                        // 流自然结束 — 通知前端尽快重连
+                        if (socket.connected) {
+                            socket.emit('error', { message: 'video stream ended' });
+                        }
+                        if (state.scrcpyClient) {
+                            await state.scrcpyClient.close().catch(() => { });
+                            state.scrcpyClient = null;
+                        }
+                    };
+                    void processStream();
+                    if (state.scrcpyClient?.controller) {
+                        socket.emit('control-ready');
+                    }
+                }
+                catch (error) {
+                    const message = error?.message || 'Unknown error';
+                    logger.error(`connect-device failed: ${message}`);
+                    if (state.scrcpyClient) {
+                        await state.scrcpyClient.close().catch(() => { });
+                        state.scrcpyClient = null;
+                    }
+                    socket.emit('error', {
+                        message: `Failed to connect device: ${message}`,
+                    });
+                }
+            });
+            // ============================================================
+            // Control channel: 触摸 / 按键 / 文本 / 物理按键快捷
+            // 客户端约定：
+            //   socket.emit('control-touch', {
+            //     action: 'down'|'move'|'up'|'cancel',
+            //     x, y,                 // 0..1 归一化 或 已映射到设备坐标
+            //     normalized?: boolean, // true 表示 x,y 是 0..1，需要乘 videoWidth/Height
+            //     pointerId?: number,
+            //     pressure?: number,
+            //   })
+            //   socket.emit('control-key', { keycode: number, action?: 'down'|'up'|'press', repeat?, metaState? })
+            //   socket.emit('control-text', { text: string })
+            //   socket.emit('control-back')         // 等价于 back/screen on
+            //   socket.emit('control-home')         // Home
+            //   socket.emit('control-app-switch')   // 最近任务
+            //   socket.emit('control-set-clipboard', { text, paste?: boolean })
+            // ============================================================
+            const ensureController = () => {
+                const controller = state.scrcpyClient?.controller;
+                if (!controller) {
+                    socket.emit('error', {
+                        message: 'Scrcpy controller not ready, connect-device first',
+                    });
+                    return null;
+                }
+                return controller;
+            };
+            const ACTION_MAP = {
+                down: 0,
+                up: 1,
+                move: 2,
+                cancel: 3,
+            };
+            // scrcpy 协议常量（参考 https://tangoadb.dev/scrcpy/control/touch/）
+            // ScrcpyPointerId.Finger = -2n
+            const FINGER_POINTER_ID = BigInt(-2);
+            const BUTTON_PRIMARY = 1;
+            socket.on('control-touch', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller) {
+                        logger.warn('control-touch: controller not ready');
+                        return;
+                    }
+                    // ⚠️ scrcpy 协议字段是 videoWidth / videoHeight（旧 d.ts 误写为 screenWidth），
+                    // 必须与最近一次 video-metadata 的 width/height 完全一致，否则 server 会忽略
+                    const videoWidth = state.videoWidth || 1080;
+                    const videoHeight = state.videoHeight || 1920;
+                    const normalized = raw.normalized === true;
+                    let x = Number(raw.x);
+                    let y = Number(raw.y);
+                    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+                        logger.warn(`control-touch: invalid coords ${JSON.stringify(raw)}`);
+                        return;
+                    }
+                    if (normalized) {
+                        x = Math.max(0, Math.min(1, x)) * videoWidth;
+                        y = Math.max(0, Math.min(1, y)) * videoHeight;
+                    }
+                    x = Math.round(Math.max(0, Math.min(videoWidth - 1, x)));
+                    y = Math.round(Math.max(0, Math.min(videoHeight - 1, y)));
+                    const actionStr = String(raw.action || 'down').toLowerCase();
+                    const action = ACTION_MAP[actionStr] ?? 0;
+                    const isUp = actionStr === 'up' || actionStr === 'cancel';
+                    // pressure: down/move=1.0, up=0
+                    const pressure = isUp ? 0 : 1;
+                    // 手指模式 (Finger=-2n)；如果前端有 pointerId 就直接用 BigInt
+                    const pointerId = raw.pointerId !== undefined && raw.pointerId !== null
+                        ? BigInt(raw.pointerId)
+                        : FINGER_POINTER_ID;
+                    // 触摸（手指）模式下，scrcpy server 在 server 端的解码不依赖 button 字段
+                    // —— 上一次设置 actionButton=Primary 反而让某些 ROM 把它当成"按下了实体鼠标键再松开"，
+                    // 结果手机上能看到 inject 但 click 不识别。回退到 0/0 最稳。
+                    const actionButton = 0;
+                    const buttons = 0;
+                    logger.info(`inject touch ${actionStr} (${x},${y}) p=${pressure} pid=${pointerId} videoSize=${videoWidth}x${videoHeight}`);
+                    await controller.injectTouch({
+                        action,
+                        pointerId,
+                        pointerX: x,
+                        pointerY: y,
+                        // 重要：字段名是 videoWidth/videoHeight
+                        videoWidth,
+                        videoHeight,
+                        pressure,
+                        actionButton,
+                        buttons,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`control-touch failed: ${error.message}`);
+                }
+            });
+            socket.on('control-key', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    const keycode = Number(raw.keycode);
+                    if (!Number.isFinite(keycode))
+                        return;
+                    const repeat = Number(raw.repeat ?? 0);
+                    const metaState = Number(raw.metaState ?? 0);
+                    const action = String(raw.action || 'press').toLowerCase();
+                    logger.info(`inject key ${action} keycode=${keycode}`);
+                    const inject = (act) => controller.injectKeyCode({
+                        action: act,
+                        keyCode: keycode,
+                        repeat,
+                        metaState,
+                    });
+                    if (action === 'down') {
+                        await inject(0);
+                    }
+                    else if (action === 'up') {
+                        await inject(1);
+                    }
+                    else {
+                        await inject(0);
+                        await inject(1);
+                    }
+                }
+                catch (error) {
+                    logger.warn(`control-key failed: ${error.message}`);
+                }
+            });
+            socket.on('control-text', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    const text = typeof raw === 'string' ? raw : String(raw.text ?? '');
+                    if (!text)
+                        return;
+                    logger.info(`inject text len=${text.length}`);
+                    await controller.injectText(text);
+                }
+                catch (error) {
+                    logger.warn(`control-text failed: ${error.message}`);
+                }
+            });
+            const pressKey = async (keyCode) => {
+                const controller = ensureController();
+                if (!controller)
+                    return;
+                await controller.injectKeyCode({
+                    action: 0,
+                    keyCode,
+                    repeat: 0,
+                    metaState: 0,
+                });
+                await controller.injectKeyCode({
+                    action: 1,
+                    keyCode,
+                    repeat: 0,
+                    metaState: 0,
+                });
+            };
+            socket.on('control-back', async () => {
+                try {
+                    await pressKey(4); // AndroidKeyCode.AndroidBack
+                }
+                catch (error) {
+                    logger.warn(`control-back failed: ${error.message}`);
+                }
+            });
+            socket.on('control-home', async () => {
+                try {
+                    await pressKey(3); // AndroidKeyCode.AndroidHome
+                }
+                catch (error) {
+                    logger.warn(`control-home failed: ${error.message}`);
+                }
+            });
+            socket.on('control-app-switch', async () => {
+                try {
+                    await pressKey(187); // AndroidKeyCode.AndroidAppSwitch
+                }
+                catch (error) {
+                    logger.warn(`control-app-switch failed: ${error.message}`);
+                }
+            });
+            socket.on('control-set-clipboard', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    const text = String(raw.text ?? '');
+                    if (!text)
+                        return;
+                    await controller.setClipboard({
+                        sequence: BigInt(Date.now()),
+                        paste: Boolean(raw.paste),
+                        content: text,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`control-set-clipboard failed: ${error.message}`);
+                }
+            });
+            // ---- scroll: 鼠标滚轮（参考 https://tangoadb.dev/scrcpy/control/scroll/） ----
+            // raw: { x, y, scrollX?, scrollY?, normalized?: bool }
+            // 默认 scrollY = -1（向下滚动一格），向上滚动用 +1
+            socket.on('control-scroll', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    const videoWidth = state.videoWidth || 1080;
+                    const videoHeight = state.videoHeight || 1920;
+                    let x = Number(raw.x ?? videoWidth / 2);
+                    let y = Number(raw.y ?? videoHeight / 2);
+                    if (raw.normalized === true) {
+                        x = Math.max(0, Math.min(1, x)) * videoWidth;
+                        y = Math.max(0, Math.min(1, y)) * videoHeight;
+                    }
+                    x = Math.round(Math.max(0, Math.min(videoWidth - 1, x)));
+                    y = Math.round(Math.max(0, Math.min(videoHeight - 1, y)));
+                    const scrollX = Math.trunc(Number(raw.scrollX ?? 0));
+                    const scrollY = Math.trunc(Number(raw.scrollY ?? -1));
+                    await controller.injectScroll({
+                        pointerX: x,
+                        pointerY: y,
+                        videoWidth,
+                        videoHeight,
+                        scrollX,
+                        scrollY,
+                        buttons: 0,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`control-scroll failed: ${error.message}`);
+                }
+            });
+            // ---- back-or-screen-on：右键模拟，息屏时唤醒 ----
+            socket.on('control-back-or-screen-on', async () => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    // action: Down(0)=按下；通常一次发 Down 就够了
+                    await controller.backOrScreenOn(0);
+                }
+                catch (error) {
+                    logger.warn(`control-back-or-screen-on failed: ${error.message}`);
+                }
+            });
+            // ---- rotate-device：旋转屏幕 ----
+            socket.on('control-rotate', async () => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    await controller.rotateDevice();
+                }
+                catch (error) {
+                    logger.warn(`control-rotate failed: ${error.message}`);
+                }
+            });
+            // ---- reset-video：让 scrcpy 重新发送 SPS/PPS 与关键帧（解决花屏） ----
+            socket.on('control-reset-video', async () => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    await controller.resetVideo();
+                }
+                catch (error) {
+                    logger.warn(`control-reset-video failed: ${error.message}`);
+                }
+            });
+            // ---- screen-power：开/关屏幕背光（不锁屏） ----
+            // raw: { mode: 'normal' | 'off' }   normal=2, off=0
+            socket.on('control-screen-power', async (raw = {}) => {
+                try {
+                    const controller = ensureController();
+                    if (!controller)
+                        return;
+                    const mode = String(raw.mode || 'normal').toLowerCase() === 'off' ? 0 : 2;
+                    await controller.setScreenPowerMode(mode);
+                }
+                catch (error) {
+                    logger.warn(`control-screen-power failed: ${error.message}`);
+                }
+            });
+            socket.on('disconnect', async (reason) => {
+                logger.info(`Client disconnected: id=${socket.id}, reason=${reason}`);
+                if (state.scrcpyClient) {
+                    try {
+                        await state.scrcpyClient.close();
+                    }
+                    catch (error) {
+                        logger.warn(`Failed to close scrcpy client on disconnect: ${error.message}`);
+                    }
+                    state.scrcpyClient = null;
+                }
+            });
+            // 立即异步推送设备列表，避免冷启动卡住
+            void sendDevicesList();
+        });
+    }
+    // ============================================================
+    // Lifecycle
+    // ============================================================
+    startDeviceMonitoring() {
+        if (this.devicePollInterval)
+            return;
+        this.devicePollInterval = setInterval(async () => {
+            try {
+                const devices = await this.getDevicesList();
+                this.broadcastDevicesList(devices);
+            }
+            catch (error) {
+                logger.warn(`Device polling error: ${error.message}`);
+            }
+        }, this.config.devicePollInterval);
+    }
+    async start() {
+        if (this.started)
+            return;
+        if (!this.config.enabled) {
+            logger.info('Scrcpy server is disabled by configuration');
+            return;
+        }
+        this.started = true;
+        await new Promise((resolve) => {
+            this.httpServer.listen(this.config.port, this.config.host, () => {
+                logger.info(`Scrcpy server running at http://${this.config.host}:${this.config.port}`);
+                logger.info(`Using scrcpy-server bin: ${this.serverBinPath}`);
+                this.startDeviceMonitoring();
+                resolve();
+            });
+        });
+    }
+    async close() {
+        if (!this.started)
+            return;
+        if (this.devicePollInterval) {
+            clearInterval(this.devicePollInterval);
+            this.devicePollInterval = null;
+        }
+        await new Promise((resolve) => {
+            if (!this.httpServer.listening) {
+                resolve();
+                return;
+            }
+            this.io.close(() => {
+                this.httpServer.close(() => resolve());
+            });
+        });
+        this.started = false;
+        logger.info('Scrcpy server closed');
+    }
+}
+//# sourceMappingURL=server.js.map