@yume-chan/scrcpy 0.0.23 → 1.0.0

package/src/1_18/options.ts

@@ -0,0 +1,141 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type {
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    EncoderRegex,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    SerializeOrder,
+    serializeSetClipboardControlMessage,
+    setListDisplays,
+    setListEncoders,
+} from "./impl/index.js";
+
+export class ScrcpyOptions1_18 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.control) {
+            this.#clipboard = new ClipboardStream();
+        }
+    }
+
+    serialize(): string[] {
+        return serialize(this.value, SerializeOrder);
+    }
+
+    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, EncoderRegex);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(stream);
+    }
+
+    async parseDeviceMessage(
+        id: number,
+        stream: AsyncExactReadable,
+    ): Promise<void> {
+        if (await this.#clipboard!.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard!.error(e);
+        } else {
+            this.#clipboard!.close();
+        }
+    }
+
+    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 {
+        return serializeSetClipboardControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        return createScrollController();
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions1_18 {
+    export type Init = Init_;
+}

package/src/1_19.ts

@@ -0,0 +1,4 @@
+export {
+    ScrcpyOptions1_18 as ScrcpyOptions1_19,
+    ScrcpyOptions1_18Impl as ScrcpyOptions1_19Impl,
+} from "./1_18/index.js";

package/src/1_20.ts

@@ -0,0 +1,4 @@
+export {
+    ScrcpyOptions1_18 as ScrcpyOptions1_20,
+    ScrcpyOptions1_18Impl as ScrcpyOptions1_20Impl,
+} from "./1_18/index.js";

package/src/1_21/impl/defaults.ts

@@ -0,0 +1,8 @@
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...PrevImpl.Defaults,
+        clipboardAutosync: true,
+    }) as const satisfies Required<Init>)();

package/src/1_21/impl/index.ts

@@ -0,0 +1,10 @@
+export * from "../../1_18/impl/index.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";
+export { EncoderRegex } from "./parse-encoder.js";
+export { serialize } from "./serialize.js";
+export {
+    AckClipboardDeviceMessage,
+    AckClipboardHandler,
+    SetClipboardControlMessage,
+} from "./set-clipboard.js";

package/src/1_21/impl/init.ts

@@ -0,0 +1,5 @@
+import type { PrevImpl } from "./prev.js";
+
+export interface Init extends PrevImpl.Init {
+    clipboardAutosync?: boolean;
+}

package/src/1_21/impl/parse-encoder.ts

@@ -0,0 +1 @@
+export const EncoderRegex = /^\s+scrcpy --encoder-name '([^']+)'$/;

package/src/1_21/impl/prev.ts

@@ -0,0 +1 @@
+export * as PrevImpl from "../../1_18/impl/index.js";

package/src/1_21/impl/serialize.ts

@@ -0,0 +1,31 @@
+import { toScrcpyOptionValue } from "../../base/option-value.js";
+
+function toSnakeCase(input: string): string {
+    return input.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+
+// 1.21 changed the format of arguments
+export function serialize<T extends object>(
+    options: T,
+    defaults: Required<T>,
+): string[] {
+    const result: string[] = [];
+    for (const [key, value] of Object.entries(options)) {
+        const serializedValue = toScrcpyOptionValue(value, undefined);
+        // v3.0 `new_display` option needs to send empty strings to server
+        if (serializedValue === undefined) {
+            continue;
+        }
+
+        const defaultValue = toScrcpyOptionValue(
+            defaults[key as keyof T],
+            undefined,
+        );
+        if (serializedValue === defaultValue) {
+            continue;
+        }
+
+        result.push(`${toSnakeCase(key)}=${serializedValue}`);
+    }
+    return result;
+}

package/src/1_21/impl/set-clipboard.ts

@@ -0,0 +1,80 @@
+import { PromiseResolver } from "@yume-chan/async";
+import type { AsyncExactReadable, StructInit } from "@yume-chan/struct";
+import { string, struct, u32, u64, u8 } from "@yume-chan/struct";
+
+import type { ScrcpyDeviceMessageParser } from "../../base/index.js";
+import type { ScrcpySetClipboardControlMessage } from "../../latest.js";
+
+export const AckClipboardDeviceMessage = struct(
+    { sequence: u64 },
+    { littleEndian: false },
+);
+
+export const SetClipboardControlMessage = struct(
+    {
+        type: u8,
+        sequence: u64,
+        paste: u8<boolean>(),
+        content: string(u32),
+    },
+    { littleEndian: false },
+);
+
+export type SetClipboardControlMessage = StructInit<
+    typeof SetClipboardControlMessage
+>;
+
+export class AckClipboardHandler implements ScrcpyDeviceMessageParser {
+    #resolvers = new Map<bigint, PromiseResolver<void>>();
+
+    #closed = false;
+
+    async parse(id: number, stream: AsyncExactReadable) {
+        if (id !== 1) {
+            return false;
+        }
+
+        const message = await AckClipboardDeviceMessage.deserialize(stream);
+        const resolver = this.#resolvers.get(message.sequence);
+        if (resolver) {
+            resolver.resolve();
+            this.#resolvers.delete(message.sequence);
+        }
+        return true;
+    }
+
+    close(): void {
+        for (const resolver of this.#resolvers.values()) {
+            resolver.reject();
+        }
+        this.#resolvers.clear();
+        this.#closed = true;
+    }
+
+    error(e?: unknown): void {
+        for (const resolver of this.#resolvers.values()) {
+            resolver.reject(e);
+        }
+        this.#resolvers.clear();
+        this.#closed = true;
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (message.sequence === 0n) {
+            return SetClipboardControlMessage.serialize(message);
+        }
+
+        if (this.#closed) {
+            throw new Error();
+        }
+
+        const resolver = new PromiseResolver<void>();
+        this.#resolvers.set(message.sequence, resolver);
+        return [
+            SetClipboardControlMessage.serialize(message),
+            resolver.promise,
+        ];
+    }
+}

package/src/1_21/index.ts

@@ -0,0 +1,2 @@
+export * as ScrcpyOptions1_21Impl from "./impl/index.js";
+export * from "./options.js";

package/src/1_21/options.ts

@@ -0,0 +1,151 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type {
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    EncoderRegex,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    setListDisplays,
+    setListEncoders,
+} from "./impl/index.js";
+
+export class ScrcpyOptions1_21 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.control && this.value.clipboardAutosync) {
+            this.#clipboard = new ClipboardStream();
+            this.#ackClipboardHandler = new AckClipboardHandler();
+        }
+    }
+
+    serialize(): string[] {
+        return serialize(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, EncoderRegex);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(stream);
+    }
+
+    async parseDeviceMessage(
+        id: number,
+        stream: AsyncExactReadable,
+    ): Promise<void> {
+        if (await this.#clipboard?.parse(id, stream)) {
+            return;
+        }
+
+        if (await this.#ackClipboardHandler?.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard?.error(e);
+            this.#ackClipboardHandler?.error(e);
+        } else {
+            this.#clipboard?.close();
+            this.#ackClipboardHandler?.close();
+        }
+    }
+
+    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();
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions1_21 {
+    export type Init = Init_;
+}

package/src/1_22/impl/defaults.ts

@@ -0,0 +1,10 @@
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export const Defaults = /* #__PURE__ */ (() =>
+    ({
+        ...PrevImpl.Defaults,
+        downsizeOnError: true,
+        sendDeviceMeta: true,
+        sendDummyByte: true,
+    }) as const satisfies Required<Init>)();

package/src/1_22/impl/index.ts

@@ -0,0 +1,8 @@
+export * from "../../1_21/impl/index.js";
+export { Defaults } from "./defaults.js";
+export type { Init } from "./init.js";
+export { parseVideoStreamMetadata } from "./parse-video-stream-metadata.js";
+export {
+    InjectScrollControlMessage,
+    ScrollController,
+} from "./scroll-controller.js";

package/src/{options/1_22 → 1_22/impl}/init.ts

@@ -1,6 +1,6 @@
-import type { ScrcpyOptionsInit1_21 } from "../1_21.js";
+import type { PrevImpl } from "./prev.js";
 
-export interface ScrcpyOptionsInit1_22 extends ScrcpyOptionsInit1_21 {
+export interface Init extends PrevImpl.Init {
     downsizeOnError?: boolean;
 
     /**

package/src/1_22/impl/parse-video-stream-metadata.ts

@@ -0,0 +1,18 @@
+import type { ReadableStream } from "@yume-chan/stream-extra";
+
+import type { ScrcpyVideoStream } from "../../base/video.js";
+import { ScrcpyVideoCodecId } from "../../base/video.js";
+
+import type { Init } from "./init.js";
+import { PrevImpl } from "./prev.js";
+
+export async function parseVideoStreamMetadata(
+    options: Pick<Init, "sendDeviceMeta">,
+    stream: ReadableStream<Uint8Array>,
+): Promise<ScrcpyVideoStream> {
+    if (!options.sendDeviceMeta) {
+        return { stream, metadata: { codec: ScrcpyVideoCodecId.H264 } };
+    } else {
+        return PrevImpl.parseVideoStreamMetadata(stream);
+    }
+}

package/src/1_22/impl/prev.ts

@@ -0,0 +1 @@
+export * as PrevImpl from "../../1_21/impl/index.js";

package/src/1_22/impl/scroll-controller.ts

@@ -0,0 +1,32 @@
+import type { StructInit } from "@yume-chan/struct";
+import { s32, struct } from "@yume-chan/struct";
+
+import type { ScrcpyInjectScrollControlMessage } from "../../latest.js";
+
+import { PrevImpl } from "./prev.js";
+
+export const InjectScrollControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            ...PrevImpl.InjectScrollControlMessage.fields,
+            buttons: s32,
+        },
+        { littleEndian: false },
+    ))();
+
+export type InjectScrollControlMessage = StructInit<
+    typeof InjectScrollControlMessage
+>;
+
+export class ScrollController extends PrevImpl.ScrollController {
+    override serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage,
+    ): Uint8Array | undefined {
+        const processed = this.processMessage(message);
+        if (!processed) {
+            return undefined;
+        }
+
+        return InjectScrollControlMessage.serialize(processed);
+    }
+}

package/src/1_22/index.ts

@@ -0,0 +1,2 @@
+export * as ScrcpyOptions1_22Impl from "./impl/index.js";
+export * from "./options.js";

package/src/1_22/options.ts

@@ -0,0 +1,151 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type {
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} from "../base/index.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+} from "../latest.js";
+
+import type { Init } from "./impl/index.js";
+import {
+    AckClipboardHandler,
+    ClipboardStream,
+    ControlMessageTypes,
+    createMediaStreamTransformer,
+    createScrollController,
+    Defaults,
+    EncoderRegex,
+    parseDisplay,
+    parseEncoder,
+    parseVideoStreamMetadata,
+    serialize,
+    serializeBackOrScreenOnControlMessage,
+    serializeInjectTouchControlMessage,
+    setListDisplays,
+    setListEncoders,
+} from "./impl/index.js";
+
+export class ScrcpyOptions1_22 implements ScrcpyOptions<Init> {
+    static readonly Defaults = Defaults;
+
+    readonly value: Required<Init>;
+
+    get controlMessageTypes(): readonly ScrcpyControlMessageType[] {
+        return ControlMessageTypes;
+    }
+
+    #clipboard: ClipboardStream | undefined;
+    get clipboard(): ReadableStream<string> | undefined {
+        return this.#clipboard;
+    }
+
+    #ackClipboardHandler: AckClipboardHandler | undefined;
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        if (this.value.control && this.value.clipboardAutosync) {
+            this.#clipboard = new ClipboardStream();
+            this.#ackClipboardHandler = new AckClipboardHandler();
+        }
+    }
+
+    serialize(): string[] {
+        return serialize(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, EncoderRegex);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(this.value, stream);
+    }
+
+    async parseDeviceMessage(
+        id: number,
+        stream: AsyncExactReadable,
+    ): Promise<void> {
+        if (await this.#clipboard?.parse(id, stream)) {
+            return;
+        }
+
+        if (await this.#ackClipboardHandler?.parse(id, stream)) {
+            return;
+        }
+
+        throw new Error("Unknown device message");
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        if (e) {
+            this.#clipboard?.error(e);
+            this.#ackClipboardHandler?.error(e);
+        } else {
+            this.#clipboard?.close();
+            this.#ackClipboardHandler?.close();
+        }
+    }
+
+    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();
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions1_22 {
+    export type Init = Init_;
+}