@yume-chan/adb 0.0.23 → 1.0.0

package/src/commands/framebuffer.ts

@@ -1,44 +1,53 @@
 import { BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct, { StructEmptyError } from "@yume-chan/struct";
+import type { StructValue } from "@yume-chan/struct";
+import { buffer, struct, StructEmptyError, u32 } from "@yume-chan/struct";
 
 import type { Adb } from "../adb.js";
 
-const Version = new Struct({ littleEndian: true }).uint32("version");
+const Version = struct({ version: u32 }, { littleEndian: true });
 
-export const AdbFrameBufferV1 = new Struct({ littleEndian: true })
-    .uint32("bpp")
-    .uint32("size")
-    .uint32("width")
-    .uint32("height")
-    .uint32("red_offset")
-    .uint32("red_length")
-    .uint32("blue_offset")
-    .uint32("blue_length")
-    .uint32("green_offset")
-    .uint32("green_length")
-    .uint32("alpha_offset")
-    .uint32("alpha_length")
-    .uint8Array("data", { lengthField: "size" });
+export const AdbFrameBufferV1 = struct(
+    {
+        bpp: u32,
+        size: u32,
+        width: u32,
+        height: u32,
+        red_offset: u32,
+        red_length: u32,
+        blue_offset: u32,
+        blue_length: u32,
+        green_offset: u32,
+        green_length: u32,
+        alpha_offset: u32,
+        alpha_length: u32,
+        data: buffer("size"),
+    },
+    { littleEndian: true },
+);
 
-export type AdbFrameBufferV1 = (typeof AdbFrameBufferV1)["TDeserializeResult"];
+export type AdbFrameBufferV1 = StructValue<typeof AdbFrameBufferV1>;
 
-export const AdbFrameBufferV2 = new Struct({ littleEndian: true })
-    .uint32("bpp")
-    .uint32("colorSpace")
-    .uint32("size")
-    .uint32("width")
-    .uint32("height")
-    .uint32("red_offset")
-    .uint32("red_length")
-    .uint32("blue_offset")
-    .uint32("blue_length")
-    .uint32("green_offset")
-    .uint32("green_length")
-    .uint32("alpha_offset")
-    .uint32("alpha_length")
-    .uint8Array("data", { lengthField: "size" });
+export const AdbFrameBufferV2 = struct(
+    {
+        bpp: u32,
+        colorSpace: u32,
+        size: u32,
+        width: u32,
+        height: u32,
+        red_offset: u32,
+        red_length: u32,
+        blue_offset: u32,
+        blue_length: u32,
+        green_offset: u32,
+        green_length: u32,
+        alpha_offset: u32,
+        alpha_length: u32,
+        data: buffer("size"),
+    },
+    { littleEndian: true },
+);
 
-export type AdbFrameBufferV2 = (typeof AdbFrameBufferV2)["TDeserializeResult"];
+export type AdbFrameBufferV2 = StructValue<typeof AdbFrameBufferV2>;
 
 /**
  * ADB uses 8 int32 fields to describe bit depths
@@ -93,9 +102,9 @@ export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
     switch (version) {
         case 1:
             // TODO: AdbFrameBuffer: does all v1 responses uses the same color space? Add it so the command returns same format for all versions.
-            return AdbFrameBufferV1.deserialize(stream);
+            return await AdbFrameBufferV1.deserialize(stream);
         case 2:
-            return AdbFrameBufferV2.deserialize(stream);
+            return await AdbFrameBufferV2.deserialize(stream);
         default:
             throw new AdbFrameBufferUnsupportedVersionError(version);
     }

package/src/commands/power.ts

@@ -40,11 +40,13 @@ export class AdbPower extends AdbCommandBase {
     }
 
     powerButton(longPress = false) {
-        return this.adb.subprocess.spawnAndWaitLegacy([
-            "input",
-            "keyevent",
-            longPress ? "--longpress POWER" : "POWER",
-        ]);
+        const args = ["input", "keyevent"];
+        if (longPress) {
+            args.push("--longpress");
+        }
+        args.push("POWER");
+
+        return this.adb.subprocess.spawnAndWaitLegacy(args);
     }
 
     /**

package/src/commands/reverse.ts

@@ -1,11 +1,15 @@
 // cspell: ignore killforward
 
-import { AutoDisposable } from "@yume-chan/event";
 import { BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct, { ExactReadableEndedError } from "@yume-chan/struct";
+import {
+    encodeUtf8,
+    ExactReadableEndedError,
+    string,
+    struct,
+} from "@yume-chan/struct";
 
 import type { Adb, AdbIncomingSocketHandler } from "../adb.js";
-import { decodeUtf8, hexToNumber } from "../utils/index.js";
+import { hexToNumber, sequenceEqual } from "../utils/index.js";
 
 export interface AdbForwardListener {
     deviceSerial: string;
@@ -15,14 +19,25 @@ export interface AdbForwardListener {
     remoteName: string;
 }
 
-const AdbReverseStringResponse = new Struct()
-    .string("length", { length: 4 })
-    .string("content", { lengthField: "length", lengthFieldRadix: 16 });
+const AdbReverseStringResponse = struct(
+    {
+        length: string(4),
+        content: string({
+            field: "length",
+            convert(value: string) {
+                return Number.parseInt(value, 16);
+            },
+            back(value) {
+                return value.toString(16).padStart(4, "0");
+            },
+        }),
+    },
+    { littleEndian: true },
+);
 
 export class AdbReverseError extends Error {
     constructor(message: string) {
         super(message);
-        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 
@@ -34,32 +49,44 @@ export class AdbReverseNotSupportedError extends AdbReverseError {
     }
 }
 
-const AdbReverseErrorResponse = new Struct()
-    .concat(AdbReverseStringResponse)
-    .postDeserialize((value) => {
-        // https://issuetracker.google.com/issues/37066218
-        // ADB on Android <9 can't create reverse tunnels when connected wirelessly (ADB over Wi-Fi),
-        // and returns this confusing "more than one device/emulator" error.
-        if (value.content === "more than one device/emulator") {
-            throw new AdbReverseNotSupportedError();
-        } else {
-            throw new AdbReverseError(value.content);
+const AdbReverseErrorResponse = struct(
+    /* #__PURE__ */ (() => AdbReverseStringResponse.fields)(),
+    {
+        littleEndian: true,
+        postDeserialize: (value) => {
+            // https://issuetracker.google.com/issues/37066218
+            // ADB on Android <9 can't create reverse tunnels when connected wirelessly (ADB over Wi-Fi),
+            // and returns this confusing "more than one device/emulator" error.
+            if (value.content === "more than one device/emulator") {
+                throw new AdbReverseNotSupportedError();
+            } else {
+                throw new AdbReverseError(value.content);
+            }
+        },
+    },
+);
+
+// Like `hexToNumber`, it's much faster than first converting `buffer` to a string
+function decimalToNumber(buffer: Uint8Array) {
+    let value = 0;
+    for (const byte of buffer) {
+        // Like `parseInt`, return when it encounters a non-digit character
+        if (byte < 48 || byte > 57) {
+            return value;
         }
-    });
-
-async function readString(stream: BufferedReadableStream, length: number) {
-    const buffer = await stream.readExactly(length);
-    return decodeUtf8(buffer);
+        value = value * 10 + byte - 48;
+    }
+    return value;
 }
 
-export class AdbReverseCommand extends AutoDisposable {
+const OKAY = encodeUtf8("OKAY");
+
+export class AdbReverseCommand {
     protected adb: Adb;
 
     readonly #deviceAddressToLocalAddress = new Map<string, string>();
 
     constructor(adb: Adb) {
-        super();
-
         this.adb = adb;
     }
 
@@ -70,34 +97,37 @@ export class AdbReverseCommand extends AutoDisposable {
 
     protected async sendRequest(service: string) {
         const stream = await this.createBufferedStream(service);
-        const success = (await readString(stream, 4)) === "OKAY";
-        if (!success) {
+
+        const response = await stream.readExactly(4);
+        if (!sequenceEqual(response, OKAY)) {
             await AdbReverseErrorResponse.deserialize(stream);
         }
+
         return stream;
     }
 
+    /**
+     * Get a list of all reverse port forwarding on the device.
+     */
     async list(): Promise<AdbForwardListener[]> {
         const stream = await this.createBufferedStream("reverse:list-forward");
 
         const response = await AdbReverseStringResponse.deserialize(stream);
-        return response.content.split("\n").map((line) => {
-            const [deviceSerial, localName, remoteName] = line.split(" ") as [
-                string,
-                string,
-                string,
-            ];
-            return { deviceSerial, localName, remoteName };
-        });
+        return response.content
+            .split("\n")
+            .filter((line) => !!line)
+            .map((line) => {
+                const [deviceSerial, localName, remoteName] = line.split(
+                    " ",
+                ) as [string, string, string];
+                return { deviceSerial, localName, remoteName };
+            });
 
         // No need to close the stream, device will close it
     }
 
     /**
-     * Add an already existing reverse tunnel. Depends on the transport type, this may not do anything.
-     * @param deviceAddress The address to be listened on device by ADB daemon. Or `tcp:0` to choose an available TCP port.
-     * @param localAddress The address that listens on the local machine.
-     * @returns `tcp:{ACTUAL_LISTENING_PORT}`, If `deviceAddress` is `tcp:0`; otherwise, `deviceAddress`.
+     * Add a reverse port forwarding for a program that already listens on a port.
      */
     async addExternal(deviceAddress: string, localAddress: string) {
         const stream = await this.sendRequest(
@@ -110,8 +140,8 @@ export class AdbReverseCommand extends AutoDisposable {
             const position = stream.position;
             try {
                 const length = hexToNumber(await stream.readExactly(4));
-                const port = await readString(stream, length);
-                deviceAddress = `tcp:${Number.parseInt(port, 10)}`;
+                const port = decimalToNumber(await stream.readExactly(length));
+                deviceAddress = `tcp:${port}`;
             } catch (e) {
                 if (
                     e instanceof ExactReadableEndedError &&
@@ -130,12 +160,7 @@ export class AdbReverseCommand extends AutoDisposable {
     }
 
     /**
-     * @param deviceAddress The address to be listened on device by ADB daemon. Or `tcp:0` to choose an available TCP port.
-     * @param handler A callback to handle incoming connections.
-     * @param localAddressThe The address that listens on the local machine. May be `undefined` to let the transport choose an appropriate one.
-     * @returns `tcp:{ACTUAL_LISTENING_PORT}`, If `deviceAddress` is `tcp:0`; otherwise, `deviceAddress`.
-     * @throws {AdbReverseNotSupportedError} If ADB reverse tunnel is not supported on this device when connected wirelessly.
-     * @throws {AdbReverseError} If ADB daemon returns an error.
+     * Add a reverse port forwarding.
      */
     async add(
         deviceAddress: string,
@@ -157,6 +182,9 @@ export class AdbReverseCommand extends AutoDisposable {
         }
     }
 
+    /**
+     * Remove a reverse port forwarding.
+     */
     async remove(deviceAddress: string): Promise<void> {
         const localAddress =
             this.#deviceAddressToLocalAddress.get(deviceAddress);
@@ -169,6 +197,9 @@ export class AdbReverseCommand extends AutoDisposable {
         // No need to close the stream, device will close it
     }
 
+    /**
+     * Remove all reverse port forwarding, including the ones added by other programs.
+     */
     async removeAll(): Promise<void> {
         await this.adb.transport.clearReverseTunnels();
         this.#deviceAddressToLocalAddress.clear();

package/src/commands/subprocess/command.ts

@@ -1,4 +1,4 @@
-import { ConcatStringStream, DecodeUtf8Stream } from "@yume-chan/stream-extra";
+import { ConcatStringStream, TextDecoderStream } from "@yume-chan/stream-extra";
 
 import { AdbCommandBase } from "../base.js";
 
@@ -112,10 +112,10 @@ export class AdbSubprocess extends AdbCommandBase {
 
         const [stdout, stderr, exitCode] = await Promise.all([
             process.stdout
-                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new TextDecoderStream())
                 .pipeThrough(new ConcatStringStream()),
             process.stderr
-                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new TextDecoderStream())
                 .pipeThrough(new ConcatStringStream()),
             process.exit,
         ]);

package/src/commands/subprocess/protocols/none.ts

@@ -1,8 +1,7 @@
-import type { Consumable, WritableStream } from "@yume-chan/stream-extra";
+import type { MaybeConsumable, WritableStream } from "@yume-chan/stream-extra";
 import { ReadableStream } from "@yume-chan/stream-extra";
 
 import type { Adb, AdbSocket } from "../../../adb.js";
-import { unreachable } from "../../../utils/index.js";
 
 import type { AdbSubprocessProtocol } from "./types.js";
 
@@ -36,7 +35,7 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     readonly #socket: AdbSocket;
 
     // Legacy shell forwards all data to stdin.
-    get stdin(): WritableStream<Consumable<Uint8Array>> {
+    get stdin(): WritableStream<MaybeConsumable<Uint8Array>> {
         return this.#socket.writable;
     }
 
@@ -64,10 +63,9 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
         this.#socket = socket;
 
         this.#stderr = new ReadableStream({
-            start: (controller) => {
-                this.#socket.closed
-                    .then(() => controller.close())
-                    .catch(unreachable);
+            start: async (controller) => {
+                await this.#socket.closed;
+                controller.close();
             },
         });
         this.#exit = socket.closed.then(() => 0);

package/src/commands/subprocess/protocols/shell.ts

@@ -1,18 +1,17 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type {
-    Consumable,
     PushReadableStreamController,
     ReadableStream,
     WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
 import {
-    ConsumableWritableStream,
+    MaybeConsumable,
     PushReadableStream,
     StructDeserializeStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
-import type { StructValueType } from "@yume-chan/struct";
-import Struct, { placeholder } from "@yume-chan/struct";
+import type { StructValue } from "@yume-chan/struct";
+import { buffer, struct, u32, u8 } from "@yume-chan/struct";
 
 import type { Adb, AdbSocket } from "../../../adb.js";
 import { AdbFeature } from "../../../features.js";
@@ -20,22 +19,28 @@ import { encodeUtf8 } from "../../../utils/index.js";
 
 import type { AdbSubprocessProtocol } from "./types.js";
 
-export enum AdbShellProtocolId {
-    Stdin,
-    Stdout,
-    Stderr,
-    Exit,
-    CloseStdin,
-    WindowSizeChange,
-}
-
-// This packet format is used in both direction.
-const AdbShellProtocolPacket = new Struct({ littleEndian: true })
-    .uint8("id", placeholder<AdbShellProtocolId>())
-    .uint32("length")
-    .uint8Array("data", { lengthField: "length" });
-
-type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
+export const AdbShellProtocolId = {
+    Stdin: 0,
+    Stdout: 1,
+    Stderr: 2,
+    Exit: 3,
+    CloseStdin: 4,
+    WindowSizeChange: 5,
+} as const;
+
+export type AdbShellProtocolId =
+    (typeof AdbShellProtocolId)[keyof typeof AdbShellProtocolId];
+
+// This packet format is used in both directions.
+export const AdbShellProtocolPacket = struct(
+    {
+        id: u8<AdbShellProtocolId>(),
+        data: buffer(u32),
+    },
+    { littleEndian: true },
+);
+
+type AdbShellProtocolPacket = StructValue<typeof AdbShellProtocolPacket>;
 
 /**
  * Shell v2 a.k.a Shell Protocol
@@ -64,9 +69,9 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     readonly #socket: AdbSocket;
-    #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    #writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>;
 
-    #stdin: WritableStream<Consumable<Uint8Array>>;
+    #stdin: WritableStream<MaybeConsumable<Uint8Array>>;
     get stdin() {
         return this.#stdin;
     }
@@ -108,14 +113,10 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                                 this.#exit.resolve(chunk.data[0]!);
                                 break;
                             case AdbShellProtocolId.Stdout:
-                                if (!stdoutController.abortSignal.aborted) {
-                                    await stdoutController.enqueue(chunk.data);
-                                }
+                                await stdoutController.enqueue(chunk.data);
                                 break;
                             case AdbShellProtocolId.Stderr:
-                                if (!stderrController.abortSignal.aborted) {
-                                    await stderrController.enqueue(chunk.data);
-                                }
+                                await stderrController.enqueue(chunk.data);
                                 break;
                         }
                     },
@@ -140,23 +141,20 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
 
         this.#writer = this.#socket.writable.getWriter();
 
-        this.#stdin = new WritableStream<Consumable<Uint8Array>>({
+        this.#stdin = new MaybeConsumable.WritableStream<Uint8Array>({
             write: async (chunk) => {
-                await ConsumableWritableStream.write(
-                    this.#writer,
+                await this.#writer.write(
                     AdbShellProtocolPacket.serialize({
                         id: AdbShellProtocolId.Stdin,
-                        data: chunk.value,
+                        data: chunk,
                     }),
                 );
-                chunk.consume();
             },
         });
     }
 
     async resize(rows: number, cols: number) {
-        await ConsumableWritableStream.write(
-            this.#writer,
+        await this.#writer.write(
             AdbShellProtocolPacket.serialize({
                 id: AdbShellProtocolId.WindowSizeChange,
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`

package/src/commands/subprocess/protocols/types.ts

@@ -1,9 +1,9 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
 import type {
-    Consumable,
+    MaybeConsumable,
     ReadableStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
-import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type { Adb, AdbSocket } from "../../../adb.js";
 
@@ -11,7 +11,7 @@ export interface AdbSubprocessProtocol {
     /**
      * A WritableStream that writes to the `stdin` stream.
      */
-    readonly stdin: WritableStream<Consumable<Uint8Array>>;
+    readonly stdin: WritableStream<MaybeConsumable<Uint8Array>>;
 
     /**
      * The `stdout` stream of the process.
@@ -40,23 +40,23 @@ export interface AdbSubprocessProtocol {
      * Some `AdbSubprocessProtocol`s may not support resizing
      * and will ignore calls to this method.
      */
-    resize(rows: number, cols: number): ValueOrPromise<void>;
+    resize(rows: number, cols: number): MaybePromiseLike<void>;
 
     /**
      * Kills the current process.
      */
-    kill(): ValueOrPromise<void>;
+    kill(): MaybePromiseLike<void>;
 }
 
 export interface AdbSubprocessProtocolConstructor {
     /** Returns `true` if the `adb` instance supports this shell */
-    isSupported(adb: Adb): ValueOrPromise<boolean>;
+    isSupported(adb: Adb): MaybePromiseLike<boolean>;
 
     /** Spawns an executable in PTY (interactive) mode. */
-    pty(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+    pty(adb: Adb, command: string): MaybePromiseLike<AdbSubprocessProtocol>;
 
     /** Spawns an executable and pipe the output. */
-    raw(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+    raw(adb: Adb, command: string): MaybePromiseLike<AdbSubprocessProtocol>;
 
     /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
     new (socket: AdbSocket): AdbSubprocessProtocol;

package/src/commands/sync/list.ts

@@ -1,4 +1,5 @@
-import Struct from "@yume-chan/struct";
+import type { StructValue } from "@yume-chan/struct";
+import { string, struct, u32 } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
@@ -14,23 +15,27 @@ export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
 }
 
-export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
-    .concat(AdbSyncLstatResponse)
-    .uint32("nameLength")
-    .string("name", { lengthField: "nameLength" })
-    .extra({ id: AdbSyncResponseId.Entry as const });
+export const AdbSyncEntryResponse = /* #__PURE__ */ (() =>
+    struct(
+        {
+            ...AdbSyncLstatResponse.fields,
+            name: string(u32),
+        },
+        { littleEndian: true, extra: AdbSyncLstatResponse.extra },
+    ))();
 
-export type AdbSyncEntryResponse =
-    (typeof AdbSyncEntryResponse)["TDeserializeResult"];
+export type AdbSyncEntryResponse = StructValue<typeof AdbSyncEntryResponse>;
 
-export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
-    .concat(AdbSyncStatResponse)
-    .uint32("nameLength")
-    .string("name", { lengthField: "nameLength" })
-    .extra({ id: AdbSyncResponseId.Entry2 as const });
+export const AdbSyncEntry2Response = /* #__PURE__ */ (() =>
+    struct(
+        {
+            ...AdbSyncStatResponse.fields,
+            name: string(u32),
+        },
+        { littleEndian: true, extra: AdbSyncStatResponse.extra },
+    ))();
 
-export type AdbSyncEntry2Response =
-    (typeof AdbSyncEntry2Response)["TDeserializeResult"];
+export type AdbSyncEntry2Response = StructValue<typeof AdbSyncEntry2Response>;
 
 export async function* adbSyncOpenDirV2(
     socket: AdbSyncSocket,

package/src/commands/sync/pull.ts

@@ -1,18 +1,18 @@
 import type { ReadableStream } from "@yume-chan/stream-extra";
 import { PushReadableStream } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import type { StructValue } from "@yume-chan/struct";
+import { buffer, struct, u32 } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
-import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
+import { adbSyncReadResponses, AdbSyncResponseId } from "./response.js";
 import type { AdbSyncSocket } from "./socket.js";
 
-export const AdbSyncDataResponse = new Struct({ littleEndian: true })
-    .uint32("dataLength")
-    .uint8Array("data", { lengthField: "dataLength" })
-    .extra({ id: AdbSyncResponseId.Data as const });
+export const AdbSyncDataResponse = struct(
+    { data: buffer(u32) },
+    { littleEndian: true },
+);
 
-export type AdbSyncDataResponse =
-    (typeof AdbSyncDataResponse)["TDeserializeResult"];
+export type AdbSyncDataResponse = StructValue<typeof AdbSyncDataResponse>;
 
 export async function* adbSyncPullGenerator(
     socket: AdbSyncSocket,
@@ -52,6 +52,7 @@ export function adbSyncPull(
     socket: AdbSyncSocket,
     path: string,
 ): ReadableStream<Uint8Array> {
+    // TODO: use `ReadableStream.from` when it's supported
     return new PushReadableStream(async (controller) => {
         for await (const data of adbSyncPullGenerator(socket, path)) {
             await controller.enqueue(data);