@yume-chan/scrcpy 0.0.19 → 0.0.21

package/src/adb/client.ts

@@ -1,329 +0,0 @@
-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);
-        }
-    });
-}
-
-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 async pushServer(
-        adb: Adb,
-        file: ReadableStream<Consumable<Uint8Array>>,
-        filename = DEFAULT_SERVER_PATH
-    ) {
-        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<ScrcpyOptionsInit1_16>
-    ) {
-        let connection: AdbScrcpyConnection | undefined;
-        let process: AdbSubprocessProtocol | undefined;
-
-        try {
-            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",
-                    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((e) => {
-                    void e;
-                });
-
-            const result = await Promise.race([
-                process.exit,
-                connection.getStreams(),
-            ]);
-
-            if (typeof result === "number") {
-                throw new ScrcpyExitedError(output);
-            }
-
-            abortController.abort();
-            await pipe;
-
-            const [videoStream, controlStream] = result;
-            return new AdbScrcpyClient(
-                options,
-                process,
-                concatStreams(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<ScrcpyOptionsInit1_16>
-    ): Promise<string[]> {
-        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 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<ScrcpyOptionsInit1_16>
-    ): Promise<number[]> {
-        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 ScrcpyExitedError) {
-                const displayIdRegex = /\s+scrcpy --display (\d+)/;
-                const displays: number[] = [];
-                for (const line of e.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<ScrcpyOptionsInit1_16>,
-        process: AdbSubprocessProtocol,
-        stdout: ReadableStream<string>,
-        videoStream: ReadableStream<Uint8Array>,
-        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;
-                    }
-                })
-            );
-
-        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/adb/connection.ts

@@ -1,209 +0,0 @@
-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;
-
-    /**
-     * 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> {
-        // do nothing
-    }
-
-    public abstract getStreams(): ValueOrPromise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-                | undefined
-        ]
-    >;
-
-    public dispose(): void {
-        // do nothing
-    }
-}
-
-export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
-    private _disposed = false;
-
-    private connect(): Promise<
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-    > {
-        return this.adb.createSocket("localabstract:scrcpy");
-    }
-
-    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) {
-                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 override async getStreams(): Promise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-                | undefined
-        ]
-    > {
-        const videoStream = await this.connectVideoStream();
-
-        let controlStream:
-            | ReadableWritablePair<Uint8Array, Consumable<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];
-    }
-
-    public override dispose(): void {
-        super.dispose();
-        this._disposed = true;
-    }
-}
-
-export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
-    private streams!: ReadableStreamDefaultReader<
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-    >;
-
-    private address!: string;
-
-    public override async initialize(): Promise<void> {
-        try {
-            // try to unbind first
-            await this.adb.reverse.remove("localabstract:scrcpy");
-        } catch (e) {
-            if (e instanceof AdbReverseNotSupportedError) {
-                throw e;
-            }
-
-            // 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) => {
-                void writer.write(socket);
-                return true;
-            }
-        );
-    }
-
-    private async accept(): Promise<
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-    > {
-        return (await this.streams.read()).value!;
-    }
-
-    public async getStreams(): Promise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-                | undefined
-        ]
-    > {
-        const { readable: videoStream } = await this.accept();
-
-        let controlStream:
-            | ReadableWritablePair<Uint8Array, Consumable<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).catch((e) => {
-            void e;
-        });
-    }
-}

package/src/adb/index.ts

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

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

@@ -1,32 +0,0 @@
-import type { Adb } from "@yume-chan/adb";
-
-import type { ScrcpyOptionsInit1_16 } from "../../options/index.js";
-import type {
-    AdbScrcpyConnection,
-    AdbScrcpyConnectionOptions,
-} from "../connection.js";
-import {
-    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

@@ -1,26 +0,0 @@
-import type { Adb } from "@yume-chan/adb";
-
-import type { ScrcpyOptionsInit1_22 } from "../../options/index.js";
-import type { AdbScrcpyConnection } from "../connection.js";
-import {
-    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

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

package/src/adb/options/types.ts

@@ -1,75 +0,0 @@
-import type { Adb } from "@yume-chan/adb";
-import type { TransformStream } from "@yume-chan/stream-extra";
-
-import type {
-    ScrcpyBackOrScreenOnControlMessage,
-    ScrcpyControlMessageType,
-    ScrcpySetClipboardControlMessage,
-} from "../../control/index.js";
-import type {
-    ScrcpyOptions,
-    ScrcpyVideoStreamPacket,
-} from "../../options/index.js";
-import type { AdbScrcpyConnection } from "../connection.js";
-
-export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
-    createConnection(adb: Adb): AdbScrcpyConnection;
-}
-
-export abstract class AdbScrcpyOptionsBase<T extends object>
-    implements ScrcpyOptions<T>
-{
-    private raw: ScrcpyOptions<T>;
-
-    public get value(): Partial<T> {
-        return this.raw.value;
-    }
-    public set value(value: Partial<T>) {
-        this.raw.value = value;
-    }
-
-    public constructor(raw: ScrcpyOptions<T>) {
-        this.raw = raw;
-    }
-
-    public getDefaultValue(): T {
-        return this.raw.getDefaultValue();
-    }
-
-    public formatServerArguments(): string[] {
-        return this.raw.formatServerArguments();
-    }
-
-    public getOutputEncoderNameRegex(): RegExp {
-        return this.raw.getOutputEncoderNameRegex();
-    }
-
-    public createVideoStreamTransformer(): TransformStream<
-        Uint8Array,
-        ScrcpyVideoStreamPacket
-    > {
-        return this.raw.createVideoStreamTransformer();
-    }
-
-    public getControlMessageTypes(): ScrcpyControlMessageType[] {
-        return this.raw.getControlMessageTypes();
-    }
-
-    public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage
-    ): Uint8Array | undefined {
-        return this.raw.serializeBackOrScreenOnControlMessage(message);
-    }
-
-    public serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
-    ): Uint8Array {
-        return this.raw.serializeSetClipboardControlMessage(message);
-    }
-
-    public getScrollController() {
-        return this.raw.getScrollController();
-    }
-
-    public abstract createConnection(adb: Adb): AdbScrcpyConnection;
-}