@yume-chan/scrcpy 0.0.24 → 1.0.0

package/src/3_0/options.ts

@@ -0,0 +1,187 @@
+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 {
+    ScrcpyAudioStreamMetadata,
+    ScrcpyControlMessageType,
+    ScrcpyDisplay,
+    ScrcpyEncoder,
+    ScrcpyMediaStreamPacket,
+    ScrcpyOptions,
+    ScrcpyScrollController,
+    ScrcpyVideoStream,
+} 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_0 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;
+
+    #uHidOutput: UHidOutputStream | undefined;
+    get uHidOutput():
+        | ReadableStream<ScrcpyUHidOutputDeviceMessage>
+        | undefined {
+        return this.#uHidOutput;
+    }
+
+    constructor(init: Init) {
+        this.value = { ...Defaults, ...init };
+
+        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 = new ClipboardStream();
+                this.#ackClipboardHandler = new AckClipboardHandler();
+            }
+
+            this.#uHidOutput = new UHidOutputStream();
+        }
+    }
+
+    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);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return parseVideoStreamMetadata(this.value, stream);
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        return parseAudioStreamMetadata(stream, this.value);
+    }
+
+    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();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        return serializeUHidCreateControlMessage(message);
+    }
+}
+
+type Init_ = Init;
+
+export namespace ScrcpyOptions3_0 {
+    export type Init = Init_;
+}

package/src/android/index.ts

@@ -0,0 +1,3 @@
+export * from "./key-event.js";
+export * from "./motion-event.js";
+export * from "./screen-power-mode.js";

package/src/android/key-event.ts

@@ -0,0 +1,218 @@
+export const AndroidKeyEventAction = {
+    Down: 0,
+    Up: 1,
+} as const;
+
+export type AndroidKeyEventAction =
+    (typeof AndroidKeyEventAction)[keyof typeof AndroidKeyEventAction];
+
+// https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/KeyEvent.java;l=993;drc=95c1165bb895dd844e1793460710f7163dd330a3
+export const AndroidKeyEventMeta = {
+    None: 0,
+    Alt: 0x02,
+    AltLeft: 0x10,
+    AltRight: 0x20,
+    Shift: 0x01,
+    ShiftLeft: 0x40,
+    ShiftRight: 0x80,
+    Ctrl: 0x1000,
+    CtrlLeft: 0x2000,
+    CtrlRight: 0x4000,
+    Meta: 0x10000,
+    MetaLeft: 0x20000,
+    MetaRight: 0x40000,
+    CapsLock: 0x100000,
+    NumLock: 0x200000,
+    ScrollLock: 0x400000,
+} as const;
+
+export type AndroidKeyEventMeta =
+    (typeof AndroidKeyEventMeta)[keyof typeof AndroidKeyEventMeta];
+
+// https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/KeyEvent.java;l=97;drc=95c1165bb895dd844e1793460710f7163dd330a3
+// Most names follow Web API `KeyboardEvent.code`,
+// Android-only (not exist in HID keyboard standard) keys are prefixed by `Android`.
+export const AndroidKeyCode = {
+    AndroidHome: 3,
+    AndroidBack: 4,
+    AndroidCall: 5,
+    AndroidEndCall: 6,
+
+    Digit0: 7,
+    Digit1: 8,
+    Digit2: 9,
+    Digit3: 10,
+    Digit4: 11,
+    Digit5: 12,
+    Digit6: 13,
+    Digit7: 14,
+    Digit8: 15,
+    Digit9: 16,
+    /**
+     * '*' key.
+     */
+    Star: 17, // Name not verified
+    /**
+     * '#' key.
+     */
+    Pound: 18, // Name not verified
+
+    /**
+     * Directional Pad Up key.
+     */
+    ArrowUp: 19,
+    /**
+     * Directional Pad Down key.
+     */
+    ArrowDown: 20,
+    /**
+     * Directional Pad Left key.
+     */
+    ArrowLeft: 21,
+    /**
+     * Directional Pad Right key.
+     */
+    ArrowRight: 22,
+    /**
+     * Directional Pad Center key.
+     */
+    AndroidDPadCenter: 23,
+
+    VolumeUp: 24, // Name not verified
+    VolumeDown: 25, // Name not verified
+    Power: 26, // Name not verified
+    AndroidCamera: 27,
+    Clear: 28, // Name not verified
+
+    KeyA: 29,
+    KeyB: 30,
+    KeyC: 31,
+    KeyD: 32,
+    KeyE: 33,
+    KeyF: 34,
+    KeyG: 35,
+    KeyH: 36,
+    KeyI: 37,
+    KeyJ: 38,
+    KeyK: 39,
+    KeyL: 40,
+    KeyM: 41,
+    KeyN: 42,
+    KeyO: 43,
+    KeyP: 44,
+    KeyQ: 45,
+    KeyR: 46,
+    KeyS: 47,
+    KeyT: 48,
+    KeyU: 49,
+    KeyV: 50,
+    KeyW: 51,
+    KeyX: 52,
+    KeyY: 53,
+    KeyZ: 54,
+    Comma: 55,
+    Period: 56,
+    AltLeft: 57,
+    AltRight: 58,
+    ShiftLeft: 59,
+    ShiftRight: 60,
+    Tab: 61,
+    Space: 62,
+    AndroidSymbol: 63,
+    AndroidExplorer: 64,
+    AndroidEnvelope: 65,
+    Enter: 66,
+    Backspace: 67,
+    Backquote: 68,
+    Minus: 69,
+    Equal: 70,
+    BracketLeft: 71,
+    BracketRight: 72,
+    Backslash: 73,
+    Semicolon: 74,
+    Quote: 75,
+    Slash: 76,
+    At: 77, // Name not verified
+
+    AndroidNum: 78,
+    AndroidHeadsetHook: 79,
+    /**
+     * Camera Focus key。
+     */
+    AndroidFocus: 80,
+
+    Plus: 81, // Name not verified
+    ContextMenu: 82,
+    AndroidNotification: 83,
+    AndroidSearch: 84,
+
+    PageUp: 92,
+    PageDown: 93,
+
+    Escape: 111,
+    Delete: 112,
+    ControlLeft: 113,
+    ControlRight: 114,
+    CapsLock: 115,
+    ScrollLock: 116,
+    MetaLeft: 117,
+    MetaRight: 118,
+    AndroidFunction: 119,
+    PrintScreen: 120,
+    Pause: 121,
+
+    Home: 122,
+    End: 123,
+    Insert: 124,
+    AndroidForward: 125,
+
+    F1: 131,
+    F2: 132,
+    F3: 133,
+    F4: 134,
+    F5: 135,
+    F6: 136,
+    F7: 137,
+    F8: 138,
+    F9: 139,
+    F10: 140,
+    F11: 141,
+    F12: 142,
+
+    NumLock: 143,
+    Numpad0: 144,
+    Numpad1: 145,
+    Numpad2: 146,
+    Numpad3: 147,
+    Numpad4: 148,
+    Numpad5: 149,
+    Numpad6: 150,
+    Numpad7: 151,
+    Numpad8: 152,
+    Numpad9: 153,
+    NumpadDivide: 154,
+    NumpadMultiply: 155,
+    NumpadSubtract: 156,
+    NumpadAdd: 157,
+    NumpadDecimal: 158,
+    NumpadComma: 159, // Name not verified
+    NumpadEnter: 160,
+    NumpadEquals: 161, // Name not verified
+    NumpadLeftParen: 162, // Name not verified
+    NumpadRightParen: 163, // Name not verified
+
+    VolumeMute: 164, // Name not verified
+    AndroidAppSwitch: 187, // Name not verified
+
+    AndroidCut: 277,
+    AndroidCopy: 278,
+    AndroidPaste: 279,
+} as const;
+
+export type AndroidKeyCode =
+    (typeof AndroidKeyCode)[keyof typeof AndroidKeyCode];
+
+export const AndroidKeyNames = /* #__PURE__ */ (() =>
+    Object.fromEntries(
+        Object.entries(AndroidKeyCode).map(([k, v]) => [v, k]),
+    ) as Record<AndroidKeyCode, string>)();

package/src/android/motion-event.ts

@@ -0,0 +1,33 @@
+// https://developer.android.com/reference/android/view/MotionEvent#constants_1
+export const AndroidMotionEventAction = {
+    Down: 0,
+    Up: 1,
+    Move: 2,
+    Cancel: 3,
+    Outside: 4,
+    PointerDown: 5,
+    PointerUp: 6,
+    HoverMove: 7,
+    Scroll: 8,
+    HoverEnter: 9,
+    HoverExit: 10,
+    ButtonPress: 11,
+    ButtonRelease: 12,
+} as const;
+
+export type AndroidMotionEventAction =
+    (typeof AndroidMotionEventAction)[keyof typeof AndroidMotionEventAction];
+
+export const AndroidMotionEventButton = {
+    None: 0,
+    Primary: 1,
+    Secondary: 2,
+    Tertiary: 4,
+    Back: 8,
+    Forward: 16,
+    StylusPrimary: 32,
+    StylusSecondary: 64,
+} as const;
+
+export type AndroidMotionEventButton =
+    (typeof AndroidMotionEventButton)[keyof typeof AndroidMotionEventButton];

package/src/android/screen-power-mode.ts

@@ -0,0 +1,8 @@
+// https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/SurfaceControl.java;l=659;drc=20303e05bf73796124ab70a279cf849b61b97905
+export const AndroidScreenPowerMode = {
+    Off: 0,
+    Normal: 2,
+} as const;
+
+export type AndroidScreenPowerMode =
+    (typeof AndroidScreenPowerMode)[keyof typeof AndroidScreenPowerMode];

package/src/{options/codec.ts → base/audio.ts}

@@ -1,45 +1,27 @@
 import type { ReadableStream } from "@yume-chan/stream-extra";
 
-import type { ScrcpyOptionValue } from "./types.js";
-
-export enum ScrcpyVideoCodecId {
-    H264 = 0x68_32_36_34,
-    H265 = 0x68_32_36_35,
-    AV1 = 0x00_61_76_31,
-}
-
-export interface ScrcpyVideoStreamMetadata {
-    deviceName?: string | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-    codec: ScrcpyVideoCodecId;
-}
-
-export interface ScrcpyVideoStream {
-    readonly stream: ReadableStream<Uint8Array>;
-    readonly metadata: ScrcpyVideoStreamMetadata;
-}
+import type { ScrcpyOptionValue } from "./option-value.js";
 
 export class ScrcpyAudioCodec implements ScrcpyOptionValue {
-    static readonly OPUS = new ScrcpyAudioCodec(
+    static readonly Opus = /* #__PURE__ */ new ScrcpyAudioCodec(
         "opus",
         0x6f_70_75_73,
         "audio/opus",
         "opus",
     );
-    static readonly AAC = new ScrcpyAudioCodec(
+    static readonly Aac = /* #__PURE__ */ new ScrcpyAudioCodec(
         "aac",
         0x00_61_61_63,
         "audio/aac",
         "mp4a.66",
     );
-    static readonly FLAC = new ScrcpyAudioCodec(
+    static readonly Flac = /* #__PURE__ */ new ScrcpyAudioCodec(
         "flac",
         0x66_6c_61_63,
         "audio/flac",
         "flac",
     );
-    static readonly RAW = new ScrcpyAudioCodec(
+    static readonly Raw = /* #__PURE__ */ new ScrcpyAudioCodec(
         "raw",
         0x00_72_61_77,
         "audio/raw",
@@ -86,19 +68,3 @@ export type ScrcpyAudioStreamMetadata =
     | ScrcpyAudioStreamDisabledMetadata
     | ScrcpyAudioStreamErroredMetadata
     | ScrcpyAudioStreamSuccessMetadata;
-
-export interface ScrcpyMediaStreamConfigurationPacket {
-    type: "configuration";
-    data: Uint8Array;
-}
-
-export interface ScrcpyMediaStreamDataPacket {
-    type: "data";
-    keyframe?: boolean;
-    pts?: bigint;
-    data: Uint8Array;
-}
-
-export type ScrcpyMediaStreamPacket =
-    | ScrcpyMediaStreamConfigurationPacket
-    | ScrcpyMediaStreamDataPacket;

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

@@ -0,0 +1,24 @@
+// Their IDs change between versions, so always use `options.getControlMessageTypes()`
+export const ScrcpyControlMessageType = {
+    InjectKeyCode: 0,
+    InjectText: 1,
+    InjectTouch: 2,
+    InjectScroll: 3,
+    BackOrScreenOn: 4,
+    ExpandNotificationPanel: 5,
+    ExpandSettingPanel: 6,
+    CollapseNotificationPanel: 7,
+    GetClipboard: 8,
+    SetClipboard: 9,
+    SetDisplayPower: 10,
+    RotateDevice: 11,
+    UHidCreate: 12,
+    UHidInput: 13,
+    UHidDestroy: 14,
+    OpenHardKeyboardSettings: 15,
+    StartApp: 16,
+    ResetVideo: 17,
+} as const;
+
+export type ScrcpyControlMessageType =
+    (typeof ScrcpyControlMessageType)[keyof typeof ScrcpyControlMessageType];

package/src/base/device-message.ts

@@ -0,0 +1,9 @@
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+export interface ScrcpyDeviceMessageParser {
+    parse(id: number, stream: AsyncExactReadable): Promise<boolean>;
+
+    close(): void;
+
+    error(e?: unknown): void;
+}

package/src/base/display.ts

@@ -0,0 +1,5 @@
+export interface ScrcpyDisplay {
+    id: number;
+
+    resolution?: string;
+}

package/src/base/encoder.ts

@@ -0,0 +1,8 @@
+export interface ScrcpyEncoder {
+    type: "video" | "audio";
+    name: string;
+    codec?: string;
+    hardwareType?: "hardware" | "software" | "hybrid" | undefined;
+    vendor?: boolean | undefined;
+    aliasFor?: string | undefined;
+}

package/src/base/index.ts

@@ -0,0 +1,10 @@
+export * from "./audio.js";
+export * from "./control-message-type.js";
+export * from "./device-message.js";
+export * from "./display.js";
+export * from "./encoder.js";
+export * from "./media.js";
+export * from "./option-value.js";
+export * from "./options.js";
+export * from "./scroll-controller.js";
+export * from "./video.js";

package/src/base/media.ts

@@ -0,0 +1,15 @@
+export interface ScrcpyMediaStreamConfigurationPacket {
+    type: "configuration";
+    data: Uint8Array;
+}
+
+export interface ScrcpyMediaStreamDataPacket {
+    type: "data";
+    keyframe?: boolean;
+    pts?: bigint;
+    data: Uint8Array;
+}
+
+export type ScrcpyMediaStreamPacket =
+    | ScrcpyMediaStreamConfigurationPacket
+    | ScrcpyMediaStreamDataPacket;

package/src/base/option-value.ts

@@ -0,0 +1,35 @@
+export interface ScrcpyOptionValue {
+    toOptionValue(): string | undefined;
+}
+
+export function isScrcpyOptionValue(
+    value: unknown,
+): value is ScrcpyOptionValue {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        "toOptionValue" in value &&
+        typeof value.toOptionValue === "function"
+    );
+}
+
+export function toScrcpyOptionValue<T>(value: unknown, empty: T): string | T {
+    if (isScrcpyOptionValue(value)) {
+        value = value.toOptionValue();
+    }
+
+    // `value` may become `undefined` after `toOptionValue`
+    if (value === undefined) {
+        return empty;
+    }
+
+    if (
+        typeof value !== "string" &&
+        typeof value !== "number" &&
+        typeof value !== "boolean"
+    ) {
+        throw new TypeError(`Invalid option value: ${String(value)}`);
+    }
+
+    return String(value);
+}