@yume-chan/adb-daemon-webusb 0.0.20 → 0.0.22

package/esm/watcher.js

@@ -4,17 +4,17 @@ export class AdbDaemonWebUsbDeviceWatcher {
     constructor(callback, usb) {
         this.#callback = callback;
         this.#usbManager = usb;
-        this.#usbManager.addEventListener("connect", this.handleConnect);
-        this.#usbManager.addEventListener("disconnect", this.handleDisconnect);
+        this.#usbManager.addEventListener("connect", this.#handleConnect);
+        this.#usbManager.addEventListener("disconnect", this.#handleDisconnect);
     }
     dispose() {
-        this.#usbManager.removeEventListener("connect", this.handleConnect);
-        this.#usbManager.removeEventListener("disconnect", this.handleDisconnect);
+        this.#usbManager.removeEventListener("connect", this.#handleConnect);
+        this.#usbManager.removeEventListener("disconnect", this.#handleDisconnect);
     }
-    handleConnect = (e) => {
+    #handleConnect = (e) => {
         this.#callback(e.device.serialNumber);
     };
-    handleDisconnect = () => {
+    #handleDisconnect = () => {
         this.#callback();
     };
 }

package/esm/watcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../src/watcher.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,4BAA4B;IACrC,SAAS,CAAqC;IAC9C,WAAW,CAAM;IAEjB,YAAmB,QAA4C,EAAE,GAAQ;QACrE,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QAEvB,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACjE,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3E,CAAC;IAEM,OAAO;QACV,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACpE,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAChC,YAAY,EACZ,IAAI,CAAC,gBAAgB,CACxB,CAAC;IACN,CAAC;IAEO,aAAa,GAAG,CAAC,CAAqB,EAAE,EAAE;QAC9C,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEM,gBAAgB,GAAG,GAAG,EAAE;QAC5B,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC,CAAC;CACL"}
+{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../src/watcher.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,4BAA4B;IACrC,SAAS,CAAqC;IAC9C,WAAW,CAAM;IAEjB,YAAY,QAA4C,EAAE,GAAQ;QAC9D,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;QAEvB,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAClE,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC5E,CAAC;IAED,OAAO;QACH,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACrE,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAChC,YAAY,EACZ,IAAI,CAAC,iBAAiB,CACzB,CAAC;IACN,CAAC;IAED,cAAc,GAAG,CAAC,CAAqB,EAAE,EAAE;QACvC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEF,iBAAiB,GAAG,GAAG,EAAE;QACrB,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC,CAAC;CACL"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yume-chan/adb-daemon-webusb",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Adb daemon transport connection for `@yume-chan/adb` using WebUSB API.",
   "keywords": [
     "webusb",
@@ -25,18 +25,18 @@
   "main": "esm/index.js",
   "types": "esm/index.d.ts",
   "dependencies": {
-    "@types/w3c-web-usb": "^1.0.6",
-    "@yume-chan/adb": "^0.0.20",
-    "@yume-chan/stream-extra": "^0.0.20",
-    "@yume-chan/struct": "^0.0.20",
-    "tslib": "^2.5.2"
+    "@types/w3c-web-usb": "^1.0.10",
+    "@yume-chan/adb": "^0.0.22",
+    "@yume-chan/stream-extra": "^0.0.22",
+    "@yume-chan/struct": "^0.0.22",
+    "tslib": "^2.6.2"
   },
   "devDependencies": {
     "@yume-chan/eslint-config": "^1.0.0",
     "@yume-chan/tsconfig": "^1.0.0",
-    "eslint": "^8.41.0",
-    "prettier": "^2.8.8",
-    "typescript": "^5.0.3"
+    "eslint": "^8.55.0",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.2"
   },
   "scripts": {
     "build": "tsc -b tsconfig.build.json",

package/src/device.ts

@@ -77,19 +77,19 @@ class Uint8ArrayExactReadable implements ExactReadable {
     #data: Uint8Array;
     #position: number;
 
-    public get position() {
+    get position() {
         return this.#position;
     }
 
-    public constructor(data: Uint8Array) {
+    constructor(data: Uint8Array) {
         this.#data = data;
         this.#position = 0;
     }
 
-    public readExactly(length: number): Uint8Array {
+    readExactly(length: number): Uint8Array {
         const result = this.#data.subarray(
             this.#position,
-            this.#position + length
+            this.#position + length,
         );
         this.#position += length;
         return result;
@@ -99,22 +99,41 @@ class Uint8ArrayExactReadable implements ExactReadable {
 export class AdbDaemonWebUsbConnection
     implements ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>
 {
+    #device: AdbDaemonWebUsbDevice;
+    get device() {
+        return this.#device;
+    }
+
+    #inEndpoint: USBEndpoint;
+    get inEndpoint() {
+        return this.#inEndpoint;
+    }
+
+    #outEndpoint: USBEndpoint;
+    get outEndpoint() {
+        return this.#outEndpoint;
+    }
+
     #readable: ReadableStream<AdbPacketData>;
-    public get readable() {
+    get readable() {
         return this.#readable;
     }
 
     #writable: WritableStream<Consumable<AdbPacketInit>>;
-    public get writable() {
+    get writable() {
         return this.#writable;
     }
 
-    public constructor(
-        device: USBDevice,
+    constructor(
+        device: AdbDaemonWebUsbDevice,
         inEndpoint: USBEndpoint,
         outEndpoint: USBEndpoint,
-        usbManager: USB
+        usbManager: USB,
     ) {
+        this.#device = device;
+        this.#inEndpoint = inEndpoint;
+        this.#outEndpoint = outEndpoint;
+
         let closed = false;
 
         const duplex = new DuplexStreamFactory<
@@ -124,7 +143,7 @@ export class AdbDaemonWebUsbConnection
             close: async () => {
                 try {
                     closed = true;
-                    await device.close();
+                    await device.raw.close();
                 } catch {
                     /* device may have already disconnected */
                 }
@@ -133,13 +152,13 @@ export class AdbDaemonWebUsbConnection
                 closed = true;
                 usbManager.removeEventListener(
                     "disconnect",
-                    handleUsbDisconnect
+                    handleUsbDisconnect,
                 );
             },
         });
 
         function handleUsbDisconnect(e: USBConnectionEvent) {
-            if (e.device === device) {
+            if (e.device === device.raw) {
                 duplex.dispose().catch(unreachable);
             }
         }
@@ -147,63 +166,19 @@ export class AdbDaemonWebUsbConnection
         usbManager.addEventListener("disconnect", handleUsbDisconnect);
 
         this.#readable = duplex.wrapReadable(
-            new ReadableStream<AdbPacketData>({
-                async pull(controller) {
-                    try {
-                        // The `length` argument in `transferIn` must not be smaller than what the device sent,
-                        // otherwise it will return `babble` status without any data.
-                        // ADB daemon sends each packet in two parts, the 24-byte header and the payload.
-                        const result = await device.transferIn(
-                            inEndpoint.endpointNumber,
-                            24
-                        );
-
-                        // TODO: webusb: handle `babble` by discarding the data and receive again
-
-                        // Per spec, the `result.data` always covers the whole `buffer`.
-                        const buffer = new Uint8Array(result.data!.buffer);
-                        const stream = new Uint8ArrayExactReadable(buffer);
-
-                        // Add `payload` field to its type, it's assigned below.
-                        const packet = AdbPacketHeader.deserialize(
-                            stream
-                        ) as AdbPacketHeader & { payload: Uint8Array };
-                        if (packet.payloadLength !== 0) {
-                            const result = await device.transferIn(
-                                inEndpoint.endpointNumber,
-                                packet.payloadLength
-                            );
-                            packet.payload = new Uint8Array(
-                                result.data!.buffer
-                            );
+            new ReadableStream<AdbPacketData>(
+                {
+                    pull: async (controller) => {
+                        const packet = await this.#transferIn();
+                        if (packet) {
+                            controller.enqueue(packet);
                         } else {
-                            packet.payload = EMPTY_UINT8_ARRAY;
+                            controller.close();
                         }
-
-                        controller.enqueue(packet);
-                    } catch (e) {
-                        // On Windows, disconnecting the device will cause `NetworkError` to be thrown,
-                        // even before the `disconnect` event is fired.
-                        // We need to wait a little bit and check if the device is still connected.
-                        // https://github.com/WICG/webusb/issues/219
-                        if (isErrorName(e, "NetworkError")) {
-                            await new Promise<void>((resolve) => {
-                                setTimeout(() => {
-                                    resolve();
-                                }, 100);
-                            });
-
-                            if (closed) {
-                                controller.close();
-                            } else {
-                                throw e;
-                            }
-                        }
-
-                        throw e;
-                    }
+                    },
                 },
-            })
+                { highWaterMark: 0 },
+            ),
         );
 
         const zeroMask = outEndpoint.packetSize - 1;
@@ -212,9 +187,9 @@ export class AdbDaemonWebUsbConnection
                 new ConsumableWritableStream({
                     write: async (chunk) => {
                         try {
-                            await device.transferOut(
+                            await device.raw.transferOut(
                                 outEndpoint.endpointNumber,
-                                chunk
+                                chunk,
                             );
 
                             // In USB protocol, a not-full packet indicates the end of a transfer.
@@ -225,9 +200,9 @@ export class AdbDaemonWebUsbConnection
                                 zeroMask &&
                                 (chunk.byteLength & zeroMask) === 0
                             ) {
-                                await device.transferOut(
+                                await device.raw.transferOut(
                                     outEndpoint.endpointNumber,
-                                    EMPTY_UINT8_ARRAY
+                                    EMPTY_UINT8_ARRAY,
                                 );
                             }
                         } catch (e) {
@@ -237,11 +212,72 @@ export class AdbDaemonWebUsbConnection
                             throw e;
                         }
                     },
-                })
+                }),
             ),
-            new AdbPacketSerializeStream()
+            new AdbPacketSerializeStream(),
         );
     }
+
+    async #transferIn(): Promise<AdbPacketData | undefined> {
+        try {
+            while (true) {
+                // ADB daemon sends each packet in two parts, the 24-byte header and the payload.
+                const result = await this.#device.raw.transferIn(
+                    this.#inEndpoint.endpointNumber,
+                    this.#inEndpoint.packetSize,
+                );
+
+                if (result.data!.byteLength !== 24) {
+                    continue;
+                }
+
+                // Per spec, the `result.data` always covers the whole `buffer`.
+                const buffer = new Uint8Array(result.data!.buffer);
+                const stream = new Uint8ArrayExactReadable(buffer);
+
+                // Add `payload` field to its type, it's assigned below.
+                const packet = AdbPacketHeader.deserialize(
+                    stream,
+                ) as AdbPacketHeader & { payload: Uint8Array };
+
+                if (packet.magic !== (packet.command ^ 0xffffffff)) {
+                    continue;
+                }
+
+                if (packet.payloadLength !== 0) {
+                    const result = await this.#device.raw.transferIn(
+                        this.#inEndpoint.endpointNumber,
+                        packet.payloadLength,
+                    );
+                    packet.payload = new Uint8Array(result.data!.buffer);
+                } else {
+                    packet.payload = EMPTY_UINT8_ARRAY;
+                }
+
+                return packet;
+            }
+        } catch (e) {
+            // On Windows, disconnecting the device will cause `NetworkError` to be thrown,
+            // even before the `disconnect` event is fired.
+            // We need to wait a little bit and check if the device is still connected.
+            // https://github.com/WICG/webusb/issues/219
+            if (isErrorName(e, "NetworkError")) {
+                await new Promise<void>((resolve) => {
+                    setTimeout(() => {
+                        resolve();
+                    }, 100);
+                });
+
+                if (closed) {
+                    return undefined;
+                } else {
+                    throw e;
+                }
+            }
+
+            throw e;
+        }
+    }
 }
 
 export class AdbDaemonWebUsbDevice implements AdbDaemonDevice {
@@ -249,15 +285,16 @@ export class AdbDaemonWebUsbDevice implements AdbDaemonDevice {
     #usbManager: USB;
 
     #raw: USBDevice;
-    public get raw() {
+    get raw() {
         return this.#raw;
     }
 
-    public get serial(): string {
-        return this.#raw.serialNumber!;
+    #serial: string;
+    get serial(): string {
+        return this.#serial;
     }
 
-    public get name(): string {
+    get name(): string {
         return this.#raw.productName!;
     }
 
@@ -267,23 +304,25 @@ export class AdbDaemonWebUsbDevice implements AdbDaemonDevice {
      * @param device The `USBDevice` instance obtained elsewhere.
      * @param filters The filters to use when searching for ADB interface. Defaults to {@link ADB_DEFAULT_DEVICE_FILTER}.
      */
-    public constructor(
+    constructor(
         device: USBDevice,
         filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER],
-        usbManager: USB
+        usbManager: USB,
     ) {
         this.#raw = device;
+        if (device.serialNumber) {
+            this.#serial = device.serialNumber;
+        } else {
+            this.#serial =
+                device.vendorId.toString(16).padStart(4, "0") +
+                "x" +
+                device.productId.toString(16).padStart(4, "0");
+        }
         this.#filters = filters;
         this.#usbManager = usbManager;
     }
 
-    /**
-     * Claim the device and create a pair of `AdbPacket` streams to the ADB interface.
-     * @returns The pair of `AdbPacket` streams.
-     */
-    public async connect(): Promise<
-        ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>
-    > {
+    async #claimInterface(): Promise<[USBEndpoint, USBEndpoint]> {
         if (!this.#raw.opened) {
             await this.#raw.open();
         }
@@ -298,7 +337,7 @@ export class AdbDaemonWebUsbDevice implements AdbDaemonDevice {
             // Note: Switching configuration is not supported on Windows,
             // but Android devices should always expose ADB function at the first (default) configuration.
             await this.#raw.selectConfiguration(
-                configuration.configurationValue
+                configuration.configurationValue,
             );
         }
 
@@ -311,18 +350,27 @@ export class AdbDaemonWebUsbDevice implements AdbDaemonDevice {
         ) {
             await this.#raw.selectAlternateInterface(
                 interface_.interfaceNumber,
-                alternate.alternateSetting
+                alternate.alternateSetting,
             );
         }
 
         const { inEndpoint, outEndpoint } = findUsbEndpoints(
-            alternate.endpoints
+            alternate.endpoints,
         );
+        return [inEndpoint, outEndpoint];
+    }
+
+    /**
+     * Claim the device and create a pair of `AdbPacket` streams to the ADB interface.
+     * @returns The pair of `AdbPacket` streams.
+     */
+    async connect(): Promise<AdbDaemonWebUsbConnection> {
+        const [inEndpoint, outEndpoint] = await this.#claimInterface();
         return new AdbDaemonWebUsbConnection(
-            this.#raw,
+            this,
             inEndpoint,
             outEndpoint,
-            this.#usbManager
+            this.#usbManager,
         );
     }
 }

package/src/manager.ts

@@ -2,13 +2,20 @@ import { ADB_DEFAULT_DEVICE_FILTER, AdbDaemonWebUsbDevice } from "./device.js";
 import type { AdbDeviceFilter } from "./utils.js";
 import { findUsbAlternateInterface, isErrorName } from "./utils.js";
 
+export namespace AdbDaemonWebUsbDeviceManager {
+    export interface RequestDeviceOptions {
+        filters?: AdbDeviceFilter[] | undefined;
+        exclusionFilters?: USBDeviceFilter[] | undefined;
+    }
+}
+
 export class AdbDaemonWebUsbDeviceManager {
     /**
      * Gets the instance of {@link AdbDaemonWebUsbDeviceManager} using browser WebUSB implementation.
      *
      * May be `undefined` if current runtime does not support WebUSB.
      */
-    public static readonly BROWSER =
+    static readonly BROWSER =
         typeof globalThis.navigator !== "undefined" &&
         !!globalThis.navigator.usb
             ? new AdbDaemonWebUsbDeviceManager(globalThis.navigator.usb)
@@ -20,7 +27,7 @@ export class AdbDaemonWebUsbDeviceManager {
      * Create a new instance of {@link AdbDaemonWebUsbDeviceManager} using the specified WebUSB implementation.
      * @param usbManager A WebUSB compatible interface.
      */
-    public constructor(usbManager: USB) {
+    constructor(usbManager: USB) {
         this.#usbManager = usbManager;
     }
 
@@ -37,14 +44,24 @@ export class AdbDaemonWebUsbDeviceManager {
      * @returns An {@link AdbDaemonWebUsbDevice} instance if the user selected a device,
      * or `undefined` if the user cancelled the device picker.
      */
-    public async requestDevice(
-        filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER]
+    async requestDevice(
+        options: AdbDaemonWebUsbDeviceManager.RequestDeviceOptions = {},
     ): Promise<AdbDaemonWebUsbDevice | undefined> {
+        if (!options.filters) {
+            options.filters = [ADB_DEFAULT_DEVICE_FILTER];
+        } else if (options.filters.length === 0) {
+            throw new TypeError("filters must not be empty");
+        }
+
         try {
-            const device = await this.#usbManager.requestDevice({
-                filters,
-            });
-            return new AdbDaemonWebUsbDevice(device, filters, this.#usbManager);
+            const device = await this.#usbManager.requestDevice(
+                options as USBDeviceRequestOptions,
+            );
+            return new AdbDaemonWebUsbDevice(
+                device,
+                options.filters,
+                this.#usbManager,
+            );
         } catch (e) {
             // No device selected
             if (isErrorName(e, "NotFoundError")) {
@@ -67,9 +84,13 @@ export class AdbDaemonWebUsbDeviceManager {
      * Defaults to {@link ADB_DEFAULT_DEVICE_FILTER}.
      * @returns An array of {@link AdbDaemonWebUsbDevice} instances for all connected and authenticated devices.
      */
-    public async getDevices(
-        filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER]
+    async getDevices(
+        filters: AdbDeviceFilter[] = [ADB_DEFAULT_DEVICE_FILTER],
     ): Promise<AdbDaemonWebUsbDevice[]> {
+        if (filters.length === 0) {
+            throw new TypeError("filters must not be empty");
+        }
+
         const devices = await this.#usbManager.getDevices();
         return devices
             .filter((device) => {
@@ -104,7 +125,11 @@ export class AdbDaemonWebUsbDeviceManager {
             })
             .map(
                 (device) =>
-                    new AdbDaemonWebUsbDevice(device, filters, this.#usbManager)
+                    new AdbDaemonWebUsbDevice(
+                        device,
+                        filters,
+                        this.#usbManager,
+                    ),
             );
     }
 }

package/src/utils.ts

@@ -18,19 +18,19 @@ export type AdbDeviceFilter = USBDeviceFilter &
 
 function alternateMatchesFilter(
     alternate: USBAlternateInterface,
-    filters: AdbDeviceFilter[]
+    filters: AdbDeviceFilter[],
 ) {
     return filters.some(
         (filter) =>
             alternate.interfaceClass === filter.classCode &&
             alternate.interfaceSubclass === filter.subclassCode &&
-            alternate.interfaceProtocol === filter.protocolCode
+            alternate.interfaceProtocol === filter.protocolCode,
     );
 }
 
 export function findUsbAlternateInterface(
     device: USBDevice,
-    filters: AdbDeviceFilter[]
+    filters: AdbDeviceFilter[],
 ) {
     for (const configuration of device.configurations) {
         for (const interface_ of configuration.interfaces) {

package/src/watcher.ts

@@ -2,27 +2,27 @@ export class AdbDaemonWebUsbDeviceWatcher {
     #callback: (newDeviceSerial?: string) => void;
     #usbManager: USB;
 
-    public constructor(callback: (newDeviceSerial?: string) => void, usb: USB) {
+    constructor(callback: (newDeviceSerial?: string) => void, usb: USB) {
         this.#callback = callback;
         this.#usbManager = usb;
 
-        this.#usbManager.addEventListener("connect", this.handleConnect);
-        this.#usbManager.addEventListener("disconnect", this.handleDisconnect);
+        this.#usbManager.addEventListener("connect", this.#handleConnect);
+        this.#usbManager.addEventListener("disconnect", this.#handleDisconnect);
     }
 
-    public dispose(): void {
-        this.#usbManager.removeEventListener("connect", this.handleConnect);
+    dispose(): void {
+        this.#usbManager.removeEventListener("connect", this.#handleConnect);
         this.#usbManager.removeEventListener(
             "disconnect",
-            this.handleDisconnect
+            this.#handleDisconnect,
         );
     }
 
-    private handleConnect = (e: USBConnectionEvent) => {
+    #handleConnect = (e: USBConnectionEvent) => {
         this.#callback(e.device.serialNumber);
     };
 
-    private handleDisconnect = () => {
+    #handleDisconnect = () => {
         this.#callback();
     };
 }