@yume-chan/adb 0.0.15 → 0.0.16

package/src/socket/socket.ts

@@ -1,144 +1,155 @@
-import { PromiseResolver } from "@yume-chan/async";
-import type { Disposable } from "@yume-chan/event";
-import { AdbCommand } from '../packet.js';
-import { ChunkStream, DuplexStreamFactory, pipeFrom, PushReadableStream, WritableStream, type PushReadableStreamController, type ReadableStream, type ReadableWritablePair } from '../stream/index.js';
-import type { AdbPacketDispatcher, Closeable } from './dispatcher.js';
-
-export interface AdbSocketInfo {
-    localId: number;
-    remoteId: number;
-
-    localCreated: boolean;
-    serviceString: string;
-}
-
-export interface AdbSocketConstructionOptions extends AdbSocketInfo {
-    dispatcher: AdbPacketDispatcher;
-
-    highWaterMark?: number | undefined;
-}
-
-export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<Uint8Array, Uint8Array>, Closeable, Disposable {
-    private readonly dispatcher!: AdbPacketDispatcher;
-
-    public readonly localId!: number;
-    public readonly remoteId!: number;
-    public readonly localCreated!: boolean;
-    public readonly serviceString!: string;
-
-    private _factory: DuplexStreamFactory<Uint8Array, Uint8Array>;
-
-    private _readable: ReadableStream<Uint8Array>;
-    private _readableController!: PushReadableStreamController<Uint8Array>;
-    public get readable() { return this._readable; }
-
-    private _writePromise: PromiseResolver<void> | undefined;
-    public readonly writable: WritableStream<Uint8Array>;
-
-    private _closed = false;
-    public get closed() { return this._closed; }
-
-    private _socket: AdbSocket;
-    public get socket() { return this._socket; }
-
-    public constructor(options: AdbSocketConstructionOptions) {
-        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._factory = new DuplexStreamFactory<Uint8Array, Uint8Array>({
-            close: async () => {
-                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: () => {
-                this._closed = true;
-
-                // Error out the pending writes
-                this._writePromise?.reject(new Error('Socket closed'));
-            },
-        });
-
-        this._readable = this._factory.wrapReadable(
-            new PushReadableStream(controller => {
-                this._readableController = controller;
-            }, {
-                highWaterMark: options.highWaterMark ?? 16 * 1024,
-                size(chunk) { return chunk.byteLength; }
-            })
-        );
-
-        this.writable = pipeFrom(
-            this._factory.createWritable(
-                new WritableStream({
-                    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 ChunkStream(this.dispatcher.options.maxPayloadSize)
-        );
-
-        this._socket = new AdbSocket(this);
-    }
-
-    public async enqueue(packet: Uint8Array) {
-        await this._readableController.enqueue(packet);
-    }
-
-    public ack() {
-        this._writePromise?.resolve();
-    }
-
-    public async close(): Promise<void> {
-        this._factory.close();
-    }
-
-    public dispose() {
-        this._factory.dispose();
-    }
-}
-
-/**
- * AdbSocket is a duplex stream.
- *
- * To close it, call either `socket.close()`,
- * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
- * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
- * `socket.writable.close()` or `socket.writable.getWriter().close()`.
- */
-export class AdbSocket implements AdbSocketInfo, ReadableWritablePair<Uint8Array, 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 readable(): ReadableStream<Uint8Array> { return this._controller.readable; }
-    public get writable(): WritableStream<Uint8Array> { return this._controller.writable; }
-
-    public constructor(controller: AdbSocketController) {
-        this._controller = controller;
-    }
-
-    public close() {
-        return this._controller.close();
-    }
-}
+import { PromiseResolver } from "@yume-chan/async";
+import type { Disposable } from "@yume-chan/event";
+import { AdbCommand } from '../packet.js';
+import { ChunkStream, DuplexStreamFactory, pipeFrom, PushReadableStream, WritableStream, type PushReadableStreamController, type ReadableStream, type ReadableWritablePair } from '../stream/index.js';
+import type { AdbPacketDispatcher, Closeable } from './dispatcher.js';
+
+export interface AdbSocketInfo {
+    localId: number;
+    remoteId: number;
+
+    localCreated: boolean;
+    serviceString: string;
+}
+
+export interface AdbSocketConstructionOptions extends AdbSocketInfo {
+    dispatcher: AdbPacketDispatcher;
+
+    highWaterMark?: number | undefined;
+}
+
+export class AdbSocketController implements AdbSocketInfo, ReadableWritablePair<Uint8Array, Uint8Array>, Closeable, Disposable {
+    private readonly dispatcher!: AdbPacketDispatcher;
+
+    public readonly localId!: number;
+    public readonly remoteId!: number;
+    public readonly localCreated!: boolean;
+    public readonly serviceString!: string;
+
+    private _duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
+
+    private _readable: ReadableStream<Uint8Array>;
+    private _readableController!: PushReadableStreamController<Uint8Array>;
+    public get readable() { return this._readable; }
+
+    private _writePromise: PromiseResolver<void> | undefined;
+    public readonly writable: WritableStream<Uint8Array>;
+
+    private _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: AdbSocket;
+    public get socket() { return this._socket; }
+
+    public constructor(options: AdbSocketConstructionOptions) {
+        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, 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 = this._duplex.wrapReadable(
+            new PushReadableStream(controller => {
+                this._readableController = controller;
+            }, {
+                highWaterMark: options.highWaterMark ?? 16 * 1024,
+                size(chunk) { return chunk.byteLength; }
+            })
+        );
+
+        this.writable = pipeFrom(
+            this._duplex.createWritable(
+                new WritableStream({
+                    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 ChunkStream(this.dispatcher.options.maxPayloadSize)
+        );
+
+        this._socket = new AdbSocket(this);
+    }
+
+    public async enqueue(packet: 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);
+    }
+
+    public ack() {
+        this._writePromise?.resolve();
+    }
+
+    public async close(): Promise<void> {
+        await this._duplex.close();
+    }
+
+    public dispose() {
+        this._duplex.dispose();
+    }
+}
+
+/**
+ * AdbSocket is a duplex stream.
+ *
+ * To close it, call either `socket.close()`,
+ * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
+ * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
+ * `socket.writable.close()` or `socket.writable.getWriter().close()`.
+ */
+export class AdbSocket implements AdbSocketInfo, ReadableWritablePair<Uint8Array, 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 readable(): ReadableStream<Uint8Array> { return this._controller.readable; }
+    public get writable(): WritableStream<Uint8Array> { return this._controller.writable; }
+
+    public constructor(controller: AdbSocketController) {
+        this._controller = controller;
+    }
+
+    public close() {
+        return this._controller.close();
+    }
+}

package/src/stream/buffered.ts

@@ -1,147 +1,168 @@
-import type { StructAsyncDeserializeStream } from '@yume-chan/struct';
-import type { AdbSocket, AdbSocketInfo } from '../socket/index.js';
-import type { ReadableStream, ReadableStreamDefaultReader } from './detect.js';
-import { PushReadableStream } from "./transform.js";
-
-export class BufferedStreamEndedError extends Error {
-    public constructor() {
-        super('Stream ended');
-
-        // Fix Error's prototype chain when compiling to ES5
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
-
-export class BufferedStream {
-    private buffer: Uint8Array | undefined;
-
-    protected readonly stream: ReadableStream<Uint8Array>;
-
-    protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
-
-    public constructor(stream: ReadableStream<Uint8Array>) {
-        this.stream = stream;
-        this.reader = stream.getReader();
-    }
-
-    /**
-     *
-     * @param length
-     * @returns
-     */
-    public async read(length: number): Promise<Uint8Array> {
-        let array: Uint8Array;
-        let index: number;
-        if (this.buffer) {
-            const buffer = this.buffer;
-            if (buffer.byteLength > length) {
-                this.buffer = buffer.subarray(length);
-                return buffer.subarray(0, length);
-            }
-
-            array = new Uint8Array(length);
-            array.set(buffer);
-            index = buffer.byteLength;
-            this.buffer = undefined;
-        } else {
-            const { done, value } = await this.reader.read();
-            if (done) {
-                throw new BufferedStreamEndedError();
-            }
-
-            if (value.byteLength === length) {
-                return value;
-            }
-
-            if (value.byteLength > length) {
-                this.buffer = value.subarray(length);
-                return value.subarray(0, length);
-            }
-
-            array = new Uint8Array(length);
-            array.set(value);
-            index = value.byteLength;
-        }
-
-        while (index < length) {
-            const left = length - index;
-
-            const { done, value } = await this.reader.read();
-            if (done) {
-                throw new BufferedStreamEndedError();
-            }
-
-            if (value.byteLength === left) {
-                array.set(value, index);
-                return array;
-            }
-
-            if (value.byteLength > left) {
-                array.set(value.subarray(0, left), index);
-                this.buffer = value.subarray(left);
-                return array;
-            }
-
-            array.set(value, index);
-            index += value.byteLength;
-        }
-
-        return array;
-    }
-
-    /**
-     * Return a readable stream with unconsumed data (if any) and
-     * all data from the wrapped stream.
-     * @returns A `ReadableStream`
-     */
-    public release(): ReadableStream<Uint8Array> {
-        if (this.buffer) {
-            return new PushReadableStream<Uint8Array>(async controller => {
-                // Put the remaining data back to the stream
-                await controller.enqueue(this.buffer!);
-
-                // Manually pipe the stream
-                while (true) {
-                    try {
-                        const { done, value } = await this.reader.read();
-                        if (done) {
-                            controller.close();
-                            break;
-                        } else {
-                            await controller.enqueue(value);
-                        }
-                    } catch (e) {
-                        controller.error(e);
-                        break;
-                    }
-                }
-            });
-        } else {
-            // Simply release the reader and return the stream
-            this.reader.releaseLock();
-            return this.stream;
-        }
-    }
-
-    public async close() {
-        await this.reader.cancel();
-    }
-}
-
-export class AdbBufferedStream
-    extends BufferedStream
-    implements AdbSocketInfo, StructAsyncDeserializeStream {
-    protected readonly socket: AdbSocket;
-
-    public get localId() { return this.socket.localId; }
-    public get remoteId() { return this.socket.remoteId; }
-    public get localCreated() { return this.socket.localCreated; }
-    public get serviceString() { return this.socket.serviceString; }
-
-    public get writable() { return this.socket.writable; }
-
-    public constructor(socket: AdbSocket) {
-        super(socket.readable);
-        this.socket = socket;
-    }
-}
+import type { StructAsyncDeserializeStream } from '@yume-chan/struct';
+import type { AdbSocket, AdbSocketInfo } from '../socket/index.js';
+import type { ReadableStream, ReadableStreamDefaultReader } from './detect.js';
+import { PushReadableStream } from "./transform.js";
+
+export class BufferedStreamEndedError extends Error {
+    public constructor() {
+        super('Stream ended');
+
+        // Fix Error's prototype chain when compiling to ES5
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+export class BufferedStream {
+    private buffered: Uint8Array | undefined;
+    private bufferedOffset = 0;
+    private bufferedLength = 0;
+
+    protected readonly stream: ReadableStream<Uint8Array>;
+
+    protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
+
+    public constructor(stream: ReadableStream<Uint8Array>) {
+        this.stream = stream;
+        this.reader = stream.getReader();
+    }
+
+    private async readSource() {
+        const { done, value } = await this.reader.read();
+        if (done) {
+            throw new BufferedStreamEndedError();
+        }
+        return value;
+    }
+
+    private async readAsync(length: number, initial?: Uint8Array) {
+        let result: Uint8Array;
+        let index: number;
+
+        if (initial) {
+            result = new Uint8Array(length);
+            result.set(initial);
+            index = initial.byteLength;
+            length -= initial.byteLength;
+        } else {
+            const array = await this.readSource();
+            if (array.byteLength === length) {
+                return array;
+            }
+
+            if (array.byteLength > length) {
+                this.buffered = array;
+                this.bufferedOffset = length;
+                this.bufferedLength = array.byteLength - length;
+                return array.subarray(0, length);
+            }
+
+            result = new Uint8Array(length);
+            result.set(array);
+            index = array.byteLength;
+            length -= array.byteLength;
+        }
+
+        while (length > 0) {
+            const array = await this.readSource();
+            if (array.byteLength === length) {
+                result.set(array, index);
+                return result;
+            }
+
+            if (array.byteLength > length) {
+                this.buffered = array;
+                this.bufferedOffset = length;
+                this.bufferedLength = array.byteLength - length;
+                result.set(array.subarray(0, length), index);
+                return result;
+            }
+
+            result.set(array, index);
+            index += array.byteLength;
+            length -= array.byteLength;
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param length
+     * @returns
+     */
+    public read(length: number): Uint8Array | Promise<Uint8Array> {
+        // PERF: Add a synchronous path for reading from internal buffer
+        if (this.buffered) {
+            const array = this.buffered;
+            const offset = this.bufferedOffset;
+            if (this.bufferedLength > length) {
+                // PERF: `subarray` is slow
+                // don't use it until absolutely necessary
+                this.bufferedOffset += length;
+                this.bufferedLength -= length;
+                return array.subarray(offset, offset + length);
+            }
+
+            this.buffered = undefined;
+            return this.readAsync(length, array.subarray(offset));
+        }
+
+        return this.readAsync(length);
+    }
+
+    /**
+     * Return a readable stream with unconsumed data (if any) and
+     * all data from the wrapped stream.
+     * @returns A `ReadableStream`
+     */
+    public release(): ReadableStream<Uint8Array> {
+        if (this.buffered) {
+            return new PushReadableStream<Uint8Array>(async controller => {
+                // Put the remaining data back to the stream
+                await controller.enqueue(this.buffered!);
+
+                // Manually pipe the stream
+                while (true) {
+                    try {
+                        const { done, value } = await this.reader.read();
+                        if (done) {
+                            controller.close();
+                            break;
+                        } else {
+                            await controller.enqueue(value);
+                        }
+                    } catch (e) {
+                        controller.error(e);
+                        break;
+                    }
+                }
+            });
+        } else {
+            // Simply release the reader and return the stream
+            this.reader.releaseLock();
+            return this.stream;
+        }
+    }
+
+    public async close() {
+        await this.reader.cancel();
+    }
+}
+
+export class AdbBufferedStream
+    extends BufferedStream
+    implements AdbSocketInfo, StructAsyncDeserializeStream {
+    protected readonly socket: AdbSocket;
+
+    public get localId() { return this.socket.localId; }
+    public get remoteId() { return this.socket.remoteId; }
+    public get localCreated() { return this.socket.localCreated; }
+    public get serviceString() { return this.socket.serviceString; }
+
+    public get writable() { return this.socket.writable; }
+
+    public constructor(socket: AdbSocket) {
+        super(socket.readable);
+        this.socket = socket;
+    }
+}