@yume-chan/scrcpy 0.0.14 → 0.0.15

package/src/client.ts

@@ -1,7 +1,7 @@
-import { AdbBufferedStream, AdbSubprocessNoneProtocol, DecodeUtf8Stream, InspectStream, TransformStream, WritableStream, type Adb, type AdbSocket, type AdbSubprocessProtocol, type ReadableStream, type WritableStreamDefaultWriter } from '@yume-chan/adb';
+import { AbortController, AdbBufferedStream, AdbSubprocessNoneProtocol, DecodeUtf8Stream, InspectStream, ReadableStream, TransformStream, WritableStream, type Adb, type AdbSocket, type AdbSubprocessProtocol, type WritableStreamDefaultWriter } from '@yume-chan/adb';
 import { EventEmitter } from '@yume-chan/event';
 import Struct from '@yume-chan/struct';
-import { AndroidMotionEventAction, ScrcpyControlMessageType, ScrcpyInjectKeyCodeControlMessage, ScrcpyInjectTextControlMessage, ScrcpyInjectTouchControlMessage, type AndroidKeyEventAction } from './message.js';
+import { AndroidMotionEventAction, ScrcpyControlMessageType, ScrcpyInjectKeyCodeControlMessage, ScrcpyInjectTextControlMessage, ScrcpyInjectTouchControlMessage, ScrcpySimpleControlMessage, type AndroidKeyEventAction } from './message.js';
 import type { ScrcpyInjectScrollControlMessage1_22, ScrcpyOptions, VideoStreamPacket } from "./options/index.js";
 
 function* splitLines(text: string): Generator<string, void, void> {
@@ -20,12 +20,87 @@ function* splitLines(text: string): Generator<string, void, void> {
     }
 }
 
+class SplitLinesStream extends TransformStream<string, string>{
+    constructor() {
+        super({
+            transform(chunk, controller) {
+                for (const line of splitLines(chunk)) {
+                    if (line === '') {
+                        continue;
+                    }
+                    controller.enqueue(line);
+                }
+            },
+        });
+    }
+}
+
+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();
+        }
+    }
+}
+
 const ClipboardMessage =
     new Struct()
         .uint32('length')
         .string('content', { lengthField: 'length' });
 
 export class ScrcpyClient {
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
     public static async getEncoders(
         adb: Adb,
         path: string,
@@ -37,6 +112,8 @@ export class ScrcpyClient {
         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
@@ -56,6 +133,45 @@ export class ScrcpyClient {
         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: ScrcpyOptions<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 ScrcpyClient.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');
+    }
+
     public static async start(
         adb: Adb,
         path: string,
@@ -85,17 +201,50 @@ export class ScrcpyClient {
                 }
             );
 
+            const stdout = process.stdout
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new SplitLinesStream());
+
+            // 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') {
-                throw new Error('scrcpy server exited prematurely');
+                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 ScrcpyClient(adb, options, process, videoStream, controlStream);
+            return new ScrcpyClient(
+                adb,
+                options,
+                process,
+                new ConcatStream(
+                    new ArrayToStream(output),
+                    stdout,
+                ),
+                videoStream,
+                controlStream
+            );
         } catch (e) {
             await process?.kill();
             throw e;
@@ -135,6 +284,7 @@ export class ScrcpyClient {
         adb: Adb,
         options: ScrcpyOptions<any>,
         process: AdbSubprocessProtocol,
+        stdout: ReadableStream<string>,
         videoStream: AdbSocket,
         controlStream: AdbSocket | undefined,
     ) {
@@ -142,18 +292,7 @@ export class ScrcpyClient {
         this.options = options;
         this.process = process;
 
-        this._stdout = process.stdout
-            .pipeThrough(new DecodeUtf8Stream())
-            .pipeThrough(new TransformStream({
-                transform(chunk, controller) {
-                    for (const line of splitLines(chunk)) {
-                        if (line === '') {
-                            continue;
-                        }
-                        controller.enqueue(line);
-                    }
-                },
-            }));
+        this._stdout = stdout;
 
         this._videoStream = videoStream.readable
             .pipeThrough(options.createVideoStreamTransformer())
@@ -195,12 +334,21 @@ export class ScrcpyClient {
         return this._controlStreamWriter;
     }
 
+    private getControlMessageTypeValue(type: ScrcpyControlMessageType) {
+        const list = this.options.getControlMessageTypes();
+        const index = list.indexOf(type);
+        if (index === -1) {
+            throw new Error('Not supported');
+        }
+        return index;
+    }
+
     public async injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, 'type'>) {
         const controlStream = this.checkControlStream('injectKeyCode');
 
         await controlStream.write(ScrcpyInjectKeyCodeControlMessage.serialize({
             ...message,
-            type: ScrcpyControlMessageType.InjectKeycode,
+            type: this.getControlMessageTypeValue(ScrcpyControlMessageType.InjectKeycode),
         }));
     }
 
@@ -208,7 +356,7 @@ export class ScrcpyClient {
         const controlStream = this.checkControlStream('injectText');
 
         await controlStream.write(ScrcpyInjectTextControlMessage.serialize({
-            type: ScrcpyControlMessageType.InjectText,
+            type: this.getControlMessageTypeValue(ScrcpyControlMessageType.InjectText),
             text,
         }));
     }
@@ -234,7 +382,7 @@ export class ScrcpyClient {
         this.lastTouchMessage = now;
         await controlStream.write(ScrcpyInjectTouchControlMessage.serialize({
             ...message,
-            type: ScrcpyControlMessageType.InjectTouch,
+            type: this.getControlMessageTypeValue(ScrcpyControlMessageType.InjectTouch),
             screenWidth: this.screenWidth,
             screenHeight: this.screenHeight,
         }));
@@ -249,7 +397,7 @@ export class ScrcpyClient {
 
         const buffer = this.options!.serializeInjectScrollControlMessage({
             ...message,
-            type: ScrcpyControlMessageType.InjectScroll,
+            type: this.getControlMessageTypeValue(ScrcpyControlMessageType.InjectScroll),
             screenWidth: this.screenWidth,
             screenHeight: this.screenHeight,
         });
@@ -260,7 +408,7 @@ export class ScrcpyClient {
         const controlStream = this.checkControlStream('pressBackOrTurnOnScreen');
 
         const buffer = this.options!.serializeBackOrScreenOnControlMessage({
-            type: ScrcpyControlMessageType.BackOrScreenOn,
+            type: this.getControlMessageTypeValue(ScrcpyControlMessageType.BackOrScreenOn),
             action,
         });
         if (buffer) {
@@ -268,6 +416,18 @@ export class ScrcpyClient {
         }
     }
 
+    private async sendSimpleControlMessage(type: ScrcpyControlMessageType, name: string) {
+        const controlStream = this.checkControlStream(name);
+        const buffer = ScrcpySimpleControlMessage.serialize({
+            type: this.getControlMessageTypeValue(type),
+        });
+        await controlStream.write(buffer);
+    }
+
+    public async rotateDevice() {
+        await this.sendSimpleControlMessage(ScrcpyControlMessageType.RotateDevice, 'rotateDevice');
+    }
+
     public async close() {
         // No need to close streams. Kill the process will destroy them from the other side.
         await this.process?.kill();

package/src/connection.ts

@@ -105,7 +105,7 @@ export class ScrcpyClientReverseConnection extends ScrcpyClientConnection {
         const writer = queue.writable.getWriter();
         this.address = await this.device.reverse.add(
             'localabstract:scrcpy',
-            27183,
+            'tcp:27183',
             socket => {
                 writer.write(socket);
                 return true;

package/src/message.ts

@@ -1,5 +1,7 @@
 import Struct, { placeholder } from '@yume-chan/struct';
 
+// https://github.com/Genymobile/scrcpy/blob/fa5b2a29e983a46b49531def9cf3d80c40c3de37/app/src/control_msg.h#L23
+// For their message bodies, see https://github.com/Genymobile/scrcpy/blob/5c62f3419d252d10cd8c9cbb7c918b358b81f2d0/app/src/control_msg.c#L92
 export enum ScrcpyControlMessageType {
     InjectKeycode,
     InjectText,
@@ -7,6 +9,7 @@ export enum ScrcpyControlMessageType {
     InjectScroll,
     BackOrScreenOn,
     ExpandNotificationPanel,
+    ExpandSettingPanel,
     CollapseNotificationPanel,
     GetClipboard,
     SetClipboard,
@@ -31,9 +34,13 @@ export enum AndroidMotionEventAction {
     ButtonRelease,
 }
 
+export const ScrcpySimpleControlMessage =
+    new Struct()
+        .uint8('type');
+
 export const ScrcpyInjectTouchControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectTouch as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint8('action', placeholder<AndroidMotionEventAction>())
         .uint64('pointerId')
         .uint32('pointerX')
@@ -47,7 +54,7 @@ export type ScrcpyInjectTouchControlMessage = typeof ScrcpyInjectTouchControlMes
 
 export const ScrcpyInjectTextControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectText as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint32('length')
         .string('text', { lengthField: 'length' });
 
@@ -95,7 +102,7 @@ export enum AndroidKeyCode {
 
 export const ScrcpyInjectKeyCodeControlMessage =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectKeycode as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint8('action', placeholder<AndroidKeyEventAction>())
         .uint32('keyCode')
         .uint32('repeat')

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

@@ -1,8 +1,8 @@
 import { StructDeserializeStream, TransformStream, type Adb } from "@yume-chan/adb";
-import Struct, { placeholder } from "@yume-chan/struct";
+import Struct from "@yume-chan/struct";
 import type { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
 import { ScrcpyClientConnection, ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnectionOptions } from "../../connection.js";
-import { AndroidKeyEventAction, ScrcpyControlMessageType } from "../../message.js";
+import { AndroidKeyEventAction, ScrcpyControlMessageType, ScrcpySimpleControlMessage } from "../../message.js";
 import type { ScrcpyBackOrScreenOnEvent1_18 } from "../1_18.js";
 import type { ScrcpyInjectScrollControlMessage1_22 } from "../1_22.js";
 import { toScrcpyOptionValue, type ScrcpyOptions, type ScrcpyOptionValue, type VideoStreamPacket } from "../common.js";
@@ -16,7 +16,7 @@ export enum ScrcpyLogLevel {
     Error = 'error',
 }
 
-export enum ScrcpyScreenOrientation {
+export enum ScrcpyVideoOrientation {
     Initial = -2,
     Unlocked = -1,
     Portrait = 0,
@@ -75,7 +75,7 @@ export interface ScrcpyOptionsInit1_16 {
      * It will not keep the device screen in specific orientation,
      * only the captured video will in this orientation.
      */
-    lockVideoOrientation: ScrcpyScreenOrientation;
+    lockVideoOrientation: ScrcpyVideoOrientation;
 
     tunnelForward: boolean;
 
@@ -119,12 +119,11 @@ export const VideoPacket =
 export const NO_PTS = BigInt(1) << BigInt(63);
 
 export const ScrcpyBackOrScreenOnEvent1_16 =
-    new Struct()
-        .uint8('type', placeholder<ScrcpyControlMessageType.BackOrScreenOn>());
+    ScrcpySimpleControlMessage;
 
 export const ScrcpyInjectScrollControlMessage1_16 =
     new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectScroll as const)
+        .fields(ScrcpySimpleControlMessage)
         .uint32('pointerX')
         .uint32('pointerY')
         .uint16('screenWidth')
@@ -142,8 +141,8 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
         }
 
         if (new.target === ScrcpyOptions1_16 &&
-            value.lockVideoOrientation === ScrcpyScreenOrientation.Initial) {
-            value.lockVideoOrientation = ScrcpyScreenOrientation.Unlocked;
+            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial) {
+            value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
         }
 
         this.value = value as Partial<T>;
@@ -174,7 +173,7 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
             maxSize: 0,
             bitRate: 8_000_000,
             maxFps: 0,
-            lockVideoOrientation: ScrcpyScreenOrientation.Unlocked,
+            lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
             tunnelForward: false,
             crop: '-',
             sendFrameMeta: true,
@@ -297,6 +296,22 @@ export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsIn
         };
     }
 
+    public getControlMessageTypes(): ScrcpyControlMessageType[] {
+        return [
+            /*  0 */ ScrcpyControlMessageType.InjectKeycode,
+            /*  1 */ ScrcpyControlMessageType.InjectText,
+            /*  2 */ ScrcpyControlMessageType.InjectTouch,
+            /*  3 */ ScrcpyControlMessageType.InjectScroll,
+            /*  4 */ ScrcpyControlMessageType.BackOrScreenOn,
+            /*  5 */ ScrcpyControlMessageType.ExpandNotificationPanel,
+            /*  6 */ ScrcpyControlMessageType.CollapseNotificationPanel,
+            /*  7 */ ScrcpyControlMessageType.GetClipboard,
+            /*  8 */ ScrcpyControlMessageType.SetClipboard,
+            /*  9 */ ScrcpyControlMessageType.SetScreenPowerMode,
+            /* 10 */ ScrcpyControlMessageType.RotateDevice,
+        ];
+    }
+
     public serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnEvent1_18,
     ) {

package/src/options/1_18.ts

@@ -1,5 +1,5 @@
 import Struct, { placeholder } from "@yume-chan/struct";
-import type { AndroidKeyEventAction } from "../message.js";
+import { AndroidKeyEventAction, ScrcpyControlMessageType } from "../message.js";
 import { ScrcpyBackOrScreenOnEvent1_16, ScrcpyOptions1_16, type ScrcpyOptionsInit1_16 } from "./1_16/index.js";
 
 export interface ScrcpyOptionsInit1_18 extends ScrcpyOptionsInit1_16 {
@@ -33,6 +33,26 @@ export class ScrcpyOptions1_18<T extends ScrcpyOptionsInit1_18 = ScrcpyOptionsIn
         return /\s+scrcpy --encoder '(.*?)'/;
     }
 
+    public override getControlMessageTypes(): ScrcpyControlMessageType[] {
+        /**
+         *  0 InjectKeycode
+         *  1 InjectText
+         *  2 InjectTouch
+         *  3 InjectScroll
+         *  4 BackOrScreenOn
+         *  5 ExpandNotificationPanel
+         *  6 ExpandSettingsPanel
+         *  7 CollapseNotificationPanel
+         *  8 GetClipboard
+         *  9 SetClipboard
+         * 10 SetScreenPowerMode
+         * 11 RotateDevice
+         */
+        const types = super.getControlMessageTypes();
+        types.splice(6, 0, ScrcpyControlMessageType.ExpandSettingPanel);
+        return types;
+    }
+
     public override serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnEvent1_18,
     ) {

package/src/options/1_22.ts

@@ -1,6 +1,6 @@
 import type { Adb } from "@yume-chan/adb";
 import Struct from "@yume-chan/struct";
-import { ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnection, type ScrcpyClientConnectionOptions } from "../connection.js";
+import { ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnection } from "../connection.js";
 import { ScrcpyInjectScrollControlMessage1_16 } from "./1_16/index.js";
 import { ScrcpyOptions1_21, type ScrcpyOptionsInit1_21 } from "./1_21.js";
 
@@ -8,14 +8,14 @@ export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
     downsizeOnError: boolean;
 
     /**
-     * Send device name and size
+     * Send device name and size at start of video stream.
      *
      * @default true
      */
     sendDeviceMeta: boolean;
 
     /**
-     * Write a byte on start to detect connection issues
+     * Send a `0` byte on start of video stream to detect connection issues
      *
      * @default true
      */
@@ -59,11 +59,9 @@ export class ScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsIn
     }
 
     public override createConnection(device: Adb): ScrcpyClientConnection {
-        const defaultValue = this.getDefaultValue();
-        const options: ScrcpyClientConnectionOptions = {
-            control: this.value.control ?? defaultValue.control,
-            sendDummyByte: this.value.sendDummyByte ?? defaultValue.sendDummyByte,
-            sendDeviceMeta: this.value.sendDeviceMeta ?? defaultValue.sendDeviceMeta,
+        const options = {
+            ...this.getDefaultValue(),
+            ...this.value,
         };
         if (this.value.tunnelForward) {
             return new ScrcpyClientForwardConnection(device, options);

package/src/options/common.ts

@@ -1,6 +1,7 @@
 import type { Adb, TransformStream } from "@yume-chan/adb";
 import type { ScrcpyClientConnection } from "../connection.js";
 import type { H264Configuration } from "../decoder/index.js";
+import type { ScrcpyControlMessageType } from "../message.js";
 import type { ScrcpyBackOrScreenOnEvent1_18 } from "./1_18.js";
 import type { ScrcpyInjectScrollControlMessage1_22 } from "./1_22.js";
 
@@ -53,6 +54,8 @@ export interface ScrcpyOptions<T> {
 
     createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket>;
 
+    getControlMessageTypes(): ScrcpyControlMessageType[];
+
     serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnEvent1_18,
     ): Uint8Array | undefined;