@yume-chan/scrcpy 0.0.18 → 0.0.20

package/src/adb/connection.ts

@@ -1,192 +0,0 @@
-import { type Adb } from "@yume-chan/adb";
-import { delay } from "@yume-chan/async";
-import { type Disposable } from "@yume-chan/event";
-import {
-    TransformStream,
-    type ReadableStream,
-    type ReadableStreamDefaultReader,
-    type ReadableWritablePair,
-} from "@yume-chan/stream-extra";
-import { type ValueOrPromise } from "@yume-chan/struct";
-
-export interface AdbScrcpyConnectionOptions {
-    control: boolean;
-
-    /**
-     * Write a byte on start to detect connection issues
-     */
-    sendDummyByte: boolean;
-
-    /**
-     * Send device name and size
-     */
-    sendDeviceMeta: boolean;
-}
-
-export abstract class AdbScrcpyConnection implements Disposable {
-    protected adb: Adb;
-
-    protected options: AdbScrcpyConnectionOptions;
-
-    public constructor(adb: Adb, options: AdbScrcpyConnectionOptions) {
-        this.adb = adb;
-        this.options = options;
-    }
-
-    public initialize(): ValueOrPromise<void> {
-        // do nothing
-    }
-
-    public abstract getStreams(): ValueOrPromise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
-                | undefined
-        ]
-    >;
-
-    public dispose(): void {
-        // do nothing
-    }
-}
-
-export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
-    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
-        return this.adb.createSocket("localabstract:scrcpy");
-    }
-
-    private async connectAndRetry(): Promise<
-        ReadableWritablePair<Uint8Array, Uint8Array>
-    > {
-        for (let i = 0; i < 100; i += 1) {
-            try {
-                return await this.connect();
-            } catch (e) {
-                await delay(100);
-            }
-        }
-        throw new Error(`Can't connect to server after 100 retries`);
-    }
-
-    private async connectVideoStream(): Promise<ReadableStream<Uint8Array>> {
-        const { readable: videoStream } = await this.connectAndRetry();
-        if (this.options.sendDummyByte) {
-            const reader = videoStream.getReader();
-            const { done, value } = await reader.read();
-            // server will write a `0` to signal connection success
-            if (done || value.byteLength !== 1 || value[0] !== 0) {
-                throw new Error("Unexpected response from server");
-            }
-            reader.releaseLock();
-        }
-        return videoStream;
-    }
-
-    public async getStreams(): Promise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
-                | undefined
-        ]
-    > {
-        const videoStream = await this.connectVideoStream();
-
-        let controlStream:
-            | ReadableWritablePair<Uint8Array, Uint8Array>
-            | undefined;
-        if (this.options.control) {
-            controlStream = await this.connectAndRetry();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error("Unexpected response from server");
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-}
-
-export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
-    private streams!: ReadableStreamDefaultReader<
-        ReadableWritablePair<Uint8Array, Uint8Array>
-    >;
-
-    private address!: string;
-
-    public override async initialize(): Promise<void> {
-        // try to unbind first, ignore errors
-        await this.adb.reverse.remove("localabstract:scrcpy").catch((e) => {
-            void e;
-        });
-
-        const queue = new TransformStream<
-            ReadableWritablePair<Uint8Array, Uint8Array>,
-            ReadableWritablePair<Uint8Array, Uint8Array>
-        >();
-        this.streams = queue.readable.getReader();
-        const writer = queue.writable.getWriter();
-        this.address = await this.adb.reverse.add(
-            "localabstract:scrcpy",
-            "tcp:27183",
-            (socket) => {
-                void writer.write(socket);
-                return true;
-            }
-        );
-    }
-
-    private async accept(): Promise<
-        ReadableWritablePair<Uint8Array, Uint8Array>
-    > {
-        return (await this.streams.read()).value!;
-    }
-
-    public async getStreams(): Promise<
-        [
-            videoSteam: ReadableStream<Uint8Array>,
-            controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
-                | undefined
-        ]
-    > {
-        const { readable: videoStream } = await this.accept();
-
-        let controlStream:
-            | ReadableWritablePair<Uint8Array, Uint8Array>
-            | undefined;
-        if (this.options.control) {
-            controlStream = await this.accept();
-        }
-
-        // Server only writes device meta after control socket is connected (if enabled)
-        if (this.options.sendDeviceMeta) {
-            const reader = videoStream.getReader();
-            const { done, value } = await reader.read();
-            // 64 bytes device name + 2 bytes video width + 2 bytes video height
-            if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error("Unexpected response from server");
-            }
-            reader.releaseLock();
-        }
-
-        return [videoStream, controlStream];
-    }
-
-    public override dispose() {
-        // Don't await this!
-        // `reverse.remove`'s response will never arrive
-        // before we read all pending data from `videoStream`
-        this.adb.reverse.remove(this.address).catch((e) => {
-            void e;
-        });
-    }
-}

package/src/adb/index.ts

@@ -1,3 +0,0 @@
-export * from './options/index.js';
-export * from './client.js';
-export * from './connection.js';

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

@@ -1,30 +0,0 @@
-import { type Adb } from "@yume-chan/adb";
-
-import { type ScrcpyOptionsInit1_16 } from "../../options/index.js";
-import {
-    AdbScrcpyForwardConnection,
-    AdbScrcpyReverseConnection,
-    type AdbScrcpyConnection,
-    type AdbScrcpyConnectionOptions,
-} from "../connection.js";
-
-import { AdbScrcpyOptionsBase } from "./types.js";
-
-export class AdbScrcpyOptions1_16<
-    T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16
-> extends AdbScrcpyOptionsBase<T> {
-    public override createConnection(adb: Adb): AdbScrcpyConnection {
-        const options: AdbScrcpyConnectionOptions = {
-            // Old versions always have control stream no matter what the option is
-            // Pass `control: false` to `Connection` will disable the control stream
-            control: true,
-            sendDummyByte: true,
-            sendDeviceMeta: true,
-        };
-        if (this.value.tunnelForward) {
-            return new AdbScrcpyForwardConnection(adb, options);
-        } else {
-            return new AdbScrcpyReverseConnection(adb, options);
-        }
-    }
-}

package/src/adb/options/1_22.ts

@@ -1,26 +0,0 @@
-import { type Adb } from "@yume-chan/adb";
-
-import { type ScrcpyOptionsInit1_22 } from "../../options/index.js";
-import {
-    type AdbScrcpyConnection,
-    AdbScrcpyForwardConnection,
-    AdbScrcpyReverseConnection,
-} from "../connection.js";
-
-import { AdbScrcpyOptions1_16 } from "./1_16.js";
-
-export class AdbScrcpyOptions1_22<
-    T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22
-> extends AdbScrcpyOptions1_16<T> {
-    public override createConnection(adb: Adb): AdbScrcpyConnection {
-        const options = {
-            ...this.getDefaultValue(),
-            ...this.value,
-        };
-        if (this.value.tunnelForward) {
-            return new AdbScrcpyForwardConnection(adb, options);
-        } else {
-            return new AdbScrcpyReverseConnection(adb, options);
-        }
-    }
-}

package/src/adb/options/index.ts

@@ -1,3 +0,0 @@
-export * from './1_16.js';
-export * from './1_22.js';
-export * from './types.js';

package/src/adb/options/types.ts

@@ -1,75 +0,0 @@
-import { type Adb } from "@yume-chan/adb";
-import { type TransformStream } from "@yume-chan/stream-extra";
-
-import {
-    type ScrcpyBackOrScreenOnControlMessage,
-    type ScrcpyControlMessageType,
-    type ScrcpySetClipboardControlMessage,
-} from "../../control/index.js";
-import {
-    type ScrcpyOptions,
-    type ScrcpyVideoStreamPacket,
-} from "../../options/index.js";
-import { type AdbScrcpyConnection } from "../connection.js";
-
-export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
-    createConnection(adb: Adb): AdbScrcpyConnection;
-}
-
-export abstract class AdbScrcpyOptionsBase<T extends object>
-    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: ScrcpyBackOrScreenOnControlMessage
-    ): Uint8Array | undefined {
-        return this.raw.serializeBackOrScreenOnControlMessage(message);
-    }
-
-    public serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
-    ): Uint8Array {
-        return this.raw.serializeSetClipboardControlMessage(message);
-    }
-
-    public getScrollController() {
-        return this.raw.getScrollController();
-    }
-
-    public abstract createConnection(adb: Adb): AdbScrcpyConnection;
-}

package/src/codec.ts

@@ -1,35 +0,0 @@
-// 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,
-}