@9b9387/android-stream-scrcpy 0.1.0

package/dist/backend/scrcpy-backend.js

@@ -0,0 +1,250 @@
+import { EventEmitter } from "node:events";
+import { AUDIO_CODEC_IDS, VIDEO_CODEC_IDS, } from "../protocol/index.js";
+import { dataView, utf8Decode, zeroTerminatedUtf8Decode, } from "../protocol/core/binary.js";
+import { ScrcpyAdbClient } from "./adb/scrcpy-adb-client.js";
+import { BufferedStreamReader } from "./io/buffered-stream-reader.js";
+import { normalizeBackendOptions, } from "./server/options.js";
+import { buildServerCommand, getDeviceServerPath, } from "./server/server-command.js";
+export class ScrcpyBackend extends EventEmitter {
+    options;
+    adbClient;
+    device = null;
+    serverStream = null;
+    videoSocket = null;
+    audioSocket = null;
+    controlSocket = null;
+    videoReader = null;
+    audioReader = null;
+    controlReader = null;
+    running = false;
+    meta = null;
+    constructor(options = {}, adbClient = new ScrcpyAdbClient()) {
+        super();
+        this.options = normalizeBackendOptions(options);
+        this.adbClient = adbClient;
+    }
+    async start() {
+        if (this.running)
+            throw new Error("backend already running");
+        const selected = await this.adbClient.selectDevice(this.options.deviceSerial);
+        this.device = selected.device;
+        await this.spawnServer();
+        await this.connectSockets();
+        this.meta = await this.handshake();
+        this.running = true;
+        this.startWorkerLoops();
+        return this.meta;
+    }
+    stop() {
+        this.running = false;
+        this.cleanup();
+    }
+    sendControlMessage(msg) {
+        if (!this.running || !this.controlSocket) {
+            throw new Error("control channel is not available");
+        }
+        this.controlSocket.write(this.options.protocol.serializeControlMessage(msg));
+    }
+    async spawnServer() {
+        const devicePath = getDeviceServerPath(this.options.protocol.serverVersion);
+        await this.adbClient.pushServerJar(this.device, this.options.serverJarPath, devicePath, this.options.pushTimeoutMs);
+        const command = buildServerCommand(devicePath, this.options);
+        this.serverStream = await this.adbClient.startServer(this.device, command);
+        this.serverStream.on("data", (chunk) => {
+            this.emit("serverLog", utf8Decode(chunk));
+        });
+        await this.waitForServerStartProbe();
+    }
+    async waitForServerStartProbe() {
+        await new Promise((resolve, reject) => {
+            let timeout;
+            const onData = () => {
+                clearTimeout(timeout);
+                cleanup();
+                resolve();
+            };
+            const onError = (e) => {
+                clearTimeout(timeout);
+                cleanup();
+                reject(e);
+            };
+            const onEnd = () => {
+                clearTimeout(timeout);
+                cleanup();
+                reject(new Error("server exited prematurely"));
+            };
+            const cleanup = () => {
+                this.serverStream.removeListener("data", onData);
+                this.serverStream.removeListener("error", onError);
+                this.serverStream.removeListener("end", onEnd);
+            };
+            timeout = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, Math.min(500, this.options.deployTimeoutMs));
+            this.serverStream.on("data", onData);
+            this.serverStream.once("error", onError);
+            this.serverStream.once("end", onEnd);
+        });
+    }
+    async connectSockets() {
+        const order = [];
+        if (this.options.video)
+            order.push("video");
+        if (this.options.audio)
+            order.push("audio");
+        if (this.options.control)
+            order.push("control");
+        const deadline = Date.now() + this.options.connectionTimeoutMs;
+        for (const kind of order) {
+            const socket = await this.connectSocket(kind, deadline);
+            this.setSocket(kind, socket);
+        }
+    }
+    async connectSocket(kind, deadline) {
+        let attempts = 0;
+        while (Date.now() < deadline) {
+            attempts++;
+            try {
+                return await this.adbClient.openLocal(this.device, this.options.socketName);
+            }
+            catch {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+        }
+        throw new Error(`failed to connect scrcpy ${kind} socket after ${attempts} attempts`);
+    }
+    setSocket(kind, socket) {
+        if (kind === "video")
+            this.videoSocket = socket;
+        if (kind === "audio")
+            this.audioSocket = socket;
+        if (kind === "control")
+            this.controlSocket = socket;
+    }
+    async handshake() {
+        const firstSocket = this.videoSocket || this.audioSocket || this.controlSocket;
+        if (!firstSocket)
+            throw new Error("no sockets connected");
+        // scrcpy writes the dummy byte and device name to the first enabled socket,
+        // then writes per-stream metadata on each stream socket in connection order.
+        const sharedReader = new BufferedStreamReader(firstSocket);
+        const dummy = await sharedReader.readExact(1);
+        if (dummy[0] !== 0)
+            throw new Error("invalid dummy byte");
+        const deviceNameRaw = await sharedReader.readExact(64);
+        const deviceName = zeroTerminatedUtf8Decode(deviceNameRaw);
+        let videoCodec;
+        let audioCodec;
+        let width = 0;
+        let height = 0;
+        if (this.videoSocket) {
+            this.videoReader =
+                this.videoSocket === firstSocket
+                    ? sharedReader
+                    : new BufferedStreamReader(this.videoSocket);
+            const codecIdBuf = await this.videoReader.readExact(4);
+            videoCodec = VIDEO_CODEC_IDS[dataView(codecIdBuf).getUint32(0)];
+            const sessionBuf = await this.videoReader.readExact(12);
+            const session = this.options.protocol.parseFrameHeader(sessionBuf);
+            width = session.width;
+            height = session.height;
+        }
+        if (this.audioSocket) {
+            this.audioReader =
+                this.audioSocket === firstSocket
+                    ? sharedReader
+                    : new BufferedStreamReader(this.audioSocket);
+            const codecIdBuf = await this.audioReader.readExact(4);
+            const codecId = dataView(codecIdBuf).getUint32(0);
+            if (codecId === 0) {
+                this.audioSocket.destroy();
+                this.audioSocket = null;
+                this.audioReader = null;
+            }
+            else {
+                audioCodec = AUDIO_CODEC_IDS[codecId];
+            }
+        }
+        if (this.controlSocket) {
+            this.controlReader =
+                this.controlSocket === firstSocket
+                    ? sharedReader
+                    : new BufferedStreamReader(this.controlSocket);
+        }
+        return { deviceName, videoCodec, audioCodec, width, height };
+    }
+    async socketReadExact(socket, n) {
+        if (this.videoSocket === socket && this.videoReader)
+            return this.videoReader.readExact(n);
+        if (this.audioSocket === socket && this.audioReader)
+            return this.audioReader.readExact(n);
+        if (this.controlSocket === socket && this.controlReader) {
+            return this.controlReader.readExact(n);
+        }
+        throw new Error("no reader for socket");
+    }
+    startWorkerLoops() {
+        if (this.videoSocket) {
+            this.workerLoop("video", this.videoSocket, this.handleVideoHeader.bind(this));
+        }
+        if (this.audioSocket) {
+            this.workerLoop("audio", this.audioSocket, this.handleAudioHeader.bind(this));
+        }
+        if (this.controlSocket)
+            this.controlWorkerLoop();
+    }
+    async workerLoop(kind, socket, headerHandler) {
+        try {
+            while (this.running) {
+                const header = await this.socketReadExact(socket, 12);
+                await headerHandler(header);
+            }
+        }
+        catch (e) {
+            if (this.running)
+                this.emit("error", e);
+        }
+    }
+    async handleVideoHeader(header) {
+        const parsed = this.options.protocol.parseFrameHeader(header);
+        if (parsed.kind === "session") {
+            // Session packets carry resolution changes and do not have a payload.
+            this.emit("session", parsed);
+            return;
+        }
+        const payload = await this.socketReadExact(this.videoSocket, parsed.size);
+        this.emit("video", parsed, payload);
+    }
+    async handleAudioHeader(header) {
+        const parsed = this.options.protocol.parseFrameHeader(header);
+        if (parsed.kind === "session")
+            return;
+        const payload = await this.socketReadExact(this.audioSocket, parsed.size);
+        this.emit("audio", parsed, payload);
+    }
+    async controlWorkerLoop() {
+        const readExact = (n) => this.socketReadExact(this.controlSocket, n);
+        try {
+            while (this.running) {
+                const msg = await this.options.protocol.parseDeviceMessage(readExact);
+                this.emit("deviceMessage", msg);
+            }
+        }
+        catch (e) {
+            if (this.running)
+                this.emit("error", e);
+        }
+    }
+    cleanup() {
+        [this.videoSocket, this.audioSocket, this.controlSocket].forEach((socket) => socket?.destroy());
+        this.videoSocket = null;
+        this.audioSocket = null;
+        this.controlSocket = null;
+        this.videoReader = null;
+        this.audioReader = null;
+        this.controlReader = null;
+        this.serverStream?.destroy();
+        this.serverStream = null;
+    }
+}

package/dist/backend/server/options.d.ts

@@ -0,0 +1,26 @@
+import { AudioCodec, VideoCodec } from "../../protocol/index.js";
+import { ScrcpyProtocol, ScrcpyProtocolVersion } from "../../protocol/core/types.js";
+export interface ScrcpyBackendOptions {
+    deviceSerial?: string;
+    protocolVersion?: ScrcpyProtocolVersion;
+    scid?: number;
+    maxSize?: number;
+    maxFps?: number;
+    videoBitRate?: number;
+    audioBitRate?: number;
+    video?: boolean;
+    audio?: boolean;
+    control?: boolean;
+    videoCodec?: VideoCodec;
+    audioCodec?: AudioCodec;
+    connectionTimeoutMs?: number;
+    deployTimeoutMs?: number;
+    pushTimeoutMs?: number;
+    serverJarPath?: string;
+}
+export interface NormalizedScrcpyBackendOptions extends Required<Omit<ScrcpyBackendOptions, "serverJarPath">> {
+    protocol: ScrcpyProtocol;
+    socketName: string;
+    serverJarPath: string;
+}
+export declare function normalizeBackendOptions(options?: ScrcpyBackendOptions): NormalizedScrcpyBackendOptions;

package/dist/backend/server/options.js

@@ -0,0 +1,31 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { AudioCodec, VideoCodec } from "../../protocol/index.js";
+import { getScrcpyProtocol } from "../../protocol/registry.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function normalizeBackendOptions(options = {}) {
+    const protocolVersion = options.protocolVersion ?? "4.0";
+    const protocol = getScrcpyProtocol(protocolVersion);
+    const scid = options.scid ?? 0x0000000a;
+    return {
+        deviceSerial: options.deviceSerial ?? "",
+        protocolVersion,
+        protocol,
+        scid,
+        socketName: protocol.getSocketName(scid),
+        maxSize: options.maxSize ?? 0,
+        maxFps: options.maxFps ?? 30,
+        videoBitRate: options.videoBitRate ?? 8000000,
+        audioBitRate: options.audioBitRate ?? 128000,
+        video: options.video !== false,
+        audio: options.audio !== false,
+        control: options.control !== false,
+        videoCodec: options.videoCodec ?? VideoCodec.H264,
+        audioCodec: options.audioCodec ?? AudioCodec.OPUS,
+        connectionTimeoutMs: options.connectionTimeoutMs ?? 8000,
+        deployTimeoutMs: options.deployTimeoutMs ?? 5000,
+        pushTimeoutMs: options.pushTimeoutMs ?? 60000,
+        serverJarPath: options.serverJarPath ??
+            path.join(__dirname, "..", "..", "..", "assets", protocol.serverJarAssetName),
+    };
+}

package/dist/backend/server/server-command.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedScrcpyBackendOptions } from "./options.js";
+export declare function getDeviceServerPath(serverVersion: string): string;
+export declare function buildServerCommand(deviceServerPath: string, options: NormalizedScrcpyBackendOptions): string;

package/dist/backend/server/server-command.js

@@ -0,0 +1,24 @@
+export function getDeviceServerPath(serverVersion) {
+    return `/data/local/tmp/scrcpy-server-v${serverVersion}.jar`;
+}
+export function buildServerCommand(deviceServerPath, options) {
+    const args = [
+        `CLASSPATH=${deviceServerPath}`,
+        "app_process",
+        "/",
+        "com.genymobile.scrcpy.Server",
+        ...options.protocol.buildServerOptions({
+            scid: options.scid,
+            video: options.video,
+            audio: options.audio,
+            control: options.control,
+            videoCodec: options.videoCodec,
+            audioCodec: options.audioCodec,
+            maxSize: options.maxSize,
+            maxFps: options.maxFps,
+            videoBitRate: options.videoBitRate,
+            audioBitRate: options.audioBitRate,
+        }),
+    ];
+    return args.join(" ");
+}

package/dist/backend/server/socket-name.d.ts

@@ -0,0 +1,2 @@
+import { ScrcpyProtocolVersion } from "../../protocol/core/types.js";
+export declare function getScrcpySocketName(scid?: number, protocolVersion?: ScrcpyProtocolVersion): string;

package/dist/backend/server/socket-name.js

@@ -0,0 +1,4 @@
+import { getScrcpyProtocol } from "../../protocol/registry.js";
+export function getScrcpySocketName(scid, protocolVersion = "4.0") {
+    return getScrcpyProtocol(protocolVersion).getSocketName(scid);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./protocol/index.js";
+export * from "./backend/index.js";
+export * from "./service/index.js";
+export * from "./snapshot/index.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./protocol/index.js";
+export * from "./backend/index.js";
+export * from "./service/index.js";
+export * from "./snapshot/index.js";

package/dist/protocol/core/binary.d.ts

@@ -0,0 +1,5 @@
+export declare function dataView(bytes: Uint8Array): DataView;
+export declare function concatBytes(chunks: readonly Uint8Array[]): Uint8Array;
+export declare function utf8Encode(text: string): Uint8Array;
+export declare function utf8Decode(bytes: Uint8Array): string;
+export declare function zeroTerminatedUtf8Decode(bytes: Uint8Array): string;

package/dist/protocol/core/binary.js

@@ -0,0 +1,23 @@
+export function dataView(bytes) {
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+export function concatBytes(chunks) {
+    const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}
+export function utf8Encode(text) {
+    return new TextEncoder().encode(text);
+}
+export function utf8Decode(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+export function zeroTerminatedUtf8Decode(bytes) {
+    const end = bytes.indexOf(0);
+    return utf8Decode(end === -1 ? bytes : bytes.subarray(0, end));
+}

package/dist/protocol/core/types.d.ts

@@ -0,0 +1,15 @@
+import { ControlMessage } from "../v4_0/control-message-types.js";
+import { DeviceMessage } from "../v4_0/device-message.js";
+import { StreamPacketMeta } from "../v4_0/frame-header.js";
+import { ScrcpyServerOptionInput } from "../v4_0/server-options.js";
+export type ScrcpyProtocolVersion = "4.0";
+export interface ScrcpyProtocol {
+    version: ScrcpyProtocolVersion;
+    serverVersion: string;
+    serverJarAssetName: string;
+    serializeControlMessage(message: ControlMessage): Uint8Array;
+    parseFrameHeader(header: Uint8Array): StreamPacketMeta;
+    parseDeviceMessage(readExact: (n: number) => Promise<Uint8Array>): Promise<DeviceMessage>;
+    buildServerOptions(input: ScrcpyServerOptionInput): string[];
+    getSocketName(scid?: number): string;
+}

package/dist/protocol/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/protocol/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core/types.js";
+export * from "./registry.js";
+export * from "./v4_0/index.js";

package/dist/protocol/index.js

@@ -0,0 +1,3 @@
+export * from "./core/types.js";
+export * from "./registry.js";
+export * from "./v4_0/index.js";

package/dist/protocol/registry.d.ts

@@ -0,0 +1,3 @@
+import { ScrcpyProtocol, ScrcpyProtocolVersion } from "./core/types.js";
+export declare function getScrcpyProtocol(version?: ScrcpyProtocolVersion): ScrcpyProtocol;
+export declare function listScrcpyProtocolVersions(): ScrcpyProtocolVersion[];

package/dist/protocol/registry.js

@@ -0,0 +1,16 @@
+import { SCRCPY_4_0_PROTOCOL } from "./v4_0/index.js";
+const PROTOCOLS = {
+    "4.0": SCRCPY_4_0_PROTOCOL,
+};
+export function getScrcpyProtocol(version = "4.0") {
+    // Keep version selection centralized so future protocol versions can be
+    // registered without changing backend or service orchestration code.
+    const protocol = PROTOCOLS[version];
+    if (!protocol) {
+        throw new Error(`unsupported scrcpy protocol version: ${version}`);
+    }
+    return protocol;
+}
+export function listScrcpyProtocolVersions() {
+    return Object.keys(PROTOCOLS);
+}

package/dist/protocol/v4_0/codecs.d.ts

@@ -0,0 +1,14 @@
+export declare enum VideoCodec {
+    H264 = "h264",
+    H265 = "h265",
+    AV1 = "av1"
+}
+export declare enum AudioCodec {
+    OPUS = "opus",
+    AAC = "aac",
+    FLAC = "flac",
+    RAW = "raw"
+}
+export declare function getCodecId(name: string): number;
+export declare const VIDEO_CODEC_IDS: Record<number, VideoCodec>;
+export declare const AUDIO_CODEC_IDS: Record<number, AudioCodec>;

package/dist/protocol/v4_0/codecs.js

@@ -0,0 +1,22 @@
+import { dataView, utf8Encode } from "../core/binary.js";
+export var VideoCodec;
+(function (VideoCodec) {
+    VideoCodec["H264"] = "h264";
+    VideoCodec["H265"] = "h265";
+    VideoCodec["AV1"] = "av1";
+})(VideoCodec || (VideoCodec = {}));
+export var AudioCodec;
+(function (AudioCodec) {
+    AudioCodec["OPUS"] = "opus";
+    AudioCodec["AAC"] = "aac";
+    AudioCodec["FLAC"] = "flac";
+    AudioCodec["RAW"] = "raw";
+})(AudioCodec || (AudioCodec = {}));
+export function getCodecId(name) {
+    const bytes = new Uint8Array(4);
+    const nameBytes = utf8Encode(name);
+    bytes.set(nameBytes, 4 - nameBytes.byteLength);
+    return dataView(bytes).getUint32(0);
+}
+export const VIDEO_CODEC_IDS = Object.fromEntries(Object.values(VideoCodec).map((codec) => [getCodecId(codec), codec]));
+export const AUDIO_CODEC_IDS = Object.fromEntries(Object.values(AudioCodec).map((codec) => [getCodecId(codec), codec]));

package/dist/protocol/v4_0/control-message-types.d.ts

@@ -0,0 +1,115 @@
+export declare enum ControlMessageType {
+    INJECT_KEYCODE = 0,
+    INJECT_TEXT = 1,
+    INJECT_TOUCH_EVENT = 2,
+    INJECT_SCROLL_EVENT = 3,
+    BACK_OR_SCREEN_ON = 4,
+    EXPAND_NOTIFICATION_PANEL = 5,
+    EXPAND_SETTINGS_PANEL = 6,
+    COLLAPSE_PANELS = 7,
+    GET_CLIPBOARD = 8,
+    SET_CLIPBOARD = 9,
+    SET_DISPLAY_POWER = 10,
+    ROTATE_DEVICE = 11,
+    UHID_CREATE = 12,
+    UHID_INPUT = 13,
+    UHID_DESTROY = 14,
+    OPEN_HARD_KEYBOARD_SETTINGS = 15,
+    START_APP = 16,
+    RESET_VIDEO = 17,
+    CAMERA_SET_TORCH = 18,
+    CAMERA_ZOOM_IN = 19,
+    CAMERA_ZOOM_OUT = 20,
+    RESIZE_DISPLAY = 21
+}
+export declare enum CopyKey {
+    NONE = 0,
+    COPY = 1,
+    CUT = 2
+}
+export declare const ACTION_DOWN = 0;
+export declare const ACTION_UP = 1;
+export declare const ACTION_MOVE = 2;
+export declare const KEY_ACTION_DOWN = 0;
+export declare const KEY_ACTION_UP = 1;
+export declare const BUTTON_PRIMARY: number;
+export declare const BUTTON_SECONDARY: number;
+export declare const BUTTON_TERTIARY: number;
+export declare const POINTER_ID_MOUSE = -1n;
+export declare const POINTER_ID_GENERIC_FINGER = -2n;
+export declare const POINTER_ID_VIRTUAL_FINGER = -3n;
+export declare const INJECT_TEXT_MAX_LENGTH = 300;
+export declare const CONTROL_MESSAGE_MAX_SIZE: number;
+export declare const SET_CLIPBOARD_TEXT_MAX_LENGTH: number;
+export declare const UHID_NAME_MAX_LENGTH = 127;
+export declare const START_APP_NAME_MAX_LENGTH = 255;
+export type ControlMessage = {
+    type: ControlMessageType.INJECT_KEYCODE;
+    action: number;
+    keycode: number;
+    repeat?: number;
+    metaState?: number;
+} | {
+    type: ControlMessageType.INJECT_TEXT;
+    text: string;
+} | {
+    type: ControlMessageType.INJECT_TOUCH_EVENT;
+    action: number;
+    pointerId: bigint;
+    x: number;
+    y: number;
+    screenWidth: number;
+    screenHeight: number;
+    pressure?: number;
+    actionButton?: number;
+    buttons?: number;
+} | {
+    type: ControlMessageType.INJECT_SCROLL_EVENT;
+    x: number;
+    y: number;
+    screenWidth: number;
+    screenHeight: number;
+    hScroll?: number;
+    vScroll?: number;
+    buttons?: number;
+} | {
+    type: ControlMessageType.BACK_OR_SCREEN_ON;
+    action: number;
+} | {
+    type: ControlMessageType.GET_CLIPBOARD;
+    copyKey: CopyKey | number;
+} | {
+    type: ControlMessageType.SET_CLIPBOARD;
+    sequence: bigint;
+    text: string;
+    paste: boolean;
+} | {
+    type: ControlMessageType.SET_DISPLAY_POWER;
+    on: boolean;
+} | {
+    type: ControlMessageType.UHID_CREATE;
+    id: number;
+    vendorId: number;
+    productId: number;
+    name: string;
+    reportDescriptor: Uint8Array;
+} | {
+    type: ControlMessageType.UHID_INPUT;
+    id: number;
+    data: Uint8Array;
+} | {
+    type: ControlMessageType.UHID_DESTROY;
+    id: number;
+} | {
+    type: ControlMessageType.START_APP;
+    name: string;
+} | {
+    type: ControlMessageType.CAMERA_SET_TORCH;
+    on: boolean;
+} | {
+    type: ControlMessageType.RESIZE_DISPLAY;
+    width: number;
+    height: number;
+} | {
+    type: ControlMessageType.EXPAND_NOTIFICATION_PANEL | ControlMessageType.EXPAND_SETTINGS_PANEL | ControlMessageType.COLLAPSE_PANELS | ControlMessageType.ROTATE_DEVICE | ControlMessageType.OPEN_HARD_KEYBOARD_SETTINGS | ControlMessageType.RESET_VIDEO | ControlMessageType.CAMERA_ZOOM_IN | ControlMessageType.CAMERA_ZOOM_OUT;
+};

package/dist/protocol/v4_0/control-message-types.js

@@ -0,0 +1,47 @@
+export var ControlMessageType;
+(function (ControlMessageType) {
+    ControlMessageType[ControlMessageType["INJECT_KEYCODE"] = 0] = "INJECT_KEYCODE";
+    ControlMessageType[ControlMessageType["INJECT_TEXT"] = 1] = "INJECT_TEXT";
+    ControlMessageType[ControlMessageType["INJECT_TOUCH_EVENT"] = 2] = "INJECT_TOUCH_EVENT";
+    ControlMessageType[ControlMessageType["INJECT_SCROLL_EVENT"] = 3] = "INJECT_SCROLL_EVENT";
+    ControlMessageType[ControlMessageType["BACK_OR_SCREEN_ON"] = 4] = "BACK_OR_SCREEN_ON";
+    ControlMessageType[ControlMessageType["EXPAND_NOTIFICATION_PANEL"] = 5] = "EXPAND_NOTIFICATION_PANEL";
+    ControlMessageType[ControlMessageType["EXPAND_SETTINGS_PANEL"] = 6] = "EXPAND_SETTINGS_PANEL";
+    ControlMessageType[ControlMessageType["COLLAPSE_PANELS"] = 7] = "COLLAPSE_PANELS";
+    ControlMessageType[ControlMessageType["GET_CLIPBOARD"] = 8] = "GET_CLIPBOARD";
+    ControlMessageType[ControlMessageType["SET_CLIPBOARD"] = 9] = "SET_CLIPBOARD";
+    ControlMessageType[ControlMessageType["SET_DISPLAY_POWER"] = 10] = "SET_DISPLAY_POWER";
+    ControlMessageType[ControlMessageType["ROTATE_DEVICE"] = 11] = "ROTATE_DEVICE";
+    ControlMessageType[ControlMessageType["UHID_CREATE"] = 12] = "UHID_CREATE";
+    ControlMessageType[ControlMessageType["UHID_INPUT"] = 13] = "UHID_INPUT";
+    ControlMessageType[ControlMessageType["UHID_DESTROY"] = 14] = "UHID_DESTROY";
+    ControlMessageType[ControlMessageType["OPEN_HARD_KEYBOARD_SETTINGS"] = 15] = "OPEN_HARD_KEYBOARD_SETTINGS";
+    ControlMessageType[ControlMessageType["START_APP"] = 16] = "START_APP";
+    ControlMessageType[ControlMessageType["RESET_VIDEO"] = 17] = "RESET_VIDEO";
+    ControlMessageType[ControlMessageType["CAMERA_SET_TORCH"] = 18] = "CAMERA_SET_TORCH";
+    ControlMessageType[ControlMessageType["CAMERA_ZOOM_IN"] = 19] = "CAMERA_ZOOM_IN";
+    ControlMessageType[ControlMessageType["CAMERA_ZOOM_OUT"] = 20] = "CAMERA_ZOOM_OUT";
+    ControlMessageType[ControlMessageType["RESIZE_DISPLAY"] = 21] = "RESIZE_DISPLAY";
+})(ControlMessageType || (ControlMessageType = {}));
+export var CopyKey;
+(function (CopyKey) {
+    CopyKey[CopyKey["NONE"] = 0] = "NONE";
+    CopyKey[CopyKey["COPY"] = 1] = "COPY";
+    CopyKey[CopyKey["CUT"] = 2] = "CUT";
+})(CopyKey || (CopyKey = {}));
+export const ACTION_DOWN = 0;
+export const ACTION_UP = 1;
+export const ACTION_MOVE = 2;
+export const KEY_ACTION_DOWN = 0;
+export const KEY_ACTION_UP = 1;
+export const BUTTON_PRIMARY = 1 << 0;
+export const BUTTON_SECONDARY = 1 << 1;
+export const BUTTON_TERTIARY = 1 << 2;
+export const POINTER_ID_MOUSE = -1n;
+export const POINTER_ID_GENERIC_FINGER = -2n;
+export const POINTER_ID_VIRTUAL_FINGER = -3n;
+export const INJECT_TEXT_MAX_LENGTH = 300;
+export const CONTROL_MESSAGE_MAX_SIZE = 1 << 18;
+export const SET_CLIPBOARD_TEXT_MAX_LENGTH = CONTROL_MESSAGE_MAX_SIZE - 14;
+export const UHID_NAME_MAX_LENGTH = 127;
+export const START_APP_NAME_MAX_LENGTH = 255;

package/dist/protocol/v4_0/control-message.d.ts

@@ -0,0 +1,2 @@
+import { ControlMessage } from "./control-message-types.js";
+export declare function serializeControlMessage(msg: ControlMessage): Uint8Array;