@yume-chan/scrcpy 0.0.17 → 0.0.19

package/src/adb/client.ts

@@ -1,103 +1,114 @@
-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();
-                }
-            },
-        });
-    }
+import type { Adb, AdbSubprocessProtocol } from "@yume-chan/adb";
+import {
+    AdbReverseNotSupportedError,
+    AdbSubprocessNoneProtocol,
+} from "@yume-chan/adb";
+import type {
+    Consumable,
+    ReadableStream,
+    ReadableWritablePair,
+} from "@yume-chan/stream-extra";
+import {
+    AbortController,
+    DecodeUtf8Stream,
+    InspectStream,
+    PushReadableStream,
+    SplitStringStream,
+    WritableStream,
+} from "@yume-chan/stream-extra";
+
+import { ScrcpyControlMessageSerializer } from "../control/index.js";
+import type { ScrcpyDeviceMessage } from "../device-message/index.js";
+import { ScrcpyDeviceMessageDeserializeStream } from "../device-message/index.js";
+import type {
+    ScrcpyOptionsInit1_16,
+    ScrcpyVideoStreamPacket,
+} from "../options/index.js";
+import { DEFAULT_SERVER_PATH } from "../options/index.js";
+
+import type { AdbScrcpyConnection } from "./connection.js";
+import type { AdbScrcpyOptions } from "./options/index.js";
+
+function arrayToStream<T>(array: T[]): ReadableStream<T> {
+    return new PushReadableStream(async (controller) => {
+        for (const item of array) {
+            await controller.enqueue(item);
+        }
+    });
 }
 
-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();
+function concatStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T> {
+    return new PushReadableStream(async (controller) => {
+        for (const stream of streams) {
+            await stream.pipeTo(
+                new WritableStream({
+                    async write(chunk) {
+                        await controller.enqueue(chunk);
+                    },
+                })
+            );
         }
+    });
+}
+
+export class ScrcpyExitedError extends Error {
+    public output: string[];
+
+    public constructor(output: string[]) {
+        super("scrcpy server exited prematurely");
+        this.output = output;
     }
 }
 
 export class AdbScrcpyClient {
-    public static pushServer(
+    public static async pushServer(
         adb: Adb,
-        path = DEFAULT_SERVER_PATH,
+        file: ReadableStream<Consumable<Uint8Array>>,
+        filename = 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();
-            },
-        });
+        const sync = await adb.sync();
+        try {
+            await sync.write({
+                filename,
+                file,
+            });
+        } finally {
+            await sync.dispose();
+        }
     }
 
     public static async start(
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ) {
-        const connection = options.createConnection(adb);
+        let connection: AdbScrcpyConnection | undefined;
         let process: AdbSubprocessProtocol | undefined;
 
         try {
-            await connection.initialize();
+            try {
+                connection = options.createConnection(adb);
+                await connection.initialize();
+            } catch (e) {
+                if (e instanceof AdbReverseNotSupportedError) {
+                    // When reverse tunnel is not supported, try forward tunnel.
+                    options.value.tunnelForward = true;
+                    connection = options.createConnection(adb);
+                    await connection.initialize();
+                } else {
+                    connection = undefined;
+                    throw e;
+                }
+            }
 
             process = await adb.subprocess.spawn(
                 [
                     // cspell: disable-next-line
                     `CLASSPATH=${path}`,
-                    'app_process',
-                    /* unused */ '/',
-                    'com.genymobile.scrcpy.Server',
+                    "app_process",
+                    /* unused */ "/",
+                    "com.genymobile.scrcpy.Server",
                     version,
                     ...options.formatServerArguments(),
                 ],
@@ -110,31 +121,34 @@ export class AdbScrcpyClient {
 
             const stdout = process.stdout
                 .pipeThrough(new DecodeUtf8Stream())
-                .pipeThrough(new SplitStringStream('\n'));
+                .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);
+                .pipeTo(
+                    new WritableStream({
+                        write(chunk) {
+                            output.push(chunk);
+                        },
+                    }),
+                    {
+                        signal: abortController.signal,
+                        preventCancel: true,
                     }
-                }), {
-                    signal: abortController.signal,
-                    preventCancel: true,
-                })
-                .catch(() => { });
+                )
+                .catch((e) => {
+                    void e;
+                });
 
             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;
+            if (typeof result === "number") {
+                throw new ScrcpyExitedError(output);
             }
 
             abortController.abort();
@@ -144,10 +158,7 @@ export class AdbScrcpyClient {
             return new AdbScrcpyClient(
                 options,
                 process,
-                new ConcatStream(
-                    new ArrayToStream(output),
-                    stdout,
-                ),
+                concatStreams(arrayToStream(output), stdout),
                 videoStream,
                 controlStream
             );
@@ -155,7 +166,7 @@ export class AdbScrcpyClient {
             await process?.kill();
             throw e;
         } finally {
-            connection.dispose();
+            connection?.dispose();
         }
     }
 
@@ -167,35 +178,34 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ): 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;
+        Object.assign(options.value, {
+            // Provide an invalid encoder name
+            // So the server will return all available encoders
+            encoderName: "_",
+            // Disable control for faster connection in 1.22+
+            control: false,
+            sendDeviceMeta: false,
+            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 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]!);
-                }
-            },
-        }));
+        await client.stdout.pipeTo(
+            new WritableStream({
+                write(line) {
+                    const match = line.match(encoderNameRegex);
+                    if (match) {
+                        encoders.push(match[1]!);
+                    }
+                },
+            })
+        );
 
         return encoders;
     }
@@ -208,25 +218,25 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ): 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;
+        Object.assign(options.value, {
+            // Similar to `getEncoders`, pass an invalid option and parse the output
+            displayId: -1,
+            // Disable control for faster connection in 1.22+
+            control: false,
+            sendDeviceMeta: false,
+            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[];
-
+            if (e instanceof ScrcpyExitedError) {
                 const displayIdRegex = /\s+scrcpy --display (\d+)/;
                 const displays: number[] = [];
-                for (const line of output) {
+                for (const line of e.output) {
                     const match = line.match(displayIdRegex);
                     if (match) {
                         displays.push(Number.parseInt(match[1]!, 10));
@@ -236,53 +246,80 @@ export class AdbScrcpyClient {
             }
         }
 
-        throw new Error('failed to get displays');
+        throw new Error("failed to get displays");
     }
 
     private process: AdbSubprocessProtocol;
 
     private _stdout: ReadableStream<string>;
-    public get stdout() { return this._stdout; }
+    public get stdout() {
+        return this._stdout;
+    }
 
-    public get exit() { return this.process.exit; }
+    public get exit() {
+        return this.process.exit;
+    }
 
     private _screenWidth: number | undefined;
-    public get screenWidth() { return this._screenWidth; }
+    public get screenWidth() {
+        return this._screenWidth;
+    }
 
     private _screenHeight: number | undefined;
-    public get screenHeight() { return this._screenHeight; }
+    public get screenHeight() {
+        return this._screenHeight;
+    }
 
     private _videoStream: ReadableStream<ScrcpyVideoStreamPacket>;
-    public get videoStream() { return this._videoStream; }
+    public get videoStream() {
+        return this._videoStream;
+    }
 
-    private _controlMessageSerializer: ScrcpyControlMessageSerializer | undefined;
-    public get controlMessageSerializer() { return this._controlMessageSerializer; }
+    private _controlMessageSerializer:
+        | ScrcpyControlMessageSerializer
+        | undefined;
+    public get controlMessageSerializer() {
+        return this._controlMessageSerializer;
+    }
 
-    private _deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined;
-    public get deviceMessageStream() { return this._deviceMessageStream; }
+    private _deviceMessageStream:
+        | ReadableStream<ScrcpyDeviceMessage>
+        | undefined;
+    public get deviceMessageStream() {
+        return this._deviceMessageStream;
+    }
 
     public constructor(
-        options: AdbScrcpyOptions<any>,
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>,
         process: AdbSubprocessProtocol,
         stdout: ReadableStream<string>,
         videoStream: ReadableStream<Uint8Array>,
-        controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined,
+        controlStream:
+            | ReadableWritablePair<Uint8Array, Consumable<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;
-                }
-            }));
+            .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());
+            this._controlMessageSerializer = new ScrcpyControlMessageSerializer(
+                controlStream.writable,
+                options
+            );
+            this._deviceMessageStream = controlStream.readable.pipeThrough(
+                new ScrcpyDeviceMessageDeserializeStream()
+            );
         }
     }
 

package/src/adb/connection.ts

@@ -1,8 +1,15 @@
-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';
+import type { Adb } from "@yume-chan/adb";
+import { AdbReverseNotSupportedError } from "@yume-chan/adb";
+import { delay } from "@yume-chan/async";
+import type { Disposable } from "@yume-chan/event";
+import type {
+    Consumable,
+    ReadableStream,
+    ReadableStreamDefaultReader,
+    ReadableWritablePair,
+} from "@yume-chan/stream-extra";
+import { TransformStream } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
 export interface AdbScrcpyConnectionOptions {
     control: boolean;
@@ -28,20 +35,37 @@ export abstract class AdbScrcpyConnection implements Disposable {
         this.options = options;
     }
 
-    public initialize(): ValueOrPromise<void> { }
-
-    public abstract getStreams(): ValueOrPromise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]>;
+    public initialize(): ValueOrPromise<void> {
+        // do nothing
+    }
 
-    public dispose(): void { }
+    public abstract getStreams(): ValueOrPromise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+                | undefined
+        ]
+    >;
+
+    public dispose(): void {
+        // do nothing
+    }
 }
 
 export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
-    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
-        return this.adb.createSocket('localabstract:scrcpy');
+    private _disposed = false;
+
+    private connect(): Promise<
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+    > {
+        return this.adb.createSocket("localabstract:scrcpy");
     }
 
-    private async connectAndRetry(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
-        for (let i = 0; i < 100; i++) {
+    private async connectAndRetry(): Promise<
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+    > {
+        for (let i = 0; !this._disposed && i < 100; i += 1) {
             try {
                 return await this.connect();
             } catch (e) {
@@ -58,17 +82,26 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
             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');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
         return videoStream;
     }
 
-    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+    public override async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+                | undefined
+        ]
+    > {
         const videoStream = await this.connectVideoStream();
 
-        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+            | undefined;
         if (this.options.control) {
             controlStream = await this.connectAndRetry();
         }
@@ -79,45 +112,74 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
             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');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
 
         return [videoStream, controlStream];
     }
+
+    public override dispose(): void {
+        super.dispose();
+        this._disposed = true;
+    }
 }
 
 export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
-    private streams!: ReadableStreamDefaultReader<ReadableWritablePair<Uint8Array, Uint8Array>>;
+    private streams!: ReadableStreamDefaultReader<
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+    >;
 
     private address!: string;
 
     public override async initialize(): Promise<void> {
-        // try to unbind first, ignore errors
-        await this.adb.reverse.remove('localabstract:scrcpy').catch(() => { });
+        try {
+            // try to unbind first
+            await this.adb.reverse.remove("localabstract:scrcpy");
+        } catch (e) {
+            if (e instanceof AdbReverseNotSupportedError) {
+                throw e;
+            }
 
-        const queue = new TransformStream<ReadableWritablePair<Uint8Array, Uint8Array>>();
+            // Ignore other errors when unbinding
+        }
+
+        const queue = new TransformStream<
+            ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
+            ReadableWritablePair<Uint8Array, Consumable<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);
+            "localabstract:scrcpy",
+            "tcp:27183",
+            (socket) => {
+                void writer.write(socket);
                 return true;
-            },
+            }
         );
     }
 
-    private async accept(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+    private async accept(): Promise<
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+    > {
         return (await this.streams.read()).value!;
     }
 
-    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+    public async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+                | undefined
+        ]
+    > {
         const { readable: videoStream } = await this.accept();
 
-        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+            | undefined;
         if (this.options.control) {
             controlStream = await this.accept();
         }
@@ -128,7 +190,7 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
             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');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
@@ -140,6 +202,8 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
         // 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);
+        this.adb.reverse.remove(this.address).catch((e) => {
+            void e;
+        });
     }
 }

package/src/adb/index.ts

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