@yume-chan/scrcpy 0.0.23 → 1.0.0

package/src/control/serializer.ts

@@ -1,36 +1,41 @@
 import type {
-    ScrcpyOptions,
-    ScrcpyScrollController,
-} from "../options/index.js";
-
-import { BasicControlMessage } from "./basic.js";
-import type { AndroidKeyEventAction } from "./inject-keycode.js";
-import { ScrcpyInjectKeyCodeControlMessage } from "./inject-keycode.js";
-import type { ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
+    AndroidKeyEventAction,
+    AndroidScreenPowerMode,
+} from "../android/index.js";
+import type { ScrcpyOptions, ScrcpyScrollController } from "../base/index.js";
+import { ScrcpyControlMessageType } from "../base/index.js";
+import type {
+    ScrcpyInjectScrollControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpyUHidCreateControlMessage,
+} from "../latest.js";
+
+import { EmptyControlMessage } from "./empty.js";
+import { ScrcpyInjectKeyCodeControlMessage } from "./inject-key-code.js";
 import { ScrcpyInjectTextControlMessage } from "./inject-text.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 { ScrcpyControlMessageTypeMap } from "./message-type-map.js";
+import { ScrcpySetDisplayPowerControlMessage } from "./set-screen-power-mode.js";
+import { ScrcpyStartAppControlMessage } from "./start-app.js";
 import {
-    ScrcpyControlMessageType,
-    ScrcpyControlMessageTypeValue,
-} from "./type.js";
+    ScrcpyUHidDestroyControlMessage,
+    ScrcpyUHidInputControlMessage,
+} from "./uhid.js";
 
 export class ScrcpyControlMessageSerializer {
     #options: ScrcpyOptions<object>;
-    #typeValues: ScrcpyControlMessageTypeValue;
+    #typeMap: ScrcpyControlMessageTypeMap;
     #scrollController: ScrcpyScrollController;
 
     constructor(options: ScrcpyOptions<object>) {
         this.#options = options;
-        this.#typeValues = new ScrcpyControlMessageTypeValue(options);
+        this.#typeMap = new ScrcpyControlMessageTypeMap(options);
         this.#scrollController = options.createScrollController();
     }
 
     injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">) {
         return ScrcpyInjectKeyCodeControlMessage.serialize(
-            this.#typeValues.fillMessageType(
+            this.#typeMap.fillMessageType(
                 message,
                 ScrcpyControlMessageType.InjectKeyCode,
             ),
@@ -40,7 +45,7 @@ export class ScrcpyControlMessageSerializer {
     injectText(text: string) {
         return ScrcpyInjectTextControlMessage.serialize({
             text,
-            type: this.#typeValues.get(ScrcpyControlMessageType.InjectText),
+            type: this.#typeMap.get(ScrcpyControlMessageType.InjectText),
         });
     }
 
@@ -49,7 +54,7 @@ export class ScrcpyControlMessageSerializer {
      */
     injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
         return this.#options.serializeInjectTouchControlMessage(
-            this.#typeValues.fillMessageType(
+            this.#typeMap.fillMessageType(
                 message,
                 ScrcpyControlMessageType.InjectTouch,
             ),
@@ -61,7 +66,7 @@ export class ScrcpyControlMessageSerializer {
      */
     injectScroll(message: Omit<ScrcpyInjectScrollControlMessage, "type">) {
         return this.#scrollController.serializeScrollMessage(
-            this.#typeValues.fillMessageType(
+            this.#typeMap.fillMessageType(
                 message,
                 ScrcpyControlMessageType.InjectScroll,
             ),
@@ -71,46 +76,103 @@ export class ScrcpyControlMessageSerializer {
     backOrScreenOn(action: AndroidKeyEventAction) {
         return this.#options.serializeBackOrScreenOnControlMessage({
             action,
-            type: this.#typeValues.get(ScrcpyControlMessageType.BackOrScreenOn),
+            type: this.#typeMap.get(ScrcpyControlMessageType.BackOrScreenOn),
         });
     }
 
-    setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        return ScrcpySetScreenPowerModeControlMessage.serialize({
+    setDisplayPower(mode: AndroidScreenPowerMode) {
+        return ScrcpySetDisplayPowerControlMessage.serialize({
             mode,
-            type: this.#typeValues.get(
-                ScrcpyControlMessageType.SetScreenPowerMode,
-            ),
+            type: this.#typeMap.get(ScrcpyControlMessageType.SetDisplayPower),
         });
     }
 
     expandNotificationPanel() {
-        return BasicControlMessage.serialize({
-            type: this.#typeValues.get(
+        return EmptyControlMessage.serialize({
+            type: this.#typeMap.get(
                 ScrcpyControlMessageType.ExpandNotificationPanel,
             ),
         });
     }
 
     expandSettingPanel() {
-        return BasicControlMessage.serialize({
-            type: this.#typeValues.get(
+        return EmptyControlMessage.serialize({
+            type: this.#typeMap.get(
                 ScrcpyControlMessageType.ExpandSettingPanel,
             ),
         });
     }
 
     collapseNotificationPanel() {
-        return BasicControlMessage.serialize({
-            type: this.#typeValues.get(
+        return EmptyControlMessage.serialize({
+            type: this.#typeMap.get(
                 ScrcpyControlMessageType.CollapseNotificationPanel,
             ),
         });
     }
 
     rotateDevice() {
-        return ScrcpyRotateDeviceControlMessage.serialize({
-            type: this.#typeValues.get(ScrcpyControlMessageType.RotateDevice),
+        return EmptyControlMessage.serialize({
+            type: this.#typeMap.get(ScrcpyControlMessageType.RotateDevice),
+        });
+    }
+
+    setClipboard(message: Omit<ScrcpySetClipboardControlMessage, "type">) {
+        return this.#options.serializeSetClipboardControlMessage({
+            ...message,
+            type: this.#typeMap.get(ScrcpyControlMessageType.SetClipboard),
+        });
+    }
+
+    uHidCreate(message: Omit<ScrcpyUHidCreateControlMessage, "type">) {
+        if (!this.#options.serializeUHidCreateControlMessage) {
+            throw new Error("UHid not supported");
+        }
+
+        return this.#options.serializeUHidCreateControlMessage(
+            this.#typeMap.fillMessageType(
+                message,
+                ScrcpyControlMessageType.UHidCreate,
+            ),
+        );
+    }
+
+    uHidInput(message: Omit<ScrcpyUHidInputControlMessage, "type">) {
+        return ScrcpyUHidInputControlMessage.serialize(
+            this.#typeMap.fillMessageType(
+                message,
+                ScrcpyControlMessageType.UHidInput,
+            ),
+        );
+    }
+
+    uHidDestroy(id: number) {
+        return ScrcpyUHidDestroyControlMessage.serialize({
+            type: this.#typeMap.get(ScrcpyControlMessageType.UHidDestroy),
+            id,
+        });
+    }
+
+    startApp(
+        name: string,
+        options?: { forceStop?: boolean; searchByName?: boolean },
+    ) {
+        if (options?.searchByName) {
+            name = "?" + name;
+        }
+        if (options?.forceStop) {
+            name = "+" + name;
+        }
+
+        return ScrcpyStartAppControlMessage.serialize({
+            type: this.#typeMap.get(ScrcpyControlMessageType.StartApp),
+            name,
+        });
+    }
+
+    resetVideo() {
+        return EmptyControlMessage.serialize({
+            type: this.#typeMap.get(ScrcpyControlMessageType.ResetVideo),
         });
     }
 }

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

@@ -1,14 +1,13 @@
-import Struct, { placeholder } from "@yume-chan/struct";
+import type { StructInit } from "@yume-chan/struct";
+import { struct, u8 } 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,
-}
+import type { AndroidScreenPowerMode } from "../android/index.js";
 
-export const ScrcpySetScreenPowerModeControlMessage = new Struct()
-    .uint8("type")
-    .uint8("mode", placeholder<AndroidScreenPowerMode>());
+export const ScrcpySetDisplayPowerControlMessage = struct(
+    { type: u8, mode: u8<AndroidScreenPowerMode>() },
+    { littleEndian: false },
+);
 
-export type ScrcpySetScreenPowerModeControlMessage =
-    (typeof ScrcpySetScreenPowerModeControlMessage)["TInit"];
+export type ScrcpySetScreenPowerModeControlMessage = StructInit<
+    typeof ScrcpySetDisplayPowerControlMessage
+>;

package/src/control/start-app.ts

@@ -0,0 +1,14 @@
+import type { StructInit } from "@yume-chan/struct";
+import { string, struct, u8 } from "@yume-chan/struct";
+
+export const ScrcpyStartAppControlMessage = struct(
+    {
+        type: u8,
+        name: string(u8),
+    },
+    { littleEndian: false },
+);
+
+export type ScrcpyStartAppControlMessage = StructInit<
+    typeof ScrcpyStartAppControlMessage
+>;

package/src/control/uhid.ts

@@ -0,0 +1,27 @@
+import type { StructInit } from "@yume-chan/struct";
+import { buffer, struct, u16, u8 } from "@yume-chan/struct";
+
+import { ScrcpyControlMessageType } from "../base/index.js";
+
+export const ScrcpyUHidInputControlMessage = /* #__PURE__ */ (() =>
+    struct(
+        {
+            type: u8(ScrcpyControlMessageType.UHidInput),
+            id: u16,
+            data: buffer(u16),
+        },
+        { littleEndian: false },
+    ))();
+
+export type ScrcpyUHidInputControlMessage = StructInit<
+    typeof ScrcpyUHidInputControlMessage
+>;
+
+export const ScrcpyUHidDestroyControlMessage = struct(
+    { type: u8, id: u16 },
+    { littleEndian: false },
+);
+
+export type ScrcpyUHidDestroyControlMessage = StructInit<
+    typeof ScrcpyUHidDestroyControlMessage
+>;

package/src/control/writer.ts

@@ -1,19 +1,21 @@
-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 { WritableStreamDefaultWriter } from "@yume-chan/stream-extra";
+import { Consumable } from "@yume-chan/stream-extra";
 
 import type {
     AndroidKeyEventAction,
-    ScrcpyInjectKeyCodeControlMessage,
-} from "./inject-keycode.js";
-import type { ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
-import type { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+    AndroidScreenPowerMode,
+} from "../android/index.js";
+import type { ScrcpyOptions } from "../base/index.js";
+import type {
+    ScrcpyInjectScrollControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpyUHidCreateControlMessage,
+} from "../latest.js";
+
+import type { ScrcpyInjectKeyCodeControlMessage } from "./inject-key-code.js";
 import { ScrcpyControlMessageSerializer } from "./serializer.js";
-import type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
+import type { ScrcpyUHidInputControlMessage } from "./uhid.js";
 
 export class ScrcpyControlMessageWriter {
     #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
@@ -27,25 +29,23 @@ export class ScrcpyControlMessageWriter {
         this.#serializer = new ScrcpyControlMessageSerializer(options);
     }
 
-    async write(message: Uint8Array) {
-        await ConsumableWritableStream.write(this.#writer, message);
+    write(message: Uint8Array) {
+        return Consumable.WritableStream.write(this.#writer, message);
     }
 
-    async injectKeyCode(
-        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">,
-    ) {
-        await this.write(this.#serializer.injectKeyCode(message));
+    injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">) {
+        return this.write(this.#serializer.injectKeyCode(message));
     }
 
-    async injectText(text: string) {
-        await this.write(this.#serializer.injectText(text));
+    injectText(text: string) {
+        return this.write(this.#serializer.injectText(text));
     }
 
     /**
      * `pressure` is a float value between 0 and 1.
      */
-    async injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
-        await this.write(this.#serializer.injectTouch(message));
+    injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        return this.write(this.#serializer.injectTouch(message));
     }
 
     /**
@@ -67,24 +67,59 @@ export class ScrcpyControlMessageWriter {
         }
     }
 
-    async setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        await this.write(this.#serializer.setScreenPowerMode(mode));
+    setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        return this.write(this.#serializer.setDisplayPower(mode));
+    }
+
+    expandNotificationPanel() {
+        return this.write(this.#serializer.expandNotificationPanel());
+    }
+
+    expandSettingPanel() {
+        return this.write(this.#serializer.expandSettingPanel());
+    }
+
+    collapseNotificationPanel() {
+        return this.write(this.#serializer.collapseNotificationPanel());
+    }
+
+    rotateDevice() {
+        return this.write(this.#serializer.rotateDevice());
+    }
+
+    async setClipboard(
+        message: Omit<ScrcpySetClipboardControlMessage, "type">,
+    ) {
+        const result = this.#serializer.setClipboard(message);
+        if (result instanceof Uint8Array) {
+            await this.write(result);
+        } else {
+            await this.write(result[0]);
+            await result[1];
+        }
+    }
+
+    uHidCreate(message: Omit<ScrcpyUHidCreateControlMessage, "type">) {
+        return this.write(this.#serializer.uHidCreate(message));
     }
 
-    async expandNotificationPanel() {
-        await this.write(this.#serializer.expandNotificationPanel());
+    uHidInput(message: Omit<ScrcpyUHidInputControlMessage, "type">) {
+        return this.write(this.#serializer.uHidInput(message));
     }
 
-    async expandSettingPanel() {
-        await this.write(this.#serializer.expandSettingPanel());
+    uHidDestroy(id: number) {
+        return this.write(this.#serializer.uHidDestroy(id));
     }
 
-    async collapseNotificationPanel() {
-        await this.write(this.#serializer.collapseNotificationPanel());
+    startApp(
+        name: string,
+        options?: { forceStop?: boolean; searchByName?: boolean },
+    ) {
+        return this.write(this.#serializer.startApp(name, options));
     }
 
-    async rotateDevice() {
-        await this.write(this.#serializer.rotateDevice());
+    resetVideo() {
+        return this.write(this.#serializer.resetVideo());
     }
 
     releaseLock() {

package/src/index.ts

@@ -1,4 +1,26 @@
+export * from "./1_15/index.js";
+export * from "./1_16.js";
+export * from "./1_17/index.js";
+export * from "./1_18/index.js";
+export * from "./1_19.js";
+export * from "./1_20.js";
+export * from "./1_21/index.js";
+export * from "./1_22/index.js";
+export * from "./1_23/index.js";
+export * from "./1_24/index.js";
+export * from "./1_25/index.js";
+export * from "./2_0/index.js";
+export * from "./2_1/index.js";
+export * from "./2_2/index.js";
+export * from "./2_3/index.js";
+export * from "./2_4/index.js";
+export * from "./2_5.js";
+export * from "./2_6/index.js";
+export * from "./2_7/index.js";
+export * from "./3_0/index.js";
+export * from "./android/index.js";
+export * from "./base/index.js";
 export * from "./codec/index.js";
 export * from "./control/index.js";
-export * from "./device-message/index.js";
-export * from "./options/index.js";
+export * from "./latest.js";
+export * from "./utils/index.js";

package/src/latest.ts

@@ -0,0 +1,15 @@
+export {
+    BackOrScreenOnControlMessage as ScrcpyBackOrScreenOnControlMessage,
+    CaptureOrientation as ScrcpyCaptureOrientation,
+    CodecOptions as ScrcpyCodecOptions,
+    InjectScrollControlMessage as ScrcpyInjectScrollControlMessage,
+    InjectTouchControlMessage as ScrcpyInjectTouchControlMessage,
+    InstanceId as ScrcpyInstanceId,
+    LockOrientation as ScrcpyLockOrientation,
+    NewDisplay as ScrcpyNewDisplay,
+    Orientation as ScrcpyOrientation,
+    PointerId as ScrcpyPointerId,
+    SetClipboardControlMessage as ScrcpySetClipboardControlMessage,
+    UHidCreateControlMessage as ScrcpyUHidCreateControlMessage,
+    UHidOutputDeviceMessage as ScrcpyUHidOutputDeviceMessage,
+} from "./3_0/impl/index.js";

package/src/utils/clamp.ts

@@ -0,0 +1,11 @@
+export function clamp(value: number, min: number, max: number): number {
+    if (value < min) {
+        return min;
+    }
+
+    if (value > max) {
+        return max;
+    }
+
+    return value;
+}

package/src/utils/constants.ts

@@ -0,0 +1 @@
+export const DefaultServerPath = "/data/local/tmp/scrcpy-server.jar";

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./clamp.js";
+export * from "./constants.js";
+export * from "./omit.js";
+export * from "./wrapper.js";

package/src/utils/omit.ts

@@ -0,0 +1,11 @@
+/* #__NO_SIDE_EFFECTS__ */
+export function omit<T extends Record<string, unknown>, K extends (keyof T)[]>(
+    value: T,
+    ...keys: K
+): T {
+    return Object.fromEntries(
+        Object.entries(value).filter(
+            ([key]) => !keys.includes(key as K[number]),
+        ),
+    ) as never;
+}

package/src/utils/wrapper.ts

@@ -0,0 +1,131 @@
+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 } from "../base/audio.js";
+import type { ScrcpyEncoder } from "../base/encoder.js";
+import type { ScrcpyMediaStreamPacket } from "../base/media.js";
+import type { ScrcpyOptions } from "../base/options.js";
+import type { ScrcpyScrollController } from "../base/scroll-controller.js";
+import type { ScrcpyVideoStream } from "../base/video.js";
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyInjectTouchControlMessage,
+    ScrcpySetClipboardControlMessage,
+    ScrcpyUHidCreateControlMessage,
+} from "../latest.js";
+
+export class ScrcpyOptionsWrapper<T extends object>
+    implements ScrcpyOptions<T>
+{
+    #base: ScrcpyOptions<T>;
+
+    get controlMessageTypes() {
+        return this.#base.controlMessageTypes;
+    }
+
+    get value() {
+        return this.#base.value;
+    }
+
+    get clipboard() {
+        return this.#base.clipboard;
+    }
+
+    get uHidOutput() {
+        return this.#base.uHidOutput;
+    }
+
+    constructor(options: ScrcpyOptions<T>) {
+        this.#base = options;
+    }
+
+    serialize(): string[] {
+        return this.#base.serialize();
+    }
+
+    setListDisplays() {
+        this.#base.setListDisplays();
+    }
+
+    parseDisplay(line: string) {
+        return this.#base.parseDisplay(line);
+    }
+
+    setListEncoders(): void {
+        if (!this.#base.setListEncoders) {
+            throw new Error("setListEncoders is not implemented");
+        }
+        this.#base.setListEncoders();
+    }
+
+    parseEncoder(line: string): ScrcpyEncoder | undefined {
+        if (!this.#base.parseEncoder) {
+            throw new Error("parseEncoder is not implemented");
+        }
+        return this.#base.parseEncoder(line);
+    }
+
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyVideoStream> {
+        return this.#base.parseVideoStreamMetadata(stream);
+    }
+
+    parseAudioStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
+    ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
+        if (!this.#base.parseAudioStreamMetadata) {
+            throw new Error("parseAudioStreamMetadata is not implemented");
+        }
+        return this.#base.parseAudioStreamMetadata(stream);
+    }
+
+    parseDeviceMessage(id: number, stream: AsyncExactReadable): Promise<void> {
+        return this.#base.parseDeviceMessage(id, stream);
+    }
+
+    endDeviceMessageStream(e?: unknown): void {
+        this.#base.endDeviceMessageStream(e);
+    }
+
+    createMediaStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyMediaStreamPacket
+    > {
+        return this.#base.createMediaStreamTransformer();
+    }
+
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
+    ): Uint8Array {
+        return this.#base.serializeInjectTouchControlMessage(message);
+    }
+
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
+    ): Uint8Array | undefined {
+        return this.#base.serializeBackOrScreenOnControlMessage(message);
+    }
+
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
+    ): Uint8Array | [Uint8Array, Promise<void>] {
+        return this.#base.serializeSetClipboardControlMessage(message);
+    }
+
+    createScrollController(): ScrcpyScrollController {
+        return this.#base.createScrollController();
+    }
+
+    serializeUHidCreateControlMessage(
+        message: ScrcpyUHidCreateControlMessage,
+    ): Uint8Array {
+        if (!this.#base.serializeUHidCreateControlMessage) {
+            throw new Error(
+                "serializeUHidCreateControlMessage is not implemented",
+            );
+        }
+        return this.#base.serializeUHidCreateControlMessage(message);
+    }
+}

package/tsconfig.build.json

@@ -6,6 +6,6 @@
         },
         {
             "path": "../struct/tsconfig.build.json"
-        },
+        }
     ]
 }