@aiscene/aiserver 1.9.6 → 1.9.8

package/dist/scrcpy/server.js

@@ -139,8 +139,13 @@ export class ScrcpyServer {
     currentDeviceId = null;
     devicePollInterval = null;
     lastDeviceListJson = '';
+    lastDeviceList = [];
+    lastDeviceListAt = 0;
+    deviceListInFlight = null;
+    deviceConnectLocks = new Map();
     serverBinPath;
     started = false;
+    startPromise = null;
     projectionBlockedDevices = new Map();
     /** 所有活动 session（按 ws 索引），用于广播 */
     sessions = new Map();
@@ -210,7 +215,7 @@ export class ScrcpyServer {
         this.adbClient = new AdbServerClient(new AdbServerNodeTcpConnector({ host: '127.0.0.1', port: 5037 }));
         return this.adbClient;
     }
-    async getDevicesList() {
+    async loadDevicesListFromAdb() {
         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`));
@@ -227,6 +232,38 @@ export class ScrcpyServer {
             return [];
         }
     }
+    async getDevicesList(forceRefresh = false) {
+        const now = Date.now();
+        const cacheTtlMs = 2000;
+        if (!forceRefresh &&
+            this.lastDeviceListAt > 0 &&
+            now - this.lastDeviceListAt < cacheTtlMs) {
+            return this.lastDeviceList;
+        }
+        if (this.deviceListInFlight) {
+            return this.deviceListInFlight;
+        }
+        this.deviceListInFlight = this.loadDevicesListFromAdb()
+            .then((devices) => {
+            this.lastDeviceList = devices;
+            this.lastDeviceListAt = Date.now();
+            return devices;
+        })
+            .finally(() => {
+            this.deviceListInFlight = null;
+        });
+        return this.deviceListInFlight;
+    }
+    selectAvailableDeviceId(devices) {
+        const online = devices.find((device) => device.status.toLowerCase() === 'device' &&
+            !this.isProjectionBlocked(device.id));
+        return online?.id || null;
+    }
+    isSessionOpen(state) {
+        return (!state.closed &&
+            state.ws.readyState === WebSocket.OPEN &&
+            this.sessions.get(state.ws) === state);
+    }
     isProjectionBlocked(deviceId) {
         if (!deviceId)
             return false;
@@ -250,14 +287,12 @@ export class ScrcpyServer {
             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;
-        const availableDevice = devices.find((device) => !this.isProjectionBlocked(device.serial));
-        if (!availableDevice)
+        const devices = await this.getDevicesList();
+        const availableDeviceId = this.selectAvailableDeviceId(devices);
+        if (!availableDeviceId)
             return null;
-        this.currentDeviceId = availableDevice.serial;
-        return new Adb(await withTimeout(client.createTransport(availableDevice), this.config.adbConnectTimeoutMs, `Timed out connecting to ${availableDevice.serial} via ADB`));
+        this.currentDeviceId = availableDeviceId;
+        return new Adb(await withTimeout(client.createTransport({ serial: availableDeviceId }), this.config.adbConnectTimeoutMs, `Timed out connecting to ${availableDeviceId} via ADB`));
     }
     async wakeDeviceScreen(deviceId) {
         const targetDeviceId = deviceId || this.currentDeviceId;
@@ -386,7 +421,7 @@ export class ScrcpyServer {
         await Promise.allSettled(releases);
     }
     async refreshDevicesList() {
-        const devices = await this.getDevicesList();
+        const devices = await this.getDevicesList(true);
         this.lastDeviceListJson = '';
         this.broadcastDevicesList(devices);
     }
@@ -403,6 +438,8 @@ export class ScrcpyServer {
                 scrcpyClient: null,
                 adb: null,
                 deviceId: null,
+                connectPromise: null,
+                closed: false,
                 videoWidth: 0,
                 videoHeight: 0,
                 streamReader: null,
@@ -415,9 +452,14 @@ export class ScrcpyServer {
     async sendDevicesListTo(state) {
         try {
             const devices = await this.getDevicesList();
+            if (!this.isSessionOpen(state))
+                return;
             if (this.currentDeviceId && this.isProjectionBlocked(this.currentDeviceId)) {
                 this.currentDeviceId = null;
             }
+            if (!this.currentDeviceId) {
+                this.currentDeviceId = this.selectAvailableDeviceId(devices);
+            }
             wsSend(state.ws, 'devices-list', {
                 devices,
                 currentDeviceId: this.currentDeviceId,
@@ -451,6 +493,185 @@ export class ScrcpyServer {
         state.videoWidth = 0;
         state.videoHeight = 0;
     }
+    async connectDeviceForSession(state, options = {}, emitStatus) {
+        const { ws } = state;
+        const safeOptions = options || {};
+        let connectLockKey = null;
+        try {
+            emitStatus('connecting-device');
+            // 重复 connect-device 时，先释放旧资源避免 scrcpy 进程残留。
+            if (state.scrcpyClient) {
+                await this.releaseSession(state);
+            }
+            if (!this.isSessionOpen(state))
+                return;
+            let targetDeviceId = resolveRequestedDeviceId(safeOptions, this.currentDeviceId);
+            if (!targetDeviceId) {
+                const devices = await this.getDevicesList();
+                if (!this.isSessionOpen(state))
+                    return;
+                targetDeviceId = this.selectAvailableDeviceId(devices) || undefined;
+            }
+            if (!targetDeviceId) {
+                wsSend(ws, 'error', { message: 'No device found' });
+                return;
+            }
+            if (this.isProjectionBlocked(targetDeviceId)) {
+                logger.info(`Skip scrcpy connect for scheduled task device: deviceId=${targetDeviceId}`);
+                wsSend(ws, 'error', { message: this.getProjectionBlockedMessage(targetDeviceId) });
+                return;
+            }
+            const lockedBy = this.deviceConnectLocks.get(targetDeviceId);
+            if (lockedBy && lockedBy !== state.id) {
+                logger.info(`Skip duplicate scrcpy connect: deviceId=${targetDeviceId},owner=${lockedBy},client=${state.id}`);
+                wsSend(ws, 'error', {
+                    message: `设备 ${targetDeviceId} 正在建立投屏连接，请稍后重试`,
+                });
+                return;
+            }
+            connectLockKey = targetDeviceId;
+            this.deviceConnectLocks.set(connectLockKey, state.id);
+            this.currentDeviceId = targetDeviceId;
+            state.deviceId = targetDeviceId;
+            state.adb = await this.getAdb(targetDeviceId);
+            if (!this.isSessionOpen(state)) {
+                await this.releaseSession(state);
+                return;
+            }
+            if (!state.adb) {
+                wsSend(ws, 'error', { message: 'No device found' });
+                return;
+            }
+            await this.wakeDeviceScreen(targetDeviceId);
+            if (!this.isSessionOpen(state)) {
+                await this.releaseSession(state);
+                return;
+            }
+            state.scrcpyClient = await this.startScrcpy(state.adb, safeOptions, emitStatus);
+            if (!this.isSessionOpen(state)) {
+                await this.releaseSession(state);
+                return;
+            }
+            logger.info(`Scrcpy started for device=${targetDeviceId},client=${state.id}`);
+            const videoStreamRaw = state.scrcpyClient?.videoStream;
+            if (!videoStreamRaw) {
+                wsSend(ws, 'error', {
+                    message: 'Video stream not available in scrcpy client',
+                });
+                await this.releaseSession(state);
+                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;
+            if (!this.isSessionOpen(state)) {
+                await this.releaseSession(state);
+                return;
+            }
+            const metadata = videoStream.metadata;
+            // 严格校验：缺失元数据直接报错，避免兜底 H264/1080x1920 与真实流不匹配。
+            if (!metadata ||
+                !metadata.codec ||
+                !metadata.width ||
+                !metadata.height) {
+                const detail = JSON.stringify(metadata || {});
+                logger.error(`incomplete video metadata: ${detail}`);
+                wsSend(ws, 'error', {
+                    message: `Incomplete video metadata from scrcpy: ${detail}`,
+                });
+                await this.releaseSession(state);
+                return;
+            }
+            // 唤醒屏幕，避免设备熄屏时 scrcpy 推黑画面。
+            const controller = state.scrcpyClient?.controller;
+            if (controller) {
+                try {
+                    await controller.setScreenPowerMode?.(2);
+                }
+                catch (e) {
+                    logger.warn(`setScreenPowerMode failed: ${e.message}`);
+                }
+                try {
+                    await controller.backOrScreenOn?.(0);
+                }
+                catch (e) {
+                    logger.warn(`backOrScreenOn failed: ${e.message}`);
+                }
+            }
+            if (!this.isSessionOpen(state)) {
+                await this.releaseSession(state);
+                return;
+            }
+            wsSend(ws, 'video-metadata', {
+                codec: metadata.codec,
+                width: metadata.width,
+                height: metadata.height,
+            });
+            state.videoWidth = metadata.width;
+            state.videoHeight = metadata.height;
+            const { stream } = videoStream;
+            const reader = stream.getReader();
+            state.streamReader = reader;
+            const processStream = async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const data = value.data;
+                        const frameType = value.type || 'data';
+                        const isKey = !!(value.keyframe ?? value.keyFrame) || isH264IdrFrame(data);
+                        const isConfig = frameType === 'configuration';
+                        if (!this.isSessionOpen(state))
+                            break;
+                        ws.send(buildVideoFrameBuffer(data, isKey, isConfig, Date.now()), { binary: true });
+                    }
+                }
+                catch (error) {
+                    const msg = error.message || '';
+                    if (!/cancel|abort/i.test(msg)) {
+                        logger.error(`Video stream error: ${msg}`);
+                        if (this.isSessionOpen(state)) {
+                            wsSend(ws, 'error', {
+                                message: 'video stream processing error',
+                            });
+                        }
+                    }
+                    return;
+                }
+                finally {
+                    if (state.streamReader === reader) {
+                        state.streamReader = null;
+                    }
+                }
+                if (this.isSessionOpen(state)) {
+                    wsSend(ws, 'error', { message: 'video stream ended' });
+                }
+                await this.releaseSession(state);
+            };
+            void processStream();
+            if (state.scrcpyClient?.controller && this.isSessionOpen(state)) {
+                wsSend(ws, 'control-ready');
+            }
+        }
+        catch (error) {
+            const message = error?.message || 'Unknown error';
+            logger.error(`connect-device failed: ${message}`);
+            await this.releaseSession(state);
+            if (this.isSessionOpen(state)) {
+                wsSend(ws, 'error', {
+                    message: `Failed to connect device: ${message}`,
+                });
+            }
+        }
+        finally {
+            if (connectLockKey &&
+                this.deviceConnectLocks.get(connectLockKey) === state.id) {
+                this.deviceConnectLocks.delete(connectLockKey);
+            }
+        }
+    }
     attachSocketHandlers(state) {
         const { ws } = state;
         const emitStatus = (phase) => {
@@ -526,6 +747,12 @@ export class ScrcpyServer {
             'get-devices': () => this.sendDevicesListTo(state),
             'switch-device': async (deviceId) => {
                 try {
+                    if (state.connectPromise) {
+                        wsSend(ws, 'error', {
+                            message: 'Device connection is already in progress',
+                        });
+                        return;
+                    }
                     const id = typeof deviceId === 'string' ? deviceId : String(deviceId ?? '');
                     if (this.isProjectionBlocked(id)) {
                         wsSend(ws, 'error', { message: this.getProjectionBlockedMessage(id) });
@@ -547,134 +774,25 @@ export class ScrcpyServer {
                     });
                 }
             },
-            'connect-device': async (options = {}) => {
-                try {
+            'connect-device': (options = {}) => {
+                if (state.connectPromise) {
                     emitStatus('connecting-device');
-                    // 重复 connect-device 时，先释放旧资源避免 scrcpy 残留
-                    if (state.scrcpyClient) {
-                        await this.releaseSession(state);
-                    }
-                    const requestedDeviceId = resolveRequestedDeviceId(options || {}, this.currentDeviceId);
-                    if (this.isProjectionBlocked(requestedDeviceId)) {
-                        const blockedDeviceId = requestedDeviceId || '';
-                        logger.info(`Skip scrcpy connect for scheduled task device: deviceId=${blockedDeviceId}`);
-                        wsSend(ws, 'error', { message: this.getProjectionBlockedMessage(blockedDeviceId) });
-                        return;
-                    }
-                    if (requestedDeviceId) {
-                        this.currentDeviceId = requestedDeviceId;
-                        state.deviceId = requestedDeviceId;
-                    }
-                    state.adb = await this.getAdb(requestedDeviceId);
-                    if (!state.adb) {
-                        wsSend(ws, 'error', { message: 'No device found' });
-                        return;
-                    }
-                    await this.wakeDeviceScreen(this.currentDeviceId || requestedDeviceId);
-                    state.scrcpyClient = await this.startScrcpy(state.adb, options || {}, emitStatus);
-                    logger.info(`Scrcpy started for device=${this.currentDeviceId},client=${state.id}`);
-                    const videoStreamRaw = state.scrcpyClient?.videoStream;
-                    if (!videoStreamRaw) {
-                        wsSend(ws, 'error', {
-                            message: 'Video stream not available in scrcpy client',
-                        });
-                        await this.releaseSession(state);
-                        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;
-                    // 严格校验：缺失元数据直接报错，避免兜底 H264/1080x1920 与真实流不匹配
-                    if (!metadata ||
-                        !metadata.codec ||
-                        !metadata.width ||
-                        !metadata.height) {
-                        const detail = JSON.stringify(metadata || {});
-                        logger.error(`incomplete video metadata: ${detail}`);
-                        wsSend(ws, 'error', {
-                            message: `Incomplete video metadata from scrcpy: ${detail}`,
-                        });
-                        await this.releaseSession(state);
-                        return;
-                    }
-                    // 唤醒屏幕，避免设备熄屏时 scrcpy 推黑画面
-                    const controller = state.scrcpyClient?.controller;
-                    if (controller) {
-                        try {
-                            await controller.setScreenPowerMode?.(2);
-                        }
-                        catch (e) {
-                            logger.warn(`setScreenPowerMode failed: ${e.message}`);
-                        }
-                        try {
-                            await controller.backOrScreenOn?.(0);
-                        }
-                        catch (e) {
-                            logger.warn(`backOrScreenOn failed: ${e.message}`);
-                        }
-                    }
-                    wsSend(ws, 'video-metadata', {
-                        codec: metadata.codec,
-                        width: metadata.width,
-                        height: metadata.height,
-                    });
-                    state.videoWidth = metadata.width;
-                    state.videoHeight = metadata.height;
-                    const { stream } = videoStream;
-                    const reader = stream.getReader();
-                    state.streamReader = reader;
-                    const processStream = async () => {
-                        try {
-                            while (true) {
-                                const { done, value } = await reader.read();
-                                if (done)
-                                    break;
-                                const data = value.data;
-                                const frameType = value.type || 'data';
-                                const isKey = !!(value.keyframe ?? value.keyFrame) || isH264IdrFrame(data);
-                                const isConfig = frameType === 'configuration';
-                                if (ws.readyState !== WebSocket.OPEN)
-                                    break;
-                                ws.send(buildVideoFrameBuffer(data, isKey, isConfig, Date.now()), { binary: true });
-                            }
-                        }
-                        catch (error) {
-                            const msg = error.message || '';
-                            if (!/cancel|abort/i.test(msg)) {
-                                logger.error(`Video stream error: ${msg}`);
-                                if (ws.readyState === WebSocket.OPEN) {
-                                    wsSend(ws, 'error', {
-                                        message: 'video stream processing error',
-                                    });
-                                }
-                            }
-                            return;
-                        }
-                        finally {
-                            if (state.streamReader === reader) {
-                                state.streamReader = null;
-                            }
-                        }
-                        if (ws.readyState === WebSocket.OPEN) {
-                            wsSend(ws, 'error', { message: 'video stream ended' });
-                        }
-                        await this.releaseSession(state);
-                    };
-                    void processStream();
-                    if (state.scrcpyClient?.controller) {
-                        wsSend(ws, 'control-ready');
-                    }
-                }
-                catch (error) {
-                    const message = error?.message || 'Unknown error';
-                    logger.error(`connect-device failed: ${message}`);
-                    await this.releaseSession(state);
                     wsSend(ws, 'error', {
-                        message: `Failed to connect device: ${message}`,
+                        message: 'Device connection is already in progress',
                     });
+                    return;
                 }
+                const promise = this.connectDeviceForSession(state, options || {}, emitStatus);
+                state.connectPromise = promise;
+                void promise
+                    .catch((error) => {
+                    logger.error(`connect-device promise failed: ${error.message}`);
+                })
+                    .finally(() => {
+                    if (state.connectPromise === promise) {
+                        state.connectPromise = null;
+                    }
+                });
             },
             'control-touch': async (raw = {}) => {
                 try {
@@ -1076,6 +1194,7 @@ export class ScrcpyServer {
         });
         ws.on('close', async (code, reason) => {
             logger.info(`Client disconnected: id=${state.id}, code=${code}, reason=${reason?.toString() || ''}`);
+            state.closed = true;
             this.sessions.delete(ws);
             androidRecordingManager.cancel(state.id);
             await this.releaseSession(state);
@@ -1092,7 +1211,7 @@ export class ScrcpyServer {
             return;
         this.devicePollInterval = setInterval(async () => {
             try {
-                const devices = await this.getDevicesList();
+                const devices = await this.getDevicesList(true);
                 this.broadcastDevicesList(devices);
             }
             catch (error) {
@@ -1100,31 +1219,97 @@ export class ScrcpyServer {
             }
         }, this.config.devicePollInterval);
     }
+    listenOnPort(port) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                this.httpServer.off('error', onError);
+                this.httpServer.off('listening', onListening);
+                this.wss.off('error', onError);
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onListening = () => {
+                cleanup();
+                resolve();
+            };
+            this.httpServer.once('error', onError);
+            this.httpServer.once('listening', onListening);
+            this.wss.once('error', onError);
+            this.httpServer.listen(port, this.config.host);
+        });
+    }
+    async listenWithPortFallback() {
+        const requestedPort = this.config.port;
+        const maxAttempts = 20;
+        for (let offset = 0; offset <= maxAttempts; offset++) {
+            const port = requestedPort + offset;
+            try {
+                await this.listenOnPort(port);
+                if (port !== requestedPort) {
+                    logger.warn(`Scrcpy port ${requestedPort} is unavailable; using ${port} instead`);
+                    this.config.port = port;
+                }
+                return;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'EADDRINUSE') {
+                    logger.warn(`Scrcpy port ${port} is already in use, trying ${port + 1}`);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error(`Unable to start scrcpy server: ports ${requestedPort}-${requestedPort + maxAttempts} are all in use`);
+    }
     async start() {
         if (this.started)
             return;
+        if (this.startPromise)
+            return this.startPromise;
         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 WebSocket server running at ws://${this.config.host}:${this.config.port}`);
-                logger.info(`Using scrcpy-server bin: ${this.serverBinPath}`);
-                this.startDeviceMonitoring();
-                resolve();
-            });
-        });
+        this.startPromise = (async () => {
+            await this.listenWithPortFallback();
+            this.started = true;
+            logger.info(`Scrcpy WebSocket server running at ws://${this.config.host}:${this.config.port}`);
+            logger.info(`Using scrcpy-server bin: ${this.serverBinPath}`);
+            this.startDeviceMonitoring();
+        })();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = null;
+        }
+    }
+    getPort() {
+        return this.config.port;
+    }
+    getUrl() {
+        return `http://${this.config.host}:${this.config.port}`;
     }
     async close() {
-        if (!this.started)
+        if (!this.started && !this.startPromise)
             return;
+        if (this.startPromise) {
+            try {
+                await this.startPromise;
+            }
+            catch {
+                // ignore start errors while closing
+            }
+        }
         if (this.devicePollInterval) {
             clearInterval(this.devicePollInterval);
             this.devicePollInterval = null;
         }
         for (const sess of this.sessions.values()) {
+            sess.closed = true;
             await this.releaseSession(sess);
             try {
                 sess.ws.close(1001, 'server shutting down');
@@ -1135,11 +1320,11 @@ export class ScrcpyServer {
         }
         this.sessions.clear();
         await new Promise((resolve) => {
-            if (!this.httpServer.listening) {
-                resolve();
-                return;
-            }
             this.wss.close(() => {
+                if (!this.httpServer.listening) {
+                    resolve();
+                    return;
+                }
                 this.httpServer.close(() => resolve());
             });
         });