@yume-chan/scrcpy 0.0.15 → 0.0.17

package/src/adb/options/types.ts

@@ -0,0 +1,55 @@
+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';
+
+export interface AdbScrcpyOptions<T> extends ScrcpyOptions<T> {
+    createConnection(adb: Adb): AdbScrcpyConnection;
+}
+
+export abstract class AdbScrcpyOptionsBase<T> 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: ScrcpyBackOrScreenOnControlMessage1_18,
+    ): Uint8Array | undefined {
+        return this.raw.serializeBackOrScreenOnControlMessage(message);
+    }
+
+    public serializeInjectScrollControlMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
+    ): Uint8Array {
+        return this.raw.serializeInjectScrollControlMessage(message);
+    }
+
+    public abstract createConnection(adb: Adb): AdbScrcpyConnection;
+}

package/src/codec.ts

@@ -1,35 +1,35 @@
-// From https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
-export enum AndroidCodecProfile {
-    Baseline = 0x01,
-    Main = 0x02,
-    Extended = 0x04,
-    High = 0x08,
-    High10 = 0x10,
-    High422 = 0x20,
-    High444 = 0x40,
-    ConstrainedBaseline = 0x10000,
-    ConstrainedHigh = 0x80000,
-}
-
-export enum AndroidCodecLevel {
-    Level1 = 0x01,
-    Level1b = 0x02,
-    Level11 = 0x04,
-    Level12 = 0x08,
-    Level13 = 0x10,
-    Level2 = 0x20,
-    Level21 = 0x40,
-    Level22 = 0x80,
-    Level3 = 0x100,
-    Level31 = 0x200,
-    Level32 = 0x400,
-    Level4 = 0x800,
-    Level41 = 0x1000,
-    Level42 = 0x2000,
-    Level5 = 0x4000,
-    Level51 = 0x8000,
-    Level52 = 0x10000,
-    Level6 = 0x20000,
-    Level61 = 0x40000,
-    Level62 = 0x80000,
-}
+// From https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
+export enum AndroidCodecProfile {
+    Baseline = 0x01,
+    Main = 0x02,
+    Extended = 0x04,
+    High = 0x08,
+    High10 = 0x10,
+    High422 = 0x20,
+    High444 = 0x40,
+    ConstrainedBaseline = 0x10000,
+    ConstrainedHigh = 0x80000,
+}
+
+export enum AndroidCodecLevel {
+    Level1 = 0x01,
+    Level1b = 0x02,
+    Level11 = 0x04,
+    Level12 = 0x08,
+    Level13 = 0x10,
+    Level2 = 0x20,
+    Level21 = 0x40,
+    Level22 = 0x80,
+    Level3 = 0x100,
+    Level31 = 0x200,
+    Level32 = 0x400,
+    Level4 = 0x800,
+    Level41 = 0x1000,
+    Level42 = 0x2000,
+    Level5 = 0x4000,
+    Level51 = 0x8000,
+    Level52 = 0x10000,
+    Level6 = 0x20000,
+    Level61 = 0x40000,
+    Level62 = 0x80000,
+}

package/src/control/index.ts

@@ -0,0 +1,7 @@
+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';

package/src/control/inject-keycode.ts

@@ -0,0 +1,59 @@
+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,
+    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,
+    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-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,34 @@
+import Struct, { 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,
+}
+
+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');
+
+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'];

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 './codec.js';
-export * from './connection.js';
-export * from './decoder/index.js';
-export * from './message.js';
-export * from './options/index.js';
-export * from './push-server.js';
-export * from './utils.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

@@ -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(',');
+    }
+}