@yume-chan/adb 0.0.24 → 1.1.0

package/src/server/observer.ts

@@ -0,0 +1,144 @@
+import { EventEmitter } from "@yume-chan/event";
+
+import { Ref } from "../utils/index.js";
+
+import { AdbServerClient } from "./client.js";
+import type { AdbServerStream } from "./stream.js";
+
+function unorderedRemove<T>(array: T[], index: number) {
+    array[index] = array[array.length - 1]!;
+    array.length -= 1;
+}
+
+export class AdbServerDeviceObserverOwner {
+    current: AdbServerClient.Device[] = [];
+
+    #client: AdbServerClient;
+    #stream: Promise<AdbServerStream> | undefined;
+    #observers: {
+        onDeviceAdd: EventEmitter<AdbServerClient.Device[]>;
+        onDeviceRemove: EventEmitter<AdbServerClient.Device[]>;
+        onListChange: EventEmitter<AdbServerClient.Device[]>;
+        onError: EventEmitter<Error>;
+    }[] = [];
+
+    constructor(client: AdbServerClient) {
+        this.#client = client;
+    }
+
+    async #receive(stream: AdbServerStream) {
+        try {
+            while (true) {
+                const response = await stream.readString();
+                const next = AdbServerClient.parseDeviceList(response);
+
+                const added: AdbServerClient.Device[] = [];
+                for (const nextDevice of next) {
+                    const index = this.current.findIndex(
+                        (device) =>
+                            device.transportId === nextDevice.transportId,
+                    );
+                    if (index === -1) {
+                        added.push(nextDevice);
+                        continue;
+                    }
+
+                    unorderedRemove(this.current, index);
+                }
+
+                if (added.length) {
+                    for (const observer of this.#observers) {
+                        observer.onDeviceAdd.fire(added);
+                    }
+                }
+                if (this.current.length) {
+                    for (const observer of this.#observers) {
+                        observer.onDeviceRemove.fire(this.current);
+                    }
+                }
+
+                this.current = next;
+                for (const observer of this.#observers) {
+                    observer.onListChange.fire(this.current);
+                }
+            }
+        } catch (e) {
+            for (const observer of this.#observers) {
+                observer.onError.fire(e as Error);
+            }
+        }
+    }
+
+    async #connect() {
+        const stream = await this.#client.createConnection(
+            "host:track-devices-l",
+            // Each individual observer will ref depending on their options
+            { unref: true },
+        );
+
+        void this.#receive(stream);
+
+        return stream;
+    }
+
+    async #handleObserverStop(stream: AdbServerStream) {
+        if (this.#observers.length === 0) {
+            this.#stream = undefined;
+            await stream.dispose();
+        }
+    }
+
+    async createObserver(
+        options?: AdbServerClient.ServerConnectionOptions,
+    ): Promise<AdbServerClient.DeviceObserver> {
+        if (options?.signal?.aborted) {
+            throw options.signal.reason;
+        }
+
+        this.#stream ??= this.#connect();
+        const stream = await this.#stream;
+
+        if (options?.signal?.aborted) {
+            await this.#handleObserverStop(stream);
+            throw options.signal.reason;
+        }
+
+        const onDeviceAdd = new EventEmitter<AdbServerClient.Device[]>();
+        const onDeviceRemove = new EventEmitter<AdbServerClient.Device[]>();
+        const onListChange = new EventEmitter<AdbServerClient.Device[]>();
+        const onError = new EventEmitter<Error>();
+
+        const observer = { onDeviceAdd, onDeviceRemove, onListChange, onError };
+        this.#observers.push(observer);
+
+        const ref = new Ref(options);
+
+        const stop = async () => {
+            const index = self.#observers.indexOf(observer);
+            if (index === -1) {
+                return;
+            }
+
+            unorderedRemove(this.#observers, index);
+
+            await this.#handleObserverStop(stream);
+
+            ref.unref();
+        };
+
+        options?.signal?.addEventListener("abort", () => void stop());
+
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            onDeviceAdd: onDeviceAdd.event,
+            onDeviceRemove: onDeviceRemove.event,
+            onListChange: onListChange.event,
+            onError: onError.event,
+            get current() {
+                return self.current;
+            },
+            stop,
+        };
+    }
+}

package/src/server/stream.ts

@@ -0,0 +1,100 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
+import type { 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 { hexToNumber, sequenceEqual, write4HexDigits } from "../utils/index.js";
+
+import type { AdbServerClient } from "./client.js";
+
+const OKAY = encodeUtf8("OKAY");
+export const FAIL = encodeUtf8("FAIL");
+
+export 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 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)}`);
+    }
+
+    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);
+    }
+
+    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();
+    }
+}

package/src/server/transport.ts

@@ -1,6 +1,4 @@
 import { PromiseResolver } from "@yume-chan/async";
-import { AbortController } from "@yume-chan/stream-extra";
-import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type {
     AdbIncomingSocketHandler,
@@ -44,9 +42,13 @@ export class AdbServerTransport implements AdbTransport {
 
     readonly banner: AdbBanner;
 
+    #sockets: AdbSocket[] = [];
+
     #closed = new PromiseResolver<void>();
-    #waitAbortController = new AbortController();
-    readonly disconnected: Promise<void>;
+    #disconnected: Promise<void>;
+    get disconnected() {
+        return this.#disconnected;
+    }
 
     get clientFeatures() {
         // No need to get host features (features supported by ADB server)
@@ -54,33 +56,29 @@ export class AdbServerTransport implements AdbTransport {
         return ADB_SERVER_DEFAULT_FEATURES;
     }
 
+    // eslint-disable-next-line @typescript-eslint/max-params
     constructor(
         client: AdbServerClient,
         serial: string,
         banner: AdbBanner,
         transportId: bigint,
+        disconnected: Promise<void>,
     ) {
         this.#client = client;
         this.serial = serial;
         this.banner = banner;
         this.transportId = transportId;
 
-        this.disconnected = Promise.race([
-            this.#closed.promise,
-            client.waitFor({ transportId }, "disconnect", {
-                signal: this.#waitAbortController.signal,
-                unref: true,
-            }),
-        ]);
+        this.#disconnected = Promise.race([this.#closed.promise, disconnected]);
     }
 
     async connect(service: string): Promise<AdbSocket> {
-        return await this.#client.createDeviceConnection(
-            {
-                transportId: this.transportId,
-            },
+        const socket = await this.#client.createDeviceConnection(
+            { transportId: this.transportId },
             service,
         );
+        this.#sockets.push(socket);
+        return socket;
     }
 
     async addReverseTunnel(
@@ -98,8 +96,11 @@ export class AdbServerTransport implements AdbTransport {
         await this.#client.connector.clearReverseTunnels();
     }
 
-    close(): ValueOrPromise<void> {
+    async close(): Promise<void> {
+        for (const socket of this.#sockets) {
+            await socket.close();
+        }
+        this.#sockets.length = 0;
         this.#closed.resolve();
-        this.#waitAbortController.abort();
     }
 }

package/src/utils/base64.ts

@@ -1,23 +1,31 @@
-// Array is faster than object literal or `Map`
-const charToIndex: number[] = [];
-const indexToChar: number[] = [];
-const paddingChar = "=".charCodeAt(0);
-
-function addRange(start: string, end: string) {
-    const charCodeStart = start.charCodeAt(0);
-    const charCodeEnd = end.charCodeAt(0);
-
-    for (let charCode = charCodeStart; charCode <= charCodeEnd; charCode += 1) {
-        charToIndex[charCode] = indexToChar.length;
-        indexToChar.push(charCode);
+const [charToIndex, indexToChar, paddingChar] = /* #__PURE__ */ (() => {
+    // Array is faster than object literal or `Map`
+    const charToIndex: number[] = [];
+    const indexToChar: number[] = [];
+    const paddingChar = "=".charCodeAt(0);
+
+    function addRange(start: string, end: string) {
+        const charCodeStart = start.charCodeAt(0);
+        const charCodeEnd = end.charCodeAt(0);
+
+        for (
+            let charCode = charCodeStart;
+            charCode <= charCodeEnd;
+            charCode += 1
+        ) {
+            charToIndex[charCode] = indexToChar.length;
+            indexToChar.push(charCode);
+        }
     }
-}
 
-addRange("A", "Z");
-addRange("a", "z");
-addRange("0", "9");
-addRange("+", "+");
-addRange("/", "/");
+    addRange("A", "Z");
+    addRange("a", "z");
+    addRange("0", "9");
+    addRange("+", "+");
+    addRange("/", "/");
+
+    return [charToIndex, indexToChar, paddingChar];
+})();
 
 /**
  * Calculate the required length of the output buffer for the given input length.

package/src/utils/index.ts

@@ -3,4 +3,5 @@ export * from "./auto-reset-event.js";
 export * from "./base64.js";
 export * from "./hex.js";
 export * from "./no-op.js";
+export * from "./ref.js";
 export * from "./sequence-equal.js";

package/src/utils/no-op.ts

@@ -1,3 +1,4 @@
+/* #__NO_SIDE_EFFECTS__ */
 export const NOOP = () => {
     // no-op
 };

package/src/utils/ref.ts

@@ -0,0 +1,37 @@
+interface GlobalExtension {
+    setInterval: (callback: () => void, delay: number) => number;
+    clearInterval: (id: number) => void;
+}
+
+const { setInterval, clearInterval } = globalThis as unknown as GlobalExtension;
+
+/**
+ * An object to keep current Node.js process alive even when no code is running.
+ *
+ * Does nothing in Web environments.
+ *
+ * Note that it does't have reference counting. Calling `unref` will
+ * remove the ref no matter how many times `ref` has been previously called, and vice versa.
+ * This is the same as how Node.js works.
+ */
+export class Ref {
+    #intervalId: number | undefined;
+
+    constructor(options?: { unref?: boolean | undefined }) {
+        if (!options?.unref) {
+            this.ref();
+        }
+    }
+
+    ref() {
+        // `setInterval` can keep current Node.js alive, the delay value doesn't matter
+        this.#intervalId = setInterval(() => {}, 60 * 1000);
+    }
+
+    unref() {
+        if (this.#intervalId) {
+            clearInterval(this.#intervalId);
+            this.#intervalId = undefined;
+        }
+    }
+}

package/tsconfig.build.json

@@ -1,14 +1,3 @@
 {
-    "extends": "./node_modules/@yume-chan/tsconfig/tsconfig.base.json",
-    "references": [
-        {
-            "path": "../event/tsconfig.build.json"
-        },
-        {
-            "path": "../stream-extra/tsconfig.build.json"
-        },
-        {
-            "path": "../struct/tsconfig.build.json"
-        }
-    ]
+    "extends": "./node_modules/@yume-chan/tsconfig/tsconfig.base.json"
 }