@yume-chan/scrcpy 0.0.18 → 0.0.19

package/src/adb/client.ts

@@ -1,88 +1,54 @@
+import type { Adb, AdbSubprocessProtocol } from "@yume-chan/adb";
 import {
+    AdbReverseNotSupportedError,
     AdbSubprocessNoneProtocol,
-    type Adb,
-    type AdbSubprocessProtocol,
-    type AdbSync,
 } from "@yume-chan/adb";
+import type {
+    Consumable,
+    ReadableStream,
+    ReadableWritablePair,
+} from "@yume-chan/stream-extra";
 import {
     AbortController,
     DecodeUtf8Stream,
     InspectStream,
-    ReadableStream,
+    PushReadableStream,
     SplitStringStream,
-    WrapWritableStream,
     WritableStream,
-    type ReadableStreamDefaultController,
-    type ReadableStreamDefaultReader,
-    type ReadableWritablePair,
 } from "@yume-chan/stream-extra";
 
 import { ScrcpyControlMessageSerializer } from "../control/index.js";
-import {
-    ScrcpyDeviceMessageDeserializeStream,
-    type ScrcpyDeviceMessage,
-} from "../device-message/index.js";
-import {
-    DEFAULT_SERVER_PATH,
-    type ScrcpyVideoStreamPacket,
+import type { ScrcpyDeviceMessage } from "../device-message/index.js";
+import { ScrcpyDeviceMessageDeserializeStream } from "../device-message/index.js";
+import type {
+    ScrcpyOptionsInit1_16,
+    ScrcpyVideoStreamPacket,
 } from "../options/index.js";
+import { DEFAULT_SERVER_PATH } from "../options/index.js";
 
-import { type AdbScrcpyOptions } from "./options/index.js";
-
-class ArrayToStream<T> extends ReadableStream<T> {
-    private array!: T[];
-    private index = 0;
-
-    constructor(array: T[]) {
-        super({
-            start: async () => {
-                await Promise.resolve();
-                this.array = array;
-            },
-            pull: (controller) => {
-                if (this.index < this.array.length) {
-                    controller.enqueue(this.array[this.index]!);
-                    this.index += 1;
-                } else {
-                    controller.close();
-                }
-            },
-        });
-    }
-}
+import type { AdbScrcpyConnection } from "./connection.js";
+import type { AdbScrcpyOptions } from "./options/index.js";
 
-class ConcatStream<T> extends ReadableStream<T> {
-    private streams!: ReadableStream<T>[];
-    private index = 0;
-    private reader!: ReadableStreamDefaultReader<T>;
-
-    constructor(...streams: ReadableStream<T>[]) {
-        super({
-            start: async (controller) => {
-                await Promise.resolve();
-
-                this.streams = streams;
-                this.advance(controller);
-            },
-            pull: async (controller) => {
-                const result = await this.reader.read();
-                if (!result.done) {
-                    controller.enqueue(result.value);
-                    return;
-                }
-                this.advance(controller);
-            },
-        });
-    }
+function arrayToStream<T>(array: T[]): ReadableStream<T> {
+    return new PushReadableStream(async (controller) => {
+        for (const item of array) {
+            await controller.enqueue(item);
+        }
+    });
+}
 
-    private advance(controller: ReadableStreamDefaultController<T>) {
-        if (this.index < this.streams.length) {
-            this.reader = this.streams[this.index]!.getReader();
-            this.index += 1;
-        } else {
-            controller.close();
+function concatStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T> {
+    return new PushReadableStream(async (controller) => {
+        for (const stream of streams) {
+            await stream.pipeTo(
+                new WritableStream({
+                    async write(chunk) {
+                        await controller.enqueue(chunk);
+                    },
+                })
+            );
         }
-    }
+    });
 }
 
 export class ScrcpyExitedError extends Error {
@@ -95,30 +61,46 @@ export class ScrcpyExitedError extends Error {
 }
 
 export class AdbScrcpyClient {
-    public static pushServer(adb: Adb, path = DEFAULT_SERVER_PATH) {
-        let sync!: AdbSync;
-        return new WrapWritableStream<Uint8Array>({
-            async start() {
-                sync = await adb.sync();
-                return sync.write(path);
-            },
-            async close() {
-                await sync.dispose();
-            },
-        });
+    public static async pushServer(
+        adb: Adb,
+        file: ReadableStream<Consumable<Uint8Array>>,
+        filename = DEFAULT_SERVER_PATH
+    ) {
+        const sync = await adb.sync();
+        try {
+            await sync.write({
+                filename,
+                file,
+            });
+        } finally {
+            await sync.dispose();
+        }
     }
 
     public static async start(
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<object>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ) {
-        const connection = options.createConnection(adb);
+        let connection: AdbScrcpyConnection | undefined;
         let process: AdbSubprocessProtocol | undefined;
 
         try {
-            await connection.initialize();
+            try {
+                connection = options.createConnection(adb);
+                await connection.initialize();
+            } catch (e) {
+                if (e instanceof AdbReverseNotSupportedError) {
+                    // When reverse tunnel is not supported, try forward tunnel.
+                    options.value.tunnelForward = true;
+                    connection = options.createConnection(adb);
+                    await connection.initialize();
+                } else {
+                    connection = undefined;
+                    throw e;
+                }
+            }
 
             process = await adb.subprocess.spawn(
                 [
@@ -176,7 +158,7 @@ export class AdbScrcpyClient {
             return new AdbScrcpyClient(
                 options,
                 process,
-                new ConcatStream(new ArrayToStream(output), stdout),
+                concatStreams(arrayToStream(output), stdout),
                 videoStream,
                 controlStream
             );
@@ -184,7 +166,7 @@ export class AdbScrcpyClient {
             await process?.kill();
             throw e;
         } finally {
-            connection.dispose();
+            connection?.dispose();
         }
     }
 
@@ -196,7 +178,7 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<object>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ): Promise<string[]> {
         Object.assign(options.value, {
             // Provide an invalid encoder name
@@ -236,7 +218,7 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<object>
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>
     ): Promise<number[]> {
         Object.assign(options.value, {
             // Similar to `getEncoders`, pass an invalid option and parse the output
@@ -308,11 +290,13 @@ export class AdbScrcpyClient {
     }
 
     public constructor(
-        options: AdbScrcpyOptions<object>,
+        options: AdbScrcpyOptions<ScrcpyOptionsInit1_16>,
         process: AdbSubprocessProtocol,
         stdout: ReadableStream<string>,
         videoStream: ReadableStream<Uint8Array>,
-        controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined
+        controlStream:
+            | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+            | undefined
     ) {
         this.process = process;
         this._stdout = stdout;

package/src/adb/connection.ts

@@ -1,13 +1,15 @@
-import { type Adb } from "@yume-chan/adb";
+import type { Adb } from "@yume-chan/adb";
+import { AdbReverseNotSupportedError } 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,
+import type { Disposable } from "@yume-chan/event";
+import type {
+    Consumable,
+    ReadableStream,
+    ReadableStreamDefaultReader,
+    ReadableWritablePair,
 } from "@yume-chan/stream-extra";
-import { type ValueOrPromise } from "@yume-chan/struct";
+import { TransformStream } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
 export interface AdbScrcpyConnectionOptions {
     control: boolean;
@@ -41,7 +43,7 @@ export abstract class AdbScrcpyConnection implements Disposable {
         [
             videoSteam: ReadableStream<Uint8Array>,
             controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
                 | undefined
         ]
     >;
@@ -52,14 +54,18 @@ export abstract class AdbScrcpyConnection implements Disposable {
 }
 
 export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
-    private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+    private _disposed = false;
+
+    private connect(): Promise<
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+    > {
         return this.adb.createSocket("localabstract:scrcpy");
     }
 
     private async connectAndRetry(): Promise<
-        ReadableWritablePair<Uint8Array, Uint8Array>
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
     > {
-        for (let i = 0; i < 100; i += 1) {
+        for (let i = 0; !this._disposed && i < 100; i += 1) {
             try {
                 return await this.connect();
             } catch (e) {
@@ -83,18 +89,18 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
         return videoStream;
     }
 
-    public async getStreams(): Promise<
+    public override async getStreams(): Promise<
         [
             videoSteam: ReadableStream<Uint8Array>,
             controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
                 | undefined
         ]
     > {
         const videoStream = await this.connectVideoStream();
 
         let controlStream:
-            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
             | undefined;
         if (this.options.control) {
             controlStream = await this.connectAndRetry();
@@ -113,24 +119,35 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
 
         return [videoStream, controlStream];
     }
+
+    public override dispose(): void {
+        super.dispose();
+        this._disposed = true;
+    }
 }
 
 export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
     private streams!: ReadableStreamDefaultReader<
-        ReadableWritablePair<Uint8Array, Uint8Array>
+        ReadableWritablePair<Uint8Array, Consumable<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;
-        });
+        try {
+            // try to unbind first
+            await this.adb.reverse.remove("localabstract:scrcpy");
+        } catch (e) {
+            if (e instanceof AdbReverseNotSupportedError) {
+                throw e;
+            }
+
+            // Ignore other errors when unbinding
+        }
 
         const queue = new TransformStream<
-            ReadableWritablePair<Uint8Array, Uint8Array>,
-            ReadableWritablePair<Uint8Array, Uint8Array>
+            ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
+            ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
         >();
         this.streams = queue.readable.getReader();
         const writer = queue.writable.getWriter();
@@ -145,7 +162,7 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
     }
 
     private async accept(): Promise<
-        ReadableWritablePair<Uint8Array, Uint8Array>
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
     > {
         return (await this.streams.read()).value!;
     }
@@ -154,14 +171,14 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
         [
             videoSteam: ReadableStream<Uint8Array>,
             controlStream:
-                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
                 | undefined
         ]
     > {
         const { readable: videoStream } = await this.accept();
 
         let controlStream:
-            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
             | undefined;
         if (this.options.control) {
             controlStream = await this.accept();

package/src/adb/index.ts

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

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

@@ -1,11 +1,13 @@
-import { type Adb } from "@yume-chan/adb";
+import type { Adb } from "@yume-chan/adb";
 
-import { type ScrcpyOptionsInit1_16 } from "../../options/index.js";
+import type { ScrcpyOptionsInit1_16 } from "../../options/index.js";
+import type {
+    AdbScrcpyConnection,
+    AdbScrcpyConnectionOptions,
+} from "../connection.js";
 import {
     AdbScrcpyForwardConnection,
     AdbScrcpyReverseConnection,
-    type AdbScrcpyConnection,
-    type AdbScrcpyConnectionOptions,
 } from "../connection.js";
 
 import { AdbScrcpyOptionsBase } from "./types.js";

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

@@ -1,8 +1,8 @@
-import { type Adb } from "@yume-chan/adb";
+import type { Adb } from "@yume-chan/adb";
 
-import { type ScrcpyOptionsInit1_22 } from "../../options/index.js";
+import type { ScrcpyOptionsInit1_22 } from "../../options/index.js";
+import type { AdbScrcpyConnection } from "../connection.js";
 import {
-    type AdbScrcpyConnection,
     AdbScrcpyForwardConnection,
     AdbScrcpyReverseConnection,
 } from "../connection.js";

package/src/adb/options/index.ts

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

package/src/adb/options/types.ts

@@ -1,16 +1,16 @@
-import { type Adb } from "@yume-chan/adb";
-import { type TransformStream } from "@yume-chan/stream-extra";
+import type { Adb } from "@yume-chan/adb";
+import type { TransformStream } from "@yume-chan/stream-extra";
 
-import {
-    type ScrcpyBackOrScreenOnControlMessage,
-    type ScrcpyControlMessageType,
-    type ScrcpySetClipboardControlMessage,
+import type {
+    ScrcpyBackOrScreenOnControlMessage,
+    ScrcpyControlMessageType,
+    ScrcpySetClipboardControlMessage,
 } from "../../control/index.js";
-import {
-    type ScrcpyOptions,
-    type ScrcpyVideoStreamPacket,
+import type {
+    ScrcpyOptions,
+    ScrcpyVideoStreamPacket,
 } from "../../options/index.js";
-import { type AdbScrcpyConnection } from "../connection.js";
+import type { AdbScrcpyConnection } from "../connection.js";
 
 export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
     createConnection(adb: Adb): AdbScrcpyConnection;

package/src/control/back-or-screen-on.ts

@@ -1,4 +1,4 @@
-import { type ScrcpyBackOrScreenOnControlMessage1_18 } from "../index.js";
+import type { ScrcpyBackOrScreenOnControlMessage1_18 } from "../index.js";
 
 export type ScrcpyBackOrScreenOnControlMessage =
     ScrcpyBackOrScreenOnControlMessage1_18;

package/src/control/hover-helper.ts

@@ -1,7 +1,5 @@
-import {
-    AndroidMotionEventAction,
-    type ScrcpyInjectTouchControlMessage,
-} from "./inject-touch.js";
+import type { ScrcpyInjectTouchControlMessage } from "./inject-touch.js";
+import { AndroidMotionEventAction } from "./inject-touch.js";
 import { ScrcpyControlMessageType } from "./type.js";
 
 /**