@yume-chan/scrcpy 0.0.16 → 0.0.18

package/src/adb/connection.ts

@@ -0,0 +1,192 @@
+import { type Adb } from "@yume-chan/adb";
+import { delay } from "@yume-chan/async";
+import { type Disposable } from "@yume-chan/event";
+import {
+    TransformStream,
+    type ReadableStream,
+    type ReadableStreamDefaultReader,
+    type ReadableWritablePair,
+} from "@yume-chan/stream-extra";
+import { type ValueOrPromise } from "@yume-chan/struct";
+
+export interface AdbScrcpyConnectionOptions {
+    control: boolean;
+
+    /**
+     * Write a byte on start to detect connection issues
+     */
+    sendDummyByte: boolean;
+
+    /**
+     * Send device name and size
+     */
+    sendDeviceMeta: boolean;
+}
+
+export abstract class AdbScrcpyConnection implements Disposable {
+    protected adb: Adb;
+
+    protected options: AdbScrcpyConnectionOptions;
+
+    public constructor(adb: Adb, options: AdbScrcpyConnectionOptions) {
+        this.adb = adb;
+        this.options = options;
+    }
+
+    public initialize(): ValueOrPromise<void> {
+        // do nothing
+    }
+
+    public abstract getStreams(): ValueOrPromise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    >;
+
+    public dispose(): void {
+        // do nothing
+    }
+}
+
+export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
+    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        return this.adb.createSocket("localabstract:scrcpy");
+    }
+
+    private async connectAndRetry(): Promise<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    > {
+        for (let i = 0; i < 100; i += 1) {
+            try {
+                return await this.connect();
+            } catch (e) {
+                await delay(100);
+            }
+        }
+        throw new Error(`Can't connect to server after 100 retries`);
+    }
+
+    private async connectVideoStream(): Promise<ReadableStream<Uint8Array>> {
+        const { readable: videoStream } = await this.connectAndRetry();
+        if (this.options.sendDummyByte) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // server will write a `0` to signal connection success
+            if (done || value.byteLength !== 1 || value[0] !== 0) {
+                throw new Error("Unexpected response from server");
+            }
+            reader.releaseLock();
+        }
+        return videoStream;
+    }
+
+    public async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    > {
+        const videoStream = await this.connectVideoStream();
+
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | undefined;
+        if (this.options.control) {
+            controlStream = await this.connectAndRetry();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error("Unexpected response from server");
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+}
+
+export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
+    private streams!: ReadableStreamDefaultReader<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    >;
+
+    private address!: string;
+
+    public override async initialize(): Promise<void> {
+        // try to unbind first, ignore errors
+        await this.adb.reverse.remove("localabstract:scrcpy").catch((e) => {
+            void e;
+        });
+
+        const queue = new TransformStream<
+            ReadableWritablePair<Uint8Array, Uint8Array>,
+            ReadableWritablePair<Uint8Array, Uint8Array>
+        >();
+        this.streams = queue.readable.getReader();
+        const writer = queue.writable.getWriter();
+        this.address = await this.adb.reverse.add(
+            "localabstract:scrcpy",
+            "tcp:27183",
+            (socket) => {
+                void writer.write(socket);
+                return true;
+            }
+        );
+    }
+
+    private async accept(): Promise<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    > {
+        return (await this.streams.read()).value!;
+    }
+
+    public async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    > {
+        const { readable: videoStream } = await this.accept();
+
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | undefined;
+        if (this.options.control) {
+            controlStream = await this.accept();
+        }
+
+        // Server only writes device meta after control socket is connected (if enabled)
+        if (this.options.sendDeviceMeta) {
+            const reader = videoStream.getReader();
+            const { done, value } = await reader.read();
+            // 64 bytes device name + 2 bytes video width + 2 bytes video height
+            if (done || value.byteLength !== 64 + 2 + 2) {
+                throw new Error("Unexpected response from server");
+            }
+            reader.releaseLock();
+        }
+
+        return [videoStream, controlStream];
+    }
+
+    public override dispose() {
+        // Don't await this!
+        // `reverse.remove`'s response will never arrive
+        // before we read all pending data from `videoStream`
+        this.adb.reverse.remove(this.address).catch((e) => {
+            void e;
+        });
+    }
+}

package/src/adb/index.ts

@@ -0,0 +1,3 @@
+export * from './options/index.js';
+export * from './client.js';
+export * from './connection.js';

package/src/adb/options/1_16.ts

@@ -0,0 +1,30 @@
+import { type Adb } from "@yume-chan/adb";
+
+import { type ScrcpyOptionsInit1_16 } from "../../options/index.js";
+import {
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+    type AdbScrcpyConnection,
+    type AdbScrcpyConnectionOptions,
+} from "../connection.js";
+
+import { AdbScrcpyOptionsBase } from "./types.js";
+
+export class AdbScrcpyOptions1_16<
+    T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16
+> extends AdbScrcpyOptionsBase<T> {
+    public override createConnection(adb: Adb): AdbScrcpyConnection {
+        const options: AdbScrcpyConnectionOptions = {
+            // Old versions always have control stream no matter what the option is
+            // Pass `control: false` to `Connection` will disable the control stream
+            control: true,
+            sendDummyByte: true,
+            sendDeviceMeta: true,
+        };
+        if (this.value.tunnelForward) {
+            return new AdbScrcpyForwardConnection(adb, options);
+        } else {
+            return new AdbScrcpyReverseConnection(adb, options);
+        }
+    }
+}

package/src/adb/options/1_22.ts

@@ -0,0 +1,26 @@
+import { type Adb } from "@yume-chan/adb";
+
+import { type ScrcpyOptionsInit1_22 } from "../../options/index.js";
+import {
+    type AdbScrcpyConnection,
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+} from "../connection.js";
+
+import { AdbScrcpyOptions1_16 } from "./1_16.js";
+
+export class AdbScrcpyOptions1_22<
+    T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22
+> extends AdbScrcpyOptions1_16<T> {
+    public override createConnection(adb: Adb): AdbScrcpyConnection {
+        const options = {
+            ...this.getDefaultValue(),
+            ...this.value,
+        };
+        if (this.value.tunnelForward) {
+            return new AdbScrcpyForwardConnection(adb, options);
+        } else {
+            return new AdbScrcpyReverseConnection(adb, options);
+        }
+    }
+}

package/src/adb/options/index.ts

@@ -0,0 +1,3 @@
+export * from './1_16.js';
+export * from './1_22.js';
+export * from './types.js';

package/src/adb/options/types.ts

@@ -0,0 +1,75 @@
+import { type Adb } from "@yume-chan/adb";
+import { type TransformStream } from "@yume-chan/stream-extra";
+
+import {
+    type ScrcpyBackOrScreenOnControlMessage,
+    type ScrcpyControlMessageType,
+    type ScrcpySetClipboardControlMessage,
+} from "../../control/index.js";
+import {
+    type ScrcpyOptions,
+    type ScrcpyVideoStreamPacket,
+} from "../../options/index.js";
+import { type AdbScrcpyConnection } from "../connection.js";
+
+export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
+    createConnection(adb: Adb): AdbScrcpyConnection;
+}
+
+export abstract class AdbScrcpyOptionsBase<T extends object>
+    implements ScrcpyOptions<T>
+{
+    private raw: ScrcpyOptions<T>;
+
+    public get value(): Partial<T> {
+        return this.raw.value;
+    }
+    public set value(value: Partial<T>) {
+        this.raw.value = value;
+    }
+
+    public constructor(raw: ScrcpyOptions<T>) {
+        this.raw = raw;
+    }
+
+    public getDefaultValue(): T {
+        return this.raw.getDefaultValue();
+    }
+
+    public formatServerArguments(): string[] {
+        return this.raw.formatServerArguments();
+    }
+
+    public getOutputEncoderNameRegex(): RegExp {
+        return this.raw.getOutputEncoderNameRegex();
+    }
+
+    public createVideoStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
+        return this.raw.createVideoStreamTransformer();
+    }
+
+    public getControlMessageTypes(): ScrcpyControlMessageType[] {
+        return this.raw.getControlMessageTypes();
+    }
+
+    public serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage
+    ): Uint8Array | undefined {
+        return this.raw.serializeBackOrScreenOnControlMessage(message);
+    }
+
+    public serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
+    ): Uint8Array {
+        return this.raw.serializeSetClipboardControlMessage(message);
+    }
+
+    public getScrollController() {
+        return this.raw.getScrollController();
+    }
+
+    public abstract createConnection(adb: Adb): AdbScrcpyConnection;
+}

package/src/control/back-or-screen-on.ts

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

package/src/control/hover-helper.ts

@@ -0,0 +1,56 @@
+import {
+    AndroidMotionEventAction,
+    type ScrcpyInjectTouchControlMessage,
+} from "./inject-touch.js";
+import { ScrcpyControlMessageType } from "./type.js";
+
+/**
+ * On both Android and Windows, while both mouse and touch are supported input devices,
+ * only one of them can be active at a time. Touch the screen with a finger will deactivate mouse,
+ * and move the mouse will deactivate touch.
+ *
+ * On Android, this is achieved by dispatching a `MotionEvent.ACTION_UP` event for the previous input type.
+ * But on Chrome, there is no such event, causing both mouse and touch to be active at the same time.
+ * This can cause the new input to appear as "ignored".
+ *
+ * This helper class synthesis `ACTION_UP` events when a different pointer type appears,
+ * so Scrcpy server can remove the previously hovering pointer.
+ */
+export class ScrcpyHoverHelper {
+    // AFAIK, only mouse and pen can have hover state
+    // and you can't have two mouses or pens.
+    // So remember the last hovering pointer is enough.
+    private lastHoverMessage: ScrcpyInjectTouchControlMessage | undefined;
+
+    public process(
+        message: Omit<ScrcpyInjectTouchControlMessage, "type">
+    ): ScrcpyInjectTouchControlMessage[] {
+        const result: ScrcpyInjectTouchControlMessage[] = [];
+
+        // A different pointer appeared,
+        // Cancel previously hovering pointer so Scrcpy server can free up the pointer ID.
+        if (
+            this.lastHoverMessage &&
+            this.lastHoverMessage.pointerId !== message.pointerId
+        ) {
+            // TODO: Inject MotionEvent.ACTION_HOVER_EXIT
+            // From testing, it seems no App cares about this event.
+            result.push({
+                ...this.lastHoverMessage,
+                action: AndroidMotionEventAction.Up,
+            });
+            this.lastHoverMessage = undefined;
+        }
+
+        if (message.action === AndroidMotionEventAction.HoverMove) {
+            // TODO: Inject MotionEvent.ACTION_HOVER_ENTER
+            this.lastHoverMessage = message as ScrcpyInjectTouchControlMessage;
+        }
+
+        (message as ScrcpyInjectTouchControlMessage).type =
+            ScrcpyControlMessageType.InjectTouch;
+        result.push(message as ScrcpyInjectTouchControlMessage);
+
+        return result;
+    }
+}

package/src/control/index.ts

@@ -0,0 +1,11 @@
+export * from "./back-or-screen-on.js";
+export * from "./hover-helper.js";
+export * from "./inject-keycode.js";
+export * from "./inject-scroll.js";
+export * from "./inject-text.js";
+export * from "./inject-touch.js";
+export * from "./rotate-device.js";
+export * from "./serializer.js";
+export * from "./set-clipboard.js";
+export * from "./set-screen-power-mode.js";
+export * from "./type.js";

package/src/control/inject-keycode.ts

@@ -0,0 +1,72 @@
+import Struct, { placeholder } from "@yume-chan/struct";
+
+import { ScrcpyControlMessageType } from "./type.js";
+
+export enum AndroidKeyEventAction {
+    Down = 0,
+    Up = 1,
+}
+
+// https://github.com/Genymobile/scrcpy/blob/cabb102a04153f9c237b18257d3269a058558c63/app/src/android/keycodes.h#L26
+export enum AndroidKeyCode {
+    Home = 3,
+    Back = 4,
+
+    DPadUp = 19,
+    DPadDown,
+    DPadLeft,
+    DPadRight,
+
+    VolumeUp = 24,
+    VolumeDown,
+
+    A = 29,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H,
+    I,
+    J,
+    K,
+    L,
+    M,
+    N,
+    O,
+    P,
+    Q,
+    R,
+    S,
+    T,
+    U,
+    V,
+    W,
+    X,
+    Y,
+    Z,
+
+    Tab = 61,
+    Space,
+    Enter = 66,
+    Delete,
+    Escape = 111,
+    ForwardDelete,
+
+    MoveHome = 122,
+    MoveEnd = 123,
+
+    VolumeMute = 164,
+    AppSwitch = 187,
+}
+
+export const ScrcpyInjectKeyCodeControlMessage = new Struct()
+    .uint8("type", ScrcpyControlMessageType.InjectKeyCode as const)
+    .uint8("action", placeholder<AndroidKeyEventAction>())
+    .uint32("keyCode")
+    .uint32("repeat")
+    .uint32("metaState");
+
+export type ScrcpyInjectKeyCodeControlMessage =
+    typeof ScrcpyInjectKeyCodeControlMessage["TInit"];

package/src/control/inject-scroll.ts

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

package/src/control/inject-text.ts

@@ -0,0 +1,12 @@
+import Struct from '@yume-chan/struct';
+
+import { ScrcpyControlMessageType } from './type.js';
+
+export const ScrcpyInjectTextControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.InjectText as const)
+        .uint32('length')
+        .string('text', { lengthField: 'length' });
+
+export type ScrcpyInjectTextControlMessage =
+    typeof ScrcpyInjectTextControlMessage['TInit'];

package/src/control/inject-touch.ts

@@ -0,0 +1,78 @@
+import Struct, {
+    NumberFieldDefinition,
+    NumberFieldType,
+    placeholder,
+} from "@yume-chan/struct";
+
+import { ScrcpyControlMessageType } from "./type.js";
+
+// https://developer.android.com/reference/android/view/MotionEvent#constants_1
+export enum AndroidMotionEventAction {
+    Down,
+    Up,
+    Move,
+    Cancel,
+    Outside,
+    PointerDown,
+    PointerUp,
+    HoverMove,
+    Scroll,
+    HoverEnter,
+    HoverExit,
+    ButtonPress,
+    ButtonRelease,
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace ScrcpyPointerId {
+    export const Mouse = BigInt(-1);
+    export const Finger = BigInt(-2);
+    export const VirtualMouse = BigInt(-3);
+    export const VirtualFinger = BigInt(-4);
+}
+
+export function clamp(value: number, min: number, max: number): number {
+    if (value < min) {
+        return min;
+    }
+
+    if (value > max) {
+        return max;
+    }
+
+    return value;
+}
+
+export const ScrcpyFloatToUint16NumberType: NumberFieldType = {
+    size: 2,
+    signed: false,
+    deserialize(array, littleEndian) {
+        const value = NumberFieldType.Uint16.deserialize(array, littleEndian);
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/server/src/main/java/com/genymobile/scrcpy/Binary.java#L22
+        return value === 0xffff ? 1 : value / 0x10000;
+    },
+    serialize(dataView, offset, value, littleEndian) {
+        // https://github.com/Genymobile/scrcpy/blob/1f138aef41de651668043b32c4effc2d4adbfc44/app/src/util/binary.h#L51
+        value = clamp(value, -1, 1);
+        value = value === 1 ? 0xffff : value * 0x10000;
+        NumberFieldType.Uint16.serialize(dataView, offset, value, littleEndian);
+    },
+};
+
+const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
+    ScrcpyFloatToUint16NumberType
+);
+
+export const ScrcpyInjectTouchControlMessage = new Struct()
+    .uint8("type", ScrcpyControlMessageType.InjectTouch as const)
+    .uint8("action", placeholder<AndroidMotionEventAction>())
+    .uint64("pointerId")
+    .uint32("pointerX")
+    .uint32("pointerY")
+    .uint16("screenWidth")
+    .uint16("screenHeight")
+    .field("pressure", ScrcpyFloatToUint16FieldDefinition)
+    .uint32("buttons");
+
+export type ScrcpyInjectTouchControlMessage =
+    typeof ScrcpyInjectTouchControlMessage["TInit"];

package/src/control/rotate-device.ts

@@ -0,0 +1,10 @@
+import Struct from '@yume-chan/struct';
+
+import { ScrcpyControlMessageType } from './type.js';
+
+export const ScrcpyRotateDeviceControlMessage =
+    new Struct()
+        .uint8('type', ScrcpyControlMessageType.RotateDevice as const)
+
+export type ScrcpyRotateDeviceControlMessage =
+    typeof ScrcpyRotateDeviceControlMessage['TInit'];