@yume-chan/scrcpy 0.0.17 → 0.0.18

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

@@ -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,6 +1,6 @@
-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,
@@ -11,8 +11,15 @@ export enum AndroidKeyEventAction {
 export enum AndroidKeyCode {
     Home = 3,
     Back = 4,
+
+    DPadUp = 19,
+    DPadDown,
+    DPadLeft,
+    DPadRight,
+
     VolumeUp = 24,
     VolumeDown,
+
     A = 29,
     B,
     C,
@@ -39,21 +46,27 @@ export enum AndroidKeyCode {
     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 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-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/serializer.ts

@@ -1,65 +1,122 @@
-import type { WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import {
+    type WritableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
 
-import type { ScrcpyInjectScrollControlMessage1_22, ScrcpyOptions } from '../options/index.js';
-import { AndroidKeyEventAction, ScrcpyInjectKeyCodeControlMessage } from './inject-keycode.js';
-import { ScrcpyInjectTextControlMessage } from './inject-text.js';
-import { ScrcpyInjectTouchControlMessage } from './inject-touch.js';
-import { ScrcpyRotateDeviceControlMessage } from './rotate-device.js';
-import { AndroidScreenPowerMode, ScrcpySetScreenPowerModeControlMessage } from './set-screen-power-mode.js';
-import { ScrcpyControlMessageType } from './type.js';
+import {
+    type ScrcpyOptions,
+    type ScrcpyScrollController,
+} from "../options/index.js";
+
+import {
+    ScrcpyInjectKeyCodeControlMessage,
+    type AndroidKeyEventAction,
+} from "./inject-keycode.js";
+import { type ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
+import { ScrcpyInjectTextControlMessage } from "./inject-text.js";
+import { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import { ScrcpyRotateDeviceControlMessage } from "./rotate-device.js";
+import {
+    ScrcpySetScreenPowerModeControlMessage,
+    type AndroidScreenPowerMode,
+} from "./set-screen-power-mode.js";
+import { ScrcpyControlMessageType } from "./type.js";
 
 export class ScrcpyControlMessageSerializer {
-    private options: ScrcpyOptions<any>;
+    private options: ScrcpyOptions<object>;
     /** Control message type values for current version of server */
     private types: ScrcpyControlMessageType[];
     private writer: WritableStreamDefaultWriter<Uint8Array>;
+    private scrollController: ScrcpyScrollController;
+
+    public constructor(
+        stream: WritableStream<Uint8Array>,
+        options: ScrcpyOptions<object>
+    ) {
+        this.writer = stream.getWriter();
 
-    public constructor(stream: WritableStream<Uint8Array>, options: ScrcpyOptions<any>) {
         this.options = options;
         this.types = options.getControlMessageTypes();
-        this.writer = stream.getWriter();
+        this.scrollController = options.getScrollController();
     }
 
-    public getTypeValue(type: ScrcpyControlMessageType): number {
+    public getActualMessageType(type: ScrcpyControlMessageType): number {
         const value = this.types.indexOf(type);
         if (value === -1) {
-            throw new Error('Not supported');
+            throw new Error("Not supported");
         }
         return value;
     }
 
-    public injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, 'type'>) {
-        return this.writer.write(ScrcpyInjectKeyCodeControlMessage.serialize({
-            ...message,
-            type: this.getTypeValue(ScrcpyControlMessageType.InjectKeyCode),
-        }));
+    public addMessageType<T extends { type: ScrcpyControlMessageType }>(
+        message: Omit<T, "type">,
+        type: T["type"]
+    ): T {
+        (message as T).type = this.getActualMessageType(type);
+        return message as T;
+    }
+
+    public injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    ) {
+        return this.writer.write(
+            ScrcpyInjectKeyCodeControlMessage.serialize(
+                this.addMessageType(
+                    message,
+                    ScrcpyControlMessageType.InjectKeyCode
+                )
+            )
+        );
     }
 
     public injectText(text: string) {
-        return this.writer.write(ScrcpyInjectTextControlMessage.serialize({
-            text,
-            type: this.getTypeValue(ScrcpyControlMessageType.InjectText),
-        }));
+        return this.writer.write(
+            ScrcpyInjectTextControlMessage.serialize({
+                text,
+                type: this.getActualMessageType(
+                    ScrcpyControlMessageType.InjectText
+                ),
+            })
+        );
     }
 
-    public injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, 'type'>) {
-        return this.writer.write(ScrcpyInjectTouchControlMessage.serialize({
-            ...message,
-            type: this.getTypeValue(ScrcpyControlMessageType.InjectTouch),
-        }));
+    /**
+     * `pressure` is a float value between 0 and 1.
+     */
+    public injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        return this.writer.write(
+            ScrcpyInjectTouchControlMessage.serialize(
+                this.addMessageType(
+                    message,
+                    ScrcpyControlMessageType.InjectTouch
+                )
+            )
+        );
     }
 
-    public injectScroll(message: Omit<ScrcpyInjectScrollControlMessage1_22, 'type'>) {
-        return this.writer.write(this.options.serializeInjectScrollControlMessage({
-            ...message,
-            type: this.getTypeValue(ScrcpyControlMessageType.InjectScroll),
-        }));
+    /**
+     * `scrollX` and `scrollY` are float values between 0 and 1.
+     */
+    public injectScroll(
+        message: Omit<ScrcpyInjectScrollControlMessage, "type">
+    ) {
+        const data = this.scrollController.serializeScrollMessage(
+            this.addMessageType(message, ScrcpyControlMessageType.InjectScroll)
+        );
+
+        if (!data) {
+            return;
+        }
+
+        return this.writer.write(data);
     }
 
     public async backOrScreenOn(action: AndroidKeyEventAction) {
         const buffer = this.options.serializeBackOrScreenOnControlMessage({
             action,
-            type: this.getTypeValue(ScrcpyControlMessageType.BackOrScreenOn),
+            type: this.getActualMessageType(
+                ScrcpyControlMessageType.BackOrScreenOn
+            ),
         });
 
         if (buffer) {
@@ -68,19 +125,27 @@ export class ScrcpyControlMessageSerializer {
     }
 
     public setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        return this.writer.write(ScrcpySetScreenPowerModeControlMessage.serialize({
-            mode,
-            type: this.getTypeValue(ScrcpyControlMessageType.SetScreenPowerMode),
-        }));
+        return this.writer.write(
+            ScrcpySetScreenPowerModeControlMessage.serialize({
+                mode,
+                type: this.getActualMessageType(
+                    ScrcpyControlMessageType.SetScreenPowerMode
+                ),
+            })
+        );
     }
 
     public rotateDevice() {
-        return this.writer.write(ScrcpyRotateDeviceControlMessage.serialize({
-            type: this.getTypeValue(ScrcpyControlMessageType.RotateDevice),
-        }));
+        return this.writer.write(
+            ScrcpyRotateDeviceControlMessage.serialize({
+                type: this.getActualMessageType(
+                    ScrcpyControlMessageType.RotateDevice
+                ),
+            })
+        );
     }
 
     public close() {
         return this.writer.close();
     }
-};
+}

package/src/control/set-clipboard.ts

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

package/src/device-message/ack-clipboard.ts

@@ -0,0 +1,10 @@
+import Struct from "@yume-chan/struct";
+
+import { ScrcpyDeviceMessageType } from "./type.js";
+
+export const ScrcpyAckClipboardDeviceMessage = new Struct()
+    .uint64("sequence")
+    .extra({ type: ScrcpyDeviceMessageType.AckClipboard as const });
+
+export type ScrcpyAckClipboardDeviceMessage =
+    typeof ScrcpyAckClipboardDeviceMessage["TDeserializeResult"];

package/src/device-message/clipboard.ts

@@ -1,11 +1,11 @@
-import Struct from '@yume-chan/struct';
-import { ScrcpyDeviceMessageType } from './type.js';
+import Struct from "@yume-chan/struct";
 
-export const ScrcpyClipboardDeviceMessage =
-    new Struct()
-        .uint32('length')
-        .string('content', { lengthField: 'length' })
-        .extra({ type: ScrcpyDeviceMessageType.Clipboard as const });
+import { ScrcpyDeviceMessageType } from "./type.js";
+
+export const ScrcpyClipboardDeviceMessage = new Struct()
+    .uint32("length")
+    .string("content", { lengthField: "length" })
+    .extra({ type: ScrcpyDeviceMessageType.Clipboard as const });
 
 export type ScrcpyClipboardDeviceMessage =
-    typeof ScrcpyClipboardDeviceMessage['TDeserializeResult'];
+    typeof ScrcpyClipboardDeviceMessage["TDeserializeResult"];

package/src/device-message/index.ts

@@ -1,3 +1,4 @@
-export * from './clipboard.js';
-export * from './stream.js';
-export * from './type.js';
+export * from "./ack-clipboard.js";
+export * from "./clipboard.js";
+export * from "./stream.js";
+export * from "./type.js";

package/src/device-message/stream.ts

@@ -1,19 +1,29 @@
-import { BufferedTransformStream } from '@yume-chan/stream-extra';
-import { ScrcpyClipboardDeviceMessage } from './clipboard.js';
+import { BufferedTransformStream } from "@yume-chan/stream-extra";
+
+import { ScrcpyAckClipboardDeviceMessage } from "./ack-clipboard.js";
+import { ScrcpyClipboardDeviceMessage } from "./clipboard.js";
+import { ScrcpyDeviceMessageType } from "./type.js";
 
 export type ScrcpyDeviceMessage =
-    | ScrcpyClipboardDeviceMessage;
+    | ScrcpyClipboardDeviceMessage
+    | ScrcpyAckClipboardDeviceMessage;
 
 export class ScrcpyDeviceMessageDeserializeStream extends BufferedTransformStream<ScrcpyDeviceMessage> {
     constructor() {
         super(async (stream) => {
             const type = await stream.read(1);
             switch (type[0]) {
-                case 0:
-                    return await ScrcpyClipboardDeviceMessage.deserialize(stream);
+                case ScrcpyDeviceMessageType.Clipboard:
+                    return await ScrcpyClipboardDeviceMessage.deserialize(
+                        stream
+                    );
+                case ScrcpyDeviceMessageType.AckClipboard:
+                    return await ScrcpyAckClipboardDeviceMessage.deserialize(
+                        stream
+                    );
                 default:
-                    throw new Error('unknown control message type');
+                    throw new Error("unknown control message type");
             }
-        })
+        });
     }
 }

package/src/options/1_16/codec-options.ts

@@ -1,5 +1,8 @@
-import type { AndroidCodecLevel, AndroidCodecProfile } from '../../codec.js';
-import type { ScrcpyOptionValue } from '../types.js';
+import {
+    type AndroidCodecLevel,
+    type AndroidCodecProfile,
+} from "../../codec.js";
+import { type ScrcpyOptionValue } from "../types.js";
 
 /**
  * If the option you need is not in this type,
@@ -10,17 +13,20 @@ export interface CodecOptionsInit {
     level: AndroidCodecLevel;
 
     iFrameInterval: number;
+    maxBframes: number;
     repeatPreviousFrameAfter: number;
     maxPtsGapToEncoder: number;
 }
 
 function toDashCase(input: string) {
-    return input.replace(/([A-Z])/g, '-$1').toLowerCase();
+    return input.replace(/([A-Z])/g, "-$1").toLowerCase();
 }
 
-const CODEC_OPTION_TYPES: Partial<Record<keyof CodecOptionsInit, 'long' | 'float' | 'string'>> = {
-    repeatPreviousFrameAfter: 'long',
-    maxPtsGapToEncoder: 'long',
+const CODEC_OPTION_TYPES: Partial<
+    Record<keyof CodecOptionsInit, "long" | "float" | "string">
+> = {
+    repeatPreviousFrameAfter: "long",
+    maxPtsGapToEncoder: "long",
 };
 
 export class CodecOptions implements ScrcpyOptionValue {
@@ -31,8 +37,9 @@ export class CodecOptions implements ScrcpyOptionValue {
     }
 
     public toOptionValue(): string | undefined {
-        const entries = Object.entries(this.value)
-            .filter(([key, value]) => value !== undefined);
+        const entries = Object.entries(this.value).filter(
+            ([, value]) => value !== undefined
+        );
 
         if (entries.length === 0) {
             return undefined;
@@ -41,8 +48,8 @@ export class CodecOptions implements ScrcpyOptionValue {
         return entries
             .map(([key, value]) => {
                 const type = CODEC_OPTION_TYPES[key as keyof CodecOptionsInit];
-                return `${toDashCase(key)}${type ? `:${type}` : ''}=${value}`;
+                return `${toDashCase(key)}${type ? `:${type}` : ""}=${value}`;
             })
-            .join(',');
+            .join(",");
     }
 }