@yume-chan/adb 0.0.21 → 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";
@@ -32,6 +36,7 @@ export interface AdbPacketDispatcherOptions {
      * Whether to preserve the connection open after the `AdbPacketDispatcher` is closed.
      */
     preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 /**
@@ -80,30 +85,18 @@ 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);
                                 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.Okay:
+                                this.#handleOkay(packet);
+                                break;
                             case AdbCommand.Open:
                                 await this.#handleOpen(packet);
                                 break;
+                            case AdbCommand.Write:
+                                await this.#handleWrite(packet);
+                                break;
                             default:
                                 // Junk data may only appear in the authentication phase,
                                 // since the dispatcher only works after authentication,
@@ -137,24 +130,6 @@ export class AdbPacketDispatcher implements Closeable {
         this.#writer = connection.writable.getWriter();
     }
 
-    #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);
-    }
-
     async #handleClose(packet: AdbPacketData) {
         // If the socket is still pending
         if (
@@ -182,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;
         }
@@ -200,16 +168,22 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    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;
+        }
 
-    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;
+        }
 
-    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);
     }
 
     async #handleOpen(packet: AdbPacketData) {
@@ -241,12 +215,41 @@ 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);
         }
     }
 
+    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";
@@ -269,6 +272,18 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
+    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,
@@ -307,7 +322,7 @@ export class AdbPacketDispatcher implements Closeable {
         this.#closed = true;
 
         this.#readAbortController.abort();
-        if (this.options.preserveConnection ?? false) {
+        if (this.options.preserveConnection) {
             this.#writer.releaseLock();
         } else {
             await this.#writer.close();
@@ -318,7 +333,7 @@ export class AdbPacketDispatcher implements Closeable {
 
     #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'
 }

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,11 +34,7 @@ export interface AdbDaemonSocketConstructionOptions
 }
 
 export class AdbDaemonSocketController
-    implements
-        AdbDaemonSocketInfo,
-        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
-        Closeable,
-        Disposable
+    implements AdbDaemonSocketInfo, AdbSocket, Disposable
 {
     readonly #dispatcher!: AdbPacketDispatcher;
 
@@ -49,8 +43,6 @@ export class AdbDaemonSocketController
     readonly localCreated!: boolean;
     readonly service!: string;
 
-    #duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
-
     #readable: ReadableStream<Uint8Array>;
     #readableController!: PushReadableStreamController<Uint8Array>;
     get readable() {
@@ -58,16 +50,14 @@ export class AdbDaemonSocketController
     }
 
     #writePromise: PromiseResolver<void> | undefined;
+    #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.
-     */
+
+    #closedPromise = new PromiseResolver<void>();
     get closed() {
-        return this.#closed;
+        return this.#closedPromise.promise;
     }
 
     #socket: AdbDaemonSocket;
@@ -82,76 +72,56 @@ export class AdbDaemonSocketController
         this.localCreated = options.localCreated;
         this.service = options.service;
 
-        // 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"));
-            },
+        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);
     }
 
     async enqueue(data: Uint8Array) {
-        // Consumer may abort the `ReadableStream` to close the socket,
-        // it's OK to throw away further packets in this case.
+        // 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;
+        }
     }
 
     ack() {
@@ -159,11 +129,32 @@ export class AdbDaemonSocketController
     }
 
     async close(): Promise<void> {
-        await this.#duplex.close();
+        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,
+        );
     }
 
     dispose() {
-        return this.#duplex.dispose();
+        try {
+            this.#readableController.close();
+        } catch {
+            // ignore
+        }
+
+        this.#closedPromise.resolve();
     }
 }
 
@@ -175,11 +166,7 @@ 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;
 
     get localId(): number {
@@ -202,7 +189,7 @@ export class AdbDaemonSocket
         return this.#controller.writable;
     }
 
-    get closed(): boolean {
+    get closed(): Promise<void> {
         return this.#controller.closed;
     }
 

package/src/daemon/transport.ts

@@ -27,20 +27,26 @@ import { AdbCommand, calculateChecksum } from "./packet.js";
 
 export const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 0x01000001;
 
+export type AdbDaemonConnection = ReadableWritablePair<
+    AdbPacketData,
+    Consumable<AdbPacketInit>
+>;
+
 interface AdbDaemonAuthenticationOptions {
     serial: string;
-    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    connection: AdbDaemonConnection;
     credentialStore: AdbCredentialStore;
     authenticators?: AdbAuthenticator[];
     /**
      * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
      */
     preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 interface AdbDaemonSocketConnectorConstructionOptions {
     serial: string;
-    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    connection: AdbDaemonConnection;
     version: number;
     maxPayloadSize: number;
     banner: string;
@@ -48,6 +54,7 @@ interface AdbDaemonSocketConnectorConstructionOptions {
      * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
      */
     preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 export class AdbDaemonTransport implements AdbTransport {
@@ -64,7 +71,7 @@ export class AdbDaemonTransport implements AdbTransport {
         connection,
         credentialStore,
         authenticators = ADB_DEFAULT_AUTHENTICATORS,
-        preserveConnection,
+        ...options
     }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport> {
         // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
@@ -94,9 +101,8 @@ export class AdbDaemonTransport implements AdbTransport {
                                 resolver.resolve(decodeUtf8(packet.payload));
                                 break;
                             case AdbCommand.Auth: {
-                                const response = await authProcessor.process(
-                                    packet,
-                                );
+                                const response =
+                                    await authProcessor.process(packet);
                                 await sendPacket(response);
                                 break;
                             }
@@ -189,10 +195,15 @@ export class AdbDaemonTransport implements AdbTransport {
             version,
             maxPayloadSize,
             banner,
-            preserveConnection,
+            ...options,
         });
     }
 
+    #connection: AdbDaemonConnection;
+    get connection() {
+        return this.#connection;
+    }
+
     readonly #dispatcher: AdbPacketDispatcher;
 
     #serial: string;
@@ -205,9 +216,8 @@ export class AdbDaemonTransport implements AdbTransport {
         return this.#protocolVersion;
     }
 
-    #maxPayloadSize: number;
     get maxPayloadSize() {
-        return this.#maxPayloadSize;
+        return this.#dispatcher.options.maxPayloadSize;
     }
 
     #banner: AdbBanner;
@@ -223,11 +233,11 @@ export class AdbDaemonTransport implements AdbTransport {
         serial,
         connection,
         version,
-        maxPayloadSize,
         banner,
-        preserveConnection,
+        ...options
     }: AdbDaemonSocketConnectorConstructionOptions) {
         this.#serial = serial;
+        this.#connection = connection;
         this.#banner = AdbBanner.parse(banner);
 
         let calculateChecksum: boolean;
@@ -243,12 +253,10 @@ export class AdbDaemonTransport implements AdbTransport {
         this.#dispatcher = new AdbPacketDispatcher(connection, {
             calculateChecksum,
             appendNullToServiceString,
-            maxPayloadSize,
-            preserveConnection,
+            ...options,
         });
 
         this.#protocolVersion = version;
-        this.#maxPayloadSize = maxPayloadSize;
     }
 
     connect(service: string): ValueOrPromise<AdbSocket> {