@yume-chan/scrcpy 0.0.16 → 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,9 +1,10 @@
-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";
+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 ScrcpyClientConnectionOptions {
+export interface AdbScrcpyConnectionOptions {
     control: boolean;
 
     /**
@@ -17,29 +18,29 @@ export interface ScrcpyClientConnectionOptions {
     sendDeviceMeta: boolean;
 }
 
-export abstract class ScrcpyClientConnection implements Disposable {
-    protected device: Adb;
+export abstract class AdbScrcpyConnection implements Disposable {
+    protected adb: Adb;
 
-    protected options: ScrcpyClientConnectionOptions;
+    protected options: AdbScrcpyConnectionOptions;
 
-    public constructor(device: Adb, options: ScrcpyClientConnectionOptions) {
-        this.device = device;
+    public constructor(adb: Adb, options: AdbScrcpyConnectionOptions) {
+        this.adb = adb;
         this.options = options;
     }
 
     public initialize(): ValueOrPromise<void> { }
 
-    public abstract getStreams(): ValueOrPromise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]>;
+    public abstract getStreams(): ValueOrPromise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]>;
 
     public dispose(): void { }
 }
 
-export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
-    private async connect(): Promise<AdbSocket> {
-        return await this.device.createSocket('localabstract:scrcpy');
+export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
+    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        return this.adb.createSocket('localabstract:scrcpy');
     }
 
-    private async connectAndRetry(): Promise<AdbSocket> {
+    private async connectAndRetry(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
         for (let i = 0; i < 100; i++) {
             try {
                 return await this.connect();
@@ -50,10 +51,10 @@ export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
         throw new Error(`Can't connect to server after 100 retries`);
     }
 
-    private async connectVideoStream(): Promise<AdbSocket> {
-        const stream = await this.connectAndRetry();
+    private async connectVideoStream(): Promise<ReadableStream<Uint8Array>> {
+        const { readable: videoStream } = await this.connectAndRetry();
         if (this.options.sendDummyByte) {
-            const reader = stream.readable.getReader();
+            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) {
@@ -61,20 +62,20 @@ export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
             }
             reader.releaseLock();
         }
-        return stream;
+        return videoStream;
     }
 
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
+    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
         const videoStream = await this.connectVideoStream();
 
-        let controlStream: AdbSocket | undefined;
+        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.readable.getReader();
+            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) {
@@ -87,23 +88,19 @@ export class ScrcpyClientForwardConnection extends ScrcpyClientConnection {
     }
 }
 
-export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
-    private streams!: ReadableStreamDefaultReader<AdbSocket>;
+export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
+    private streams!: ReadableStreamDefaultReader<ReadableWritablePair<Uint8Array, Uint8Array>>;
 
     private address!: string;
 
     public override async initialize(): Promise<void> {
-        try {
-            // try to unbind first
-            await this.device.reverse.remove('localabstract:scrcpy');
-        } catch {
-            // ignore error
-        }
+        // try to unbind first, ignore errors
+        await this.adb.reverse.remove('localabstract:scrcpy').catch(() => { });
 
-        const queue = new TransformStream<AdbSocket>();
+        const queue = new TransformStream<ReadableWritablePair<Uint8Array, Uint8Array>>();
         this.streams = queue.readable.getReader();
         const writer = queue.writable.getWriter();
-        this.address = await this.device.reverse.add(
+        this.address = await this.adb.reverse.add(
             'localabstract:scrcpy',
             'tcp:27183',
             socket => {
@@ -113,21 +110,21 @@ export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
         );
     }
 
-    private async accept(): Promise<AdbSocket> {
+    private async accept(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
         return (await this.streams.read()).value!;
     }
 
-    public async getStreams(): Promise<[videoSteam: AdbSocket, controlStream: AdbSocket | undefined]> {
-        const videoStream = await this.accept();
+    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+        const { readable: videoStream } = await this.accept();
 
-        let controlStream: AdbSocket | undefined;
+        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.readable.getReader();
+            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) {
@@ -143,6 +140,6 @@ export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
         // 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);
+        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';

package/src/adb/options/types.ts

@@ -0,0 +1,55 @@
+import type { Adb } from '@yume-chan/adb';
+import type { TransformStream } from '@yume-chan/stream-extra';
+
+import type { ScrcpyControlMessageType } from '../../control/index.js';
+import type { ScrcpyBackOrScreenOnControlMessage1_18, ScrcpyInjectScrollControlMessage1_22, ScrcpyOptions, ScrcpyVideoStreamPacket } from '../../options/index.js';
+import type { AdbScrcpyConnection } from '../connection.js';
+
+export interface AdbScrcpyOptions<T> extends ScrcpyOptions<T> {
+    createConnection(adb: Adb): AdbScrcpyConnection;
+}
+
+export abstract class AdbScrcpyOptionsBase<T> 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: ScrcpyBackOrScreenOnControlMessage1_18,
+    ): Uint8Array | undefined {
+        return this.raw.serializeBackOrScreenOnControlMessage(message);
+    }
+
+    public serializeInjectScrollControlMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
+    ): Uint8Array {
+        return this.raw.serializeInjectScrollControlMessage(message);
+    }
+
+    public abstract createConnection(adb: Adb): AdbScrcpyConnection;
+}

package/src/control/index.ts

@@ -0,0 +1,7 @@
+export * from './inject-keycode.js';
+export * from './inject-text.js';
+export * from './inject-touch.js';
+export * from './rotate-device.js';
+export * from './serializer.js';
+export * from './set-screen-power-mode.js';
+export * from './type.js';

package/src/control/inject-keycode.ts

@@ -0,0 +1,59 @@
+import Struct, { placeholder } from '@yume-chan/struct';
+
+import { ScrcpyControlMessageType } from './type.js';
+
+export enum AndroidKeyEventAction {
+    Down = 0,
+    Up = 1,
+}
+
+// https://github.com/Genymobile/scrcpy/blob/cabb102a04153f9c237b18257d3269a058558c63/app/src/android/keycodes.h#L26
+export enum AndroidKeyCode {
+    Home = 3,
+    Back = 4,
+    VolumeUp = 24,
+    VolumeDown,
+    A = 29,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H,
+    I,
+    J,
+    K,
+    L,
+    M,
+    N,
+    O,
+    P,
+    Q,
+    R,
+    S,
+    T,
+    U,
+    V,
+    W,
+    X,
+    Y,
+    Z,
+    Tab = 61,
+    Space,
+    Enter = 66,
+    Delete,
+    VolumeMute = 164,
+    AppSwitch = 187,
+}
+
+export const ScrcpyInjectKeyCodeControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.InjectKeyCode as const)
+        .uint8('action', placeholder<AndroidKeyEventAction>())
+        .uint32('keyCode')
+        .uint32('repeat')
+        .uint32('metaState');
+
+export type ScrcpyInjectKeyCodeControlMessage =
+    typeof ScrcpyInjectKeyCodeControlMessage['TInit'];

package/src/control/inject-text.ts

@@ -0,0 +1,12 @@
+import Struct from '@yume-chan/struct';
+
+import { ScrcpyControlMessageType } from './type.js';
+
+export const ScrcpyInjectTextControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.InjectText as const)
+        .uint32('length')
+        .string('text', { lengthField: 'length' });
+
+export type ScrcpyInjectTextControlMessage =
+    typeof ScrcpyInjectTextControlMessage['TInit'];

package/src/control/inject-touch.ts

@@ -0,0 +1,34 @@
+import Struct, { placeholder } from '@yume-chan/struct';
+import { ScrcpyControlMessageType } from './type.js';
+
+// https://developer.android.com/reference/android/view/MotionEvent#constants_1
+export enum AndroidMotionEventAction {
+    Down,
+    Up,
+    Move,
+    Cancel,
+    Outside,
+    PointerDown,
+    PointerUp,
+    HoverMove,
+    Scroll,
+    HoverEnter,
+    HoverExit,
+    ButtonPress,
+    ButtonRelease,
+}
+
+export const ScrcpyInjectTouchControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.InjectTouch as const)
+        .uint8('action', placeholder<AndroidMotionEventAction>())
+        .uint64('pointerId')
+        .uint32('pointerX')
+        .uint32('pointerY')
+        .uint16('screenWidth')
+        .uint16('screenHeight')
+        .uint16('pressure')
+        .uint32('buttons');
+
+export type ScrcpyInjectTouchControlMessage =
+    typeof ScrcpyInjectTouchControlMessage['TInit'];