@yume-chan/scrcpy 0.0.17 → 0.0.19

package/src/control/serializer.ts

@@ -1,86 +1,154 @@
-import type { WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import type {
+    Consumable,
+    WritableStream,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import { ConsumableWritableStream } 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,
+    ScrcpyOptionsInit1_16,
+    ScrcpyScrollController,
+} from "../options/index.js";
+
+import type { AndroidKeyEventAction } from "./inject-keycode.js";
+import { ScrcpyInjectKeyCodeControlMessage } 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 type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
+import { ScrcpySetScreenPowerModeControlMessage } from "./set-screen-power-mode.js";
+import { ScrcpyControlMessageType } from "./type.js";
 
 export class ScrcpyControlMessageSerializer {
-    private options: ScrcpyOptions<any>;
+    private options: ScrcpyOptions<ScrcpyOptionsInit1_16>;
     /** Control message type values for current version of server */
     private types: ScrcpyControlMessageType[];
-    private writer: WritableStreamDefaultWriter<Uint8Array>;
+    private writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    private scrollController: ScrcpyScrollController;
+
+    public constructor(
+        stream: WritableStream<Consumable<Uint8Array>>,
+        options: ScrcpyOptions<ScrcpyOptionsInit1_16>
+    ) {
+        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;
+    }
+
+    private async write(data: Uint8Array) {
+        await ConsumableWritableStream.write(this.writer, data);
+    }
+
+    public injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    ) {
+        return this.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.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.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.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) {
-            return await this.writer.write(buffer);
+            return await this.write(buffer);
         }
     }
 
     public setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        return this.writer.write(ScrcpySetScreenPowerModeControlMessage.serialize({
-            mode,
-            type: this.getTypeValue(ScrcpyControlMessageType.SetScreenPowerMode),
-        }));
+        return this.write(
+            ScrcpySetScreenPowerModeControlMessage.serialize({
+                mode,
+                type: this.getActualMessageType(
+                    ScrcpyControlMessageType.SetScreenPowerMode
+                ),
+            })
+        );
     }
 
     public rotateDevice() {
-        return this.writer.write(ScrcpyRotateDeviceControlMessage.serialize({
-            type: this.getTypeValue(ScrcpyControlMessageType.RotateDevice),
-        }));
+        return this.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/control/set-screen-power-mode.ts

@@ -1,17 +1,16 @@
-import Struct, { placeholder } from '@yume-chan/struct';
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { ScrcpyControlMessageType } from './type.js';
+import { ScrcpyControlMessageType } from "./type.js";
 
 // 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
+    Normal = 2,
 }
 
-export const ScrcpySetScreenPowerModeControlMessage =
-    new Struct()
-        .uint8('type', ScrcpyControlMessageType.SetScreenPowerMode as const)
-        .uint8('mode', placeholder<AndroidScreenPowerMode>());
+export const ScrcpySetScreenPowerModeControlMessage = new Struct()
+    .uint8("type", ScrcpyControlMessageType.SetScreenPowerMode as const)
+    .uint8("mode", placeholder<AndroidScreenPowerMode>());
 
 export type ScrcpySetScreenPowerModeControlMessage =
-    typeof ScrcpySetScreenPowerModeControlMessage['TInit'];
+    (typeof ScrcpySetScreenPowerModeControlMessage)["TInit"];

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/index.ts

@@ -1,5 +1,5 @@
-export * from './adb/index.js';
-export * from './codec.js';
-export * from './control/index.js';
-export * from './device-message/index.js';
-export * from './options/index.js';
+export * from "./adb/index.js";
+export * from "./codec.js";
+export * from "./control/index.js";
+export * from "./device-message/index.js";
+export * from "./options/index.js";

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

@@ -1,5 +1,5 @@
-import type { AndroidCodecLevel, AndroidCodecProfile } from '../../codec.js';
-import type { ScrcpyOptionValue } from '../types.js';
+import type { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
+import type { ScrcpyOptionValue } from "../types.js";
 
 /**
  * If the option you need is not in this type,
@@ -10,29 +10,34 @@ export interface CodecOptionsInit {
     level: AndroidCodecLevel;
 
     iFrameInterval: number;
+    maxBframes: number;
     repeatPreviousFrameAfter: number;
     maxPtsGapToEncoder: number;
+    intraRefreshPeriod: 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 {
     public value: Partial<CodecOptionsInit>;
 
-    public constructor(value: Partial<CodecOptionsInit>) {
+    public constructor(value: Partial<CodecOptionsInit> = {}) {
         this.value = value;
     }
 
     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 +46,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(",");
     }
 }