@yume-chan/adb 0.0.10 → 0.0.11

package/src/socket/dispatcher.ts

@@ -1,46 +1,36 @@
-import { AsyncOperationManager } from '@yume-chan/async';
+import { AsyncOperationManager, PromiseResolver } from '@yume-chan/async';
 import { AutoDisposable, EventEmitter } from '@yume-chan/event';
-import { AdbBackend } from '../backend';
-import { AdbCommand, AdbPacket, AdbPacketInit } from '../packet';
-import { AutoResetEvent, decodeUtf8, encodeUtf8 } from '../utils';
-import { AdbSocketController } from './controller';
-import { AdbLogger } from './logger';
-import { AdbSocket } from './socket';
-
-export interface AdbPacketReceivedEventArgs {
-    handled: boolean;
-
-    packet: AdbPacket;
-}
+import { AdbCommand, calculateChecksum, type AdbPacketCore, type AdbPacketInit } from '../packet.js';
+import { AbortController, WritableStream, WritableStreamDefaultWriter, type ReadableWritablePair } from '../stream/index.js';
+import { decodeUtf8, encodeUtf8 } from '../utils/index.js';
+import { AdbSocket } from './socket.js';
 
 export interface AdbIncomingSocketEventArgs {
     handled: boolean;
 
-    packet: AdbPacket;
+    packet: AdbPacketCore;
 
     serviceString: string;
 
     socket: AdbSocket;
 }
 
-const EmptyArrayBuffer = new ArrayBuffer(0);
+const EmptyUint8Array = new Uint8Array(0);
 
 export class AdbPacketDispatcher extends AutoDisposable {
     // ADB socket id starts from 1
     // (0 means open failed)
     private readonly initializers = new AsyncOperationManager(1);
-    private readonly sockets = new Map<number, AdbSocketController>();
-    private readonly sendLock = new AutoResetEvent();
-    private readonly logger: AdbLogger | undefined;
+    private readonly sockets = new Map<number, AdbSocket>();
 
-    public readonly backend: AdbBackend;
+    private _writer!: WritableStreamDefaultWriter<AdbPacketInit>;
 
     public maxPayloadSize = 0;
     public calculateChecksum = true;
     public appendNullToServiceString = true;
 
-    private readonly packetEvent = this.addDisposable(new EventEmitter<AdbPacketReceivedEventArgs>());
-    public get onPacket() { return this.packetEvent.event; }
+    private _disconnected = new PromiseResolver<void>();
+    public get disconnected() { return this._disconnected.promise; }
 
     private readonly incomingSocketEvent = this.addDisposable(new EventEmitter<AdbIncomingSocketEventArgs>());
     public get onIncomingSocket() { return this.incomingSocketEvent.event; }
@@ -48,64 +38,60 @@ export class AdbPacketDispatcher extends AutoDisposable {
     private readonly errorEvent = this.addDisposable(new EventEmitter<Error>());
     public get onError() { return this.errorEvent.event; }
 
-    private _running = false;
-    public get running() { return this._running; }
+    private _abortController = new AbortController();
 
-    public constructor(backend: AdbBackend, logger?: AdbLogger) {
+    public constructor(
+        connection: ReadableWritablePair<AdbPacketCore, AdbPacketInit>,
+    ) {
         super();
 
-        this.backend = backend;
-        this.logger = logger;
-    }
-
-    private async receiveLoop() {
-        try {
-            while (this._running) {
-                const packet = await AdbPacket.read(this.backend);
-                this.logger?.onIncomingPacket?.(packet);
-
-                switch (packet.command) {
-                    case AdbCommand.OK:
-                        this.handleOk(packet);
-                        continue;
-                    case AdbCommand.Close:
-                        await this.handleClose(packet);
-                        continue;
-                    case AdbCommand.Write:
-                        if (this.sockets.has(packet.arg1)) {
-                            await this.sockets.get(packet.arg1)!.dataEvent.fire(packet.payload!);
-                            await this.sendPacket(AdbCommand.OK, packet.arg1, packet.arg0);
+        connection.readable
+            .pipeTo(new WritableStream({
+                write: async (packet) => {
+                    try {
+                        switch (packet.command) {
+                            case AdbCommand.OK:
+                                this.handleOk(packet);
+                                return;
+                            case AdbCommand.Close:
+                                await this.handleClose(packet);
+                                return;
+                            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);
+                                }
+
+                                // Maybe the device is responding to a packet of last connection
+                                // Just ignore it
+                                return;
+                            case AdbCommand.Open:
+                                await this.handleOpen(packet);
+                                return;
                         }
-
-                        // Maybe the device is responding to a packet of last connection
-                        // Just ignore it
-                        continue;
-                    case AdbCommand.Open:
-                        await this.handleOpen(packet);
-                        continue;
-                }
-
-                const args: AdbPacketReceivedEventArgs = {
-                    handled: false,
-                    packet,
-                };
-                this.packetEvent.fire(args);
-                if (!args.handled) {
-                    this.dispose();
-                    throw new Error(`Unhandled packet with command '${packet.command}'`);
-                }
-            }
-        } catch (e) {
-            if (!this._running) {
-                // ignore error
-                return;
-            }
-
-            this.errorEvent.fire(e as Error);
-        }
+                    } catch (e) {
+                        this.errorEvent.fire(e as Error);
+
+                        // Throw error here will stop the pipe
+                        // But won't close `readable` because of `preventCancel: true`
+                        throw e;
+                    }
+                },
+            }), {
+                preventCancel: false,
+                signal: this._abortController.signal,
+            })
+            .then(() => {
+                this.dispose();
+            }, () => {
+                // TODO: AdbPacketDispatcher: reject `_disconnected` when pipe errored?
+                this.dispose();
+            });
+
+        this._writer = connection.writable.getWriter();
     }
 
-    private handleOk(packet: AdbPacket) {
+    private handleOk(packet: AdbPacketCore) {
         if (this.initializers.resolve(packet.arg1, packet.arg0)) {
             // Device successfully created the socket
             return;
@@ -123,7 +109,7 @@ export class AdbPacketDispatcher extends AutoDisposable {
         this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
     }
 
-    private async handleClose(packet: AdbPacket) {
+    private async handleClose(packet: AdbPacketCore) {
         // From https://android.googlesource.com/platform/packages/modules/adb/+/65d18e2c1cc48b585811954892311b28a4c3d188/adb.cpp#459
         /* According to protocol.txt, p->msg.arg0 might be 0 to indicate
          * a failed OPEN only. However, due to a bug in previous ADB
@@ -153,23 +139,22 @@ export class AdbPacketDispatcher extends AutoDisposable {
         // Just ignore it
     }
 
-    private async handleOpen(packet: AdbPacket) {
+    private async handleOpen(packet: AdbPacketCore) {
         // AsyncOperationManager doesn't support get and skip an ID
         // Use `add` + `resolve` to simulate this behavior
         const [localId] = this.initializers.add<number>();
         this.initializers.resolve(localId, undefined);
 
         const remoteId = packet.arg0;
-        const serviceString = decodeUtf8(packet.payload!);
+        const serviceString = decodeUtf8(packet.payload);
 
-        const controller = new AdbSocketController({
+        const socket = new AdbSocket({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: false,
             serviceString,
         });
-        const socket = new AdbSocket(controller);
 
         const args: AdbIncomingSocketEventArgs = {
             handled: false,
@@ -180,18 +165,13 @@ export class AdbPacketDispatcher extends AutoDisposable {
         this.incomingSocketEvent.fire(args);
 
         if (args.handled) {
-            this.sockets.set(localId, controller);
+            this.sockets.set(localId, socket);
             await this.sendPacket(AdbCommand.OK, localId, remoteId);
         } else {
             await this.sendPacket(AdbCommand.Close, 0, remoteId);
         }
     }
 
-    public start() {
-        this._running = true;
-        this.receiveLoop();
-    }
-
     public async createSocket(serviceString: string): Promise<AdbSocket> {
         if (this.appendNullToServiceString) {
             serviceString += '\0';
@@ -201,16 +181,16 @@ export class AdbPacketDispatcher extends AutoDisposable {
         await this.sendPacket(AdbCommand.Open, localId, 0, serviceString);
 
         const remoteId = await initializer;
-        const controller = new AdbSocketController({
+        const socket = new AdbSocket({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: true,
             serviceString,
         });
-        this.sockets.set(controller.localId, controller);
+        this.sockets.set(localId, socket);
 
-        return new AdbSocket(controller);
+        return socket;
     }
 
     public sendPacket(packet: AdbPacketInit): Promise<void>;
@@ -218,23 +198,27 @@ export class AdbPacketDispatcher extends AutoDisposable {
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload?: string | ArrayBuffer
+        payload?: string | Uint8Array
     ): Promise<void>;
     public async sendPacket(
         packetOrCommand: AdbPacketInit | AdbCommand,
         arg0?: number,
         arg1?: number,
-        payload: string | ArrayBuffer = EmptyArrayBuffer,
+        payload: string | Uint8Array = EmptyUint8Array,
     ): Promise<void> {
-        let init: AdbPacketInit;
+        let init: AdbPacketCore;
         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: typeof payload === 'string' ? encodeUtf8(payload) : payload,
+                payload,
             };
         }
 
@@ -243,27 +227,30 @@ export class AdbPacketDispatcher extends AutoDisposable {
             throw new Error('payload too large');
         }
 
-        try {
-            // `AdbPacket.write` writes each packet in two parts
-            // Use a lock to prevent packets been interlaced
-            await this.sendLock.wait();
-
-            this.logger?.onOutgoingPacket?.(init);
-
-            await AdbPacket.write(init, this.calculateChecksum, this.backend);
-        } finally {
-            this.sendLock.notify();
+        if (this.calculateChecksum) {
+            calculateChecksum(init);
+        } else {
+            (init as AdbPacketInit).checksum = 0;
         }
+
+        await this._writer.write(init as AdbPacketInit);
     }
 
     public override dispose() {
-        this._running = false;
-
         for (const socket of this.sockets.values()) {
             socket.dispose();
         }
         this.sockets.clear();
 
+        try {
+            // Stop pipes
+            this._abortController.abort();
+        } catch { }
+
+        this._writer.releaseLock();
+
+        this._disconnected.resolve();
+
         super.dispose();
     }
 }

package/src/socket/index.ts

@@ -1,6 +1,2 @@
-export * from './close-event-emitter';
-export * from './controller';
-export * from './data-event-emitter';
-export * from './dispatcher';
-export * from './logger';
-export * from './socket';
+export * from './socket.js';
+export * from './dispatcher.js';

package/src/socket/socket.ts

@@ -1,28 +1,129 @@
-import { AdbSocketController, AdbSocketInfo } from './controller';
+import { PromiseResolver } from "@yume-chan/async";
+import { AdbCommand } from '../packet.js';
+import { ChunkStream, DuplexStreamFactory, pipeFrom, ReadableStream, WritableStream, type PushReadableStreamController } from '../stream/index.js';
+import type { AdbPacketDispatcher } from './dispatcher.js';
+
+export interface AdbSocketInfo {
+    localId: number;
+    remoteId: number;
+
+    localCreated: boolean;
+
+    serviceString: string;
+}
+
+export interface AdbSocketConstructionOptions {
+    dispatcher: AdbPacketDispatcher;
+
+    localId: number;
+
+    remoteId: number;
+
+    localCreated: boolean;
+
+    serviceString: string;
+
+    highWaterMark?: number | undefined;
+}
 
 export class AdbSocket implements AdbSocketInfo {
-    private readonly controller: AdbSocketController;
+    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>;
 
-    public get backend() { return this.controller.backend; }
-    public get localId() { return this.controller.localId; }
-    public get remoteId() { return this.controller.remoteId; }
-    public get localCreated() { return this.controller.localCreated; }
-    public get serviceString() { return this.controller.serviceString; }
+    private _readable: ReadableStream<Uint8Array>;
+    private _readableController!: PushReadableStreamController<Uint8Array>;
+    public get readable() { return this._readable; }
 
-    public get closed() { return this.controller.closed; }
+    private _writePromise: PromiseResolver<void> | undefined;
+    public readonly writable: WritableStream<Uint8Array>;
 
-    public get onData() { return this.controller.dataEvent.event; }
-    public get onClose() { return this.controller.onClose; }
+    private _closed = false;
+    public get closed() { return this._closed; }
 
-    public constructor(controller: AdbSocketController) {
-        this.controller = controller;
+    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.close();
+            },
+        });
+
+        this._readable = this._factory.createPushReadable(controller => {
+            this._readableController = controller;
+        }, {
+            highWaterMark: options.highWaterMark ?? 16 * 1024,
+            size(chunk) { return chunk.byteLength; }
+        });
+
+        this.writable = pipeFrom(
+            this._factory.createWritable({
+                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.maxPayloadSize)
+        );
+    }
+
+    /**
+     * @internal
+     */
+    public async enqueue(packet: Uint8Array) {
+        await this._readableController.enqueue(packet);
     }
 
-    public write(data: ArrayBuffer): Promise<void> {
-        return this.controller.write(data);
+    /**
+     * @internal
+     */
+    public ack() {
+        this._writePromise?.resolve();
     }
 
-    public close(): Promise<void> {
-        return this.controller.close();
+    public async close(): Promise<void> {
+        // Error out the pending writes
+        this._writePromise?.reject(new Error('Socket closed'));
+
+        if (!this._closed) {
+            this._closed = true;
+
+            // Only send close packet when `close` is called before `dispose`
+            // (the client initiated the close)
+            await this.dispatcher.sendPacket(
+                AdbCommand.Close,
+                this.localId,
+                this.remoteId
+            );
+        }
+    }
+
+    /**
+     * @internal
+     */
+    public dispose() {
+        this._closed = true;
+
+        this._factory.close();
+
+        // Close `writable` side
+        this.close();
     }
 }

package/src/stream/buffered.ts

@@ -0,0 +1,147 @@
+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 close() {
+        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;
+    }
+}