@yume-chan/adb 0.0.22 → 0.0.24

package/src/commands/reverse.ts

@@ -2,10 +2,10 @@
 
 import { AutoDisposable } from "@yume-chan/event";
 import { BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct, { ExactReadableEndedError } from "@yume-chan/struct";
+import Struct, { ExactReadableEndedError, encodeUtf8 } 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;
@@ -38,7 +38,7 @@ 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 WiFi),
+        // 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();
@@ -47,11 +47,21 @@ const AdbReverseErrorResponse = new Struct()
         }
     });
 
-async function readString(stream: BufferedReadableStream, length: number) {
-    const buffer = await stream.readExactly(length);
-    return decodeUtf8(buffer);
+// 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;
+        }
+        value = value * 10 + byte - 48;
+    }
+    return value;
 }
 
+const OKAY = encodeUtf8("OKAY");
+
 export class AdbReverseCommand extends AutoDisposable {
     protected adb: Adb;
 
@@ -70,10 +80,12 @@ 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;
     }
 
@@ -81,14 +93,15 @@ export class AdbReverseCommand extends AutoDisposable {
         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
     }
@@ -110,8 +123,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 &&

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,4 +1,4 @@
-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";
@@ -36,7 +36,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;
     }
 

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

@@ -1,17 +1,14 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type {
-    Consumable,
     PushReadableStreamController,
     ReadableStream,
     WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
 import {
-    ConsumableTransformStream,
-    ConsumableWritableStream,
+    MaybeConsumable,
     PushReadableStream,
     StructDeserializeStream,
     WritableStream,
-    pipeFrom,
 } from "@yume-chan/stream-extra";
 import type { StructValueType } from "@yume-chan/struct";
 import Struct, { placeholder } from "@yume-chan/struct";
@@ -37,68 +34,8 @@ const AdbShellProtocolPacket = new Struct({ littleEndian: true })
     .uint32("length")
     .uint8Array("data", { lengthField: "length" });
 
-type AdbShellProtocolPacketInit = (typeof AdbShellProtocolPacket)["TInit"];
-
 type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
 
-class StdinSerializeStream extends ConsumableTransformStream<
-    Uint8Array,
-    AdbShellProtocolPacketInit
-> {
-    constructor() {
-        super({
-            async transform(chunk, controller) {
-                await controller.enqueue({
-                    id: AdbShellProtocolId.Stdin,
-                    data: chunk,
-                });
-            },
-            flush() {
-                // TODO: AdbShellSubprocessProtocol: support closing stdin
-            },
-        });
-    }
-}
-
-class MultiplexStream<T> {
-    #readable: PushReadableStream<T>;
-    #readableController!: PushReadableStreamController<T>;
-    get readable() {
-        return this.#readable;
-    }
-
-    #activeCount = 0;
-
-    constructor() {
-        this.#readable = new PushReadableStream((controller) => {
-            this.#readableController = controller;
-        });
-    }
-
-    createWriteable() {
-        return new WritableStream<T>({
-            start: () => {
-                this.#activeCount += 1;
-            },
-            write: async (chunk) => {
-                await this.#readableController.enqueue(chunk);
-            },
-            abort: () => {
-                this.#activeCount -= 1;
-                if (this.#activeCount === 0) {
-                    this.#readableController.close();
-                }
-            },
-            close: () => {
-                this.#activeCount -= 1;
-                if (this.#activeCount === 0) {
-                    this.#readableController.close();
-                }
-            },
-        });
-    }
-}
-
 /**
  * Shell v2 a.k.a Shell Protocol
  *
@@ -109,7 +46,7 @@ class MultiplexStream<T> {
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     static isSupported(adb: Adb) {
-        return adb.supportsFeature(AdbFeature.ShellV2);
+        return adb.canUseFeature(AdbFeature.ShellV2);
     }
 
     static async pty(adb: Adb, command: string) {
@@ -126,11 +63,9 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     readonly #socket: AdbSocket;
-    #socketWriter: WritableStreamDefaultWriter<
-        Consumable<AdbShellProtocolPacketInit>
-    >;
+    #writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>;
 
-    #stdin: WritableStream<Consumable<Uint8Array>>;
+    #stdin: WritableStream<MaybeConsumable<Uint8Array>>;
     get stdin() {
         return this.#stdin;
     }
@@ -153,13 +88,8 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     constructor(socket: AdbSocket) {
         this.#socket = socket;
 
-        // Check this image to help you understand the stream graph
-        // cspell: disable-next-line
-        // https://www.plantuml.com/plantuml/png/bL91QiCm4Bpx5SAdv90lb1JISmiw5XzaQKf5PIkiLZIqzEyLSg8ks13gYtOykpFhiOw93N6UGjVDqK7rZsxKqNw0U_NTgVAy4empOy2mm4_olC0VEVEE47GUpnGjKdgXoD76q4GIEpyFhOwP_m28hW0NNzxNUig1_JdW0bA7muFIJDco1daJ_1SAX9bgvoPJPyIkSekhNYctvIGXrCH6tIsPL5fs-s6J5yc9BpWXhKtNdF2LgVYPGM_6GlMwfhWUsIt4lbScANrwlgVVUifPSVi__t44qStnwPvZwobdSmHHlL57p2vFuHS0
-
         let stdoutController!: PushReadableStreamController<Uint8Array>;
         let stderrController!: PushReadableStreamController<Uint8Array>;
-
         this.#stdout = new PushReadableStream<Uint8Array>((controller) => {
             stdoutController = controller;
         });
@@ -207,39 +137,30 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                 },
             );
 
-        const multiplexer = new MultiplexStream<
-            Consumable<AdbShellProtocolPacketInit>
-        >();
-        void multiplexer.readable
-            .pipeThrough(
-                new ConsumableTransformStream({
-                    async transform(chunk, controller) {
-                        await controller.enqueue(
-                            AdbShellProtocolPacket.serialize(chunk),
-                        );
-                    },
-                }),
-            )
-            .pipeTo(socket.writable);
-
-        this.#stdin = pipeFrom(
-            multiplexer.createWriteable(),
-            new StdinSerializeStream(),
-        );
+        this.#writer = this.#socket.writable.getWriter();
 
-        this.#socketWriter = multiplexer.createWriteable().getWriter();
+        this.#stdin = new MaybeConsumable.WritableStream<Uint8Array>({
+            write: async (chunk) => {
+                await this.#writer.write(
+                    AdbShellProtocolPacket.serialize({
+                        id: AdbShellProtocolId.Stdin,
+                        data: chunk,
+                    }),
+                );
+            },
+        });
     }
 
     async resize(rows: number, cols: number) {
-        await ConsumableWritableStream.write(this.#socketWriter, {
-            id: AdbShellProtocolId.WindowSizeChange,
-            data: encodeUtf8(
+        await this.#writer.write(
+            AdbShellProtocolPacket.serialize({
+                id: AdbShellProtocolId.WindowSizeChange,
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
                 // However, according to https://linux.die.net/man/4/tty_ioctl
                 // `x_pixels` and `y_pixels` are unused, so always sending `0` should be fine.
-                `${rows}x${cols},0x0\0`,
-            ),
-        });
+                data: encodeUtf8(`${rows}x${cols},0x0\0`),
+            }),
+        );
     }
 
     kill() {

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

@@ -1,5 +1,5 @@
 import type {
-    Consumable,
+    MaybeConsumable,
     ReadableStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
@@ -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.

package/src/commands/subprocess/utils.ts

@@ -10,7 +10,7 @@ export function escapeArg(s: string) {
             break;
         }
         result += s.substring(base, found);
-        // a'b becomes a'\'b
+        // a'b becomes a'\'b (the backslash is not a escape character)
         result += String.raw`'\''`;
         base = found + 1;
     }

package/src/commands/sync/list.ts

@@ -17,8 +17,7 @@ export interface AdbSyncEntry extends AdbSyncStat {
 export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
     .concat(AdbSyncLstatResponse)
     .uint32("nameLength")
-    .string("name", { lengthField: "nameLength" })
-    .extra({ id: AdbSyncResponseId.Entry as const });
+    .string("name", { lengthField: "nameLength" });
 
 export type AdbSyncEntryResponse =
     (typeof AdbSyncEntryResponse)["TDeserializeResult"];
@@ -26,8 +25,7 @@ export type AdbSyncEntryResponse =
 export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
     .concat(AdbSyncStatResponse)
     .uint32("nameLength")
-    .string("name", { lengthField: "nameLength" })
-    .extra({ id: AdbSyncResponseId.Entry2 as const });
+    .string("name", { lengthField: "nameLength" });
 
 export type AdbSyncEntry2Response =
     (typeof AdbSyncEntry2Response)["TDeserializeResult"];

package/src/commands/sync/pull.ts

@@ -8,8 +8,7 @@ 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 });
+    .uint8Array("data", { lengthField: "dataLength" });
 
 export type AdbSyncDataResponse =
     (typeof AdbSyncDataResponse)["TDeserializeResult"];
@@ -52,6 +51,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);

package/src/commands/sync/push.ts

@@ -1,8 +1,8 @@
-import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+import type { ReadableStream } from "@yume-chan/stream-extra";
 import {
     AbortController,
-    ConsumableWritableStream,
     DistributionStream,
+    MaybeConsumable,
 } from "@yume-chan/stream-extra";
 import Struct, { placeholder } from "@yume-chan/struct";
 
@@ -18,7 +18,7 @@ export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 export interface AdbSyncPushV1Options {
     socket: AdbSyncSocket;
     filename: string;
-    file: ReadableStream<Consumable<Uint8Array>>;
+    file: ReadableStream<MaybeConsumable<Uint8Array>>;
     type?: LinuxFileType;
     permission?: number;
     mtime?: number;
@@ -31,7 +31,7 @@ export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
 
 async function pipeFileData(
     locked: AdbSyncSocketLocked,
-    file: ReadableStream<Consumable<Uint8Array>>,
+    file: ReadableStream<MaybeConsumable<Uint8Array>>,
     packetSize: number,
     mtime: number,
 ) {
@@ -40,7 +40,7 @@ async function pipeFileData(
     const abortController = new AbortController();
     file.pipeThrough(new DistributionStream(packetSize, true))
         .pipeTo(
-            new ConsumableWritableStream({
+            new MaybeConsumable.WritableStream({
                 write: async (chunk) => {
                     await adbSyncWriteRequest(
                         locked,
@@ -97,10 +97,7 @@ export enum AdbSyncSendV2Flags {
      * 4
      */
     Zstd = 1 << 2,
-    /**
-     * 0x80000000
-     */
-    DryRun = (1 << 31) >>> 0,
+    DryRun = 0x80000000,
 }
 
 export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
@@ -114,7 +111,7 @@ export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
 }
 
 export const AdbSyncSendV2Request = new Struct({ littleEndian: true })
-    .uint32("id", placeholder<AdbSyncRequestId>())
+    .uint32("id")
     .uint32("mode")
     .uint32("flags", placeholder<AdbSyncSendV2Flags>());
 

package/src/commands/sync/request.ts

@@ -2,53 +2,53 @@ import Struct from "@yume-chan/struct";
 
 import { encodeUtf8 } from "../../utils/index.js";
 
-export enum AdbSyncRequestId {
-    List = "LIST",
-    ListV2 = "LIS2",
-    Send = "SEND",
-    SendV2 = "SND2",
-    Lstat = "STAT",
-    Stat = "STA2",
-    LstatV2 = "LST2",
-    Data = "DATA",
-    Done = "DONE",
-    Receive = "RECV",
+import { adbSyncEncodeId } from "./response.js";
+
+export namespace AdbSyncRequestId {
+    export const List = adbSyncEncodeId("LIST");
+    export const ListV2 = adbSyncEncodeId("LIS2");
+    export const Send = adbSyncEncodeId("SEND");
+    export const SendV2 = adbSyncEncodeId("SND2");
+    export const Lstat = adbSyncEncodeId("STAT");
+    export const Stat = adbSyncEncodeId("STA2");
+    export const LstatV2 = adbSyncEncodeId("LST2");
+    export const Data = adbSyncEncodeId("DATA");
+    export const Done = adbSyncEncodeId("DONE");
+    export const Receive = adbSyncEncodeId("RECV");
 }
 
 export const AdbSyncNumberRequest = new Struct({ littleEndian: true })
-    .string("id", { length: 4 })
+    .uint32("id")
     .uint32("arg");
 
-export const AdbSyncDataRequest = new Struct({ littleEndian: true })
-    .concat(AdbSyncNumberRequest)
-    .uint8Array("data", { lengthField: "arg" });
-
 export interface AdbSyncWritable {
     write(buffer: Uint8Array): Promise<void>;
 }
 
 export async function adbSyncWriteRequest(
     writable: AdbSyncWritable,
-    id: AdbSyncRequestId | string,
+    id: number | string,
     value: number | string | Uint8Array,
 ): Promise<void> {
+    if (typeof id === "string") {
+        id = adbSyncEncodeId(id);
+    }
+
     if (typeof value === "number") {
-        const buffer = AdbSyncNumberRequest.serialize({
-            id,
-            arg: value,
-        });
-        await writable.write(buffer);
-    } else if (typeof value === "string") {
-        // Let `writable` buffer writes
-        const buffer = encodeUtf8(value);
         await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength }),
+            AdbSyncNumberRequest.serialize({ id, arg: value }),
         );
-        await writable.write(buffer);
-    } else {
-        await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength }),
-        );
-        await writable.write(value);
+        return;
+    }
+
+    if (typeof value === "string") {
+        value = encodeUtf8(value);
     }
+
+    // `writable` is buffered, it copies inputs to an internal buffer,
+    // so don't concatenate headers and data here, that will be an unnecessary copy.
+    await writable.write(
+        AdbSyncNumberRequest.serialize({ id, arg: value.length }),
+    );
+    await writable.write(value);
 }

package/src/commands/sync/response.ts

@@ -1,22 +1,39 @@
+import { getUint32LittleEndian } from "@yume-chan/no-data-view";
 import type {
     AsyncExactReadable,
     StructLike,
     StructValueType,
 } from "@yume-chan/struct";
-import Struct from "@yume-chan/struct";
+import Struct, { decodeUtf8 } from "@yume-chan/struct";
 
-import { decodeUtf8 } from "../../utils/index.js";
+function encodeAsciiUnchecked(value: string): Uint8Array {
+    const result = new Uint8Array(value.length);
+    for (let i = 0; i < value.length; i += 1) {
+        result[i] = value.charCodeAt(i);
+    }
+    return result;
+}
+
+/**
+ * Encode ID to numbers for faster comparison
+ * @param value A 4-character string
+ * @returns A 32-bit integer by encoding the string as little-endian
+ */
+export function adbSyncEncodeId(value: string): number {
+    const buffer = encodeAsciiUnchecked(value);
+    return getUint32LittleEndian(buffer, 0);
+}
 
-export enum AdbSyncResponseId {
-    Entry = "DENT",
-    Entry2 = "DNT2",
-    Lstat = "STAT",
-    Stat = "STA2",
-    Lstat2 = "LST2",
-    Done = "DONE",
-    Data = "DATA",
-    Ok = "OKAY",
-    Fail = "FAIL",
+export namespace AdbSyncResponseId {
+    export const Entry = adbSyncEncodeId("DENT");
+    export const Entry2 = adbSyncEncodeId("DNT2");
+    export const Lstat = adbSyncEncodeId("STAT");
+    export const Stat = adbSyncEncodeId("STA2");
+    export const Lstat2 = adbSyncEncodeId("LST2");
+    export const Done = adbSyncEncodeId("DONE");
+    export const Data = adbSyncEncodeId("DATA");
+    export const Ok = adbSyncEncodeId("OKAY");
+    export const Fail = adbSyncEncodeId("FAIL");
 }
 
 export class AdbSyncError extends Error {}
@@ -30,18 +47,24 @@ export const AdbSyncFailResponse = new Struct({ littleEndian: true })
 
 export async function adbSyncReadResponse<T>(
     stream: AsyncExactReadable,
-    id: AdbSyncResponseId,
+    id: number | string,
     type: StructLike<T>,
 ): Promise<T> {
-    const actualId = decodeUtf8(await stream.readExactly(4));
-    switch (actualId) {
+    if (typeof id === "string") {
+        id = adbSyncEncodeId(id);
+    }
+
+    const buffer = await stream.readExactly(4);
+    switch (getUint32LittleEndian(buffer, 0)) {
         case AdbSyncResponseId.Fail:
             await AdbSyncFailResponse.deserialize(stream);
             throw new Error("Unreachable");
         case id:
             return await type.deserialize(stream);
         default:
-            throw new Error(`Expected '${id}', but got '${actualId}'`);
+            throw new Error(
+                `Expected '${id}', but got '${decodeUtf8(buffer)}'`,
+            );
     }
 }
 
@@ -49,12 +72,16 @@ export async function* adbSyncReadResponses<
     T extends Struct<object, PropertyKey, object, unknown>,
 >(
     stream: AsyncExactReadable,
-    id: AdbSyncResponseId,
+    id: number | string,
     type: T,
 ): AsyncGenerator<StructValueType<T>, void, void> {
+    if (typeof id === "string") {
+        id = adbSyncEncodeId(id);
+    }
+
     while (true) {
-        const actualId = decodeUtf8(await stream.readExactly(4));
-        switch (actualId) {
+        const buffer = await stream.readExactly(4);
+        switch (getUint32LittleEndian(buffer, 0)) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
                 throw new Error("Unreachable");
@@ -70,7 +97,7 @@ export async function* adbSyncReadResponses<
                 break;
             default:
                 throw new Error(
-                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`,
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${decodeUtf8(buffer)}'`,
                 );
         }
     }