@yume-chan/scrcpy 0.0.16 → 0.0.17

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'];

package/src/control/serializer.ts

@@ -0,0 +1,86 @@
+import type { WritableStream, 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';
+
+export class ScrcpyControlMessageSerializer {
+    private options: ScrcpyOptions<any>;
+    /** Control message type values for current version of server */
+    private types: ScrcpyControlMessageType[];
+    private writer: WritableStreamDefaultWriter<Uint8Array>;
+
+    public constructor(stream: WritableStream<Uint8Array>, options: ScrcpyOptions<any>) {
+        this.options = options;
+        this.types = options.getControlMessageTypes();
+        this.writer = stream.getWriter();
+    }
+
+    public getTypeValue(type: ScrcpyControlMessageType): number {
+        const value = this.types.indexOf(type);
+        if (value === -1) {
+            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 injectText(text: string) {
+        return this.writer.write(ScrcpyInjectTextControlMessage.serialize({
+            text,
+            type: this.getTypeValue(ScrcpyControlMessageType.InjectText),
+        }));
+    }
+
+    public injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, 'type'>) {
+        return this.writer.write(ScrcpyInjectTouchControlMessage.serialize({
+            ...message,
+            type: this.getTypeValue(ScrcpyControlMessageType.InjectTouch),
+        }));
+    }
+
+    public injectScroll(message: Omit<ScrcpyInjectScrollControlMessage1_22, 'type'>) {
+        return this.writer.write(this.options.serializeInjectScrollControlMessage({
+            ...message,
+            type: this.getTypeValue(ScrcpyControlMessageType.InjectScroll),
+        }));
+    }
+
+    public async backOrScreenOn(action: AndroidKeyEventAction) {
+        const buffer = this.options.serializeBackOrScreenOnControlMessage({
+            action,
+            type: this.getTypeValue(ScrcpyControlMessageType.BackOrScreenOn),
+        });
+
+        if (buffer) {
+            return await this.writer.write(buffer);
+        }
+    }
+
+    public setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        return this.writer.write(ScrcpySetScreenPowerModeControlMessage.serialize({
+            mode,
+            type: this.getTypeValue(ScrcpyControlMessageType.SetScreenPowerMode),
+        }));
+    }
+
+    public rotateDevice() {
+        return this.writer.write(ScrcpyRotateDeviceControlMessage.serialize({
+            type: this.getTypeValue(ScrcpyControlMessageType.RotateDevice),
+        }));
+    }
+
+    public close() {
+        return this.writer.close();
+    }
+};

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

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

package/src/control/type.ts

@@ -0,0 +1,17 @@
+// https://github.com/Genymobile/scrcpy/blob/fa5b2a29e983a46b49531def9cf3d80c40c3de37/app/src/control_msg.h#L23
+// For their message bodies, see https://github.com/Genymobile/scrcpy/blob/5c62f3419d252d10cd8c9cbb7c918b358b81f2d0/app/src/control_msg.c#L92
+// Their IDs change between versions, so always use `options.getControlMessageTypes()`
+export enum ScrcpyControlMessageType {
+    InjectKeyCode,
+    InjectText,
+    InjectTouch,
+    InjectScroll,
+    BackOrScreenOn,
+    ExpandNotificationPanel,
+    ExpandSettingPanel,
+    CollapseNotificationPanel,
+    GetClipboard,
+    SetClipboard,
+    SetScreenPowerMode,
+    RotateDevice,
+}

package/src/device-message/clipboard.ts

@@ -0,0 +1,11 @@
+import Struct from '@yume-chan/struct';
+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'];

package/src/device-message/index.ts

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

package/src/device-message/stream.ts

@@ -0,0 +1,19 @@
+import { BufferedTransformStream } from '@yume-chan/stream-extra';
+import { ScrcpyClipboardDeviceMessage } from './clipboard.js';
+
+export type ScrcpyDeviceMessage =
+    | ScrcpyClipboardDeviceMessage;
+
+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);
+                default:
+                    throw new Error('unknown control message type');
+            }
+        })
+    }
+}

package/src/device-message/type.ts

@@ -0,0 +1,5 @@
+// https://github.com/Genymobile/scrcpy/blob/41abe021e2a73efd4899b0efcd0b9eef9ec68c9b/server/src/main/java/com/genymobile/scrcpy/DeviceMessage.java#L5
+export enum ScrcpyDeviceMessageType {
+    Clipboard,
+    AckClipboard,
+}

package/src/index.ts

@@ -1,8 +1,5 @@
-export * from './client.js';
+export * from './adb/index.js';
 export * from './codec.js';
-export * from './connection.js';
-export * from './decoder/index.js';
-export * from './message.js';
+export * from './control/index.js';
+export * from './device-message/index.js';
 export * from './options/index.js';
-export * from './push-server.js';
-export * from './utils.js';

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

@@ -0,0 +1,48 @@
+import type { AndroidCodecLevel, AndroidCodecProfile } from '../../codec.js';
+import type { ScrcpyOptionValue } from '../types.js';
+
+/**
+ * If the option you need is not in this type,
+ * please file an issue on GitHub.
+ */
+export interface CodecOptionsInit {
+    profile: AndroidCodecProfile;
+    level: AndroidCodecLevel;
+
+    iFrameInterval: number;
+    repeatPreviousFrameAfter: number;
+    maxPtsGapToEncoder: number;
+}
+
+function toDashCase(input: string) {
+    return input.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+
+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>) {
+        this.value = value;
+    }
+
+    public toOptionValue(): string | undefined {
+        const entries = Object.entries(this.value)
+            .filter(([key, value]) => value !== undefined);
+
+        if (entries.length === 0) {
+            return undefined;
+        }
+
+        return entries
+            .map(([key, value]) => {
+                const type = CODEC_OPTION_TYPES[key as keyof CodecOptionsInit];
+                return `${toDashCase(key)}${type ? `:${type}` : ''}=${value}`;
+            })
+            .join(',');
+    }
+}

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

@@ -1,345 +1,3 @@
-import { StructDeserializeStream, TransformStream, type Adb } from "@yume-chan/adb";
-import Struct from "@yume-chan/struct";
-import type { AndroidCodecLevel, AndroidCodecProfile } from "../../codec.js";
-import { ScrcpyClientConnection, ScrcpyClientForwardConnection, ScrcpyClientReverseConnection, type ScrcpyClientConnectionOptions } from "../../connection.js";
-import { AndroidKeyEventAction, ScrcpyControlMessageType, ScrcpySimpleControlMessage } from "../../message.js";
-import type { ScrcpyBackOrScreenOnEvent1_18 } from "../1_18.js";
-import type { ScrcpyInjectScrollControlMessage1_22 } from "../1_22.js";
-import { toScrcpyOptionValue, type ScrcpyOptions, type ScrcpyOptionValue, type VideoStreamPacket } from "../common.js";
-import { parse_sequence_parameter_set } from "./sps.js";
-
-export enum ScrcpyLogLevel {
-    Verbose = 'verbose',
-    Debug = 'debug',
-    Info = 'info',
-    Warn = 'warn',
-    Error = 'error',
-}
-
-export enum ScrcpyVideoOrientation {
-    Initial = -2,
-    Unlocked = -1,
-    Portrait = 0,
-    Landscape = 1,
-    PortraitFlipped = 2,
-    LandscapeFlipped = 3,
-}
-
-export interface CodecOptionsInit {
-    profile: AndroidCodecProfile;
-    level: AndroidCodecLevel;
-
-    iFrameInterval: number;
-    repeatPreviousFrameAfter: number;
-    maxPtsGapToEncoder: number;
-}
-
-function toDashCase(input: string) {
-    return input.replace(/([A-Z])/g, '-$1').toLowerCase();
-}
-
-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>) {
-        this.value = value;
-    }
-
-    public toOptionValue(): string | undefined {
-        const entries = Object.entries(this.value)
-            .filter(([key, value]) => value !== undefined);
-
-        if (entries.length === 0) {
-            return undefined;
-        }
-
-        return entries
-            .map(([key, value]) => {
-                const type = CODEC_OPTION_TYPES[key as keyof CodecOptionsInit];
-                return `${toDashCase(key)}${type ? `:${type}` : ''}=${value}`;
-            })
-            .join(',');
-    }
-}
-
-export interface ScrcpyOptionsInit1_16 {
-    logLevel: ScrcpyLogLevel;
-
-    /**
-     * The maximum value of both width and height.
-     */
-    maxSize: number;
-
-    bitRate: number;
-
-    /**
-     * 0 for unlimited.
-     *
-     * @default 0
-     */
-    maxFps: number;
-
-    /**
-     * The orientation of the video stream.
-     *
-     * It will not keep the device screen in specific orientation,
-     * only the captured video will in this orientation.
-     */
-    lockVideoOrientation: ScrcpyVideoOrientation;
-
-    tunnelForward: boolean;
-
-    crop: string;
-
-    /**
-     * Send PTS so that the client may record properly
-     *
-     * Note: When `sendFrameMeta: false` is specified,
-     * `onChangeEncoding` event won't fire and `onVideoData` event doesn't
-     * merge sps/pps frame and first video frame. Which means you can't use
-     * the shipped decoders to render the video
-     * (You can still record the stream into a file).
-     *
-     * @default true
-     */
-    sendFrameMeta: boolean;
-
-    /**
-     * @default true
-     */
-    control: boolean;
-
-    displayId: number;
-
-    showTouches: boolean;
-
-    stayAwake: boolean;
-
-    codecOptions: CodecOptions;
-
-    encoderName: string;
-}
-
-export const VideoPacket =
-    new Struct()
-        .uint64('pts')
-        .uint32('size')
-        .uint8Array('data', { lengthField: 'size' });
-
-export const NO_PTS = BigInt(1) << BigInt(63);
-
-export const ScrcpyBackOrScreenOnEvent1_16 =
-    ScrcpySimpleControlMessage;
-
-export const ScrcpyInjectScrollControlMessage1_16 =
-    new Struct()
-        .fields(ScrcpySimpleControlMessage)
-        .uint32('pointerX')
-        .uint32('pointerY')
-        .uint16('screenWidth')
-        .uint16('screenHeight')
-        .int32('scrollX')
-        .int32('scrollY');
-
-export class ScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16> implements ScrcpyOptions<T> {
-    public value: Partial<T>;
-
-    public constructor(value: Partial<ScrcpyOptionsInit1_16>) {
-        if (new.target === ScrcpyOptions1_16 &&
-            value.logLevel === ScrcpyLogLevel.Verbose) {
-            value.logLevel = ScrcpyLogLevel.Debug;
-        }
-
-        if (new.target === ScrcpyOptions1_16 &&
-            value.lockVideoOrientation === ScrcpyVideoOrientation.Initial) {
-            value.lockVideoOrientation = ScrcpyVideoOrientation.Unlocked;
-        }
-
-        this.value = value as Partial<T>;
-    }
-
-    protected getArgumentOrder(): (keyof T)[] {
-        return [
-            'logLevel',
-            'maxSize',
-            'bitRate',
-            'maxFps',
-            'lockVideoOrientation',
-            'tunnelForward',
-            'crop',
-            'sendFrameMeta',
-            'control',
-            'displayId',
-            'showTouches',
-            'stayAwake',
-            'codecOptions',
-            'encoderName',
-        ];
-    }
-
-    protected getDefaultValue(): T {
-        return {
-            logLevel: ScrcpyLogLevel.Debug,
-            maxSize: 0,
-            bitRate: 8_000_000,
-            maxFps: 0,
-            lockVideoOrientation: ScrcpyVideoOrientation.Unlocked,
-            tunnelForward: false,
-            crop: '-',
-            sendFrameMeta: true,
-            control: true,
-            displayId: 0,
-            showTouches: false,
-            stayAwake: false,
-            codecOptions: new CodecOptions({}),
-            encoderName: '-',
-        } as T;
-    }
-
-    public formatServerArguments(): string[] {
-        const defaults = this.getDefaultValue();
-        return this.getArgumentOrder()
-            .map(key => toScrcpyOptionValue(this.value[key] || defaults[key], '-'));
-    }
-
-    public createConnection(adb: Adb): ScrcpyClientConnection {
-        const options: ScrcpyClientConnectionOptions = {
-            // Old scrcpy connection always have control stream no matter what the option is
-            control: true,
-            sendDummyByte: true,
-            sendDeviceMeta: true,
-        };
-        if (this.value.tunnelForward) {
-            return new ScrcpyClientForwardConnection(adb, options);
-        } else {
-            return new ScrcpyClientReverseConnection(adb, options);
-        }
-    }
-
-    public getOutputEncoderNameRegex(): RegExp {
-        return /\s+scrcpy --encoder-name '(.*?)'/;
-    }
-
-    public createVideoStreamTransformer(): TransformStream<Uint8Array, VideoStreamPacket> {
-        // Optimized path for video frames only
-        if (this.value.sendFrameMeta === false) {
-            return new TransformStream({
-                transform(chunk, controller) {
-                    controller.enqueue({
-                        type: 'frame',
-                        data: chunk,
-                    });
-                },
-            });
-        }
-
-        let header: Uint8Array | undefined;
-
-        let deserializeStream = new StructDeserializeStream(VideoPacket);
-        return {
-            writable: deserializeStream.writable,
-            readable: deserializeStream.readable.pipeThrough(new TransformStream({
-                transform(packet, controller) {
-                    if (packet.pts === NO_PTS) {
-                        const sequenceParameterSet = parse_sequence_parameter_set(packet.data.slice().buffer);
-
-                        const {
-                            profile_idc: profileIndex,
-                            constraint_set: constraintSet,
-                            level_idc: levelIndex,
-                            pic_width_in_mbs_minus1,
-                            pic_height_in_map_units_minus1,
-                            frame_mbs_only_flag,
-                            frame_crop_left_offset,
-                            frame_crop_right_offset,
-                            frame_crop_top_offset,
-                            frame_crop_bottom_offset,
-                        } = sequenceParameterSet;
-
-                        const encodedWidth = (pic_width_in_mbs_minus1 + 1) * 16;
-                        const encodedHeight = (pic_height_in_map_units_minus1 + 1) * (2 - frame_mbs_only_flag) * 16;
-                        const cropLeft = frame_crop_left_offset * 2;
-                        const cropRight = frame_crop_right_offset * 2;
-                        const cropTop = frame_crop_top_offset * 2;
-                        const cropBottom = frame_crop_bottom_offset * 2;
-
-                        const croppedWidth = encodedWidth - cropLeft - cropRight;
-                        const croppedHeight = encodedHeight - cropTop - cropBottom;
-
-                        header = packet.data;
-                        controller.enqueue({
-                            type: 'configuration',
-                            data: {
-                                profileIndex,
-                                constraintSet,
-                                levelIndex,
-                                encodedWidth,
-                                encodedHeight,
-                                cropLeft,
-                                cropRight,
-                                cropTop,
-                                cropBottom,
-                                croppedWidth,
-                                croppedHeight,
-                            }
-                        });
-                        return;
-                    }
-
-                    let frameData: Uint8Array;
-                    if (header) {
-                        frameData = new Uint8Array(header.byteLength + packet.data.byteLength);
-                        frameData.set(header);
-                        frameData.set(packet.data, header.byteLength);
-                        header = undefined;
-                    } else {
-                        frameData = packet.data;
-                    }
-
-                    controller.enqueue({
-                        type: 'frame',
-                        pts: packet.pts,
-                        data: frameData,
-                    });
-                }
-            }))
-        };
-    }
-
-    public getControlMessageTypes(): ScrcpyControlMessageType[] {
-        return [
-            /*  0 */ ScrcpyControlMessageType.InjectKeycode,
-            /*  1 */ ScrcpyControlMessageType.InjectText,
-            /*  2 */ ScrcpyControlMessageType.InjectTouch,
-            /*  3 */ ScrcpyControlMessageType.InjectScroll,
-            /*  4 */ ScrcpyControlMessageType.BackOrScreenOn,
-            /*  5 */ ScrcpyControlMessageType.ExpandNotificationPanel,
-            /*  6 */ ScrcpyControlMessageType.CollapseNotificationPanel,
-            /*  7 */ ScrcpyControlMessageType.GetClipboard,
-            /*  8 */ ScrcpyControlMessageType.SetClipboard,
-            /*  9 */ ScrcpyControlMessageType.SetScreenPowerMode,
-            /* 10 */ ScrcpyControlMessageType.RotateDevice,
-        ];
-    }
-
-    public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnEvent1_18,
-    ) {
-        if (message.action === AndroidKeyEventAction.Down) {
-            return ScrcpyBackOrScreenOnEvent1_16.serialize(message);
-        }
-
-        return undefined;
-    }
-
-    public serializeInjectScrollControlMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
-    ): Uint8Array {
-        return ScrcpyInjectScrollControlMessage1_16.serialize(message);
-    }
-}
+export * from './codec-options.js';
+export * from './options.js';
+export * from './sps.js';