@yume-chan/scrcpy 0.0.16 → 0.0.18

package/src/control/serializer.ts

@@ -0,0 +1,151 @@
+import {
+    type WritableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+
+import {
+    type ScrcpyOptions,
+    type ScrcpyScrollController,
+} from "../options/index.js";
+
+import {
+    ScrcpyInjectKeyCodeControlMessage,
+    type AndroidKeyEventAction,
+} from "./inject-keycode.js";
+import { type ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
+import { ScrcpyInjectTextControlMessage } from "./inject-text.js";
+import { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import { ScrcpyRotateDeviceControlMessage } from "./rotate-device.js";
+import {
+    ScrcpySetScreenPowerModeControlMessage,
+    type AndroidScreenPowerMode,
+} from "./set-screen-power-mode.js";
+import { ScrcpyControlMessageType } 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;
+    }
+
+    public injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    ) {
+        return this.writer.write(
+            ScrcpyInjectKeyCodeControlMessage.serialize(
+                this.addMessageType(
+                    message,
+                    ScrcpyControlMessageType.InjectKeyCode
+                )
+            )
+        );
+    }
+
+    public injectText(text: string) {
+        return this.writer.write(
+            ScrcpyInjectTextControlMessage.serialize({
+                text,
+                type: this.getActualMessageType(
+                    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
+                )
+            )
+        );
+    }
+
+    /**
+     * `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)
+        );
+
+        if (!data) {
+            return;
+        }
+
+        return this.writer.write(data);
+    }
+
+    public async backOrScreenOn(action: AndroidKeyEventAction) {
+        const buffer = this.options.serializeBackOrScreenOnControlMessage({
+            action,
+            type: this.getActualMessageType(
+                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
+                ),
+            })
+        );
+    }
+
+    public rotateDevice() {
+        return this.writer.write(
+            ScrcpyRotateDeviceControlMessage.serialize({
+                type: this.getActualMessageType(
+                    ScrcpyControlMessageType.RotateDevice
+                ),
+            })
+        );
+    }
+
+    public close() {
+        return this.writer.close();
+    }
+}

package/src/control/set-clipboard.ts

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

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

@@ -0,0 +1,17 @@
+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,
+    Normal = 2
+}
+
+export const ScrcpySetScreenPowerModeControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.SetScreenPowerMode as const)
+        .uint8('mode', placeholder<AndroidScreenPowerMode>());
+
+export type ScrcpySetScreenPowerModeControlMessage =
+    typeof ScrcpySetScreenPowerModeControlMessage['TInit'];

package/src/control/type.ts

@@ -0,0 +1,17 @@
+// 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
+// Their IDs change between versions, so always use `options.getControlMessageTypes()`
+export enum ScrcpyControlMessageType {
+    InjectKeyCode,
+    InjectText,
+    InjectTouch,
+    InjectScroll,
+    BackOrScreenOn,
+    ExpandNotificationPanel,
+    ExpandSettingPanel,
+    CollapseNotificationPanel,
+    GetClipboard,
+    SetClipboard,
+    SetScreenPowerMode,
+    RotateDevice,
+}

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

@@ -0,0 +1,10 @@
+import Struct from "@yume-chan/struct";
+
+import { ScrcpyDeviceMessageType } from "./type.js";
+
+export const ScrcpyAckClipboardDeviceMessage = new Struct()
+    .uint64("sequence")
+    .extra({ type: ScrcpyDeviceMessageType.AckClipboard as const });
+
+export type ScrcpyAckClipboardDeviceMessage =
+    typeof ScrcpyAckClipboardDeviceMessage["TDeserializeResult"];

package/src/device-message/clipboard.ts

@@ -0,0 +1,11 @@
+import Struct from "@yume-chan/struct";
+
+import { ScrcpyDeviceMessageType } from "./type.js";
+
+export const ScrcpyClipboardDeviceMessage = new Struct()
+    .uint32("length")
+    .string("content", { lengthField: "length" })
+    .extra({ type: ScrcpyDeviceMessageType.Clipboard as const });
+
+export type ScrcpyClipboardDeviceMessage =
+    typeof ScrcpyClipboardDeviceMessage["TDeserializeResult"];

package/src/device-message/index.ts

@@ -0,0 +1,4 @@
+export * from "./ack-clipboard.js";
+export * from "./clipboard.js";
+export * from "./stream.js";
+export * from "./type.js";

package/src/device-message/stream.ts

@@ -0,0 +1,29 @@
+import { BufferedTransformStream } from "@yume-chan/stream-extra";
+
+import { ScrcpyAckClipboardDeviceMessage } from "./ack-clipboard.js";
+import { ScrcpyClipboardDeviceMessage } from "./clipboard.js";
+import { ScrcpyDeviceMessageType } from "./type.js";
+
+export type ScrcpyDeviceMessage =
+    | ScrcpyClipboardDeviceMessage
+    | ScrcpyAckClipboardDeviceMessage;
+
+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");
+            }
+        });
+    }
+}

package/src/device-message/type.ts

@@ -0,0 +1,5 @@
+// https://github.com/Genymobile/scrcpy/blob/41abe021e2a73efd4899b0efcd0b9eef9ec68c9b/server/src/main/java/com/genymobile/scrcpy/DeviceMessage.java#L5
+export enum ScrcpyDeviceMessageType {
+    Clipboard,
+    AckClipboard,
+}

package/src/index.ts

@@ -1,8 +1,5 @@
-export * from './client.js';
+export * from './adb/index.js';
 export * from './codec.js';
-export * from './connection.js';
-export * from './decoder/index.js';
-export * from './message.js';
+export * from './control/index.js';
+export * from './device-message/index.js';
 export * from './options/index.js';
-export * from './push-server.js';
-export * from './utils.js';

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

@@ -0,0 +1,55 @@
+import {
+    type AndroidCodecLevel,
+    type AndroidCodecProfile,
+} from "../../codec.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;
+
+    iFrameInterval: number;
+    maxBframes: number;
+    repeatPreviousFrameAfter: number;
+    maxPtsGapToEncoder: number;
+}
+
+function toDashCase(input: string) {
+    return input.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+
+const CODEC_OPTION_TYPES: Partial<
+    Record<keyof CodecOptionsInit, "long" | "float" | "string">
+> = {
+    repeatPreviousFrameAfter: "long",
+    maxPtsGapToEncoder: "long",
+};
+
+export class CodecOptions implements ScrcpyOptionValue {
+    public value: Partial<CodecOptionsInit>;
+
+    public constructor(value: Partial<CodecOptionsInit>) {
+        this.value = value;
+    }
+
+    public toOptionValue(): string | undefined {
+        const entries = Object.entries(this.value).filter(
+            ([, value]) => value !== undefined
+        );
+
+        if (entries.length === 0) {
+            return undefined;
+        }
+
+        return entries
+            .map(([key, value]) => {
+                const type = CODEC_OPTION_TYPES[key as keyof CodecOptionsInit];
+                return `${toDashCase(key)}${type ? `:${type}` : ""}=${value}`;
+            })
+            .join(",");
+    }
+}