@9b9387/android-stream-scrcpy 0.1.0

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

@@ -0,0 +1,149 @@
+import { ControlMessageType, INJECT_TEXT_MAX_LENGTH, SET_CLIPBOARD_TEXT_MAX_LENGTH, START_APP_NAME_MAX_LENGTH, UHID_NAME_MAX_LENGTH, } from "./control-message-types.js";
+import { truncateUtf8, writeTinyString } from "./string-payload.js";
+function u16FixedPoint(value) {
+    if (value >= 1.0)
+        return 0xffff;
+    if (value <= 0.0)
+        return 0;
+    return Math.floor(value * 0x10000) & 0xffff;
+}
+function i16FixedPoint(value) {
+    if (value >= 1.0)
+        return 0x7fff;
+    if (value <= -1.0)
+        return 0x8000;
+    return Math.floor(value * 0x8000) & 0xffff;
+}
+export function serializeControlMessage(msg) {
+    switch (msg.type) {
+        case ControlMessageType.INJECT_KEYCODE: {
+            const buf = new Uint8Array(14);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint8(1, msg.action & 0xff);
+            view.setUint32(2, msg.keycode >>> 0);
+            view.setUint32(6, (msg.repeat ?? 0) >>> 0);
+            view.setUint32(10, (msg.metaState ?? 0) >>> 0);
+            return buf;
+        }
+        case ControlMessageType.INJECT_TEXT: {
+            const textBuf = truncateUtf8(msg.text, INJECT_TEXT_MAX_LENGTH);
+            const buf = new Uint8Array(5 + textBuf.byteLength);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint32(1, textBuf.byteLength);
+            buf.set(textBuf, 5);
+            return buf;
+        }
+        case ControlMessageType.INJECT_TOUCH_EVENT: {
+            const buf = new Uint8Array(32);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint8(1, msg.action & 0xff);
+            view.setBigUint64(2, BigInt.asUintN(64, msg.pointerId));
+            view.setInt32(10, Math.floor(msg.x));
+            view.setInt32(14, Math.floor(msg.y));
+            view.setUint16(18, msg.screenWidth & 0xffff);
+            view.setUint16(20, msg.screenHeight & 0xffff);
+            view.setUint16(22, u16FixedPoint(msg.pressure ?? 1.0));
+            view.setUint32(24, (msg.actionButton ?? 0) >>> 0);
+            view.setUint32(28, (msg.buttons ?? 0) >>> 0);
+            return buf;
+        }
+        case ControlMessageType.INJECT_SCROLL_EVENT: {
+            const buf = new Uint8Array(21);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setInt32(1, Math.floor(msg.x));
+            view.setInt32(5, Math.floor(msg.y));
+            view.setUint16(9, msg.screenWidth & 0xffff);
+            view.setUint16(11, msg.screenHeight & 0xffff);
+            const h = Math.max(-1.0, Math.min(1.0, (msg.hScroll ?? 0.0) / 16.0));
+            const v = Math.max(-1.0, Math.min(1.0, (msg.vScroll ?? 0.0) / 16.0));
+            view.setUint16(13, i16FixedPoint(h));
+            view.setUint16(15, i16FixedPoint(v));
+            view.setUint32(17, (msg.buttons ?? 0) >>> 0);
+            return buf;
+        }
+        case ControlMessageType.BACK_OR_SCREEN_ON: {
+            return Uint8Array.of(msg.type, msg.action & 0xff);
+        }
+        case ControlMessageType.GET_CLIPBOARD: {
+            return Uint8Array.of(msg.type, msg.copyKey & 0xff);
+        }
+        case ControlMessageType.SET_CLIPBOARD: {
+            const textBuf = truncateUtf8(msg.text, SET_CLIPBOARD_TEXT_MAX_LENGTH);
+            const buf = new Uint8Array(14 + textBuf.byteLength);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setBigUint64(1, BigInt.asUintN(64, msg.sequence));
+            view.setUint8(9, msg.paste ? 1 : 0);
+            view.setUint32(10, textBuf.byteLength);
+            buf.set(textBuf, 14);
+            return buf;
+        }
+        case ControlMessageType.SET_DISPLAY_POWER:
+        case ControlMessageType.CAMERA_SET_TORCH: {
+            return Uint8Array.of(msg.type, msg.on ? 1 : 0);
+        }
+        case ControlMessageType.UHID_CREATE: {
+            const nameBuf = truncateUtf8(msg.name, UHID_NAME_MAX_LENGTH);
+            const reportDescriptor = msg.reportDescriptor;
+            const buf = new Uint8Array(10 + nameBuf.byteLength + reportDescriptor.byteLength);
+            const view = new DataView(buf.buffer);
+            let offset = 0;
+            view.setUint8(offset++, msg.type);
+            view.setUint16(offset, msg.id & 0xffff);
+            offset += 2;
+            view.setUint16(offset, msg.vendorId & 0xffff);
+            offset += 2;
+            view.setUint16(offset, msg.productId & 0xffff);
+            offset += 2;
+            offset += writeTinyString(buf, offset, msg.name, UHID_NAME_MAX_LENGTH);
+            view.setUint16(offset, reportDescriptor.byteLength & 0xffff);
+            offset += 2;
+            buf.set(reportDescriptor, offset);
+            return buf;
+        }
+        case ControlMessageType.UHID_INPUT: {
+            const buf = new Uint8Array(5 + msg.data.byteLength);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint16(1, msg.id & 0xffff);
+            view.setUint16(3, msg.data.byteLength & 0xffff);
+            buf.set(msg.data, 5);
+            return buf;
+        }
+        case ControlMessageType.UHID_DESTROY: {
+            const buf = new Uint8Array(3);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint16(1, msg.id & 0xffff);
+            return buf;
+        }
+        case ControlMessageType.START_APP: {
+            const nameBuf = truncateUtf8(msg.name, START_APP_NAME_MAX_LENGTH);
+            const buf = new Uint8Array(2 + nameBuf.byteLength);
+            new DataView(buf.buffer).setUint8(0, msg.type);
+            writeTinyString(buf, 1, msg.name, START_APP_NAME_MAX_LENGTH);
+            return buf;
+        }
+        case ControlMessageType.RESIZE_DISPLAY: {
+            const buf = new Uint8Array(5);
+            const view = new DataView(buf.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint16(1, msg.width & 0xffff);
+            view.setUint16(3, msg.height & 0xffff);
+            return buf;
+        }
+        case ControlMessageType.EXPAND_NOTIFICATION_PANEL:
+        case ControlMessageType.EXPAND_SETTINGS_PANEL:
+        case ControlMessageType.COLLAPSE_PANELS:
+        case ControlMessageType.ROTATE_DEVICE:
+        case ControlMessageType.OPEN_HARD_KEYBOARD_SETTINGS:
+        case ControlMessageType.RESET_VIDEO:
+        case ControlMessageType.CAMERA_ZOOM_IN:
+        case ControlMessageType.CAMERA_ZOOM_OUT:
+            return Uint8Array.of(msg.type);
+    }
+}

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

@@ -0,0 +1,17 @@
+export declare enum DeviceMessageType {
+    CLIPBOARD = 0,
+    ACK_CLIPBOARD = 1,
+    UHID_OUTPUT = 2
+}
+export type DeviceMessage = {
+    type: DeviceMessageType.CLIPBOARD;
+    text: string;
+} | {
+    type: DeviceMessageType.ACK_CLIPBOARD;
+    sequence: bigint;
+} | {
+    type: DeviceMessageType.UHID_OUTPUT;
+    uhidId: number;
+    data: Uint8Array;
+};
+export declare function parseDeviceMessage(readExact: (n: number) => Promise<Uint8Array>): Promise<DeviceMessage>;

package/dist/protocol/v4_0/device-message.js

@@ -0,0 +1,33 @@
+import { dataView, utf8Decode } from "../core/binary.js";
+export var DeviceMessageType;
+(function (DeviceMessageType) {
+    DeviceMessageType[DeviceMessageType["CLIPBOARD"] = 0] = "CLIPBOARD";
+    DeviceMessageType[DeviceMessageType["ACK_CLIPBOARD"] = 1] = "ACK_CLIPBOARD";
+    DeviceMessageType[DeviceMessageType["UHID_OUTPUT"] = 2] = "UHID_OUTPUT";
+})(DeviceMessageType || (DeviceMessageType = {}));
+export async function parseDeviceMessage(readExact) {
+    const head = await readExact(1);
+    const type = head[0];
+    switch (type) {
+        case DeviceMessageType.CLIPBOARD: {
+            const lenBuf = await readExact(4);
+            const length = dataView(lenBuf).getUint32(0);
+            const textBuf = await readExact(length);
+            return { type, text: utf8Decode(textBuf) };
+        }
+        case DeviceMessageType.ACK_CLIPBOARD: {
+            const seqBuf = await readExact(8);
+            return { type, sequence: dataView(seqBuf).getBigUint64(0) };
+        }
+        case DeviceMessageType.UHID_OUTPUT: {
+            const metaBuf = await readExact(4);
+            const meta = dataView(metaBuf);
+            const uhidId = meta.getUint16(0);
+            const length = meta.getUint16(2);
+            const data = await readExact(length);
+            return { type, uhidId, data };
+        }
+        default:
+            throw new Error(`unknown device message type: ${type}`);
+    }
+}

package/dist/protocol/v4_0/frame-header.d.ts

@@ -0,0 +1,19 @@
+export declare const SESSION_PACKET_FLAG: bigint;
+export declare const CONFIG_PACKET_FLAG: bigint;
+export declare const KEY_FRAME_FLAG: bigint;
+export declare const PTS_MASK: bigint;
+export interface SessionPacket {
+    kind: "session";
+    width: number;
+    height: number;
+    clientResized: boolean;
+}
+export interface FrameMeta {
+    kind: "frame";
+    ptsUs: bigint;
+    size: number;
+    config: boolean;
+    keyFrame: boolean;
+}
+export type StreamPacketMeta = SessionPacket | FrameMeta;
+export declare function parseFrameHeader(header: Uint8Array): StreamPacketMeta;

package/dist/protocol/v4_0/frame-header.js

@@ -0,0 +1,29 @@
+import { dataView } from "../core/binary.js";
+export const SESSION_PACKET_FLAG = 1n << 63n;
+export const CONFIG_PACKET_FLAG = 1n << 62n;
+export const KEY_FRAME_FLAG = 1n << 61n;
+export const PTS_MASK = (1n << 61n) - 1n;
+export function parseFrameHeader(header) {
+    if (header.byteLength !== 12) {
+        throw new Error(`frame header must be 12 bytes, got ${header.byteLength}`);
+    }
+    const view = dataView(header);
+    const ptsAndFlags = view.getBigUint64(0);
+    const size = view.getUint32(8);
+    if (ptsAndFlags & SESSION_PACKET_FLAG) {
+        const flagsHigh = Number((ptsAndFlags >> 32n) & 0xffffffffn);
+        return {
+            kind: "session",
+            width: Number(ptsAndFlags & 0xffffffffn),
+            height: size,
+            clientResized: (flagsHigh & 0x01) !== 0,
+        };
+    }
+    return {
+        kind: "frame",
+        ptsUs: ptsAndFlags & PTS_MASK,
+        size,
+        config: (ptsAndFlags & CONFIG_PACKET_FLAG) !== 0n,
+        keyFrame: (ptsAndFlags & KEY_FRAME_FLAG) !== 0n,
+    };
+}

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

@@ -0,0 +1,9 @@
+import { ScrcpyProtocol } from "../core/types.js";
+export * from "./codecs.js";
+export * from "./control-message.js";
+export * from "./control-message-types.js";
+export * from "./device-message.js";
+export * from "./frame-header.js";
+export * from "./server-options.js";
+export * from "./string-payload.js";
+export declare const SCRCPY_4_0_PROTOCOL: ScrcpyProtocol;

package/dist/protocol/v4_0/index.js

@@ -0,0 +1,21 @@
+import { serializeControlMessage } from "./control-message.js";
+import { parseDeviceMessage } from "./device-message.js";
+import { parseFrameHeader } from "./frame-header.js";
+import { buildServerOptions, getSocketName, SCRCPY_4_0_SERVER_JAR, SCRCPY_4_0_SERVER_VERSION, } from "./server-options.js";
+export * from "./codecs.js";
+export * from "./control-message.js";
+export * from "./control-message-types.js";
+export * from "./device-message.js";
+export * from "./frame-header.js";
+export * from "./server-options.js";
+export * from "./string-payload.js";
+export const SCRCPY_4_0_PROTOCOL = {
+    version: "4.0",
+    serverVersion: SCRCPY_4_0_SERVER_VERSION,
+    serverJarAssetName: SCRCPY_4_0_SERVER_JAR,
+    serializeControlMessage,
+    parseFrameHeader,
+    parseDeviceMessage,
+    buildServerOptions,
+    getSocketName,
+};

package/dist/protocol/v4_0/server-options.d.ts

@@ -0,0 +1,19 @@
+import { AudioCodec, VideoCodec } from "./codecs.js";
+export declare const SCRCPY_4_0_SERVER_VERSION = "4.0";
+export declare const SCRCPY_4_0_SERVER_JAR = "scrcpy-server-v4.0.jar";
+export declare const DEFAULT_SCRCPY_SCID = 10;
+export interface ScrcpyServerOptionInput {
+    scid?: number;
+    logLevel?: "verbose" | "debug" | "info" | "warn" | "error";
+    video: boolean;
+    audio: boolean;
+    control: boolean;
+    videoCodec: VideoCodec;
+    audioCodec: AudioCodec;
+    maxSize: number;
+    maxFps: number;
+    videoBitRate: number;
+    audioBitRate: number;
+}
+export declare function getSocketName(scid?: number): string;
+export declare function buildServerOptions(input: ScrcpyServerOptionInput): string[];

package/dist/protocol/v4_0/server-options.js

@@ -0,0 +1,38 @@
+export const SCRCPY_4_0_SERVER_VERSION = "4.0";
+export const SCRCPY_4_0_SERVER_JAR = "scrcpy-server-v4.0.jar";
+export const DEFAULT_SCRCPY_SCID = 0x0000000a;
+export function getSocketName(scid = DEFAULT_SCRCPY_SCID) {
+    if (scid === -1)
+        return "scrcpy";
+    if (scid < -1) {
+        throw new Error(`scrcpy scid must be -1 or a non-negative 31-bit value, got ${scid}`);
+    }
+    return `scrcpy_${scid.toString(16).padStart(8, "0")}`;
+}
+export function buildServerOptions(input) {
+    const scid = input.scid ?? DEFAULT_SCRCPY_SCID;
+    return [
+        SCRCPY_4_0_SERVER_VERSION,
+        `log_level=${input.logLevel ?? "info"}`,
+        "tunnel_forward=true",
+        `scid=${scid.toString(16)}`,
+        `video=${input.video}`,
+        `audio=${input.audio}`,
+        `control=${input.control}`,
+        `video_codec=${input.videoCodec}`,
+        `audio_codec=${input.audioCodec}`,
+        `max_size=${input.maxSize}`,
+        `max_fps=${input.maxFps}`,
+        `video_bit_rate=${input.videoBitRate}`,
+        `audio_bit_rate=${input.audioBitRate}`,
+        "send_device_meta=true",
+        "send_frame_meta=true",
+        "send_dummy_byte=true",
+        "send_stream_meta=true",
+        "cleanup=true",
+        "stay_awake=false",
+        "show_touches=false",
+        "power_off_on_close=false",
+        "clipboard_autosync=false",
+    ];
+}

package/dist/protocol/v4_0/string-payload.d.ts

@@ -0,0 +1,2 @@
+export declare function truncateUtf8(text: string, maxBytes: number): Uint8Array;
+export declare function writeTinyString(target: Uint8Array, offset: number, text: string, maxBytes: number): number;

package/dist/protocol/v4_0/string-payload.js

@@ -0,0 +1,23 @@
+import { utf8Encode } from "../core/binary.js";
+export function truncateUtf8(text, maxBytes) {
+    const bytes = utf8Encode(text);
+    if (bytes.byteLength <= maxBytes)
+        return bytes;
+    let end = maxBytes;
+    while (end > 0 && (bytes[end] & 0xc0) === 0x80) {
+        end--;
+    }
+    if (end > 0 && (bytes[end] & 0x80) !== 0) {
+        end--;
+    }
+    return bytes.subarray(0, end);
+}
+export function writeTinyString(target, offset, text, maxBytes) {
+    if (maxBytes > 0xff) {
+        throw new Error(`tiny string max length must fit in one byte, got ${maxBytes}`);
+    }
+    const payload = truncateUtf8(text, maxBytes);
+    target[offset] = payload.byteLength;
+    target.set(payload, offset + 1);
+    return 1 + payload.byteLength;
+}

package/dist/service/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./packet-queue-subscriber.js";
+export * from "./scrcpy-stream-service.js";
+export * from "./types.js";

package/dist/service/index.js

@@ -0,0 +1,3 @@
+export * from "./packet-queue-subscriber.js";
+export * from "./scrcpy-stream-service.js";
+export * from "./types.js";

package/dist/service/packet-queue-subscriber.d.ts

@@ -0,0 +1,11 @@
+import { MediaPacket } from "./types.js";
+export declare class PacketQueueSubscriber implements AsyncIterable<MediaPacket> {
+    private maxQueue;
+    private queue;
+    private resolveNext;
+    private closed;
+    constructor(maxQueue: number);
+    push(packet: MediaPacket): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<MediaPacket>;
+}

package/dist/service/packet-queue-subscriber.js

@@ -0,0 +1,56 @@
+import { MediaKind } from "./types.js";
+export class PacketQueueSubscriber {
+    maxQueue;
+    queue = [];
+    resolveNext = null;
+    closed = false;
+    constructor(maxQueue) {
+        this.maxQueue = maxQueue;
+    }
+    push(packet) {
+        if (this.closed)
+            return;
+        if (this.resolveNext) {
+            const resolve = this.resolveNext;
+            this.resolveNext = null;
+            resolve({ done: false, value: packet });
+            return;
+        }
+        if (this.queue.length >= this.maxQueue) {
+            // Preserve config/session packets because late subscribers need them to
+            // initialize decoders before receiving regular media frames.
+            const index = this.queue.findIndex((item) => !item.config && item.kind !== MediaKind.SESSION);
+            if (index !== -1) {
+                this.queue.splice(index, 1);
+            }
+            else {
+                this.queue.shift();
+            }
+        }
+        this.queue.push(packet);
+    }
+    close() {
+        this.closed = true;
+        if (this.resolveNext) {
+            const resolve = this.resolveNext;
+            this.resolveNext = null;
+            resolve({ done: true, value: undefined });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                yield this.queue.shift();
+                continue;
+            }
+            if (this.closed)
+                return;
+            const result = await new Promise((resolve) => {
+                this.resolveNext = resolve;
+            });
+            if (result.done)
+                return;
+            yield result.value;
+        }
+    }
+}

package/dist/service/scrcpy-stream-service.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "node:events";
+import { StreamMeta } from "../backend/scrcpy-backend.js";
+import { ControlMessage } from "../protocol/index.js";
+import { MediaPacket, ScrcpyStreamServiceOptions, StreamState } from "./types.js";
+export declare class ScrcpyStreamService extends EventEmitter {
+    private backend;
+    private state;
+    private meta;
+    private queueMaxPackets;
+    private videoConfig;
+    private audioConfig;
+    private latestKeyFrame;
+    private latestSession;
+    private subscribers;
+    constructor(options?: ScrcpyStreamServiceOptions);
+    start(): Promise<StreamMeta>;
+    stop(): void;
+    sendControlMessage(msg: ControlMessage): void;
+    subscribe(): AsyncIterableIterator<MediaPacket>;
+    get currentState(): StreamState;
+    get currentMeta(): StreamMeta | null;
+    private setupBackendListeners;
+    private pushSnapshot;
+    private broadcast;
+    private setState;
+}

package/dist/service/scrcpy-stream-service.js

@@ -0,0 +1,178 @@
+import { EventEmitter } from "node:events";
+import { ScrcpyBackend } from "../backend/scrcpy-backend.js";
+import { PacketQueueSubscriber } from "./packet-queue-subscriber.js";
+import { MediaKind, StreamState, } from "./types.js";
+const EMPTY_PAYLOAD = new Uint8Array(0);
+export class ScrcpyStreamService extends EventEmitter {
+    backend;
+    state = StreamState.STOPPED;
+    meta = null;
+    queueMaxPackets;
+    videoConfig = null;
+    audioConfig = null;
+    latestKeyFrame = null;
+    latestSession = null;
+    subscribers = new Set();
+    constructor(options = {}) {
+        super();
+        this.queueMaxPackets = options.queueMaxPackets ?? 240;
+        this.backend = new ScrcpyBackend(options);
+        this.setupBackendListeners();
+    }
+    async start() {
+        if (this.state === StreamState.RUNNING ||
+            this.state === StreamState.STARTING) {
+            return this.meta;
+        }
+        this.setState(StreamState.STARTING);
+        try {
+            this.meta = await this.backend.start();
+            this.setState(StreamState.RUNNING);
+            return this.meta;
+        }
+        catch (e) {
+            this.setState(StreamState.ERROR);
+            throw e;
+        }
+    }
+    stop() {
+        if (this.state === StreamState.STOPPED)
+            return;
+        this.setState(StreamState.STOPPING);
+        this.backend.stop();
+        this.videoConfig = null;
+        this.audioConfig = null;
+        this.latestKeyFrame = null;
+        this.latestSession = null;
+        this.subscribers.forEach((subscriber) => subscriber.close());
+        this.subscribers.clear();
+        this.setState(StreamState.STOPPED);
+    }
+    sendControlMessage(msg) {
+        this.backend.sendControlMessage(msg);
+    }
+    subscribe() {
+        const subscriber = new PacketQueueSubscriber(this.queueMaxPackets);
+        this.subscribers.add(subscriber);
+        this.pushSnapshot(subscriber);
+        const iterator = subscriber[Symbol.asyncIterator]();
+        return {
+            next: () => iterator.next(),
+            return: async (value) => {
+                this.subscribers.delete(subscriber);
+                subscriber.close();
+                if (iterator.return)
+                    return iterator.return(value);
+                return { done: true, value };
+            },
+            throw: async (e) => {
+                this.subscribers.delete(subscriber);
+                subscriber.close();
+                if (iterator.throw)
+                    return iterator.throw(e);
+                throw e;
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+    get currentState() {
+        return this.state;
+    }
+    get currentMeta() {
+        return this.meta;
+    }
+    setupBackendListeners() {
+        this.backend.on("video", (meta, payload) => {
+            const packet = {
+                kind: MediaKind.VIDEO,
+                ptsUs: meta.ptsUs,
+                config: meta.config,
+                keyFrame: meta.keyFrame,
+                payload,
+            };
+            if (meta.config)
+                this.videoConfig = payload;
+            if (meta.keyFrame)
+                this.latestKeyFrame = packet;
+            this.broadcast(packet);
+        });
+        this.backend.on("audio", (meta, payload) => {
+            const packet = {
+                kind: MediaKind.AUDIO,
+                ptsUs: meta.ptsUs,
+                config: meta.config,
+                keyFrame: false,
+                payload,
+            };
+            if (meta.config)
+                this.audioConfig = payload;
+            this.broadcast(packet);
+        });
+        this.backend.on("session", (session) => {
+            this.latestSession = session;
+            this.broadcast({
+                kind: MediaKind.SESSION,
+                ptsUs: 0n,
+                config: false,
+                keyFrame: false,
+                payload: EMPTY_PAYLOAD,
+                width: session.width,
+                height: session.height,
+            });
+        });
+        this.backend.on("deviceMessage", (msg) => {
+            this.emit("deviceMessage", msg);
+        });
+        this.backend.on("error", (e) => {
+            this.setState(StreamState.ERROR);
+            this.emit("error", e);
+            this.stop();
+        });
+    }
+    pushSnapshot(subscriber) {
+        if (this.latestSession) {
+            subscriber.push({
+                kind: MediaKind.SESSION,
+                ptsUs: 0n,
+                config: false,
+                keyFrame: false,
+                payload: EMPTY_PAYLOAD,
+                width: this.latestSession.width,
+                height: this.latestSession.height,
+            });
+        }
+        if (this.videoConfig) {
+            subscriber.push({
+                kind: MediaKind.VIDEO,
+                ptsUs: 0n,
+                config: true,
+                keyFrame: false,
+                payload: this.videoConfig,
+            });
+        }
+        if (this.latestKeyFrame)
+            subscriber.push(this.latestKeyFrame);
+        if (this.audioConfig) {
+            subscriber.push({
+                kind: MediaKind.AUDIO,
+                ptsUs: 0n,
+                config: true,
+                keyFrame: false,
+                payload: this.audioConfig,
+            });
+        }
+    }
+    broadcast(packet) {
+        for (const subscriber of this.subscribers) {
+            subscriber.push(packet);
+        }
+    }
+    setState(state) {
+        if (this.state === state)
+            return;
+        this.state = state;
+        this.emit("state", state);
+    }
+}

package/dist/service/types.d.ts

@@ -0,0 +1,25 @@
+import { ScrcpyBackendOptions } from "../backend/server/options.js";
+export declare enum StreamState {
+    STOPPED = "stopped",
+    STARTING = "starting",
+    RUNNING = "running",
+    STOPPING = "stopping",
+    ERROR = "error"
+}
+export declare enum MediaKind {
+    VIDEO = "video",
+    AUDIO = "audio",
+    SESSION = "session"
+}
+export interface MediaPacket {
+    kind: MediaKind;
+    ptsUs: bigint;
+    config: boolean;
+    keyFrame: boolean;
+    payload: Uint8Array;
+    width?: number;
+    height?: number;
+}
+export interface ScrcpyStreamServiceOptions extends ScrcpyBackendOptions {
+    queueMaxPackets?: number;
+}