@yume-chan/scrcpy 2.1.0 → 2.2.0

package/src/3_3_1/options.ts

@@ -0,0 +1,177 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+
+import type {
+    ScrcpyAudioStreamMetadata,
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyOptionsListEncoders,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import { ScrcpyDeviceMessageParsers } from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpyUHidCreateControlMessage,
+    ScrcpyUHidOutputDeviceMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    parseAudioStreamMetadata,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    serializeUHidCreateControlMessage,
+    setListDisplays,
+    setListEncoders,
+    UHidOutputStream,
+} from "./impl/index.js";
+
+export class ScrcpyOptions3_3_1<TVideo extends boolean>
+    implements ScrcpyOptions<Init<TVideo>>, ScrcpyOptionsListEncoders
+{
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init<TVideo>>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput():
+        | ReadableStream<ScrcpyUHidOutputDeviceMessage>
+        | undefined {
+        return this.#uHidOutput;
+    }
+
+    #deviceMessageParsers = new ScrcpyDeviceMessageParsers();
+    get deviceMessageParsers() {
+        return this.#deviceMessageParsers;
+    }
+
+    constructor(init: Init<TVideo>) {
+        this.value = { ...Defaults, ...init } as never;
+
+        if (this.value.videoSource === "camera") {
+            this.value.control = false;
+        }
+
+        if (this.value.audioDup) {
+            this.value.audioSource = "playback";
+        }
+
+        if (this.value.control) {
+            if (this.value.clipboardAutosync) {
+                this.#clipboard = this.#deviceMessageParsers.add(
+                    new ClipboardStream(),
+                );
+
+                this.#ackClipboardHandler = this.#deviceMessageParsers.add(
+                    new AckClipboardHandler(),
+                );
+            }
+
+            this.#uHidOutput = this.#deviceMessageParsers.add(
+                new UHidOutputStream(),
+            );
+        }
+    }
+
+    serialize(): string[] {
+        return serialize<Init<boolean>>(this.value, Defaults);
+    }
+
+    setListDisplays(): void {
+        setListDisplays(this.value);
+    }
+
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
+        return parseDisplay(line);
+    }
+
+    setListEncoders() {
+        setListEncoders(this.value);
+    }
+
+    parseEncoder(line: string): ScrcpyEncoder | undefined {
+        return parseEncoder(line);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(this.value, stream);
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(stream, this.value);
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyMediaStreamPacket
+    > {
+        return createMediaStreamTransformer(this.value);
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        return serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        return serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        return this.#ackClipboardHandler!.serializeSetClipboardControlMessage(
+            message,
+        );
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        return createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_<TVideo extends boolean> = Init<TVideo>;
+
+export namespace ScrcpyOptions3_3_1 {
+    export type Init<TVideo extends boolean = boolean> = Init_<TVideo>;
+}

package/src/3_3_2.ts

@@ -0,0 +1,14 @@
+import { ScrcpyOptions3_3_1 } from "./3_3_1/index.js";
+
+export class ScrcpyOptions3_3_2<
+    TVideo extends boolean,
+> extends ScrcpyOptions3_3_1<TVideo> {
+    constructor(init: ScrcpyOptions3_3_1.Init<TVideo>) {
+        super(init);
+    }
+}
+
+export namespace ScrcpyOptions3_3_2 {
+    export type Init<TVideo extends boolean = boolean> =
+        ScrcpyOptions3_3_1.Init<TVideo>;
+}

package/src/base/device-message.ts

@@ -1,9 +1,58 @@
 import type { AsyncExactReadable } from "@yume-chan/struct";
 
 export interface ScrcpyDeviceMessageParser {
-    parse(id: number, stream: AsyncExactReadable): Promise<boolean>;
+    readonly id: number | readonly number[];
+
+    parse(id: number, stream: AsyncExactReadable): Promise<undefined>;
 
     close(): void;
 
     error(e?: unknown): void;
 }
+
+export class ScrcpyDeviceMessageParsers {
+    #parsers: ScrcpyDeviceMessageParser[] = [];
+    get parsers(): readonly ScrcpyDeviceMessageParser[] {
+        return this.#parsers;
+    }
+
+    #add(id: number, parser: ScrcpyDeviceMessageParser) {
+        if (this.#parsers[id]) {
+            throw new Error(`Duplicate parser for id ${id}`);
+        }
+        this.#parsers[id] = parser;
+    }
+
+    add<T extends ScrcpyDeviceMessageParser>(parser: T): T {
+        if (Array.isArray(parser.id)) {
+            for (const id of parser.id) {
+                this.#add(id as number, parser);
+            }
+        } else {
+            this.#add(parser.id as number, parser);
+        }
+
+        return parser;
+    }
+
+    async parse(id: number, stream: AsyncExactReadable): Promise<undefined> {
+        const parser = this.#parsers[id];
+        if (!parser) {
+            throw new Error(`Unknown device message id ${id}`);
+        }
+
+        return parser.parse(id, stream);
+    }
+
+    close() {
+        for (const parser of this.#parsers) {
+            parser.close();
+        }
+    }
+
+    error(e?: unknown) {
+        for (const parser of this.#parsers) {
+            parser.error(e);
+        }
+    }
+}

package/src/base/options.ts

@@ -1,6 +1,5 @@
 import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
-import type { AsyncExactReadable, ExactReadable } from "@yume-chan/struct";
 
 import type {
     ScrcpyBackOrScreenOnControlMessage,
@@ -12,6 +11,7 @@ import type {
 
 import type { ScrcpyAudioStreamMetadata } from "./audio.js";
 import type { ScrcpyControlMessageType } from "./control-message-type.js";
+import type { ScrcpyDeviceMessageParsers } from "./device-message.js";
 import type { ScrcpyDisplay } from "./display.js";
 import type { ScrcpyEncoder } from "./encoder.js";
 import type { ScrcpyMediaStreamPacket } from "./media.js";
@@ -29,6 +29,8 @@ export interface ScrcpyOptions<T extends object> {
         | ReadableStream<ScrcpyUHidOutputDeviceMessage>
         | undefined;
 
+    readonly deviceMessageParsers: ScrcpyDeviceMessageParsers;
+
     serialize(): string[];
 
     setListDisplays(): void;
@@ -43,13 +45,6 @@ export interface ScrcpyOptions<T extends object> {
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyAudioStreamMetadata>;
 
-    parseDeviceMessage(
-        id: number,
-        stream: ExactReadable | AsyncExactReadable,
-    ): Promise<void>;
-
-    endDeviceMessageStream(e?: unknown): void;
-
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
         ScrcpyMediaStreamPacket

package/src/control/message-type-map.ts

@@ -20,11 +20,11 @@ export class ScrcpyControlMessageTypeMap {
         return value;
     }
 
-    fillMessageType<T extends { type: ScrcpyControlMessageType }>(
+    fillMessageType<T extends { type: number }>(
         message: Omit<T, "type">,
-        type: T["type"],
+        type: ScrcpyControlMessageType,
     ): T {
-        (message as T).type = this.get(type) as ScrcpyControlMessageType;
+        (message as T).type = this.get(type);
         return message as T;
     }
 }

package/src/index.ts

@@ -26,6 +26,9 @@ export * from "./3_0_1.js";
 export * from "./3_0_2.js";
 export * from "./3_1/index.js";
 export * from "./3_2/index.js";
+export * from "./3_3.js";
+export * from "./3_3_1/index.js";
+export * from "./3_3_2.js";
 export * from "./android/index.js";
 export * from "./base/index.js";
 export * from "./codec/index.js";

package/src/latest.ts

@@ -1,16 +1,16 @@
-import { ScrcpyOptions3_2 } from "./3_2/options.js";
+import { ScrcpyOptions3_3_2 } from "./3_3_2.js";
 
 export class ScrcpyOptionsLatest<
     TVideo extends boolean,
-> extends ScrcpyOptions3_2<TVideo> {
-    constructor(init: ScrcpyOptions3_2.Init<TVideo>) {
+> extends ScrcpyOptions3_3_2<TVideo> {
+    constructor(init: ScrcpyOptions3_3_2.Init<TVideo>) {
         super(init);
     }
 }
 
 export namespace ScrcpyOptionsLatest {
     export type Init<TVideo extends boolean = boolean> =
-        ScrcpyOptions3_2.Init<TVideo>;
+        ScrcpyOptions3_3_2.Init<TVideo>;
 }
 
 export {
@@ -28,4 +28,4 @@ export {
     SetClipboardControlMessage as ScrcpySetClipboardControlMessage,
     UHidCreateControlMessage as ScrcpyUHidCreateControlMessage,
     UHidOutputDeviceMessage as ScrcpyUHidOutputDeviceMessage,
-} from "./3_2/impl/index.js";
+} from "./3_3_1/impl/index.js";