@yume-chan/adb 0.0.17 → 0.0.19

package/src/socket/dispatcher.ts

@@ -1,11 +1,24 @@
-import { AsyncOperationManager, PromiseResolver } from '@yume-chan/async';
-import type { RemoveEventListener } from '@yume-chan/event';
-import { AbortController, WritableStream, WritableStreamDefaultWriter, type ReadableWritablePair } from '@yume-chan/stream-extra';
-import { EMPTY_UINT8_ARRAY, type ValueOrPromise } from '@yume-chan/struct';
-
-import { AdbCommand, calculateChecksum, type AdbPacketData, type AdbPacketInit } from '../packet.js';
-import { decodeUtf8, encodeUtf8 } from '../utils/index.js';
-import { AdbSocket, AdbSocketController } from './socket.js';
+import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
+import type { RemoveEventListener } from "@yume-chan/event";
+import type {
+    Consumable,
+    ReadableWritablePair,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    AbortController,
+    ConsumableWritableStream,
+    WritableStream,
+} from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
+
+import type { AdbPacketData, AdbPacketInit } from "../packet.js";
+import { AdbCommand, calculateChecksum } from "../packet.js";
+import { decodeUtf8, encodeUtf8 } from "../utils/index.js";
+
+import type { AdbSocket } from "./socket.js";
+import { AdbSocketController } from "./socket.js";
 
 export interface AdbPacketDispatcherOptions {
     calculateChecksum: boolean;
@@ -19,7 +32,9 @@ export interface AdbPacketDispatcherOptions {
     maxPayloadSize: number;
 }
 
-export type AdbIncomingSocketHandler = (socket: AdbSocket) => ValueOrPromise<boolean>;
+export type AdbIncomingSocketHandler = (
+    socket: AdbSocket
+) => ValueOrPromise<boolean>;
 
 export interface Closeable {
     close(): ValueOrPromise<void>;
@@ -44,72 +59,92 @@ export class AdbPacketDispatcher implements Closeable {
      */
     private readonly sockets = new Map<number, AdbSocketController>();
 
-    private _writer!: WritableStreamDefaultWriter<AdbPacketInit>;
+    private _writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     public readonly options: AdbPacketDispatcherOptions;
 
     private _closed = false;
     private _disconnected = new PromiseResolver<void>();
-    public get disconnected() { return this._disconnected.promise; }
+    public get disconnected() {
+        return this._disconnected.promise;
+    }
 
     private _incomingSocketHandlers: Set<AdbIncomingSocketHandler> = new Set();
 
     private _abortController = new AbortController();
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         options: AdbPacketDispatcherOptions
     ) {
         this.options = options;
 
         connection.readable
-            .pipeTo(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);
+            .pipeTo(
+                new WritableStream({
+                    write: async (packet) => {
+                        switch (packet.command) {
+                            case AdbCommand.OK:
+                                this.handleOk(packet);
                                 break;
-                            }
-                            throw new Error(`Unknown local socket id: ${packet.arg1}`);
-                        case AdbCommand.Open:
-                            await this.handleOpen(packet);
-                            break;
-                        default:
-                            // Junk data may only appear in the authentication phase,
-                            // since the dispatcher only works after authentication,
-                            // all packets should have a valid command.
-                            // (although it's possible that Adb added new commands in the future)
-                            throw new Error(`Unknown command: ${packet.command.toString(16)}`);
-                    }
+                            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.Open:
+                                await this.handleOpen(packet);
+                                break;
+                            default:
+                                // Junk data may only appear in the authentication phase,
+                                // since the dispatcher only works after authentication,
+                                // all packets should have a valid command.
+                                // (although it's possible that Adb added new commands in the future)
+                                throw new Error(
+                                    `Unknown command: ${packet.command.toString(
+                                        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,
+                    signal: this._abortController.signal,
+                }
+            )
+            .then(
+                () => {
+                    this.dispose();
                 },
-            }), {
-                // 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,
-                signal: this._abortController.signal,
-            })
-            .then(() => {
-                this.dispose();
-            }, (e) => {
-                // https://github.com/MattiasBuelens/web-streams-polyfill/issues/115
-                // `e` is always `AbortError` (instead of what I give in `abortController.abort()`)
-                // so we can't check if `e` is a real error.
-                if (!this._closed) {
-                    this._disconnected.reject(e);
+                (e) => {
+                    if (!this._closed) {
+                        this._disconnected.reject(e);
+                    }
+                    this.dispose();
                 }
-                this.dispose();
-            });
+            );
 
         this._writer = connection.writable.getWriter();
     }
@@ -129,13 +164,18 @@ export class AdbPacketDispatcher implements Closeable {
 
         // Maybe the device is responding to a packet of last connection
         // Tell the device to close the socket
-        this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
+        void this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
     }
 
     private async handleClose(packet: AdbPacketData) {
         // If the socket is still pending
-        if (packet.arg0 === 0 &&
-            this.initializers.reject(packet.arg1, new Error('Socket open failed'))) {
+        if (
+            packet.arg0 === 0 &&
+            this.initializers.reject(
+                packet.arg1,
+                new Error("Socket open failed")
+            )
+        ) {
             // Device failed to create the socket
             // (unknown service string, failed to execute command, etc.)
             // it doesn't break the connection,
@@ -156,9 +196,13 @@ export class AdbPacketDispatcher implements Closeable {
         if (socket) {
             // The device want to close the socket
             if (!socket.closed) {
-                await this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
+                await this.sendPacket(
+                    AdbCommand.Close,
+                    packet.arg1,
+                    packet.arg0
+                );
             }
-            socket.dispose();
+            await socket.dispose();
             this.sockets.delete(packet.arg1);
             return;
         }
@@ -173,7 +217,9 @@ export class AdbPacketDispatcher implements Closeable {
      * @param handler A function to call with new incoming sockets. It must return `true` if it accepts the socket.
      * @returns A function to remove the handler.
      */
-    public onIncomingSocket(handler: AdbIncomingSocketHandler): RemoveEventListener {
+    public onIncomingSocket(
+        handler: AdbIncomingSocketHandler
+    ): RemoveEventListener {
         this._incomingSocketHandlers.add(handler);
         const remove = () => {
             this._incomingSocketHandlers.delete(handler);
@@ -212,16 +258,11 @@ export class AdbPacketDispatcher implements Closeable {
 
     public async createSocket(serviceString: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
-            serviceString += '\0';
+            serviceString += "\0";
         }
 
         const [localId, initializer] = this.initializers.add<number>();
-        await this.sendPacket(
-            AdbCommand.Open,
-            localId,
-            0,
-            serviceString
-        );
+        await this.sendPacket(AdbCommand.Open, localId, 0, serviceString);
 
         // Fulfilled by `handleOk`
         const remoteId = await initializer;
@@ -237,57 +278,36 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
-    public sendPacket(packet: AdbPacketInit): Promise<void>;
-    public sendPacket(
+    public async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload?: string | Uint8Array
-    ): Promise<void>;
-    public async sendPacket(
-        packetOrCommand: AdbPacketInit | AdbCommand,
-        arg0?: number,
-        arg1?: number,
-        payload: string | Uint8Array = EMPTY_UINT8_ARRAY,
+        payload: string | Uint8Array = EMPTY_UINT8_ARRAY
     ): Promise<void> {
-        let init: AdbPacketData;
-        if (arg0 === undefined) {
-            init = packetOrCommand as AdbPacketInit;
-        } else {
-            if (typeof payload === 'string') {
-                payload = encodeUtf8(payload);
-            }
-
-            init = {
-                command: packetOrCommand as AdbCommand,
-                arg0: arg0 as number,
-                arg1: arg1 as number,
-                payload,
-            };
+        if (typeof payload === "string") {
+            payload = encodeUtf8(payload);
         }
 
-        if (init.payload &&
-            init.payload.byteLength > this.options.maxPayloadSize) {
-            throw new Error('payload too large');
+        if (payload.byteLength > this.options.maxPayloadSize) {
+            throw new Error("payload too large");
         }
 
-        if (this.options.calculateChecksum) {
-            calculateChecksum(init);
-        } else {
-            (init as AdbPacketInit).checksum = 0;
-        }
-
-        await this._writer.ready;
-        await this._writer.write(init as AdbPacketInit);
+        await ConsumableWritableStream.write(this._writer, {
+            command,
+            arg0,
+            arg1,
+            payload,
+            checksum: this.options.calculateChecksum
+                ? calculateChecksum(payload)
+                : 0,
+            magic: command ^ 0xffffffff,
+        });
     }
 
     public 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
@@ -302,7 +322,9 @@ export class AdbPacketDispatcher implements Closeable {
 
     private dispose() {
         for (const socket of this.sockets.values()) {
-            socket.dispose();
+            socket.dispose().catch((e) => {
+                void e;
+            });
         }
 
         this._disconnected.resolve();

package/src/socket/index.ts

@@ -1,2 +1,2 @@
-export * from './dispatcher.js';
-export * from './socket.js';
+export * from "./dispatcher.js";
+export * from "./socket.js";

package/src/socket/socket.ts

@@ -1,9 +1,23 @@
-import { PromiseResolver } from '@yume-chan/async';
-import type { Disposable } from '@yume-chan/event';
-import { ChunkStream, DuplexStreamFactory, pipeFrom, PushReadableStream, WritableStream, type PushReadableStreamController, type ReadableStream, type ReadableWritablePair } from '@yume-chan/stream-extra';
-
-import { AdbCommand } from '../packet.js';
-import type { AdbPacketDispatcher, Closeable } from './dispatcher.js';
+import { PromiseResolver } from "@yume-chan/async";
+import type { Disposable } from "@yume-chan/event";
+import type {
+    Consumable,
+    PushReadableStreamController,
+    ReadableStream,
+    ReadableWritablePair,
+    WritableStream,
+} from "@yume-chan/stream-extra";
+import {
+    ConsumableWritableStream,
+    DistributionStream,
+    DuplexStreamFactory,
+    PushReadableStream,
+    pipeFrom,
+} from "@yume-chan/stream-extra";
+
+import { AdbCommand } from "../packet.js";
+
+import type { AdbPacketDispatcher, Closeable } from "./dispatcher.js";
 
 export interface AdbSocketInfo {
     localId: number;
@@ -19,7 +33,13 @@ export interface AdbSocketConstructionOptions extends AdbSocketInfo {
     highWaterMark?: number | undefined;
 }
 
-export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<Uint8Array, Uint8Array>, Closeable, Disposable {
+export class AdbSocketController
+    implements
+        AdbSocketInfo,
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
+        Closeable,
+        Disposable
+{
     private readonly dispatcher!: AdbPacketDispatcher;
 
     public readonly localId!: number;
@@ -27,14 +47,16 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
     public readonly localCreated!: boolean;
     public readonly serviceString!: string;
 
-    private _duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
+    private _duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
 
     private _readable: ReadableStream<Uint8Array>;
     private _readableController!: PushReadableStreamController<Uint8Array>;
-    public get readable() { return this._readable; }
+    public get readable() {
+        return this._readable;
+    }
 
     private _writePromise: PromiseResolver<void> | undefined;
-    public readonly writable: WritableStream<Uint8Array>;
+    public readonly writable: WritableStream<Consumable<Uint8Array>>;
 
     private _closed = false;
     /**
@@ -42,10 +64,14 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
      *
      * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
      */
-    public get closed() { return this._closed; }
+    public get closed() {
+        return this._closed;
+    }
 
     private _socket: AdbSocket;
-    public get socket() { return this._socket; }
+    public get socket() {
+        return this._socket;
+    }
 
     public constructor(options: AdbSocketConstructionOptions) {
         Object.assign(this, options);
@@ -54,7 +80,10 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
         // cspell: disable-next-line
         // https://www.plantuml.com/plantuml/png/TL0zoeGm4ErpYc3l5JxyS0yWM6mX5j4C6p4cxcJ25ejttuGX88ZftizxUKmJI275pGhXl0PP_UkfK_CAz5Z2hcWsW9Ny2fdU4C1f5aSchFVxA8vJjlTPRhqZzDQMRB7AklwJ0xXtX0ZSKH1h24ghoKAdGY23FhxC4nS2pDvxzIvxb-8THU0XlEQJ-ZB7SnXTAvc_LhOckhMdLBnbtndpb-SB7a8q2SRD_W00
 
-        this._duplex = new DuplexStreamFactory<Uint8Array, Uint8Array>({
+        this._duplex = new DuplexStreamFactory<
+            Uint8Array,
+            Consumable<Uint8Array>
+        >({
             close: async () => {
                 this._closed = true;
 
@@ -69,22 +98,27 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
             },
             dispose: () => {
                 // Error out the pending writes
-                this._writePromise?.reject(new Error('Socket closed'));
+                this._writePromise?.reject(new Error("Socket closed"));
             },
         });
 
         this._readable = this._duplex.wrapReadable(
-            new PushReadableStream(controller => {
-                this._readableController = controller;
-            }, {
-                highWaterMark: options.highWaterMark ?? 16 * 1024,
-                size(chunk) { return chunk.byteLength; }
-            })
+            new PushReadableStream(
+                (controller) => {
+                    this._readableController = controller;
+                },
+                {
+                    highWaterMark: options.highWaterMark ?? 16 * 1024,
+                    size(chunk) {
+                        return chunk.byteLength;
+                    },
+                }
+            )
         );
 
         this.writable = pipeFrom(
             this._duplex.createWritable(
-                new WritableStream({
+                new ConsumableWritableStream<Uint8Array>({
                     write: async (chunk) => {
                         // Wait for an ack packet
                         this._writePromise = new PromiseResolver();
@@ -95,23 +129,23 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
                             chunk
                         );
                         await this._writePromise.promise;
-                    }
-                }),
+                    },
+                })
             ),
-            new ChunkStream(this.dispatcher.options.maxPayloadSize)
+            new DistributionStream(this.dispatcher.options.maxPayloadSize)
         );
 
         this._socket = new AdbSocket(this);
     }
 
-    public async enqueue(packet: Uint8Array) {
+    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.
         if (this._readableController.abortSignal.aborted) {
             return;
         }
 
-        await this._readableController.enqueue(packet);
+        await this._readableController.enqueue(data);
     }
 
     public ack() {
@@ -123,7 +157,7 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
     }
 
     public dispose() {
-        this._duplex.dispose();
+        return this._duplex.dispose();
     }
 }
 
@@ -135,16 +169,32 @@ export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<
  * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
  * `socket.writable.close()` or `socket.writable.getWriter().close()`.
  */
-export class AdbSocket implements AdbSocketInfo, ReadableWritablePair<Uint8Array, Uint8Array>{
+export class AdbSocket
+    implements
+        AdbSocketInfo,
+        ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
+{
     private _controller: AdbSocketController;
 
-    public get localId(): number { return this._controller.localId; }
-    public get remoteId(): number { return this._controller.remoteId; }
-    public get localCreated(): boolean { return this._controller.localCreated; }
-    public get serviceString(): string { return this._controller.serviceString; }
+    public get localId(): number {
+        return this._controller.localId;
+    }
+    public get remoteId(): number {
+        return this._controller.remoteId;
+    }
+    public get localCreated(): boolean {
+        return this._controller.localCreated;
+    }
+    public get serviceString(): string {
+        return this._controller.serviceString;
+    }
 
-    public get readable(): ReadableStream<Uint8Array> { return this._controller.readable; }
-    public get writable(): WritableStream<Uint8Array> { return this._controller.writable; }
+    public get readable(): ReadableStream<Uint8Array> {
+        return this._controller.readable;
+    }
+    public get writable(): WritableStream<Consumable<Uint8Array>> {
+        return this._controller.writable;
+    }
 
     public constructor(controller: AdbSocketController) {
         this._controller = controller;

package/src/utils/auto-reset-event.ts

@@ -1,41 +1,40 @@
-import { PromiseResolver } from '@yume-chan/async';
-import type { Disposable } from '@yume-chan/event';
+import { PromiseResolver } from "@yume-chan/async";
+import type { Disposable } from "@yume-chan/event";
 
 export class AutoResetEvent implements Disposable {
-    private readonly list: PromiseResolver<void>[] = [];
-
-    private blocking: boolean;
+    private _set: boolean;
+    private readonly _queue: PromiseResolver<void>[] = [];
 
     public constructor(initialSet = false) {
-        this.blocking = initialSet;
+        this._set = initialSet;
     }
 
     public wait(): Promise<void> {
-        if (!this.blocking) {
-            this.blocking = true;
+        if (!this._set) {
+            this._set = true;
 
-            if (this.list.length === 0) {
+            if (this._queue.length === 0) {
                 return Promise.resolve();
             }
         }
 
         const resolver = new PromiseResolver<void>();
-        this.list.push(resolver);
+        this._queue.push(resolver);
         return resolver.promise;
     }
 
-    public notify() {
-        if (this.list.length !== 0) {
-            this.list.pop()!.resolve();
+    public notifyOne() {
+        if (this._queue.length !== 0) {
+            this._queue.pop()!.resolve();
         } else {
-            this.blocking = false;
+            this._set = false;
         }
     }
 
     public dispose() {
-        for (const item of this.list) {
-            item.reject(new Error('The AutoResetEvent has been disposed'));
+        for (const item of this._queue) {
+            item.reject(new Error("The AutoResetEvent has been disposed"));
         }
-        this.list.length = 0;
+        this._queue.length = 0;
     }
 }