@yume-chan/scrcpy 0.0.17 → 0.0.19

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

@@ -1,11 +1,20 @@
-import type { Adb } from '@yume-chan/adb';
+import type { Adb } from "@yume-chan/adb";
 
-import type { ScrcpyOptionsInit1_16 } from '../../options/index.js';
-import { AdbScrcpyConnection, AdbScrcpyConnectionOptions, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
-import { AdbScrcpyOptionsBase } from './types.js';
+import type { ScrcpyOptionsInit1_16 } from "../../options/index.js";
+import type {
+    AdbScrcpyConnection,
+    AdbScrcpyConnectionOptions,
+} from "../connection.js";
+import {
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+} from "../connection.js";
 
-export class AdbScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16>
-    extends AdbScrcpyOptionsBase<T> {
+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

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

@@ -1,11 +1,17 @@
-import type { Adb } from '@yume-chan/adb';
+import type { Adb } from "@yume-chan/adb";
 
-import type { ScrcpyOptionsInit1_22 } from '../../options/index.js';
-import { AdbScrcpyConnection, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
-import { AdbScrcpyOptions1_16 } from './1_16.js';
+import type { ScrcpyOptionsInit1_22 } from "../../options/index.js";
+import type { AdbScrcpyConnection } from "../connection.js";
+import {
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+} from "../connection.js";
 
-export class AdbScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22>
-    extends AdbScrcpyOptions1_16<T> {
+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(),

package/src/adb/options/index.ts

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

package/src/adb/options/types.ts

@@ -1,19 +1,32 @@
-import type { Adb } from '@yume-chan/adb';
-import type { TransformStream } from '@yume-chan/stream-extra';
+import type { Adb } from "@yume-chan/adb";
+import type { TransformStream } from "@yume-chan/stream-extra";
 
-import type { ScrcpyControlMessageType } from '../../control/index.js';
-import type { ScrcpyBackOrScreenOnControlMessage1_18, ScrcpyInjectScrollControlMessage1_22, ScrcpyOptions, ScrcpyVideoStreamPacket } from '../../options/index.js';
-import type { AdbScrcpyConnection } from '../connection.js';
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyControlMessageType,
+    ScrcpySetClipboardControlMessage,
+} from "../../control/index.js";
+import type {
+    ScrcpyOptions,
+    ScrcpyVideoStreamPacket,
+} from "../../options/index.js";
+import type { AdbScrcpyConnection } from "../connection.js";
 
-export interface AdbScrcpyOptions<T> extends ScrcpyOptions<T> {
+export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
     createConnection(adb: Adb): AdbScrcpyConnection;
 }
 
-export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
+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 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;
@@ -31,7 +44,10 @@ export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
         return this.raw.getOutputEncoderNameRegex();
     }
 
-    public createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
+    public createVideoStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
         return this.raw.createVideoStreamTransformer();
     }
 
@@ -40,15 +56,19 @@ export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
     }
 
     public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage1_18,
+        message: ScrcpyBackOrScreenOnControlMessage
     ): Uint8Array | undefined {
         return this.raw.serializeBackOrScreenOnControlMessage(message);
     }
 
-    public serializeInjectScrollControlMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
+    public serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
     ): Uint8Array {
-        return this.raw.serializeInjectScrollControlMessage(message);
+        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,54 @@
+import type { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import { AndroidMotionEventAction } 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

@@ -1,7 +1,11 @@
-export * from './inject-keycode.js';
-export * from './inject-text.js';
-export * from './inject-touch.js';
-export * from './rotate-device.js';
-export * from './serializer.js';
-export * from './set-screen-power-mode.js';
-export * from './type.js';
+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

@@ -1,59 +1,217 @@
-import Struct, { placeholder } from '@yume-chan/struct';
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { ScrcpyControlMessageType } from './type.js';
+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
+// https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/KeyEvent.java;l=993;drc=95c1165bb895dd844e1793460710f7163dd330a3
+export enum AndroidKeyEventMeta {
+    AltOn = 0x02,
+    AltLeftOn = 0x10,
+    AltRightOn = 0x20,
+    ShiftOn = 0x01,
+    ShiftLeftOn = 0x40,
+    ShiftRightOn = 0x80,
+    CtrlOn = 0x1000,
+    CtrlLeftOn = 0x2000,
+    CtrlRightOn = 0x4000,
+    MetaOn = 0x10000,
+    MetaLeftOn = 0x20000,
+    MetaRightOn = 0x40000,
+    CapsLockOn = 0x100000,
+    NumLockOn = 0x200000,
+    ScrollLockOn = 0x400000,
+}
+
+// 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 enum AndroidKeyCode {
-    Home = 3,
-    Back = 4,
-    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,
+    AndroidHome = 3,
+    AndroidBack = 4,
+    AndroidCall,
+    AndroidEndCall,
+
+    Digit0,
+    Digit1,
+    Digit2,
+    Digit3,
+    Digit4,
+    Digit5,
+    Digit6,
+    Digit7,
+    Digit8,
+    Digit9,
+    /**
+     * '*' key.
+     */
+    Star, // Name not verified
+    /**
+     * '#' key.
+     */
+    Pound, // Name not verified
+
+    /**
+     * Directional Pad Up key.
+     */
+    ArrowUp,
+    /**
+     * Directional Pad Down key.
+     */
+    ArrowDown,
+    /**
+     * Directional Pad Left key.
+     */
+    ArrowLeft,
+    /**
+     * Directional Pad Right key.
+     */
+    ArrowRight,
+    /**
+     * Directional Pad Center key.
+     */
+    AndroidDPadCenter,
+
+    VolumeUp, // Name not verified
+    VolumeDown, // Name not verified
+    Power, // Name not verified
+    AndroidCamera,
+    Clear, // Name not verified
+
+    KeyA,
+    KeyB,
+    KeyC,
+    KeyD,
+    KeyE,
+    KeyF,
+    KeyG,
+    KeyH,
+    KeyI,
+    KeyJ,
+    KeyK,
+    KeyL,
+    KeyM,
+    KeyN,
+    KeyO,
+    KeyP,
+    KeyQ,
+    KeyR,
+    KeyS,
+    KeyT,
+    KeyU,
+    KeyV,
+    KeyW,
+    KeyX,
+    KeyY,
+    KeyZ,
+    Comma,
+    Period,
+    AltLeft,
+    AltRight,
+    ShiftLeft,
+    ShiftRight,
+    Tab,
     Space,
-    Enter = 66,
+    AndroidSymbol,
+    AndroidExplorer,
+    AndroidEnvelope,
+    Enter,
+    Backspace,
+    Backquote,
+    Minus,
+    Equal,
+    BracketLeft,
+    BracketRight,
+    Backslash,
+    Semicolon,
+    Quote,
+    Slash,
+    At, // Name not verified
+
+    AndroidNum,
+    AndroidHeadsetHook,
+    /**
+     * Camera Focus key。
+     */
+    AndroidFocus,
+
+    Plus, // Name not verified
+    ContextMenu,
+    AndroidNotification,
+    AndroidSearch,
+
+    PageUp = 92,
+    PageDown,
+
+    Escape = 111,
     Delete,
-    VolumeMute = 164,
-    AppSwitch = 187,
+    ControlLeft,
+    ControlRight,
+    CapsLock,
+    ScrollLock,
+    MetaLeft,
+    MetaRight,
+    AndroidFunction,
+    PrintScreen,
+    Pause,
+
+    Home,
+    End,
+    Insert,
+    AndroidForward,
+
+    F1 = 131,
+    F2,
+    F3,
+    F4,
+    F5,
+    F6,
+    F7,
+    F8,
+    F9,
+    F10,
+    F11,
+    F12,
+
+    NumLock,
+    Numpad0,
+    Numpad1,
+    Numpad2,
+    Numpad3,
+    Numpad4,
+    Numpad5,
+    Numpad6,
+    Numpad7,
+    Numpad8,
+    Numpad9,
+    NumpadDivide,
+    NumpadMultiply,
+    NumpadSubtract,
+    NumpadAdd,
+    NumpadDecimal,
+    NumpadComma, // Name not verified
+    NumpadEnter,
+    NumpadEquals, // Name not verified
+    NumpadLeftParen, // Name not verified
+    NumpadRightParen, // Name not verified
+
+    VolumeMute = 164, // Name not verified
+    AndroidAppSwitch = 187,
+
+    AndroidCut = 277,
+    AndroidCopy,
+    AndroidPaste,
 }
 
-export const ScrcpyInjectKeyCodeControlMessage =
-    new Struct()
-        .uint8('type', ScrcpyControlMessageType.InjectKeyCode as const)
-        .uint8('action', placeholder<AndroidKeyEventAction>())
-        .uint32('keyCode')
-        .uint32('repeat')
-        .uint32('metaState');
+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'];
+    (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

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

package/src/control/inject-touch.ts

@@ -1,5 +1,10 @@
-import Struct, { placeholder } from '@yume-chan/struct';
-import { ScrcpyControlMessageType } from './type.js';
+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 {
@@ -18,17 +23,56 @@ export enum AndroidMotionEventAction {
     ButtonRelease,
 }
 
-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')
-        .uint16('pressure')
-        .uint32('buttons');
+// 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'];
+    (typeof ScrcpyInjectTouchControlMessage)["TInit"];

package/src/control/rotate-device.ts

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