@yume-chan/adb 0.0.19 → 0.0.20

package/src/{socket → daemon}/dispatcher.ts

@@ -1,5 +1,4 @@
 import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
-import type { RemoveEventListener } from "@yume-chan/event";
 import type {
     Consumable,
     ReadableWritablePair,
@@ -10,15 +9,14 @@ import {
     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 { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
+import { decodeUtf8, encodeUtf8, unreachable } from "../utils/index.js";
 
-import type { AdbSocket } from "./socket.js";
-import { AdbSocketController } from "./socket.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+import { AdbDaemonSocketController } from "./socket.js";
 
 export interface AdbPacketDispatcherOptions {
     calculateChecksum: boolean;
@@ -32,14 +30,6 @@ export interface AdbPacketDispatcherOptions {
     maxPayloadSize: number;
 }
 
-export type AdbIncomingSocketHandler = (
-    socket: AdbSocket
-) => ValueOrPromise<boolean>;
-
-export interface Closeable {
-    close(): ValueOrPromise<void>;
-}
-
 /**
  * The dispatcher is the "dumb" part of the connection handling logic.
  *
@@ -53,25 +43,24 @@ export interface Closeable {
 export class AdbPacketDispatcher implements Closeable {
     // ADB socket id starts from 1
     // (0 means open failed)
-    private readonly initializers = new AsyncOperationManager(1);
+    readonly #initializers = new AsyncOperationManager(1);
     /**
      * Socket local ID to the socket controller.
      */
-    private readonly sockets = new Map<number, AdbSocketController>();
+    readonly #sockets = new Map<number, AdbDaemonSocketController>();
 
-    private _writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
+    #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     public readonly options: AdbPacketDispatcherOptions;
 
-    private _closed = false;
-    private _disconnected = new PromiseResolver<void>();
+    #closed = false;
+    #disconnected = new PromiseResolver<void>();
     public get disconnected() {
-        return this._disconnected.promise;
+        return this.#disconnected.promise;
     }
 
-    private _incomingSocketHandlers: Set<AdbIncomingSocketHandler> = new Set();
-
-    private _abortController = new AbortController();
+    #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
+    #readAbortController = new AbortController();
 
     public constructor(
         connection: ReadableWritablePair<
@@ -94,8 +83,8 @@ export class AdbPacketDispatcher implements Closeable {
                                 await this.handleClose(packet);
                                 break;
                             case AdbCommand.Write:
-                                if (this.sockets.has(packet.arg1)) {
-                                    await this.sockets
+                                if (this.#sockets.has(packet.arg1)) {
+                                    await this.#sockets
                                         .get(packet.arg1)!
                                         .enqueue(packet.payload);
                                     await this.sendPacket(
@@ -131,7 +120,7 @@ export class AdbPacketDispatcher implements Closeable {
                     // it's still possible to create another ADB connection.
                     // So don't close `readable` here.
                     preventCancel: true,
-                    signal: this._abortController.signal,
+                    signal: this.#readAbortController.signal,
                 }
             )
             .then(
@@ -139,23 +128,23 @@ export class AdbPacketDispatcher implements Closeable {
                     this.dispose();
                 },
                 (e) => {
-                    if (!this._closed) {
-                        this._disconnected.reject(e);
+                    if (!this.#closed) {
+                        this.#disconnected.reject(e);
                     }
                     this.dispose();
                 }
             );
 
-        this._writer = connection.writable.getWriter();
+        this.#writer = connection.writable.getWriter();
     }
 
     private handleOk(packet: AdbPacketData) {
-        if (this.initializers.resolve(packet.arg1, packet.arg0)) {
+        if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
             // Device successfully created the socket
             return;
         }
 
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // Device has received last `WRTE` to the socket
             socket.ack();
@@ -171,7 +160,7 @@ export class AdbPacketDispatcher implements Closeable {
         // If the socket is still pending
         if (
             packet.arg0 === 0 &&
-            this.initializers.reject(
+            this.#initializers.reject(
                 packet.arg1,
                 new Error("Socket open failed")
             )
@@ -192,7 +181,7 @@ export class AdbPacketDispatcher implements Closeable {
          */
 
         // Ignore `arg0` and search for the socket
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // The device want to close the socket
             if (!socket.closed) {
@@ -203,7 +192,7 @@ export class AdbPacketDispatcher implements Closeable {
                 );
             }
             await socket.dispose();
-            this.sockets.delete(packet.arg1);
+            this.#sockets.delete(packet.arg1);
             return;
         }
 
@@ -212,68 +201,74 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    /**
-     * Add a handler for incoming socket.
-     * @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(
+    public addReverseTunnel(
+        service: string,
         handler: AdbIncomingSocketHandler
-    ): RemoveEventListener {
-        this._incomingSocketHandlers.add(handler);
-        const remove = () => {
-            this._incomingSocketHandlers.delete(handler);
-        };
-        remove.dispose = remove;
-        return remove;
+    ) {
+        this.#incomingSocketHandlers.set(service, handler);
+    }
+
+    public removeReverseTunnel(address: string) {
+        this.#incomingSocketHandlers.delete(address);
+    }
+
+    public clearReverseTunnels() {
+        this.#incomingSocketHandlers.clear();
     }
 
     private async handleOpen(packet: AdbPacketData) {
         // `AsyncOperationManager` doesn't support skipping IDs
         // Use `add` + `resolve` to simulate this behavior
-        const [localId] = this.initializers.add<number>();
-        this.initializers.resolve(localId, undefined);
+        const [localId] = this.#initializers.add<number>();
+        this.#initializers.resolve(localId, undefined);
 
         const remoteId = packet.arg0;
-        const serviceString = decodeUtf8(packet.payload);
+        let service = decodeUtf8(packet.payload);
+        if (service.endsWith("\0")) {
+            service = service.substring(0, service.length - 1);
+        }
+
+        const handler = this.#incomingSocketHandlers.get(service);
+        if (!handler) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
+            return;
+        }
 
-        const controller = new AdbSocketController({
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: false,
-            serviceString,
+            service,
         });
 
-        for (const handler of this._incomingSocketHandlers) {
-            if (await handler(controller.socket)) {
-                this.sockets.set(localId, controller);
-                await this.sendPacket(AdbCommand.OK, localId, remoteId);
-                return;
-            }
+        try {
+            await handler(controller.socket);
+            this.#sockets.set(localId, controller);
+            await this.sendPacket(AdbCommand.OK, localId, remoteId);
+        } catch (e) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
         }
-
-        await this.sendPacket(AdbCommand.Close, 0, remoteId);
     }
 
-    public async createSocket(serviceString: string): Promise<AdbSocket> {
+    public async createSocket(service: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
-            serviceString += "\0";
+            service += "\0";
         }
 
-        const [localId, initializer] = this.initializers.add<number>();
-        await this.sendPacket(AdbCommand.Open, localId, 0, serviceString);
+        const [localId, initializer] = this.#initializers.add<number>();
+        await this.sendPacket(AdbCommand.Open, localId, 0, service);
 
         // Fulfilled by `handleOk`
         const remoteId = await initializer;
-        const controller = new AdbSocketController({
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: true,
-            serviceString,
+            service,
         });
-        this.sockets.set(localId, controller);
+        this.#sockets.set(localId, controller);
 
         return controller.socket;
     }
@@ -292,7 +287,7 @@ export class AdbPacketDispatcher implements Closeable {
             throw new Error("payload too large");
         }
 
-        await ConsumableWritableStream.write(this._writer, {
+        await ConsumableWritableStream.write(this.#writer, {
             command,
             arg0,
             arg1,
@@ -307,26 +302,24 @@ export class AdbPacketDispatcher implements Closeable {
     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
         // 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._abortController.abort();
-        this._writer.releaseLock();
+        this.#closed = true;
+        this.#readAbortController.abort();
+        this.#writer.releaseLock();
 
         // `pipe().then()` will call `dispose`
     }
 
     private dispose() {
-        for (const socket of this.sockets.values()) {
-            socket.dispose().catch((e) => {
-                void e;
-            });
+        for (const socket of this.#sockets.values()) {
+            socket.dispose().catch(unreachable);
         }
 
-        this._disconnected.resolve();
+        this.#disconnected.resolve();
     }
 }

package/src/daemon/index.ts

@@ -0,0 +1,7 @@
+export * from "./auth.js";
+export * from "./crypto.js";
+export * from "./device.js";
+export * from "./dispatcher.js";
+export * from "./packet.js";
+export * from "./socket.js";
+export * from "./transport.js";

package/src/{packet.ts → daemon/packet.ts}

@@ -23,7 +23,7 @@ export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
 type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
 
 export const AdbPacket = new Struct({ littleEndian: true })
-    .fields(AdbPacketHeader)
+    .concat(AdbPacketHeader)
     .uint8Array("payload", { lengthField: "payloadLength" });
 
 export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
@@ -31,11 +31,11 @@ export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
 /**
  * `AdbPacketData` contains all the useful fields of `AdbPacket`.
  *
- * `AdbBackend#connect` will return a `ReadableStream<AdbPacketData>`,
- * so each backend can encode `AdbPacket` in different ways.
+ * `AdvDaemonConnection#connect` will return a `ReadableStream<AdbPacketData>`,
+ * allow each connection to encode `AdbPacket` in different methods.
  *
- * `AdbBackend#connect` will return a `WritableStream<AdbPacketInit>`,
- * however, `AdbPacketDispatcher` will transform `AdbPacketData` to `AdbPacketInit` for you,
+ * `AdbDaemonConnection#connect` will return a `WritableStream<AdbPacketInit>`,
+ * however, `AdbDaemonTransport` will transform `AdbPacketData` to `AdbPacketInit` for you,
  * so `AdbSocket#writable#write` only needs `AdbPacketData`.
  */
 export type AdbPacketData = Omit<

package/src/{socket → daemon}/socket.ts

@@ -15,27 +15,29 @@ import {
     pipeFrom,
 } from "@yume-chan/stream-extra";
 
-import { AdbCommand } from "../packet.js";
+import type { Closeable } from "../adb.js";
 
-import type { AdbPacketDispatcher, Closeable } from "./dispatcher.js";
+import type { AdbPacketDispatcher } from "./dispatcher.js";
+import { AdbCommand } from "./packet.js";
 
-export interface AdbSocketInfo {
+export interface AdbDaemonSocketInfo {
     localId: number;
     remoteId: number;
 
     localCreated: boolean;
-    serviceString: string;
+    service: string;
 }
 
-export interface AdbSocketConstructionOptions extends AdbSocketInfo {
+export interface AdbDaemonSocketConstructionOptions
+    extends AdbDaemonSocketInfo {
     dispatcher: AdbPacketDispatcher;
 
     highWaterMark?: number | undefined;
 }
 
-export class AdbSocketController
+export class AdbDaemonSocketController
     implements
-        AdbSocketInfo,
+        AdbDaemonSocketInfo,
         ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>,
         Closeable,
         Disposable
@@ -45,47 +47,47 @@ export class AdbSocketController
     public readonly localId!: number;
     public readonly remoteId!: number;
     public readonly localCreated!: boolean;
-    public readonly serviceString!: string;
+    public readonly service!: string;
 
-    private _duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
+    #duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
 
-    private _readable: ReadableStream<Uint8Array>;
-    private _readableController!: PushReadableStreamController<Uint8Array>;
+    #readable: ReadableStream<Uint8Array>;
+    #readableController!: PushReadableStreamController<Uint8Array>;
     public get readable() {
-        return this._readable;
+        return this.#readable;
     }
 
-    private _writePromise: PromiseResolver<void> | undefined;
+    #writePromise: PromiseResolver<void> | undefined;
     public readonly writable: WritableStream<Consumable<Uint8Array>>;
 
-    private _closed = false;
+    #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;
+        return this.#closed;
     }
 
-    private _socket: AdbSocket;
+    private _socket: AdbDaemonSocket;
     public get socket() {
         return this._socket;
     }
 
-    public constructor(options: AdbSocketConstructionOptions) {
+    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<
+        this.#duplex = new DuplexStreamFactory<
             Uint8Array,
             Consumable<Uint8Array>
         >({
             close: async () => {
-                this._closed = true;
+                this.#closed = true;
 
                 await this.dispatcher.sendPacket(
                     AdbCommand.Close,
@@ -98,14 +100,14 @@ export class AdbSocketController
             },
             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(
+        this.#readable = this.#duplex.wrapReadable(
             new PushReadableStream(
                 (controller) => {
-                    this._readableController = controller;
+                    this.#readableController = controller;
                 },
                 {
                     highWaterMark: options.highWaterMark ?? 16 * 1024,
@@ -117,47 +119,47 @@ export class AdbSocketController
         );
 
         this.writable = pipeFrom(
-            this._duplex.createWritable(
+            this.#duplex.createWritable(
                 new ConsumableWritableStream<Uint8Array>({
                     write: async (chunk) => {
                         // Wait for an ack packet
-                        this._writePromise = new PromiseResolver();
+                        this.#writePromise = new PromiseResolver();
                         await this.dispatcher.sendPacket(
                             AdbCommand.Write,
                             this.localId,
                             this.remoteId,
                             chunk
                         );
-                        await this._writePromise.promise;
+                        await this.#writePromise.promise;
                     },
                 })
             ),
             new DistributionStream(this.dispatcher.options.maxPayloadSize)
         );
 
-        this._socket = new AdbSocket(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.
-        if (this._readableController.abortSignal.aborted) {
+        if (this.#readableController.abortSignal.aborted) {
             return;
         }
 
-        await this._readableController.enqueue(data);
+        await this.#readableController.enqueue(data);
     }
 
     public ack() {
-        this._writePromise?.resolve();
+        this.#writePromise?.resolve();
     }
 
     public async close(): Promise<void> {
-        await this._duplex.close();
+        await this.#duplex.close();
     }
 
     public dispose() {
-        return this._duplex.dispose();
+        return this.#duplex.dispose();
     }
 }
 
@@ -169,38 +171,42 @@ export class AdbSocketController
  * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
  * `socket.writable.close()` or `socket.writable.getWriter().close()`.
  */
-export class AdbSocket
+export class AdbDaemonSocket
     implements
-        AdbSocketInfo,
+        AdbDaemonSocketInfo,
         ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>
 {
-    private _controller: AdbSocketController;
+    #controller: AdbDaemonSocketController;
 
     public get localId(): number {
-        return this._controller.localId;
+        return this.#controller.localId;
     }
     public get remoteId(): number {
-        return this._controller.remoteId;
+        return this.#controller.remoteId;
     }
     public get localCreated(): boolean {
-        return this._controller.localCreated;
+        return this.#controller.localCreated;
     }
-    public get serviceString(): string {
-        return this._controller.serviceString;
+    public get service(): string {
+        return this.#controller.service;
     }
 
     public get readable(): ReadableStream<Uint8Array> {
-        return this._controller.readable;
+        return this.#controller.readable;
     }
     public get writable(): WritableStream<Consumable<Uint8Array>> {
-        return this._controller.writable;
+        return this.#controller.writable;
     }
 
-    public constructor(controller: AdbSocketController) {
-        this._controller = controller;
+    public get closed(): boolean {
+        return this.#controller.closed;
+    }
+
+    public constructor(controller: AdbDaemonSocketController) {
+        this.#controller = controller;
     }
 
     public close() {
-        return this._controller.close();
+        return this.#controller.close();
     }
 }