@yume-chan/adb 0.0.20 → 0.0.22

package/src/daemon/dispatcher.ts

@@ -1,4 +1,8 @@
-import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
+import {
+    AsyncOperationManager,
+    PromiseResolver,
+    delay,
+} from "@yume-chan/async";
 import type {
     Consumable,
     ReadableWritablePair,
@@ -12,7 +16,7 @@ import {
 import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
 import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
-import { decodeUtf8, encodeUtf8, unreachable } from "../utils/index.js";
+import { decodeUtf8, encodeUtf8 } from "../utils/index.js";
 
 import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 import { AdbCommand, calculateChecksum } from "./packet.js";
@@ -28,6 +32,11 @@ export interface AdbPacketDispatcherOptions {
      */
     appendNullToServiceString: boolean;
     maxPayloadSize: number;
+    /**
+     * Whether to preserve the connection open after the `AdbPacketDispatcher` is closed.
+     */
+    preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 /**
@@ -51,23 +60,23 @@ export class AdbPacketDispatcher implements Closeable {
 
     #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
-    public readonly options: AdbPacketDispatcherOptions;
+    readonly options: AdbPacketDispatcherOptions;
 
     #closed = false;
     #disconnected = new PromiseResolver<void>();
-    public get disconnected() {
+    get disconnected() {
         return this.#disconnected.promise;
     }
 
     #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
     #readAbortController = new AbortController();
 
-    public constructor(
+    constructor(
         connection: ReadableWritablePair<
             AdbPacketData,
             Consumable<AdbPacketInit>
         >,
-        options: AdbPacketDispatcherOptions
+        options: AdbPacketDispatcherOptions,
     ) {
         this.options = options;
 
@@ -76,29 +85,17 @@ export class AdbPacketDispatcher implements Closeable {
                 new WritableStream({
                     write: async (packet) => {
                         switch (packet.command) {
-                            case AdbCommand.OK:
-                                this.handleOk(packet);
-                                break;
                             case AdbCommand.Close:
-                                await this.handleClose(packet);
+                                await this.#handleClose(packet);
+                                break;
+                            case AdbCommand.Okay:
+                                this.#handleOkay(packet);
                                 break;
-                            case AdbCommand.Write:
-                                if (this.#sockets.has(packet.arg1)) {
-                                    await this.#sockets
-                                        .get(packet.arg1)!
-                                        .enqueue(packet.payload);
-                                    await this.sendPacket(
-                                        AdbCommand.OK,
-                                        packet.arg1,
-                                        packet.arg0
-                                    );
-                                    break;
-                                }
-                                throw new Error(
-                                    `Unknown local socket id: ${packet.arg1}`
-                                );
                             case AdbCommand.Open:
-                                await this.handleOpen(packet);
+                                await this.#handleOpen(packet);
+                                break;
+                            case AdbCommand.Write:
+                                await this.#handleWrite(packet);
                                 break;
                             default:
                                 // Junk data may only appear in the authentication phase,
@@ -107,62 +104,39 @@ export class AdbPacketDispatcher implements Closeable {
                                 // (although it's possible that Adb added new commands in the future)
                                 throw new Error(
                                     `Unknown command: ${packet.command.toString(
-                                        16
-                                    )}`
+                                        16,
+                                    )}`,
                                 );
                         }
                     },
                 }),
                 {
-                    // There are multiple reasons for the pipe to stop,
-                    // (device disconnection, protocol error, or user abortion)
-                    // if the underlying streams are still open,
-                    // it's still possible to create another ADB connection.
-                    // So don't close `readable` here.
-                    preventCancel: true,
+                    preventCancel: options.preserveConnection ?? false,
                     signal: this.#readAbortController.signal,
-                }
+                },
             )
             .then(
                 () => {
-                    this.dispose();
+                    this.#dispose();
                 },
                 (e) => {
                     if (!this.#closed) {
                         this.#disconnected.reject(e);
                     }
-                    this.dispose();
-                }
+                    this.#dispose();
+                },
             );
 
         this.#writer = connection.writable.getWriter();
     }
 
-    private handleOk(packet: AdbPacketData) {
-        if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
-            // Device successfully created the socket
-            return;
-        }
-
-        const socket = this.#sockets.get(packet.arg1);
-        if (socket) {
-            // Device has received last `WRTE` to the socket
-            socket.ack();
-            return;
-        }
-
-        // Maybe the device is responding to a packet of last connection
-        // Tell the device to close the socket
-        void this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
-    }
-
-    private async handleClose(packet: AdbPacketData) {
+    async #handleClose(packet: AdbPacketData) {
         // If the socket is still pending
         if (
             packet.arg0 === 0 &&
             this.#initializers.reject(
                 packet.arg1,
-                new Error("Socket open failed")
+                new Error("Socket open failed"),
             )
         ) {
             // Device failed to create the socket
@@ -183,15 +157,8 @@ export class AdbPacketDispatcher implements Closeable {
         // Ignore `arg0` and search for the socket
         const socket = this.#sockets.get(packet.arg1);
         if (socket) {
-            // The device want to close the socket
-            if (!socket.closed) {
-                await this.sendPacket(
-                    AdbCommand.Close,
-                    packet.arg1,
-                    packet.arg0
-                );
-            }
-            await socket.dispose();
+            await socket.close();
+            socket.dispose();
             this.#sockets.delete(packet.arg1);
             return;
         }
@@ -201,22 +168,25 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    public addReverseTunnel(
-        service: string,
-        handler: AdbIncomingSocketHandler
-    ) {
-        this.#incomingSocketHandlers.set(service, handler);
-    }
+    #handleOkay(packet: AdbPacketData) {
+        if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
+            // Device successfully created the socket
+            return;
+        }
 
-    public removeReverseTunnel(address: string) {
-        this.#incomingSocketHandlers.delete(address);
-    }
+        const socket = this.#sockets.get(packet.arg1);
+        if (socket) {
+            // Device has received last `WRTE` to the socket
+            socket.ack();
+            return;
+        }
 
-    public clearReverseTunnels() {
-        this.#incomingSocketHandlers.clear();
+        // Maybe the device is responding to a packet of last connection
+        // Tell the device to close the socket
+        void this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
     }
 
-    private async handleOpen(packet: AdbPacketData) {
+    async #handleOpen(packet: AdbPacketData) {
         // `AsyncOperationManager` doesn't support skipping IDs
         // Use `add` + `resolve` to simulate this behavior
         const [localId] = this.#initializers.add<number>();
@@ -245,13 +215,42 @@ export class AdbPacketDispatcher implements Closeable {
         try {
             await handler(controller.socket);
             this.#sockets.set(localId, controller);
-            await this.sendPacket(AdbCommand.OK, localId, remoteId);
+            await this.sendPacket(AdbCommand.Okay, localId, remoteId);
         } catch (e) {
             await this.sendPacket(AdbCommand.Close, 0, remoteId);
         }
     }
 
-    public async createSocket(service: string): Promise<AdbSocket> {
+    async #handleWrite(packet: AdbPacketData) {
+        const socket = this.#sockets.get(packet.arg1);
+        if (!socket) {
+            throw new Error(`Unknown local socket id: ${packet.arg1}`);
+        }
+
+        let handled = false;
+        await Promise.race([
+            delay(5000).then(() => {
+                if (this.options.debugSlowRead && !handled) {
+                    throw new Error(
+                        `packet for \`${socket.service}\` not handled in 5 seconds`,
+                    );
+                }
+            }),
+            (async () => {
+                await socket.enqueue(packet.payload);
+                await this.sendPacket(
+                    AdbCommand.Okay,
+                    packet.arg1,
+                    packet.arg0,
+                );
+                handled = true;
+            })(),
+        ]);
+
+        return;
+    }
+
+    async createSocket(service: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
             service += "\0";
         }
@@ -273,11 +272,23 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
-    public async sendPacket(
+    addReverseTunnel(service: string, handler: AdbIncomingSocketHandler) {
+        this.#incomingSocketHandlers.set(service, handler);
+    }
+
+    removeReverseTunnel(address: string) {
+        this.#incomingSocketHandlers.delete(address);
+    }
+
+    clearReverseTunnels() {
+        this.#incomingSocketHandlers.clear();
+    }
+
+    async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload: string | Uint8Array = EMPTY_UINT8_ARRAY
+        payload: string | Uint8Array = EMPTY_UINT8_ARRAY,
     ): Promise<void> {
         if (typeof payload === "string") {
             payload = encodeUtf8(payload);
@@ -299,25 +310,30 @@ export class AdbPacketDispatcher implements Closeable {
         });
     }
 
-    public async close() {
+    async close() {
         // Send `CLSE` packets for all sockets
         await Promise.all(
-            Array.from(this.#sockets.values(), (socket) => socket.close())
+            Array.from(this.#sockets.values(), (socket) => socket.close()),
         );
 
         // Stop receiving
         // It's possible that we haven't received all `CLSE` confirm packets,
         // but it doesn't matter, the next connection can cope with them.
         this.#closed = true;
+
         this.#readAbortController.abort();
-        this.#writer.releaseLock();
+        if (this.options.preserveConnection) {
+            this.#writer.releaseLock();
+        } else {
+            await this.#writer.close();
+        }
 
         // `pipe().then()` will call `dispose`
     }
 
-    private dispose() {
+    #dispose() {
         for (const socket of this.#sockets.values()) {
-            socket.dispose().catch(unreachable);
+            socket.dispose();
         }
 
         this.#disconnected.resolve();

package/src/daemon/packet.ts

@@ -5,7 +5,7 @@ export enum AdbCommand {
     Auth = 0x48545541, // 'AUTH'
     Close = 0x45534c43, // 'CLSE'
     Connect = 0x4e584e43, // 'CNXN'
-    OK = 0x59414b4f, // 'OKAY'
+    Okay = 0x59414b4f, // 'OKAY'
     Open = 0x4e45504f, // 'OPEN'
     Write = 0x45545257, // 'WRTE'
 }
@@ -53,7 +53,7 @@ export class AdbPacketSerializeStream extends ConsumableTransformStream<
     AdbPacketInit,
     Uint8Array
 > {
-    public constructor() {
+    constructor() {
         const headerBuffer = new Uint8Array(AdbPacketHeader.size);
         super({
             transform: async (chunk, controller) => {

package/src/daemon/socket.ts

@@ -4,18 +4,16 @@ import type {
     Consumable,
     PushReadableStreamController,
     ReadableStream,
-    ReadableWritablePair,
     WritableStream,
+    WritableStreamDefaultController,
 } from "@yume-chan/stream-extra";
 import {
     ConsumableWritableStream,
-    DistributionStream,
-    DuplexStreamFactory,
     PushReadableStream,
-    pipeFrom,
 } from "@yume-chan/stream-extra";
 
-import type { Closeable } from "../adb.js";
+import type { AdbSocket } from "../adb.js";
+import { raceSignal } from "../server/index.js";
 
 import type { AdbPacketDispatcher } from "./dispatcher.js";
 import { AdbCommand } from "./packet.js";
@@ -36,130 +34,127 @@ export interface AdbDaemonSocketConstructionOptions
 }
 
 export class AdbDaemonSocketController
-    implements
-        AdbDaemonSocketInfo,
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
-        Closeable,
-        Disposable
+    implements AdbDaemonSocketInfo, AdbSocket, Disposable
 {
-    private readonly dispatcher!: AdbPacketDispatcher;
+    readonly #dispatcher!: AdbPacketDispatcher;
 
-    public readonly localId!: number;
-    public readonly remoteId!: number;
-    public readonly localCreated!: boolean;
-    public readonly service!: string;
-
-    #duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
+    readonly localId!: number;
+    readonly remoteId!: number;
+    readonly localCreated!: boolean;
+    readonly service!: string;
 
     #readable: ReadableStream<Uint8Array>;
     #readableController!: PushReadableStreamController<Uint8Array>;
-    public get readable() {
+    get readable() {
         return this.#readable;
     }
 
     #writePromise: PromiseResolver<void> | undefined;
-    public readonly writable: WritableStream<Consumable<Uint8Array>>;
+    #writableController!: WritableStreamDefaultController;
+    readonly writable: WritableStream<Consumable<Uint8Array>>;
 
     #closed = false;
-    /**
-     * Whether the socket is half-closed (i.e. the local side initiated the close).
-     *
-     * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
-     */
-    public get closed() {
-        return this.#closed;
-    }
-
-    private _socket: AdbDaemonSocket;
-    public get socket() {
-        return this._socket;
-    }
-
-    public constructor(options: AdbDaemonSocketConstructionOptions) {
-        Object.assign(this, options);
-
-        // Check this image to help you understand the stream graph
-        // cspell: disable-next-line
-        // https://www.plantuml.com/plantuml/png/TL0zoeGm4ErpYc3l5JxyS0yWM6mX5j4C6p4cxcJ25ejttuGX88ZftizxUKmJI275pGhXl0PP_UkfK_CAz5Z2hcWsW9Ny2fdU4C1f5aSchFVxA8vJjlTPRhqZzDQMRB7AklwJ0xXtX0ZSKH1h24ghoKAdGY23FhxC4nS2pDvxzIvxb-8THU0XlEQJ-ZB7SnXTAvc_LhOckhMdLBnbtndpb-SB7a8q2SRD_W00
-
-        this.#duplex = new DuplexStreamFactory<
-            Uint8Array,
-            Consumable<Uint8Array>
-        >({
-            close: async () => {
-                this.#closed = true;
-
-                await this.dispatcher.sendPacket(
-                    AdbCommand.Close,
-                    this.localId,
-                    this.remoteId
-                );
-
-                // Don't `dispose` here, we need to wait for `CLSE` response packet.
-                return false;
-            },
-            dispose: () => {
-                // Error out the pending writes
-                this.#writePromise?.reject(new Error("Socket closed"));
-            },
+
+    #closedPromise = new PromiseResolver<void>();
+    get closed() {
+        return this.#closedPromise.promise;
+    }
+
+    #socket: AdbDaemonSocket;
+    get socket() {
+        return this.#socket;
+    }
+
+    constructor(options: AdbDaemonSocketConstructionOptions) {
+        this.#dispatcher = options.dispatcher;
+        this.localId = options.localId;
+        this.remoteId = options.remoteId;
+        this.localCreated = options.localCreated;
+        this.service = options.service;
+
+        this.#readable = new PushReadableStream((controller) => {
+            this.#readableController = controller;
         });
 
-        this.#readable = this.#duplex.wrapReadable(
-            new PushReadableStream(
-                (controller) => {
-                    this.#readableController = controller;
-                },
-                {
-                    highWaterMark: options.highWaterMark ?? 16 * 1024,
-                    size(chunk) {
-                        return chunk.byteLength;
-                    },
+        this.writable = new ConsumableWritableStream<Uint8Array>({
+            start: (controller) => {
+                this.#writableController = controller;
+            },
+            write: async (data, controller) => {
+                const size = data.length;
+                const chunkSize = this.#dispatcher.options.maxPayloadSize;
+                for (
+                    let start = 0, end = chunkSize;
+                    start < size;
+                    start = end, end += chunkSize
+                ) {
+                    this.#writePromise = new PromiseResolver();
+                    await this.#dispatcher.sendPacket(
+                        AdbCommand.Write,
+                        this.localId,
+                        this.remoteId,
+                        data.subarray(start, end),
+                    );
+                    // Wait for ack packet
+                    await raceSignal(
+                        () => this.#writePromise!.promise,
+                        controller.signal,
+                    );
                 }
-            )
-        );
-
-        this.writable = pipeFrom(
-            this.#duplex.createWritable(
-                new ConsumableWritableStream<Uint8Array>({
-                    write: async (chunk) => {
-                        // Wait for an ack packet
-                        this.#writePromise = new PromiseResolver();
-                        await this.dispatcher.sendPacket(
-                            AdbCommand.Write,
-                            this.localId,
-                            this.remoteId,
-                            chunk
-                        );
-                        await this.#writePromise.promise;
-                    },
-                })
-            ),
-            new DistributionStream(this.dispatcher.options.maxPayloadSize)
-        );
+            },
+        });
 
-        this._socket = new AdbDaemonSocket(this);
+        this.#socket = new AdbDaemonSocket(this);
     }
 
-    public async enqueue(data: Uint8Array) {
-        // Consumer may abort the `ReadableStream` to close the socket,
-        // it's OK to throw away further packets in this case.
+    async enqueue(data: Uint8Array) {
+        // Consumers can `cancel` the `readable` if they are not interested in future data.
+        // Throw away the data if that happens.
         if (this.#readableController.abortSignal.aborted) {
             return;
         }
 
-        await this.#readableController.enqueue(data);
+        try {
+            await this.#readableController.enqueue(data);
+        } catch (e) {
+            if (this.#readableController.abortSignal.aborted) {
+                return;
+            }
+            throw e;
+        }
     }
 
-    public ack() {
+    ack() {
         this.#writePromise?.resolve();
     }
 
-    public async close(): Promise<void> {
-        await this.#duplex.close();
+    async close(): Promise<void> {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+
+        try {
+            this.#writableController.error(new Error("Socket closed"));
+        } catch {
+            // ignore
+        }
+
+        await this.#dispatcher.sendPacket(
+            AdbCommand.Close,
+            this.localId,
+            this.remoteId,
+        );
     }
 
-    public dispose() {
-        return this.#duplex.dispose();
+    dispose() {
+        try {
+            this.#readableController.close();
+        } catch {
+            // ignore
+        }
+
+        this.#closedPromise.resolve();
     }
 }
 
@@ -171,42 +166,38 @@ export class AdbDaemonSocketController
  * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
  * `socket.writable.close()` or `socket.writable.getWriter().close()`.
  */
-export class AdbDaemonSocket
-    implements
-        AdbDaemonSocketInfo,
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
-{
+export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
     #controller: AdbDaemonSocketController;
 
-    public get localId(): number {
+    get localId(): number {
         return this.#controller.localId;
     }
-    public get remoteId(): number {
+    get remoteId(): number {
         return this.#controller.remoteId;
     }
-    public get localCreated(): boolean {
+    get localCreated(): boolean {
         return this.#controller.localCreated;
     }
-    public get service(): string {
+    get service(): string {
         return this.#controller.service;
     }
 
-    public get readable(): ReadableStream<Uint8Array> {
+    get readable(): ReadableStream<Uint8Array> {
         return this.#controller.readable;
     }
-    public get writable(): WritableStream<Consumable<Uint8Array>> {
+    get writable(): WritableStream<Consumable<Uint8Array>> {
         return this.#controller.writable;
     }
 
-    public get closed(): boolean {
+    get closed(): Promise<void> {
         return this.#controller.closed;
     }
 
-    public constructor(controller: AdbDaemonSocketController) {
+    constructor(controller: AdbDaemonSocketController) {
         this.#controller = controller;
     }
 
-    public close() {
+    close() {
         return this.#controller.close();
     }
 }