@yume-chan/adb 1.0.0 → 2.0.0

package/src/commands/tcpip.ts

@@ -1,4 +1,4 @@
-import { AdbCommandBase } from "./base.js";
+import { AdbServiceBase } from "./base.js";
 
 /**
  * ADB daemon checks for the following properties in the order of
@@ -27,7 +27,7 @@ function parsePort(value: string): number | undefined {
     return Number.parseInt(value, 10);
 }
 
-export class AdbTcpIpCommand extends AdbCommandBase {
+export class AdbTcpIpService extends AdbServiceBase {
     async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
         const serviceListenAddresses = await this.adb.getProp(
             "service.adb.listen_addrs",

package/src/daemon/dispatcher.ts

@@ -101,18 +101,21 @@ export class AdbPacketDispatcher implements Closeable {
      */
     readonly #sockets = new Map<number, AdbDaemonSocketController>();
 
-    #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
+    readonly #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     readonly options: AdbPacketDispatcherOptions;
 
     #closed = false;
-    #disconnected = new PromiseResolver<void>();
+    readonly #disconnected = new PromiseResolver<void>();
     get disconnected() {
         return this.#disconnected.promise;
     }
 
-    #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
-    #readAbortController = new AbortController();
+    readonly #incomingSocketHandlers = new Map<
+        string,
+        AdbIncomingSocketHandler
+    >();
+    readonly #readAbortController = new AbortController();
 
     constructor(
         connection: ReadableWritablePair<

package/src/daemon/packet.ts

@@ -1,6 +1,6 @@
 import { Consumable, TransformStream } from "@yume-chan/stream-extra";
 import type { StructInit, StructValue } from "@yume-chan/struct";
-import { buffer, s32, struct, u32 } from "@yume-chan/struct";
+import { buffer, extend, s32, struct, u32 } from "@yume-chan/struct";
 
 export const AdbCommand = {
     Auth: 0x48545541, // 'AUTH'
@@ -29,13 +29,9 @@ export type AdbPacketHeader = StructValue<typeof AdbPacketHeader>;
 
 type AdbPacketHeaderInit = StructInit<typeof AdbPacketHeader>;
 
-export const AdbPacket = struct(
-    /* #__PURE__ */ (() => ({
-        ...AdbPacketHeader.fields,
-        payload: buffer("payloadLength"),
-    }))(),
-    { littleEndian: true },
-);
+export const AdbPacket = extend(AdbPacketHeader, {
+    payload: buffer("payloadLength"),
+});
 
 export type AdbPacket = StructValue<typeof AdbPacket>;
 

package/src/daemon/socket.ts

@@ -43,7 +43,7 @@ export class AdbDaemonSocketController
     readonly localCreated!: boolean;
     readonly service!: string;
 
-    #readable: ReadableStream<Uint8Array>;
+    readonly #readable: ReadableStream<Uint8Array>;
     #readableController!: PushReadableStreamController<Uint8Array>;
     get readable() {
         return this.#readable;
@@ -54,12 +54,12 @@ export class AdbDaemonSocketController
 
     #closed = false;
 
-    #closedPromise = new PromiseResolver<void>();
+    readonly #closedPromise = new PromiseResolver<undefined>();
     get closed() {
         return this.#closedPromise.promise;
     }
 
-    #socket: AdbDaemonSocket;
+    readonly #socket: AdbDaemonSocket;
     get socket() {
         return this.#socket;
     }
@@ -170,7 +170,7 @@ export class AdbDaemonSocketController
 
     dispose() {
         this.#readableController.close();
-        this.#closedPromise.resolve();
+        this.#closedPromise.resolve(undefined);
     }
 }
 
@@ -178,7 +178,7 @@ export class AdbDaemonSocketController
  * A duplex stream representing a socket to ADB daemon.
  */
 export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
-    #controller: AdbDaemonSocketController;
+    readonly #controller: AdbDaemonSocketController;
 
     get localId(): number {
         return this.#controller.localId;
@@ -200,7 +200,7 @@ export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
         return this.#controller.writable;
     }
 
-    get closed(): Promise<void> {
+    get closed(): Promise<undefined> {
         return this.#controller.closed;
     }
 

package/src/device-observer.ts

@@ -2,9 +2,9 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { Event } from "@yume-chan/event";
 
 export interface DeviceObserver<T> {
-    onDeviceAdd: Event<T[]>;
-    onDeviceRemove: Event<T[]>;
-    onListChange: Event<T[]>;
-    current: T[];
+    readonly onDeviceAdd: Event<readonly T[]>;
+    readonly onDeviceRemove: Event<readonly T[]>;
+    readonly onListChange: Event<readonly T[]>;
+    readonly current: readonly T[];
     stop(): MaybePromiseLike<void>;
 }

package/src/server/client.ts

@@ -3,122 +3,38 @@
 import type { MaybePromiseLike } from "@yume-chan/async";
 import { PromiseResolver } from "@yume-chan/async";
 import type { Event } from "@yume-chan/event";
-import { EventEmitter } from "@yume-chan/event";
 import { getUint64LittleEndian } from "@yume-chan/no-data-view";
 import type {
     AbortSignal,
     MaybeConsumable,
     ReadableWritablePair,
-    WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
-import {
-    BufferedReadableStream,
-    tryCancel,
-    tryClose,
-} from "@yume-chan/stream-extra";
-import {
-    bipedal,
-    decodeUtf8,
-    encodeUtf8,
-    TextDecoder,
-} from "@yume-chan/struct";
+import { AbortController } from "@yume-chan/stream-extra";
 
 import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 import { AdbBanner } from "../banner.js";
 import type { DeviceObserver as DeviceObserverBase } from "../device-observer.js";
 import type { AdbFeature } from "../features.js";
-import { hexToNumber, sequenceEqual, write4HexDigits } from "../utils/index.js";
+import { hexToNumber } from "../utils/index.js";
 
+import {
+    MDnsCommands,
+    WirelessCommands,
+    AlreadyConnectedError as _AlreadyConnectedError,
+    NetworkError as _NetworkError,
+    UnauthorizedError as _UnauthorizedError,
+} from "./commands/index.js";
+import { AdbServerDeviceObserverOwner } from "./observer.js";
+import { AdbServerStream } from "./stream.js";
 import { AdbServerTransport } from "./transport.js";
 
-const OKAY = encodeUtf8("OKAY");
-const FAIL = encodeUtf8("FAIL");
-
-class AdbServerStream {
-    #connection: AdbServerClient.ServerConnection;
-    #buffered: BufferedReadableStream;
-    #writer: WritableStreamDefaultWriter<Uint8Array>;
-
-    constructor(connection: AdbServerClient.ServerConnection) {
-        this.#connection = connection;
-        this.#buffered = new BufferedReadableStream(connection.readable);
-        this.#writer = connection.writable.getWriter();
-    }
-
-    readExactly(length: number): MaybePromiseLike<Uint8Array> {
-        return this.#buffered.readExactly(length);
-    }
-
-    readString = bipedal(function* (this: AdbServerStream, then) {
-        const data = yield* then(this.readExactly(4));
-        const length = hexToNumber(data);
-        if (length === 0) {
-            return "";
-        } else {
-            const decoder = new TextDecoder();
-            let result = "";
-            const iterator = this.#buffered.iterateExactly(length);
-            while (true) {
-                const { done, value } = iterator.next();
-                if (done) {
-                    break;
-                }
-                result += decoder.decode(yield* then(value), { stream: true });
-            }
-            result += decoder.decode();
-            return result;
-        }
-    });
-
-    async writeString(value: string): Promise<void> {
-        // TODO: investigate using `encodeUtf8("0000" + value)` then modifying the length
-        // That way allocates a new string (hopefully only a rope) instead of a new buffer
-        const encoded = encodeUtf8(value);
-        const buffer = new Uint8Array(4 + encoded.length);
-        write4HexDigits(buffer, 0, encoded.length);
-        buffer.set(encoded, 4);
-        await this.#writer.write(buffer);
-    }
-
-    async readOkay(): Promise<void> {
-        const response = await this.readExactly(4);
-        if (sequenceEqual(response, OKAY)) {
-            // `OKAY` is followed by data length and data
-            // But different services want to parse the data differently
-            // So don't read the data here
-            return;
-        }
-
-        if (sequenceEqual(response, FAIL)) {
-            const reason = await this.readString();
-            throw new Error(reason);
-        }
-
-        throw new Error(`Unexpected response: ${decodeUtf8(response)}`);
-    }
-
-    release() {
-        this.#writer.releaseLock();
-        return {
-            readable: this.#buffered.release(),
-            writable: this.#connection.writable,
-            closed: this.#connection.closed,
-            close: () => this.#connection.close(),
-        };
-    }
-
-    async dispose() {
-        void tryCancel(this.#buffered);
-        void tryClose(this.#writer);
-        await this.#connection.close();
-    }
-}
-
 /**
  * Client for the ADB Server.
  */
 export class AdbServerClient {
-    static readonly VERSION = 41;
+    static NetworkError = _NetworkError;
+    static UnauthorizedError = _UnauthorizedError;
+    static AlreadyConnectedError = _AlreadyConnectedError;
 
     static parseDeviceList(value: string): AdbServerClient.Device[] {
         const devices: AdbServerClient.Device[] = [];
@@ -194,8 +110,9 @@ export class AdbServerClient {
 
     readonly connector: AdbServerClient.ServerConnector;
 
-    readonly wireless = new AdbServerClient.WirelessCommands(this);
-    readonly mDns = new AdbServerClient.MDnsCommands(this);
+    readonly wireless = new WirelessCommands(this);
+    readonly mDns = new MDnsCommands(this);
+    readonly #observerOwner = new AdbServerDeviceObserverOwner(this);
 
     constructor(connector: AdbServerClient.ServerConnector) {
         this.connector = connector;
@@ -240,11 +157,11 @@ export class AdbServerClient {
         }
     }
 
-    async validateVersion() {
+    async validateVersion(minimalVersion: number) {
         const version = await this.getVersion();
-        if (version !== AdbServerClient.VERSION) {
+        if (version < minimalVersion) {
             throw new Error(
-                `adb server version (${version}) doesn't match this client (${AdbServerClient.VERSION})`,
+                `adb server version (${version}) doesn't match this client (${minimalVersion})`,
             );
         }
     }
@@ -288,61 +205,10 @@ export class AdbServerClient {
     /**
      * Monitors device list changes.
      */
-    async trackDevices(): Promise<AdbServerClient.DeviceObserver> {
-        const connection = await this.createConnection("host:track-devices-l");
-
-        let current: AdbServerClient.Device[] = [];
-        const onError = new EventEmitter<Error>();
-        const onDeviceAdd = new EventEmitter<AdbServerClient.Device[]>();
-        const onDeviceRemove = new EventEmitter<AdbServerClient.Device[]>();
-        const onListChange = new EventEmitter<AdbServerClient.Device[]>();
-
-        void (async () => {
-            try {
-                while (true) {
-                    const response = await connection.readString();
-                    const next = AdbServerClient.parseDeviceList(response);
-
-                    const added: AdbServerClient.Device[] = [];
-                    for (const nextDevice of next) {
-                        const index = current.findIndex(
-                            (device) =>
-                                device.transportId === nextDevice.transportId,
-                        );
-                        if (index === -1) {
-                            added.push(nextDevice);
-                            continue;
-                        }
-
-                        current[index] = current[current.length - 1]!;
-                        current.length -= 1;
-                    }
-
-                    if (added.length) {
-                        onDeviceAdd.fire(added);
-                    }
-                    if (current.length) {
-                        onDeviceRemove.fire(current);
-                    }
-
-                    current = next;
-                    onListChange.fire(current);
-                }
-            } catch (e) {
-                onError.fire(e as Error);
-            }
-        })();
-
-        return {
-            onError: onError.event,
-            onDeviceAdd: onDeviceAdd.event,
-            onDeviceRemove: onDeviceRemove.event,
-            onListChange: onListChange.event,
-            get current() {
-                return current;
-            },
-            stop: () => connection.dispose(),
-        };
+    async trackDevices(
+        options?: AdbServerClient.ServerConnectionOptions,
+    ): Promise<AdbServerClient.DeviceObserver> {
+        return this.#observerOwner.createObserver(options);
     }
 
     /**
@@ -412,20 +278,22 @@ export class AdbServerClient {
         device: AdbServerClient.DeviceSelector,
         service: string,
     ): Promise<AdbServerClient.Socket> {
-        await this.validateVersion();
-
         let switchService: string;
         let transportId: bigint | undefined;
         if (!device) {
+            await this.validateVersion(41);
             switchService = `host:tport:any`;
         } else if ("transportId" in device) {
             switchService = `host:transport-id:${device.transportId}`;
             transportId = device.transportId;
         } else if ("serial" in device) {
+            await this.validateVersion(41);
             switchService = `host:tport:serial:${device.serial}`;
         } else if ("usb" in device) {
+            await this.validateVersion(41);
             switchService = `host:tport:usb`;
         } else if ("tcp" in device) {
+            await this.validateVersion(41);
             switchService = `host:tport:local`;
         } else {
             throw new TypeError("Invalid device selector");
@@ -467,18 +335,7 @@ export class AdbServerClient {
             throw e;
         }
     }
-
-    /**
-     * Wait for a device to be connected or disconnected.
-     *
-     * `adb wait-for-<state>`
-     *
-     * @param device The device selector
-     * @param state The state to wait for
-     * @param options The options
-     * @returns A promise that resolves when the condition is met.
-     */
-    async waitFor(
+    async #waitForUnchecked(
         device: AdbServerClient.DeviceSelector,
         state: "device" | "disconnect",
         options?: AdbServerClient.ServerConnectionOptions,
@@ -513,6 +370,60 @@ export class AdbServerClient {
         }
     }
 
+    /**
+     * Wait for a device to be connected or disconnected.
+     *
+     * `adb wait-for-<state>`
+     *
+     * @param device The device selector
+     * @param state The state to wait for
+     * @param options The options
+     * @returns A promise that resolves when the condition is met.
+     */
+    async waitFor(
+        device: AdbServerClient.DeviceSelector,
+        state: "device" | "disconnect",
+        options?: AdbServerClient.ServerConnectionOptions,
+    ): Promise<void> {
+        if (state === "disconnect") {
+            await this.validateVersion(41);
+        }
+
+        return this.#waitForUnchecked(device, state, options);
+    }
+
+    async waitForDisconnect(
+        transportId: bigint,
+        options?: AdbServerClient.ServerConnectionOptions,
+    ): Promise<void> {
+        const serverVersion = await this.getVersion();
+        if (serverVersion >= 41) {
+            return this.#waitForUnchecked(
+                { transportId },
+                "disconnect",
+                options,
+            );
+        } else {
+            const observer = await this.trackDevices(options);
+            return new Promise<void>((resolve, reject) => {
+                observer.onDeviceRemove((devices) => {
+                    if (
+                        devices.some(
+                            (device) => device.transportId === transportId,
+                        )
+                    ) {
+                        observer.stop();
+                        resolve();
+                    }
+                });
+                observer.onError((e) => {
+                    observer.stop();
+                    reject(e);
+                });
+            });
+        }
+    }
+
     /**
      * Creates an ADB Transport for the specified device.
      */
@@ -533,12 +444,23 @@ export class AdbServerClient {
             features,
         );
 
-        return new AdbServerTransport(
+        const waitAbortController = new AbortController();
+        const disconnected = this.waitForDisconnect(transportId, {
+            unref: true,
+            signal: waitAbortController.signal,
+        });
+
+        const transport = new AdbServerTransport(
             this,
             info?.serial ?? "",
             banner,
             transportId,
+            disconnected,
         );
+
+        void transport.disconnected.finally(() => waitAbortController.abort());
+
+        return transport;
     }
 }
 
@@ -582,7 +504,7 @@ export namespace AdbServerClient {
     export interface ServerConnection
         extends ReadableWritablePair<Uint8Array, MaybeConsumable<Uint8Array>>,
             Closeable {
-        get closed(): Promise<void>;
+        get closed(): Promise<undefined>;
     }
 
     export interface ServerConnector {
@@ -623,138 +545,11 @@ export namespace AdbServerClient {
         transportId: bigint;
     }
 
-    export class NetworkError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "NetworkError";
-        }
-    }
-
-    export class UnauthorizedError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "UnauthorizedError";
-        }
-    }
-
-    export class AlreadyConnectedError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "AlreadyConnectedError";
-        }
-    }
-
-    export class WirelessCommands {
-        #client: AdbServerClient;
-
-        constructor(client: AdbServerClient) {
-            this.#client = client;
-        }
-
-        /**
-         * `adb pair <password> <address>`
-         */
-        async pair(address: string, password: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:pair:${password}:${address}`,
-            );
-            try {
-                const response = await connection.readExactly(4);
-                // `response` is either `FAIL`, or 4 hex digits for length of the string
-                if (sequenceEqual(response, FAIL)) {
-                    throw new Error(await connection.readString());
-                }
-                const length = hexToNumber(response);
-                // Ignore the string as it's always `Successful ...`
-                await connection.readExactly(length);
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        /**
-         * `adb connect <address>`
-         */
-        async connect(address: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:connect:${address}`,
-            );
-            try {
-                const response = await connection.readString();
-                switch (response) {
-                    case `already connected to ${address}`:
-                        throw new AdbServerClient.AlreadyConnectedError(
-                            response,
-                        );
-                    case `failed to connect to ${address}`: // `adb pair` mode not authorized
-                    case `failed to authenticate to ${address}`: // `adb tcpip` mode not authorized
-                        throw new AdbServerClient.UnauthorizedError(response);
-                    case `connected to ${address}`:
-                        return;
-                    default:
-                        throw new AdbServerClient.NetworkError(response);
-                }
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        /**
-         * `adb disconnect <address>`
-         */
-        async disconnect(address: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:disconnect:${address}`,
-            );
-            try {
-                await connection.readString();
-            } finally {
-                await connection.dispose();
-            }
-        }
-    }
-
-    export class MDnsCommands {
-        #client: AdbServerClient;
-
-        constructor(client: AdbServerClient) {
-            this.#client = client;
-        }
-
-        async check() {
-            const connection =
-                await this.#client.createConnection("host:mdns:check");
-            try {
-                const response = await connection.readString();
-                return !response.startsWith("ERROR:");
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        async getServices() {
-            const connection =
-                await this.#client.createConnection("host:mdns:services");
-            try {
-                const response = await connection.readString();
-                return response
-                    .split("\n")
-                    .filter(Boolean)
-                    .map((line) => {
-                        const parts = line.split("\t");
-                        return {
-                            name: parts[0]!,
-                            service: parts[1]!,
-                            address: parts[2]!,
-                        };
-                    });
-            } finally {
-                await connection.dispose();
-            }
-        }
-    }
-
     export interface DeviceObserver extends DeviceObserverBase<Device> {
         onError: Event<Error>;
     }
+
+    export type NetworkError = _NetworkError;
+    export type UnauthorizedError = _UnauthorizedError;
+    export type AlreadyConnectedError = _AlreadyConnectedError;
 }

package/src/server/commands/index.ts

@@ -0,0 +1,2 @@
+export * from "./m-dns.js";
+export * from "./wireless.js";

package/src/server/commands/m-dns.ts

@@ -0,0 +1,43 @@
+// cspell:ignore mdns
+
+import type { AdbServerClient } from "../client.js";
+
+export class MDnsCommands {
+    readonly #client: AdbServerClient;
+
+    constructor(client: AdbServerClient) {
+        this.#client = client;
+    }
+
+    async check() {
+        const connection =
+            await this.#client.createConnection("host:mdns:check");
+        try {
+            const response = await connection.readString();
+            return !response.startsWith("ERROR:");
+        } finally {
+            await connection.dispose();
+        }
+    }
+
+    async getServices() {
+        const connection =
+            await this.#client.createConnection("host:mdns:services");
+        try {
+            const response = await connection.readString();
+            return response
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                    const parts = line.split("\t");
+                    return {
+                        name: parts[0]!,
+                        service: parts[1]!,
+                        address: parts[2]!,
+                    };
+                });
+        } finally {
+            await connection.dispose();
+        }
+    }
+}