@yume-chan/adb 0.0.22 → 0.0.23

package/src/daemon/socket.ts

@@ -1,6 +1,7 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type { Disposable } from "@yume-chan/event";
 import type {
+    AbortSignal,
     Consumable,
     PushReadableStreamController,
     ReadableStream,
@@ -13,7 +14,6 @@ import {
 } from "@yume-chan/stream-extra";
 
 import type { AdbSocket } from "../adb.js";
-import { raceSignal } from "../server/index.js";
 
 import type { AdbPacketDispatcher } from "./dispatcher.js";
 import { AdbCommand } from "./packet.js";
@@ -49,7 +49,6 @@ export class AdbDaemonSocketController
         return this.#readable;
     }
 
-    #writePromise: PromiseResolver<void> | undefined;
     #writableController!: WritableStreamDefaultController;
     readonly writable: WritableStream<Consumable<Uint8Array>>;
 
@@ -65,6 +64,17 @@ export class AdbDaemonSocketController
         return this.#socket;
     }
 
+    #availableWriteBytesChanged: PromiseResolver<void> | undefined;
+    /**
+     * When delayed ack is disabled, can be `Infinity` if the socket is ready to write.
+     * Exactly one packet can be written no matter how large it is. Or `-1` if the socket
+     * is waiting for ack.
+     *
+     * When delayed ack is enabled, a non-negative finite number indicates the number of
+     * bytes that can be written to the socket before receiving an ack.
+     */
+    #availableWriteBytes = 0;
+
     constructor(options: AdbDaemonSocketConstructionOptions) {
         this.#dispatcher = options.dispatcher;
         this.localId = options.localId;
@@ -88,18 +98,8 @@ export class AdbDaemonSocketController
                     start < size;
                     start = end, end += chunkSize
                 ) {
-                    this.#writePromise = new PromiseResolver();
-                    await this.#dispatcher.sendPacket(
-                        AdbCommand.Write,
-                        this.localId,
-                        this.remoteId,
-                        data.subarray(start, end),
-                    );
-                    // Wait for ack packet
-                    await raceSignal(
-                        () => this.#writePromise!.promise,
-                        controller.signal,
-                    );
+                    const chunk = data.subarray(start, end);
+                    await this.#writeChunk(chunk, controller.signal);
                 }
             },
         });
@@ -107,6 +107,34 @@ export class AdbDaemonSocketController
         this.#socket = new AdbDaemonSocket(this);
     }
 
+    async #writeChunk(data: Uint8Array, signal: AbortSignal) {
+        const length = data.byteLength;
+        while (this.#availableWriteBytes < length) {
+            // Only one lock is required because Web Streams API guarantees
+            // that `write` is not reentrant.
+            const resolver = new PromiseResolver<void>();
+            signal.addEventListener("abort", () => {
+                resolver.reject(signal.reason);
+            });
+
+            this.#availableWriteBytesChanged = resolver;
+            await resolver.promise;
+        }
+
+        if (this.#availableWriteBytes === Infinity) {
+            this.#availableWriteBytes = -1;
+        } else {
+            this.#availableWriteBytes -= length;
+        }
+
+        await this.#dispatcher.sendPacket(
+            AdbCommand.Write,
+            this.localId,
+            this.remoteId,
+            data,
+        );
+    }
+
     async enqueue(data: Uint8Array) {
         // Consumers can `cancel` the `readable` if they are not interested in future data.
         // Throw away the data if that happens.
@@ -124,8 +152,9 @@ export class AdbDaemonSocketController
         }
     }
 
-    ack() {
-        this.#writePromise?.resolve();
+    public ack(bytes: number) {
+        this.#availableWriteBytes += bytes;
+        this.#availableWriteBytesChanged?.resolve();
     }
 
     async close(): Promise<void> {
@@ -134,6 +163,8 @@ export class AdbDaemonSocketController
         }
         this.#closed = true;
 
+        this.#availableWriteBytesChanged?.reject(new Error("Socket closed"));
+
         try {
             this.#writableController.error(new Error("Socket closed"));
         } catch {

package/src/daemon/transport.ts

@@ -26,6 +26,30 @@ import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 import { AdbCommand, calculateChecksum } from "./packet.js";
 
 export const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 0x01000001;
+// https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
+// There are some other feature constants, but some of them are only used by ADB server, not devices (daemons).
+export const ADB_DAEMON_DEFAULT_FEATURES = [
+    AdbFeature.ShellV2,
+    AdbFeature.Cmd,
+    AdbFeature.StatV2,
+    AdbFeature.ListV2,
+    AdbFeature.FixedPushMkdir,
+    "apex",
+    AdbFeature.Abb,
+    // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
+    // No special handling required.
+    "fixed_push_symlink_timestamp",
+    AdbFeature.AbbExec,
+    "remount_shell",
+    "track_app",
+    AdbFeature.SendReceiveV2,
+    "sendrecv_v2_brotli",
+    "sendrecv_v2_lz4",
+    "sendrecv_v2_zstd",
+    "sendrecv_v2_dry_run_send",
+    AdbFeature.DelayedAck,
+] as AdbFeature[];
+export const ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE = 32 * 1024 * 1024;
 
 export type AdbDaemonConnection = ReadableWritablePair<
     AdbPacketData,
@@ -37,6 +61,16 @@ interface AdbDaemonAuthenticationOptions {
     connection: AdbDaemonConnection;
     credentialStore: AdbCredentialStore;
     authenticators?: AdbAuthenticator[];
+    features?: readonly AdbFeature[];
+    /**
+     * The number of bytes the device can send before receiving an ack packet.
+     *
+     * Set to 0 or any negative value to disable delayed ack in handshake.
+     * Otherwise the value must be in the range of unsigned 32-bit integer.
+     *
+     * Delayed ack requires Android 14, this option is ignored on older versions.
+     */
+    initialDelayedAckBytes?: number;
     /**
      * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
      */
@@ -50,6 +84,16 @@ interface AdbDaemonSocketConnectorConstructionOptions {
     version: number;
     maxPayloadSize: number;
     banner: string;
+    features?: readonly AdbFeature[];
+    /**
+     * The number of bytes the device can send before receiving an ack packet.
+     *
+     * Set to 0 or any negative value to disable delayed ack in handshake.
+     * Otherwise the value must be in the range of unsigned 32-bit integer.
+     *
+     * Delayed ack requires Android 14, this option is ignored on older versions.
+     */
+    initialDelayedAckBytes?: number;
     /**
      * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
      */
@@ -71,6 +115,8 @@ export class AdbDaemonTransport implements AdbTransport {
         connection,
         credentialStore,
         authenticators = ADB_DEFAULT_AUTHENTICATORS,
+        features = ADB_DAEMON_DEFAULT_FEATURES,
+        initialDelayedAckBytes = ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE,
         ...options
     }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport> {
         // Initially, set to highest-supported version and payload size.
@@ -144,38 +190,25 @@ export class AdbDaemonTransport implements AdbTransport {
             await ConsumableWritableStream.write(writer, init as AdbPacketInit);
         }
 
+        const actualFeatures = features.slice();
+        if (initialDelayedAckBytes <= 0) {
+            const index = features.indexOf(AdbFeature.DelayedAck);
+            if (index !== -1) {
+                actualFeatures.splice(index, 1);
+            }
+        }
+
         let banner: string;
         try {
-            // https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
-            // There are some other feature constants, but some of them are only used by ADB server, not devices (daemons).
-            const features = [
-                AdbFeature.ShellV2,
-                AdbFeature.Cmd,
-                AdbFeature.StatV2,
-                AdbFeature.ListV2,
-                AdbFeature.FixedPushMkdir,
-                "apex",
-                AdbFeature.Abb,
-                // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
-                // No special handling required.
-                "fixed_push_symlink_timestamp",
-                AdbFeature.AbbExec,
-                "remount_shell",
-                "track_app",
-                AdbFeature.SendReceiveV2,
-                "sendrecv_v2_brotli",
-                "sendrecv_v2_lz4",
-                "sendrecv_v2_zstd",
-                "sendrecv_v2_dry_run_send",
-            ].join(",");
-
             await sendPacket({
                 command: AdbCommand.Connect,
                 arg0: version,
                 arg1: maxPayloadSize,
                 // The terminating `;` is required in formal definition
                 // But ADB daemon (all versions) can still work without it
-                payload: encodeUtf8(`host::features=${features}`),
+                payload: encodeUtf8(
+                    `host::features=${actualFeatures.join(",")}`,
+                ),
             });
 
             banner = await resolver.promise;
@@ -195,6 +228,8 @@ export class AdbDaemonTransport implements AdbTransport {
             version,
             maxPayloadSize,
             banner,
+            features: actualFeatures,
+            initialDelayedAckBytes,
             ...options,
         });
     }
@@ -229,16 +264,38 @@ export class AdbDaemonTransport implements AdbTransport {
         return this.#dispatcher.disconnected;
     }
 
+    #clientFeatures: readonly AdbFeature[];
+    get clientFeatures() {
+        return this.#clientFeatures;
+    }
+
     constructor({
         serial,
         connection,
         version,
         banner,
+        features = ADB_DAEMON_DEFAULT_FEATURES,
+        initialDelayedAckBytes = ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE,
         ...options
     }: AdbDaemonSocketConnectorConstructionOptions) {
         this.#serial = serial;
         this.#connection = connection;
         this.#banner = AdbBanner.parse(banner);
+        this.#clientFeatures = features;
+
+        if (features.includes(AdbFeature.DelayedAck)) {
+            if (initialDelayedAckBytes <= 0) {
+                throw new Error(
+                    "`initialDelayedAckBytes` must be greater than 0 when DelayedAck feature is enabled.",
+                );
+            }
+
+            if (!this.#banner.features.includes(AdbFeature.DelayedAck)) {
+                initialDelayedAckBytes = 0;
+            }
+        } else {
+            initialDelayedAckBytes = 0;
+        }
 
         let calculateChecksum: boolean;
         let appendNullToServiceString: boolean;
@@ -253,6 +310,7 @@ export class AdbDaemonTransport implements AdbTransport {
         this.#dispatcher = new AdbPacketDispatcher(connection, {
             calculateChecksum,
             appendNullToServiceString,
+            initialDelayedAckBytes,
             ...options,
         });
 

package/src/features.ts

@@ -1,5 +1,5 @@
 // The order follows
-// https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
+// https://cs.android.com/android/platform/superproject/+/master:packages/modules/adb/transport.cpp;l=77;drc=6d14d35d0241f6fee145f8e54ffd77252e8d29fd
 export enum AdbFeature {
     ShellV2 = "shell_v2",
     Cmd = "cmd",
@@ -9,4 +9,5 @@ export enum AdbFeature {
     Abb = "abb",
     AbbExec = "abb_exec",
     SendReceiveV2 = "sendrecv_v2",
+    DelayedAck = "delayed_ack",
 }

package/src/server/client.ts

@@ -18,6 +18,7 @@ import type {
 } from "@yume-chan/struct";
 import {
     BigIntFieldType,
+    EMPTY_UINT8_ARRAY,
     SyncPromise,
     decodeUtf8,
     encodeUtf8,
@@ -26,7 +27,7 @@ import {
 import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 import { AdbBanner } from "../banner.js";
 import type { AdbFeature } from "../features.js";
-import { NOOP, hexToNumber, numberToHex } from "../utils/index.js";
+import { NOOP, hexToNumber, numberToHex, unreachable } from "../utils/index.js";
 
 import { AdbServerTransport } from "./transport.js";
 
@@ -92,7 +93,11 @@ export class AdbServerClient {
         return SyncPromise.try(() => stream.readExactly(4))
             .then((buffer) => {
                 const length = hexToNumber(buffer);
-                return stream.readExactly(length);
+                if (length === 0) {
+                    return EMPTY_UINT8_ARRAY;
+                } else {
+                    return stream.readExactly(length);
+                }
             })
             .then((valueBuffer) => {
                 return decodeUtf8(valueBuffer);
@@ -209,63 +214,91 @@ export class AdbServerClient {
         }
     }
 
+    parseDeviceList(value: string): AdbServerDevice[] {
+        const devices: AdbServerDevice[] = [];
+        for (const line of value.split("\n")) {
+            if (!line) {
+                continue;
+            }
+
+            const parts = line.split(" ").filter(Boolean);
+            const serial = parts[0]!;
+            const status = parts[1]!;
+            if (status !== "device") {
+                continue;
+            }
+
+            let product: string | undefined;
+            let model: string | undefined;
+            let device: string | undefined;
+            let transportId: bigint | undefined;
+            for (let i = 2; i < parts.length; i += 1) {
+                const [key, value] = parts[i]!.split(":");
+                switch (key) {
+                    case "product":
+                        product = value;
+                        break;
+                    case "model":
+                        model = value;
+                        break;
+                    case "device":
+                        device = value;
+                        break;
+                    case "transport_id":
+                        transportId = BigInt(value!);
+                        break;
+                }
+            }
+            if (!transportId) {
+                throw new Error(`No transport id for device ${serial}`);
+            }
+            devices.push({
+                serial,
+                product,
+                model,
+                device,
+                transportId,
+            });
+        }
+        return devices;
+    }
+
     async getDevices(): Promise<AdbServerDevice[]> {
         const connection = await this.connect("host:devices-l");
         const readable = new BufferedReadableStream(connection.readable);
         try {
-            const devices: AdbServerDevice[] = [];
             const response = await AdbServerClient.readString(readable);
-            for (const line of response.split("\n")) {
-                if (!line) {
-                    continue;
-                }
-
-                const parts = line.split(" ").filter(Boolean);
-                const serial = parts[0]!;
-                const status = parts[1]!;
-                if (status !== "device") {
-                    continue;
-                }
-
-                let product: string | undefined;
-                let model: string | undefined;
-                let device: string | undefined;
-                let transportId: bigint | undefined;
-                for (let i = 2; i < parts.length; i += 1) {
-                    const [key, value] = parts[i]!.split(":");
-                    switch (key) {
-                        case "product":
-                            product = value;
-                            break;
-                        case "model":
-                            model = value;
-                            break;
-                        case "device":
-                            device = value;
-                            break;
-                        case "transport_id":
-                            transportId = BigInt(value!);
-                            break;
-                    }
-                }
-                if (!transportId) {
-                    throw new Error(`No transport id for device ${serial}`);
-                }
-                devices.push({
-                    serial,
-                    product,
-                    model,
-                    device,
-                    transportId,
-                });
-            }
-            return devices;
+            return this.parseDeviceList(response);
         } finally {
             connection.writable.close().catch(NOOP);
             readable.cancel().catch(NOOP);
         }
     }
 
+    async trackDevices(
+        callback: (devices: AdbServerDevice[]) => void,
+    ): Promise<() => void> {
+        const connection = await this.connect("host:track-devices-l");
+        const readable = new BufferedReadableStream(connection.readable);
+        let running = true;
+        (async () => {
+            try {
+                while (running) {
+                    const response = await AdbServerClient.readString(readable);
+                    const devices = this.parseDeviceList(response);
+                    callback(devices);
+                }
+            } catch {
+                // ignore
+            }
+        })().catch(unreachable);
+        return () => {
+            running = false;
+            readable.cancel().catch(NOOP);
+            Promise.resolve(connection.close()).catch(NOOP);
+        };
+    }
+
     formatDeviceService(device: AdbServerDeviceSelector, command: string) {
         if (!device) {
             return `host:${command}`;
@@ -424,9 +457,12 @@ export class AdbServerClient {
             `wait-for-${type}-${state}`,
         );
 
-        // `connect` resolves when server writes `OKAY`,
-        // but for this command the server writes `OKAY` after the condition is met.
-        await this.connect(service, options);
+        const socket = await this.connect(service, options);
+        const readable = new BufferedReadableStream(socket.readable);
+        await AdbServerClient.readOkay(readable);
+
+        await readable.cancel();
+        await socket.close();
     }
 
     async createTransport(

package/src/server/transport.ts

@@ -8,9 +8,31 @@ import type {
     AdbTransport,
 } from "../adb.js";
 import type { AdbBanner } from "../banner.js";
+import { AdbFeature } from "../features.js";
 
 import type { AdbServerClient } from "./client.js";
 
+export const ADB_SERVER_DEFAULT_FEATURES = [
+    AdbFeature.ShellV2,
+    AdbFeature.Cmd,
+    AdbFeature.StatV2,
+    AdbFeature.ListV2,
+    AdbFeature.FixedPushMkdir,
+    "apex",
+    AdbFeature.Abb,
+    // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
+    // No special handling required.
+    "fixed_push_symlink_timestamp",
+    AdbFeature.AbbExec,
+    "remount_shell",
+    "track_app",
+    AdbFeature.SendReceiveV2,
+    "sendrecv_v2_brotli",
+    "sendrecv_v2_lz4",
+    "sendrecv_v2_zstd",
+    "sendrecv_v2_dry_run_send",
+] as AdbFeature[];
+
 export class AdbServerTransport implements AdbTransport {
     #client: AdbServerClient;
 
@@ -26,6 +48,12 @@ export class AdbServerTransport implements AdbTransport {
     #waitAbortController = new AbortController();
     readonly disconnected: Promise<void>;
 
+    get clientFeatures() {
+        // No need to get host features (features supported by ADB server)
+        // Because we create all ADB packets ourselves
+        return ADB_SERVER_DEFAULT_FEATURES;
+    }
+
     constructor(
         client: AdbServerClient,
         serial: string,