@yume-chan/scrcpy 0.0.15 → 0.0.17

package/src/adb/client.ts

@@ -0,0 +1,292 @@
+import { Adb, AdbSubprocessNoneProtocol, AdbSubprocessProtocol, AdbSync } from '@yume-chan/adb';
+import { AbortController, DecodeUtf8Stream, InspectStream, ReadableStream, SplitStringStream, WrapWritableStream, WritableStream, type ReadableStreamDefaultController, type ReadableStreamDefaultReader, type ReadableWritablePair } from '@yume-chan/stream-extra';
+
+import { ScrcpyControlMessageSerializer } from '../control/index.js';
+import { ScrcpyDeviceMessageDeserializeStream, type ScrcpyDeviceMessage } from '../device-message/index.js';
+import { DEFAULT_SERVER_PATH, type ScrcpyVideoStreamPacket } from '../options/index.js';
+import type { AdbScrcpyOptions } from './options/index.js';
+
+class ArrayToStream<T> extends ReadableStream<T>{
+    private array!: T[];
+    private index = 0;
+
+    constructor(array: T[]) {
+        super({
+            start: async () => {
+                await Promise.resolve();
+                this.array = array;
+            },
+            pull: (controller) => {
+                if (this.index < this.array.length) {
+                    controller.enqueue(this.array[this.index]!);
+                    this.index += 1;
+                } else {
+                    controller.close();
+                }
+            },
+        });
+    }
+}
+
+class ConcatStream<T> extends ReadableStream<T>{
+    private streams!: ReadableStream<T>[];
+    private index = 0;
+    private reader!: ReadableStreamDefaultReader<T>;
+
+    constructor(...streams: ReadableStream<T>[]) {
+        super({
+            start: async (controller) => {
+                await Promise.resolve();
+
+                this.streams = streams;
+                this.advance(controller);
+            },
+            pull: async (controller) => {
+                const result = await this.reader.read();
+                if (!result.done) {
+                    controller.enqueue(result.value);
+                    return;
+                }
+                this.advance(controller);
+            }
+        });
+    }
+
+    private advance(controller: ReadableStreamDefaultController<T>) {
+        if (this.index < this.streams.length) {
+            this.reader = this.streams[this.index]!.getReader();
+            this.index += 1;
+        } else {
+            controller.close();
+        }
+    }
+}
+
+export class AdbScrcpyClient {
+    public static pushServer(
+        adb: Adb,
+        path = DEFAULT_SERVER_PATH,
+    ) {
+        let sync!: AdbSync;
+        return new WrapWritableStream<Uint8Array>({
+            async start() {
+                sync = await adb.sync();
+                return sync.write(path);
+            },
+            async close() {
+                await sync.dispose();
+            },
+        });
+    }
+
+    public static async start(
+        adb: Adb,
+        path: string,
+        version: string,
+        options: AdbScrcpyOptions<any>
+    ) {
+        const connection = options.createConnection(adb);
+        let process: AdbSubprocessProtocol | undefined;
+
+        try {
+            await connection.initialize();
+
+            process = await adb.subprocess.spawn(
+                [
+                    // cspell: disable-next-line
+                    `CLASSPATH=${path}`,
+                    'app_process',
+                    /* unused */ '/',
+                    'com.genymobile.scrcpy.Server',
+                    version,
+                    ...options.formatServerArguments(),
+                ],
+                {
+                    // Scrcpy server doesn't use stderr,
+                    // so disable Shell Protocol to simplify processing
+                    protocols: [AdbSubprocessNoneProtocol],
+                }
+            );
+
+            const stdout = process.stdout
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new SplitStringStream('\n'));
+
+            // Read stdout, otherwise `process.exit` won't resolve.
+            const output: string[] = [];
+            const abortController = new AbortController();
+            const pipe = stdout
+                .pipeTo(new WritableStream({
+                    write(chunk) {
+                        output.push(chunk);
+                    }
+                }), {
+                    signal: abortController.signal,
+                    preventCancel: true,
+                })
+                .catch(() => { });
+
+            const result = await Promise.race([
+                process.exit,
+                connection.getStreams(),
+            ]);
+
+            if (typeof result === 'number') {
+                const error = new Error('scrcpy server exited prematurely');
+                (error as any).output = output;
+                throw error;
+            }
+
+            abortController.abort();
+            await pipe;
+
+            const [videoStream, controlStream] = result;
+            return new AdbScrcpyClient(
+                options,
+                process,
+                new ConcatStream(
+                    new ArrayToStream(output),
+                    stdout,
+                ),
+                videoStream,
+                controlStream
+            );
+        } catch (e) {
+            await process?.kill();
+            throw e;
+        } finally {
+            connection.dispose();
+        }
+    }
+
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    public static async getEncoders(
+        adb: Adb,
+        path: string,
+        version: string,
+        options: AdbScrcpyOptions<any>
+    ): Promise<string[]> {
+        // Provide an invalid encoder name
+        // So the server will return all available encoders
+        options.value.encoderName = '_';
+        // Disable control for faster connection in 1.22+
+        options.value.control = false;
+        options.value.sendDeviceMeta = false;
+        options.value.sendDummyByte = false;
+
+        // Scrcpy server will open connections, before initializing encoder
+        // Thus although an invalid encoder name is given, the start process will success
+        const client = await AdbScrcpyClient.start(
+            adb,
+            path,
+            version,
+            options
+        );
+
+        const encoderNameRegex = options.getOutputEncoderNameRegex();
+        const encoders: string[] = [];
+        await client.stdout.pipeTo(new WritableStream({
+            write(line) {
+                const match = line.match(encoderNameRegex);
+                if (match) {
+                    encoders.push(match[1]!);
+                }
+            },
+        }));
+
+        return encoders;
+    }
+
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    public static async getDisplays(
+        adb: Adb,
+        path: string,
+        version: string,
+        options: AdbScrcpyOptions<any>
+    ): Promise<number[]> {
+        // Similar to `getEncoders`, pass an invalid option and parse the output
+        options.value.displayId = -1;
+
+        options.value.control = false;
+        options.value.sendDeviceMeta = false;
+        options.value.sendDummyByte = false;
+
+        try {
+            // Server will exit before opening connections when an invalid display id was given.
+            await AdbScrcpyClient.start(adb, path, version, options);
+        } catch (e) {
+            if (e instanceof Error) {
+                const output = (e as any).output as string[];
+
+                const displayIdRegex = /\s+scrcpy --display (\d+)/;
+                const displays: number[] = [];
+                for (const line of output) {
+                    const match = line.match(displayIdRegex);
+                    if (match) {
+                        displays.push(Number.parseInt(match[1]!, 10));
+                    }
+                }
+                return displays;
+            }
+        }
+
+        throw new Error('failed to get displays');
+    }
+
+    private process: AdbSubprocessProtocol;
+
+    private _stdout: ReadableStream<string>;
+    public get stdout() { return this._stdout; }
+
+    public get exit() { return this.process.exit; }
+
+    private _screenWidth: number | undefined;
+    public get screenWidth() { return this._screenWidth; }
+
+    private _screenHeight: number | undefined;
+    public get screenHeight() { return this._screenHeight; }
+
+    private _videoStream: ReadableStream<ScrcpyVideoStreamPacket>;
+    public get videoStream() { return this._videoStream; }
+
+    private _controlMessageSerializer: ScrcpyControlMessageSerializer | undefined;
+    public get controlMessageSerializer() { return this._controlMessageSerializer; }
+
+    private _deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined;
+    public get deviceMessageStream() { return this._deviceMessageStream; }
+
+    public constructor(
+        options: AdbScrcpyOptions<any>,
+        process: AdbSubprocessProtocol,
+        stdout: ReadableStream<string>,
+        videoStream: ReadableStream<Uint8Array>,
+        controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined,
+    ) {
+        this.process = process;
+        this._stdout = stdout;
+
+        this._videoStream = videoStream
+            .pipeThrough(options.createVideoStreamTransformer())
+            .pipeThrough(new InspectStream(packet => {
+                if (packet.type === 'configuration') {
+                    this._screenWidth = packet.data.croppedWidth;
+                    this._screenHeight = packet.data.croppedHeight;
+                }
+            }));
+
+        if (controlStream) {
+            this._controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
+            this._deviceMessageStream = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+        }
+    }
+
+    public async close() {
+        await this.process.kill();
+    }
+}

package/src/{connection.ts → adb/connection.ts}

@@ -1,148 +1,145 @@
-import type { Adb, AdbSocket } from "@yume-chan/adb";
-import type { Disposable } from "@yume-chan/event";
-import type { ValueOrPromise } from "@yume-chan/struct";
-import { delay } from "./utils.js";
-
-export interface ScrcpyClientConnectionOptions {
-    control: boolean;
-
-    /**
-     * Write a byte on start to detect connection issues
-     */
-    sendDummyByte: boolean;
-
-    /**
-     * Send device name and size
-     */
-    sendDeviceMeta: boolean;
-}
-
-export abstract class ScrcpyClientConnection implements Disposable {
-    protected device: Adb;
-
-    protected options: ScrcpyClientConnectionOptions;
-
-    public constructor(device: Adb, options: ScrcpyClientConnectionOptions) {
-        this.device = device;
-        this.options = options;
-    }
-
-    public initialize(): ValueOrPromise<void> { }
-
-    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]>;
-
-    public dispose(): void { }
-}
-
-export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
-    private async connect(): Promise<AdbSocket> {
-        return await this.device.createSocket('localabstract:scrcpy');
-    }
-
-    private async connectAndRetry(): Promise<AdbSocket> {
-        for (let i = 0; i < 100; i++) {
-            try {
-                return await this.connect();
-            } catch (e) {
-                await delay(100);
-            }
-        }
-        throw new Error(`Can't connect to server after 100 retries`);
-    }
-
-    private async connectVideoStream(): Promise<AdbSocket> {
-        const stream = await this.connectAndRetry();
-        if (this.options.sendDummyByte) {
-            const reader = stream.readable.getReader();
-            const { done, value } = await reader.read();
-            // server will write a `0` to signal connection success
-            if (done || value.byteLength !== 1 || value[0] !== 0) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-        return stream;
-    }
-
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
-        const videoStream = await this.connectVideoStream();
-
-        let controlStream: AdbSocket | undefined;
-        if (this.options.control) {
-            controlStream = await this.connectAndRetry();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.readable.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-}
-
-export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
-    private streams!: ReadableStreamDefaultReader<AdbSocket>;
-
-    private address!: string;
-
-    public override async initialize(): Promise<void> {
-        try {
-            // try to unbind first
-            await this.device.reverse.remove('localabstract:scrcpy');
-        } catch {
-            // ignore error
-        }
-
-        const queue = new TransformStream<AdbSocket>();
-        this.streams = queue.readable.getReader();
-        const writer = queue.writable.getWriter();
-        this.address = await this.device.reverse.add(
-            'localabstract:scrcpy',
-            'tcp:27183',
-            socket => {
-                writer.write(socket);
-                return true;
-            },
-        );
-    }
-
-    private async accept(): Promise<AdbSocket> {
-        return (await this.streams.read()).value!;
-    }
-
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
-        const videoStream = await this.accept();
-
-        let controlStream: AdbSocket | undefined;
-        if (this.options.control) {
-            controlStream = await this.accept();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.readable.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-
-    public override dispose() {
-        // Don't await this!
-        // `reverse.remove`'s response will never arrive
-        // before we read all pending data from `videoStream`
-        this.device.reverse.remove(this.address);
-    }
-}
+import type { Adb } from '@yume-chan/adb';
+import { delay } from '@yume-chan/async';
+import type { Disposable } from '@yume-chan/event';
+import { TransformStream, type ReadableStream, type ReadableStreamDefaultReader, type ReadableWritablePair } from '@yume-chan/stream-extra';
+import type { ValueOrPromise } from '@yume-chan/struct';
+
+export interface AdbScrcpyConnectionOptions {
+    control: boolean;
+
+    /**
+     * Write a byte on start to detect connection issues
+     */
+    sendDummyByte: boolean;
+
+    /**
+     * Send device name and size
+     */
+    sendDeviceMeta: boolean;
+}
+
+export abstract class AdbScrcpyConnection implements Disposable {
+    protected adb: Adb;
+
+    protected options: AdbScrcpyConnectionOptions;
+
+    public constructor(adb: Adb, options: AdbScrcpyConnectionOptions) {
+        this.adb = adb;
+        this.options = options;
+    }
+
+    public initialize(): ValueOrPromise<void> { }
+
+    public abstract getStreams(): ValueOrPromise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]>;
+
+    public dispose(): void { }
+}
+
+export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
+    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        return this.adb.createSocket('localabstract:scrcpy');
+    }
+
+    private async connectAndRetry(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        for (let i = 0; i < 100; i++) {
+            try {
+                return await this.connect();
+            } catch (e) {
+                await delay(100);
+            }
+        }
+        throw new Error(`Can't connect to server after 100 retries`);
+    }
+
+    private async connectVideoStream(): Promise<ReadableStream<Uint8Array>> {
+        const { readable: videoStream } = await this.connectAndRetry();
+        if (this.options.sendDummyByte) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // server will write a `0` to signal connection success
+            if (done || value.byteLength !== 1 || value[0] !== 0) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+        return videoStream;
+    }
+
+    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+        const videoStream = await this.connectVideoStream();
+
+        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        if (this.options.control) {
+            controlStream = await this.connectAndRetry();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+}
+
+export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
+    private streams!: ReadableStreamDefaultReader<ReadableWritablePair<Uint8Array, Uint8Array>>;
+
+    private address!: string;
+
+    public override async initialize(): Promise<void> {
+        // try to unbind first, ignore errors
+        await this.adb.reverse.remove('localabstract:scrcpy').catch(() => { });
+
+        const queue = new TransformStream<ReadableWritablePair<Uint8Array, Uint8Array>>();
+        this.streams = queue.readable.getReader();
+        const writer = queue.writable.getWriter();
+        this.address = await this.adb.reverse.add(
+            'localabstract:scrcpy',
+            'tcp:27183',
+            socket => {
+                writer.write(socket);
+                return true;
+            },
+        );
+    }
+
+    private async accept(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        return (await this.streams.read()).value!;
+    }
+
+    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+        const { readable: videoStream } = await this.accept();
+
+        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        if (this.options.control) {
+            controlStream = await this.accept();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error('Unexpected response from server');
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+
+    public override dispose() {
+        // Don't await this!
+        // `reverse.remove`'s response will never arrive
+        // before we read all pending data from `videoStream`
+        this.adb.reverse.remove(this.address);
+    }
+}

package/src/adb/index.ts

@@ -0,0 +1,3 @@
+export * from './options/index.js';
+export * from './client.js';
+export * from './connection.js';

package/src/adb/options/1_16.ts

@@ -0,0 +1,23 @@
+import type { Adb } from '@yume-chan/adb';
+
+import type { ScrcpyOptionsInit1_16 } from '../../options/index.js';
+import { AdbScrcpyConnection, AdbScrcpyConnectionOptions, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
+import { AdbScrcpyOptionsBase } from './types.js';
+
+export class AdbScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16>
+    extends AdbScrcpyOptionsBase<T> {
+    public override createConnection(adb: Adb): AdbScrcpyConnection {
+        const options: AdbScrcpyConnectionOptions = {
+            // Old versions always have control stream no matter what the option is
+            // Pass `control: false` to `Connection` will disable the control stream
+            control: true,
+            sendDummyByte: true,
+            sendDeviceMeta: true,
+        };
+        if (this.value.tunnelForward) {
+            return new AdbScrcpyForwardConnection(adb, options);
+        } else {
+            return new AdbScrcpyReverseConnection(adb, options);
+        }
+    }
+}

package/src/adb/options/1_22.ts

@@ -0,0 +1,20 @@
+import type { Adb } from '@yume-chan/adb';
+
+import type { ScrcpyOptionsInit1_22 } from '../../options/index.js';
+import { AdbScrcpyConnection, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
+import { AdbScrcpyOptions1_16 } from './1_16.js';
+
+export class AdbScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22>
+    extends AdbScrcpyOptions1_16<T> {
+    public override createConnection(adb: Adb): AdbScrcpyConnection {
+        const options = {
+            ...this.getDefaultValue(),
+            ...this.value,
+        };
+        if (this.value.tunnelForward) {
+            return new AdbScrcpyForwardConnection(adb, options);
+        } else {
+            return new AdbScrcpyReverseConnection(adb, options);
+        }
+    }
+}

package/src/adb/options/index.ts

@@ -0,0 +1,3 @@
+export * from './1_16.js';
+export * from './1_22.js';
+export * from './types.js';