@yume-chan/scrcpy 0.0.18 → 0.0.20

package/src/control/inject-touch.ts

@@ -1,10 +1,4 @@
-import Struct, {
-    NumberFieldDefinition,
-    NumberFieldType,
-    placeholder,
-} from "@yume-chan/struct";
-
-import { ScrcpyControlMessageType } from "./type.js";
+import type { ScrcpyInjectTouchControlMessage2_0 } from "../options/index.js";
 
 // https://developer.android.com/reference/android/view/MotionEvent#constants_1
 export enum AndroidMotionEventAction {
@@ -23,56 +17,23 @@ export enum AndroidMotionEventAction {
     ButtonRelease,
 }
 
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace ScrcpyPointerId {
-    export const Mouse = BigInt(-1);
-    export const Finger = BigInt(-2);
-    export const VirtualMouse = BigInt(-3);
-    export const VirtualFinger = BigInt(-4);
+export enum AndroidMotionEventButton {
+    Primary = 0x01,
+    Secondary = 0x02,
+    Tertiary = 0x04,
+    Back = 0x08,
+    Forward = 0x10,
+    StylusPrimary = 0x20,
+    StylusSecondary = 0x40,
 }
 
-export function clamp(value: number, min: number, max: number): number {
-    if (value < min) {
-        return min;
-    }
-
-    if (value > max) {
-        return max;
-    }
-
-    return value;
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace ScrcpyPointerId {
+    export const Mouse = -1n;
+    export const Finger = -2n;
+    export const VirtualMouse = -3n;
+    export const VirtualFinger = -4n;
 }
 
-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);
-    },
-};
-
-const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
-    ScrcpyFloatToUint16NumberType
-);
-
-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")
-    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
-    .uint32("buttons");
-
 export type ScrcpyInjectTouchControlMessage =
-    typeof ScrcpyInjectTouchControlMessage["TInit"];
+    ScrcpyInjectTouchControlMessage2_0;

package/src/control/rotate-device.ts

@@ -1,10 +1,6 @@
-import Struct from '@yume-chan/struct';
+import { BasicControlMessage } from "./basic.js";
 
-import { ScrcpyControlMessageType } from './type.js';
-
-export const ScrcpyRotateDeviceControlMessage =
-    new Struct()
-        .uint8('type', ScrcpyControlMessageType.RotateDevice as const)
+export const ScrcpyRotateDeviceControlMessage = BasicControlMessage;
 
 export type ScrcpyRotateDeviceControlMessage =
-    typeof ScrcpyRotateDeviceControlMessage['TInit'];
+    (typeof ScrcpyRotateDeviceControlMessage)["TInit"];

package/src/control/serializer.ts

@@ -1,95 +1,58 @@
-import {
-    type WritableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
-
-import {
-    type ScrcpyOptions,
-    type ScrcpyScrollController,
+import type {
+    ScrcpyOptions,
+    ScrcpyScrollController,
 } from "../options/index.js";
 
-import {
-    ScrcpyInjectKeyCodeControlMessage,
-    type AndroidKeyEventAction,
-} from "./inject-keycode.js";
-import { type ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
+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 {
-    ScrcpySetScreenPowerModeControlMessage,
-    type AndroidScreenPowerMode,
-} from "./set-screen-power-mode.js";
-import { ScrcpyControlMessageType } from "./type.js";
+    ScrcpyControlMessageType,
+    ScrcpyControlMessageTypeValue,
+} from "./type.js";
 
 export class ScrcpyControlMessageSerializer {
-    private options: ScrcpyOptions<object>;
-    /** Control message type values for current version of server */
-    private types: ScrcpyControlMessageType[];
-    private writer: WritableStreamDefaultWriter<Uint8Array>;
-    private scrollController: ScrcpyScrollController;
-
-    public constructor(
-        stream: WritableStream<Uint8Array>,
-        options: ScrcpyOptions<object>
-    ) {
-        this.writer = stream.getWriter();
-
-        this.options = options;
-        this.types = options.getControlMessageTypes();
-        this.scrollController = options.getScrollController();
-    }
-
-    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 _options: ScrcpyOptions<object>;
+    private _typeValues: ScrcpyControlMessageTypeValue;
+    private _scrollController: ScrcpyScrollController;
+
+    public constructor(options: ScrcpyOptions<object>) {
+        this._options = options;
+        this._typeValues = new ScrcpyControlMessageTypeValue(options);
+        this._scrollController = options.createScrollController();
     }
 
     public injectKeyCode(
         message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
     ) {
-        return this.writer.write(
-            ScrcpyInjectKeyCodeControlMessage.serialize(
-                this.addMessageType(
-                    message,
-                    ScrcpyControlMessageType.InjectKeyCode
-                )
+        return ScrcpyInjectKeyCodeControlMessage.serialize(
+            this._typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectKeyCode
             )
         );
     }
 
     public injectText(text: string) {
-        return this.writer.write(
-            ScrcpyInjectTextControlMessage.serialize({
-                text,
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.InjectText
-                ),
-            })
-        );
+        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.writer.write(
-            ScrcpyInjectTouchControlMessage.serialize(
-                this.addMessageType(
-                    message,
-                    ScrcpyControlMessageType.InjectTouch
-                )
+        return this._options.serializeInjectTouchControlMessage(
+            this._typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectTouch
             )
         );
     }
@@ -100,52 +63,33 @@ export class ScrcpyControlMessageSerializer {
     public injectScroll(
         message: Omit<ScrcpyInjectScrollControlMessage, "type">
     ) {
-        const data = this.scrollController.serializeScrollMessage(
-            this.addMessageType(message, ScrcpyControlMessageType.InjectScroll)
+        return this._scrollController.serializeScrollMessage(
+            this._typeValues.fillMessageType(
+                message,
+                ScrcpyControlMessageType.InjectScroll
+            )
         );
-
-        if (!data) {
-            return;
-        }
-
-        return this.writer.write(data);
     }
 
-    public async backOrScreenOn(action: AndroidKeyEventAction) {
-        const buffer = this.options.serializeBackOrScreenOnControlMessage({
+    public backOrScreenOn(action: AndroidKeyEventAction) {
+        return this._options.serializeBackOrScreenOnControlMessage({
             action,
-            type: this.getActualMessageType(
-                ScrcpyControlMessageType.BackOrScreenOn
-            ),
+            type: this._typeValues.get(ScrcpyControlMessageType.BackOrScreenOn),
         });
-
-        if (buffer) {
-            return await this.writer.write(buffer);
-        }
     }
 
     public setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        return this.writer.write(
-            ScrcpySetScreenPowerModeControlMessage.serialize({
-                mode,
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.SetScreenPowerMode
-                ),
-            })
-        );
+        return ScrcpySetScreenPowerModeControlMessage.serialize({
+            mode,
+            type: this._typeValues.get(
+                ScrcpyControlMessageType.SetScreenPowerMode
+            ),
+        });
     }
 
     public rotateDevice() {
-        return this.writer.write(
-            ScrcpyRotateDeviceControlMessage.serialize({
-                type: this.getActualMessageType(
-                    ScrcpyControlMessageType.RotateDevice
-                ),
-            })
-        );
-    }
-
-    public close() {
-        return this.writer.close();
+        return ScrcpyRotateDeviceControlMessage.serialize({
+            type: this._typeValues.get(ScrcpyControlMessageType.RotateDevice),
+        });
     }
 }

package/src/control/set-clipboard.ts

@@ -1,4 +1,4 @@
-import { type ScrcpySetClipboardControlMessage1_21 } from "../options/index.js";
+import type { ScrcpySetClipboardControlMessage1_21 } from "../options/index.js";
 
 export type ScrcpySetClipboardControlMessage =
     ScrcpySetClipboardControlMessage1_21;

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

@@ -1,17 +1,14 @@
-import Struct, { placeholder } from '@yume-chan/struct';
-
-import { ScrcpyControlMessageType } from './type.js';
+import Struct, { placeholder } from "@yume-chan/struct";
 
 // 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,
-    Normal = 2
+    Normal = 2,
 }
 
-export const ScrcpySetScreenPowerModeControlMessage =
-    new Struct()
-        .uint8('type', ScrcpyControlMessageType.SetScreenPowerMode as const)
-        .uint8('mode', placeholder<AndroidScreenPowerMode>());
+export const ScrcpySetScreenPowerModeControlMessage = new Struct()
+    .uint8("type")
+    .uint8("mode", placeholder<AndroidScreenPowerMode>());
 
 export type ScrcpySetScreenPowerModeControlMessage =
-    typeof ScrcpySetScreenPowerModeControlMessage['TInit'];
+    (typeof ScrcpySetScreenPowerModeControlMessage)["TInit"];

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 {
+    private types: readonly ScrcpyControlMessageType[];
+
+    public constructor(options: ScrcpyOptions<object>) {
+        this.types = options.controlMessageTypes;
+    }
+
+    public get(type: ScrcpyControlMessageType): number {
+        const value = this.types.indexOf(type);
+        if (value === -1) {
+            throw new Error("Not supported");
+        }
+        return value;
+    }
+
+    public 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,87 @@
+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 {
+    private _writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    private _serializer: ScrcpyControlMessageSerializer;
+
+    public constructor(
+        writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
+        options: ScrcpyOptions<object>
+    ) {
+        this._writer = writer;
+        this._serializer = new ScrcpyControlMessageSerializer(options);
+    }
+
+    private async write(message: Uint8Array) {
+        await ConsumableWritableStream.write(this._writer, message);
+    }
+
+    public async injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    ) {
+        await this.write(this._serializer.injectKeyCode(message));
+    }
+
+    public async injectText(text: string) {
+        await this.write(this._serializer.injectText(text));
+    }
+
+    /**
+     * `pressure` is a float value between 0 and 1.
+     */
+    public async injectTouch(
+        message: Omit<ScrcpyInjectTouchControlMessage, "type">
+    ) {
+        await this.write(this._serializer.injectTouch(message));
+    }
+
+    /**
+     * `scrollX` and `scrollY` are float values between 0 and 1.
+     */
+    public async injectScroll(
+        message: Omit<ScrcpyInjectScrollControlMessage, "type">
+    ) {
+        const data = this._serializer.injectScroll(message);
+        if (data) {
+            await this.write(data);
+        }
+    }
+
+    public async backOrScreenOn(action: AndroidKeyEventAction) {
+        const data = this._serializer.backOrScreenOn(action);
+        if (data) {
+            await this.write(data);
+        }
+    }
+
+    public async setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        await this.write(this._serializer.setScreenPowerMode(mode));
+    }
+
+    public async rotateDevice() {
+        await this.write(this._serializer.rotateDevice());
+    }
+
+    public releaseLock() {
+        this._writer.releaseLock();
+    }
+
+    public async close() {
+        await this._writer.close();
+    }
+}

package/src/device-message/ack-clipboard.ts

@@ -7,4 +7,4 @@ export const ScrcpyAckClipboardDeviceMessage = new Struct()
     .extra({ type: ScrcpyDeviceMessageType.AckClipboard as const });
 
 export type ScrcpyAckClipboardDeviceMessage =
-    typeof ScrcpyAckClipboardDeviceMessage["TDeserializeResult"];
+    (typeof ScrcpyAckClipboardDeviceMessage)["TDeserializeResult"];

package/src/device-message/clipboard.ts

@@ -8,4 +8,4 @@ export const ScrcpyClipboardDeviceMessage = new Struct()
     .extra({ type: ScrcpyDeviceMessageType.Clipboard as const });
 
 export type ScrcpyClipboardDeviceMessage =
-    typeof ScrcpyClipboardDeviceMessage["TDeserializeResult"];
+    (typeof ScrcpyClipboardDeviceMessage)["TDeserializeResult"];

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 './control/index.js';
-export * from './device-message/index.js';
-export * from './options/index.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,21 +1,18 @@
-import {
-    type AndroidCodecLevel,
-    type AndroidCodecProfile,
-} from "../../codec.js";
-import { type ScrcpyOptionValue } from "../types.js";
+import type { ScrcpyOptionValue } from "../types.js";
 
 /**
  * If the option you need is not in this type,
  * please file an issue on GitHub.
  */
 export interface CodecOptionsInit {
-    profile: AndroidCodecProfile;
-    level: AndroidCodecLevel;
+    profile: number;
+    level: number;
 
     iFrameInterval: number;
     maxBframes: number;
     repeatPreviousFrameAfter: number;
     maxPtsGapToEncoder: number;
+    intraRefreshPeriod: number;
 }
 
 function toDashCase(input: string) {
@@ -32,7 +29,7 @@ const CODEC_OPTION_TYPES: Partial<
 export class CodecOptions implements ScrcpyOptionValue {
     public value: Partial<CodecOptionsInit>;
 
-    public constructor(value: Partial<CodecOptionsInit>) {
+    public constructor(value: Partial<CodecOptionsInit> = {}) {
         this.value = value;
     }
 

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";