@yume-chan/scrcpy 0.0.19 → 0.0.21

package/src/control/serializer.ts

@@ -1,13 +1,5 @@
-import type {
-    Consumable,
-    WritableStream,
-    WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
-import { ConsumableWritableStream } from "@yume-chan/stream-extra";
-
 import type {
     ScrcpyOptions,
-    ScrcpyOptionsInit1_16,
     ScrcpyScrollController,
 } from "../options/index.js";
 
@@ -15,140 +7,85 @@ import type { AndroidKeyEventAction } from "./inject-keycode.js";
 import { ScrcpyInjectKeyCodeControlMessage } from "./inject-keycode.js";
 import type { ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
 import { ScrcpyInjectTextControlMessage } from "./inject-text.js";
-import { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import type { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
 import { ScrcpyRotateDeviceControlMessage } from "./rotate-device.js";
 import type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
 import { ScrcpySetScreenPowerModeControlMessage } from "./set-screen-power-mode.js";
-import { ScrcpyControlMessageType } from "./type.js";
+import {
+    ScrcpyControlMessageType,
+    ScrcpyControlMessageTypeValue,
+} from "./type.js";
 
 export class ScrcpyControlMessageSerializer {
-    private options: ScrcpyOptions<ScrcpyOptionsInit1_16>;
-    /** Control message type values for current version of server */
-    private types: ScrcpyControlMessageType[];
-    private writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
-    private scrollController: ScrcpyScrollController;
-
-    public constructor(
-        stream: WritableStream<Consumable<Uint8Array>>,
-        options: ScrcpyOptions<ScrcpyOptionsInit1_16>
-    ) {
-        this.writer = stream.getWriter();
-
-        this.options = options;
-        this.types = options.getControlMessageTypes();
-        this.scrollController = options.getScrollController();
+    #options: ScrcpyOptions<object>;
+    #typeValues: ScrcpyControlMessageTypeValue;
+    #scrollController: ScrcpyScrollController;
+
+    constructor(options: ScrcpyOptions<object>) {
+        this.#options = options;
+        this.#typeValues = new ScrcpyControlMessageTypeValue(options);
+        this.#scrollController = options.createScrollController();
     }
 
-    public getActualMessageType(type: ScrcpyControlMessageType): number {
-        const value = this.types.indexOf(type);
-        if (value === -1) {
-            throw new Error("Not supported");
-        }
-        return value;
-    }
-
-    public addMessageType<T extends { type: ScrcpyControlMessageType }>(
-        message: Omit<T, "type">,
-        type: T["type"]
-    ): T {
-        (message as T).type = this.getActualMessageType(type);
-        return message as T;
-    }
-
-    private async write(data: Uint8Array) {
-        await ConsumableWritableStream.write(this.writer, data);
-    }
-
-    public injectKeyCode(
-        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
-    ) {
-        return this.write(
-            ScrcpyInjectKeyCodeControlMessage.serialize(
-                this.addMessageType(
-                    message,
-                    ScrcpyControlMessageType.InjectKeyCode
-                )
-            )
+    injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">) {
+        return ScrcpyInjectKeyCodeControlMessage.serialize(
+            this.#typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectKeyCode,
+            ),
         );
     }
 
-    public injectText(text: string) {
-        return this.write(
-            ScrcpyInjectTextControlMessage.serialize({
-                text,
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.InjectText
-                ),
-            })
-        );
+    injectText(text: string) {
+        return ScrcpyInjectTextControlMessage.serialize({
+            text,
+            type: this.#typeValues.get(ScrcpyControlMessageType.InjectText),
+        });
     }
 
     /**
      * `pressure` is a float value between 0 and 1.
      */
-    public injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
-        return this.write(
-            ScrcpyInjectTouchControlMessage.serialize(
-                this.addMessageType(
-                    message,
-                    ScrcpyControlMessageType.InjectTouch
-                )
-            )
+    injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        return this.#options.serializeInjectTouchControlMessage(
+            this.#typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectTouch,
+            ),
         );
     }
 
     /**
      * `scrollX` and `scrollY` are float values between 0 and 1.
      */
-    public injectScroll(
-        message: Omit<ScrcpyInjectScrollControlMessage, "type">
-    ) {
-        const data = this.scrollController.serializeScrollMessage(
-            this.addMessageType(message, ScrcpyControlMessageType.InjectScroll)
+    injectScroll(message: Omit<ScrcpyInjectScrollControlMessage, "type">) {
+        return this.#scrollController.serializeScrollMessage(
+            this.#typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectScroll,
+            ),
         );
-
-        if (!data) {
-            return;
-        }
-
-        return this.write(data);
     }
 
-    public async backOrScreenOn(action: AndroidKeyEventAction) {
-        const buffer = this.options.serializeBackOrScreenOnControlMessage({
+    backOrScreenOn(action: AndroidKeyEventAction) {
+        return this.#options.serializeBackOrScreenOnControlMessage({
             action,
-            type: this.getActualMessageType(
-                ScrcpyControlMessageType.BackOrScreenOn
-            ),
+            type: this.#typeValues.get(ScrcpyControlMessageType.BackOrScreenOn),
         });
-
-        if (buffer) {
-            return await this.write(buffer);
-        }
     }
 
-    public setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        return this.write(
-            ScrcpySetScreenPowerModeControlMessage.serialize({
-                mode,
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.SetScreenPowerMode
-                ),
-            })
-        );
-    }
-
-    public rotateDevice() {
-        return this.write(
-            ScrcpyRotateDeviceControlMessage.serialize({
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.RotateDevice
-                ),
-            })
-        );
+    setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        return ScrcpySetScreenPowerModeControlMessage.serialize({
+            mode,
+            type: this.#typeValues.get(
+                ScrcpyControlMessageType.SetScreenPowerMode,
+            ),
+        });
     }
 
-    public close() {
-        return this.writer.close();
+    rotateDevice() {
+        return ScrcpyRotateDeviceControlMessage.serialize({
+            type: this.#typeValues.get(ScrcpyControlMessageType.RotateDevice),
+        });
     }
 }

package/src/control/set-screen-power-mode.ts

@@ -1,7 +1,5 @@
 import Struct, { placeholder } from "@yume-chan/struct";
 
-import { ScrcpyControlMessageType } from "./type.js";
-
 // https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/SurfaceControl.java;l=659;drc=20303e05bf73796124ab70a279cf849b61b97905
 export enum AndroidScreenPowerMode {
     Off = 0,
@@ -9,7 +7,7 @@ export enum AndroidScreenPowerMode {
 }
 
 export const ScrcpySetScreenPowerModeControlMessage = new Struct()
-    .uint8("type", ScrcpyControlMessageType.SetScreenPowerMode as const)
+    .uint8("type")
     .uint8("mode", placeholder<AndroidScreenPowerMode>());
 
 export type ScrcpySetScreenPowerModeControlMessage =

package/src/control/type.ts

@@ -1,5 +1,8 @@
 // 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
+
+import type { ScrcpyOptions } from "../options/index.js";
+
 // Their IDs change between versions, so always use `options.getControlMessageTypes()`
 export enum ScrcpyControlMessageType {
     InjectKeyCode,
@@ -15,3 +18,32 @@ export enum ScrcpyControlMessageType {
     SetScreenPowerMode,
     RotateDevice,
 }
+
+/**
+ * Scrcpy control message types have different values between versions.
+ *
+ * This class provides a way to get the actual value for a given type.
+ */
+export class ScrcpyControlMessageTypeValue {
+    #types: readonly ScrcpyControlMessageType[];
+
+    constructor(options: ScrcpyOptions<object>) {
+        this.#types = options.controlMessageTypes;
+    }
+
+    get(type: ScrcpyControlMessageType): number {
+        const value = this.#types.indexOf(type);
+        if (value === -1) {
+            throw new Error("Not supported");
+        }
+        return value;
+    }
+
+    fillMessageType<T extends { type: ScrcpyControlMessageType }>(
+        message: Omit<T, "type">,
+        type: T["type"],
+    ): T {
+        (message as T).type = this.get(type);
+        return message as T;
+    }
+}

package/src/control/writer.ts

@@ -0,0 +1,85 @@
+import type {
+    Consumable,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import { ConsumableWritableStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyOptions } from "../options/index.js";
+
+import type {
+    AndroidKeyEventAction,
+    ScrcpyInjectKeyCodeControlMessage,
+} from "./inject-keycode.js";
+import type { ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
+import type { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import { ScrcpyControlMessageSerializer } from "./serializer.js";
+import type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
+
+export class ScrcpyControlMessageWriter {
+    #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    #serializer: ScrcpyControlMessageSerializer;
+
+    constructor(
+        writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
+        options: ScrcpyOptions<object>,
+    ) {
+        this.#writer = writer;
+        this.#serializer = new ScrcpyControlMessageSerializer(options);
+    }
+
+    async #write(message: Uint8Array) {
+        await ConsumableWritableStream.write(this.#writer, message);
+    }
+
+    async injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">,
+    ) {
+        await this.#write(this.#serializer.injectKeyCode(message));
+    }
+
+    async injectText(text: string) {
+        await this.#write(this.#serializer.injectText(text));
+    }
+
+    /**
+     * `pressure` is a float value between 0 and 1.
+     */
+    async injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        await this.#write(this.#serializer.injectTouch(message));
+    }
+
+    /**
+     * `scrollX` and `scrollY` are float values between 0 and 1.
+     */
+    async injectScroll(
+        message: Omit<ScrcpyInjectScrollControlMessage, "type">,
+    ) {
+        const data = this.#serializer.injectScroll(message);
+        if (data) {
+            await this.#write(data);
+        }
+    }
+
+    async backOrScreenOn(action: AndroidKeyEventAction) {
+        const data = this.#serializer.backOrScreenOn(action);
+        if (data) {
+            await this.#write(data);
+        }
+    }
+
+    async setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        await this.#write(this.#serializer.setScreenPowerMode(mode));
+    }
+
+    async rotateDevice() {
+        await this.#write(this.#serializer.rotateDevice());
+    }
+
+    releaseLock() {
+        this.#writer.releaseLock();
+    }
+
+    async close() {
+        await this.#writer.close();
+    }
+}

package/src/device-message/stream.ts

@@ -1,4 +1,9 @@
 import { BufferedTransformStream } from "@yume-chan/stream-extra";
+import {
+    ExactReadableEndedError,
+    StructEmptyError,
+    StructNotEnoughDataError,
+} from "@yume-chan/struct";
 
 import { ScrcpyAckClipboardDeviceMessage } from "./ack-clipboard.js";
 import { ScrcpyClipboardDeviceMessage } from "./clipboard.js";
@@ -11,18 +16,33 @@ export type ScrcpyDeviceMessage =
 export class ScrcpyDeviceMessageDeserializeStream extends BufferedTransformStream<ScrcpyDeviceMessage> {
     constructor() {
         super(async (stream) => {
-            const type = await stream.read(1);
-            switch (type[0]) {
-                case ScrcpyDeviceMessageType.Clipboard:
-                    return await ScrcpyClipboardDeviceMessage.deserialize(
-                        stream
-                    );
-                case ScrcpyDeviceMessageType.AckClipboard:
-                    return await ScrcpyAckClipboardDeviceMessage.deserialize(
-                        stream
-                    );
-                default:
-                    throw new Error("unknown control message type");
+            try {
+                const type = await stream.readExactly(1);
+                switch (type[0]) {
+                    case ScrcpyDeviceMessageType.Clipboard:
+                        return await ScrcpyClipboardDeviceMessage.deserialize(
+                            stream,
+                        );
+                    case ScrcpyDeviceMessageType.AckClipboard:
+                        return await ScrcpyAckClipboardDeviceMessage.deserialize(
+                            stream,
+                        );
+                    default:
+                        throw new Error("Unsupported control message type");
+                }
+            } catch (e) {
+                // Can't read the `type` byte
+                if (e instanceof ExactReadableEndedError) {
+                    throw new StructEmptyError();
+                }
+
+                // Can't read struct body,
+                // treat as not enough data because `type` byte is already read
+                if (e instanceof StructEmptyError) {
+                    throw new StructNotEnoughDataError();
+                }
+
+                throw e;
             }
         });
     }

package/src/index.ts

@@ -1,5 +1,4 @@
-export * from "./adb/index.js";
-export * from "./codec.js";
+export * from "./codec/index.js";
 export * from "./control/index.js";
 export * from "./device-message/index.js";
 export * from "./options/index.js";

package/src/options/1_16/codec-options.ts

@@ -1,4 +1,3 @@
-import type { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
 import type { ScrcpyOptionValue } from "../types.js";
 
 /**
@@ -6,8 +5,8 @@ import type { ScrcpyOptionValue } from "../types.js";
  * please file an issue on GitHub.
  */
 export interface CodecOptionsInit {
-    profile: AndroidCodecProfile;
-    level: AndroidCodecLevel;
+    profile: number;
+    level: number;
 
     iFrameInterval: number;
     maxBframes: number;
@@ -28,15 +27,15 @@ const CODEC_OPTION_TYPES: Partial<
 };
 
 export class CodecOptions implements ScrcpyOptionValue {
-    public value: Partial<CodecOptionsInit>;
+    value: Partial<CodecOptionsInit>;
 
-    public constructor(value: Partial<CodecOptionsInit> = {}) {
+    constructor(value: Partial<CodecOptionsInit> = {}) {
         this.value = value;
     }
 
-    public toOptionValue(): string | undefined {
+    toOptionValue(): string | undefined {
         const entries = Object.entries(this.value).filter(
-            ([, value]) => value !== undefined
+            ([, value]) => value !== undefined,
         );
 
         if (entries.length === 0) {

package/src/options/1_16/float-to-uint16.ts

@@ -0,0 +1,33 @@
+import { NumberFieldDefinition, NumberFieldType } from "@yume-chan/struct";
+
+export function clamp(value: number, min: number, max: number): number {
+    if (value < min) {
+        return min;
+    }
+
+    if (value > max) {
+        return max;
+    }
+
+    return value;
+}
+
+export const ScrcpyFloatToUint16NumberType: NumberFieldType = {
+    size: 2,
+    signed: false,
+    deserialize(array, littleEndian) {
+        const value = NumberFieldType.Uint16.deserialize(array, littleEndian);
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/server/src/main/java/com/genymobile/scrcpy/Binary.java#L22
+        return value === 0xffff ? 1 : value / 0x10000;
+    },
+    serialize(dataView, offset, value, littleEndian) {
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/app/src/util/binary.h#L51
+        value = clamp(value, -1, 1);
+        value = value === 1 ? 0xffff : value * 0x10000;
+        NumberFieldType.Uint16.serialize(dataView, offset, value, littleEndian);
+    },
+};
+
+export const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
+    ScrcpyFloatToUint16NumberType,
+);

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

@@ -1,4 +1,6 @@
 export * from "./codec-options.js";
-export * from "./h264-configuration.js";
+export * from "./float-to-uint16.js";
+export * from "./init.js";
+export * from "./message.js";
 export * from "./options.js";
 export * from "./scroll.js";

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

@@ -0,0 +1,80 @@
+import type { CodecOptions } from "./codec-options.js";
+
+export enum ScrcpyLogLevel1_16 {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error",
+}
+
+export enum ScrcpyVideoOrientation1_16 {
+    Unlocked = -1,
+    Portrait = 0,
+    Landscape = 1,
+    PortraitFlipped = 2,
+    LandscapeFlipped = 3,
+}
+
+export interface ScrcpyOptionsInit1_16 {
+    logLevel?: ScrcpyLogLevel1_16;
+
+    /**
+     * The maximum value of both width and height.
+     */
+    maxSize?: number;
+
+    bitRate?: number;
+
+    /**
+     * 0 for unlimited.
+     *
+     * @default 0
+     */
+    maxFps?: number;
+
+    /**
+     * The orientation of the video stream.
+     *
+     * It will not keep the device screen in specific orientation,
+     * only the captured video will in this orientation.
+     */
+    lockVideoOrientation?: ScrcpyVideoOrientation1_16;
+
+    /**
+     * Use ADB forward tunnel instead of reverse tunnel.
+     *
+     * This option is mainly used for working around the bug that on Android <9,
+     * ADB daemon can't create reverse tunnels if connected wirelessly (ADB over WiFi).
+     *
+     * When using `AdbScrcpyClient`, it can detect this situation and enable this option automatically.
+     */
+    tunnelForward?: boolean;
+
+    crop?: string | undefined;
+
+    /**
+     * Send PTS so that the client may record properly
+     *
+     * Note: When `sendFrameMeta: false` is specified,
+     * the video stream will not contain `configuration` typed packets,
+     * which means it can't be decoded by the companion decoders.
+     * It's still possible to record the stream into a file,
+     * or to decode it with a more tolerant decoder like FFMpeg.
+     *
+     * @default true
+     */
+    sendFrameMeta?: boolean;
+
+    /**
+     * @default true
+     */
+    control?: boolean;
+
+    displayId?: number;
+
+    showTouches?: boolean;
+
+    stayAwake?: boolean;
+
+    codecOptions?: CodecOptions;
+}

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

@@ -0,0 +1,55 @@
+import Struct, { placeholder } from "@yume-chan/struct";
+
+import type { AndroidMotionEventAction } from "../../control/index.js";
+import {
+    BasicControlMessage,
+    ScrcpyControlMessageType,
+} from "../../control/index.js";
+
+import { ScrcpyFloatToUint16FieldDefinition } from "./float-to-uint16.js";
+
+export const SCRCPY_CONTROL_MESSAGE_TYPES_1_16: readonly ScrcpyControlMessageType[] =
+    [
+        /*  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,
+    ];
+
+export const ScrcpyMediaStreamRawPacket = new Struct()
+    .uint64("pts")
+    .uint32("size")
+    .uint8Array("data", { lengthField: "size" });
+
+export const SCRCPY_MEDIA_PACKET_FLAG_CONFIG = 1n << 63n;
+
+export const ScrcpyInjectTouchControlMessage1_16 = new Struct()
+    .uint8("type")
+    .uint8("action", placeholder<AndroidMotionEventAction>())
+    .uint64("pointerId")
+    .uint32("pointerX")
+    .uint32("pointerY")
+    .uint16("screenWidth")
+    .uint16("screenHeight")
+    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
+    .uint32("buttons");
+
+export type ScrcpyInjectTouchControlMessage1_16 =
+    (typeof ScrcpyInjectTouchControlMessage1_16)["TInit"];
+
+export const ScrcpyBackOrScreenOnControlMessage1_16 = BasicControlMessage;
+
+export const ScrcpySetClipboardControlMessage1_15 = new Struct()
+    .uint8("type")
+    .uint32("length")
+    .string("content", { lengthField: "length" });
+
+export type ScrcpySetClipboardControlMessage1_15 =
+    (typeof ScrcpySetClipboardControlMessage1_15)["TInit"];