@yume-chan/android-bin 1.1.0 → 2.0.1

package/src/bug-report.ts

@@ -2,7 +2,7 @@
 // cspell: ignore bugreportz
 
 import type { Adb, AdbSync } from "@yume-chan/adb";
-import { AdbCommandBase, AdbSubprocessShellProtocol } from "@yume-chan/adb";
+import { AdbServiceBase } from "@yume-chan/adb";
 import type { AbortSignal, ReadableStream } from "@yume-chan/stream-extra";
 import {
     AbortController,
@@ -31,7 +31,7 @@ export interface BugReportZOptions {
     onProgress?: ((completed: string, total: string) => void) | undefined;
 }
 
-export class BugReport extends AdbCommandBase {
+export class BugReport extends AdbServiceBase {
     static VERSION_REGEX: RegExp = /(\d+)\.(\d+)/;
 
     static BEGIN_REGEX: RegExp = /BEGIN:(.*)/;
@@ -47,7 +47,7 @@ export class BugReport extends AdbCommandBase {
      */
     static async queryCapabilities(adb: Adb): Promise<BugReport> {
         // bugreportz requires shell protocol
-        if (!AdbSubprocessShellProtocol.isSupported(adb)) {
+        if (!adb.subprocess.shellProtocol) {
             return new BugReport(adb, {
                 supportsBugReport: true,
                 bugReportZVersion: undefined,
@@ -57,11 +57,11 @@ export class BugReport extends AdbCommandBase {
             });
         }
 
-        const { stderr, exitCode } = await adb.subprocess.spawnAndWait([
+        const result = await adb.subprocess.shellProtocol.spawnWaitText([
             "bugreportz",
             "-v",
         ]);
-        if (exitCode !== 0 || stderr === "") {
+        if (result.exitCode !== 0 || result.stderr === "") {
             return new BugReport(adb, {
                 supportsBugReport: true,
                 bugReportZVersion: undefined,
@@ -71,7 +71,7 @@ export class BugReport extends AdbCommandBase {
             });
         }
 
-        const match = stderr.match(BugReport.VERSION_REGEX);
+        const match = result.stderr.match(BugReport.VERSION_REGEX);
         if (!match) {
             return new BugReport(adb, {
                 supportsBugReport: true,
@@ -170,8 +170,9 @@ export class BugReport extends AdbCommandBase {
 
         return new WrapReadableStream(async () => {
             // https://cs.android.com/android/platform/superproject/+/master:frameworks/native/cmds/bugreport/bugreport.cpp;drc=9b73bf07d73dbab5b792632e1e233edbad77f5fd;bpv=0;bpt=0
-            const process = await this.adb.subprocess.spawn(["bugreport"]);
-            return process.stdout;
+            const process =
+                await this.adb.subprocess.noneProtocol.spawn("bugreport");
+            return process.output;
         });
     }
 
@@ -200,9 +201,8 @@ export class BugReport extends AdbCommandBase {
             args.push("-p");
         }
 
-        const process = await this.adb.subprocess.spawn(args, {
-            protocols: [AdbSubprocessShellProtocol],
-        });
+        // `subprocess.shellProtocol` must be defined when `this.#supportsBugReportZ` is `true`
+        const process = await this.adb.subprocess.shellProtocol!.spawn(args);
 
         options?.signal?.addEventListener("abort", () => {
             void process.kill();
@@ -258,10 +258,10 @@ export class BugReport extends AdbCommandBase {
      */
     bugReportZStream(): ReadableStream<Uint8Array> {
         return new PushReadableStream(async (controller) => {
-            const process = await this.adb.subprocess.spawn(
-                ["bugreportz", "-s"],
-                { protocols: [AdbSubprocessShellProtocol] },
-            );
+            const process = await this.adb.subprocess.shellProtocol!.spawn([
+                "bugreportz",
+                "-s",
+            ]);
             process.stdout
                 .pipeTo(
                     new WritableStream({
@@ -285,7 +285,7 @@ export class BugReport extends AdbCommandBase {
                 .catch((e) => {
                     controller.error(e);
                 });
-            await process.exit;
+            await process.exited;
         });
     }
 

package/src/cmd.ts

@@ -1,23 +1,70 @@
-import type {
-    Adb,
-    AdbSubprocessProtocol,
-    AdbSubprocessProtocolConstructor,
-    AdbSubprocessWaitResult,
-} from "@yume-chan/adb";
+import type { Adb, AdbShellProtocolProcess } from "@yume-chan/adb";
 import {
-    AdbCommandBase,
     AdbFeature,
-    AdbSubprocessNoneProtocol,
-    AdbSubprocessShellProtocol,
+    AdbNoneProtocolProcessImpl,
+    AdbNoneProtocolSpawner,
+    AdbServiceBase,
+    AdbShellProtocolProcessImpl,
+    AdbShellProtocolSpawner,
 } from "@yume-chan/adb";
-import { ConcatStringStream, TextDecoderStream } from "@yume-chan/stream-extra";
 
-export class Cmd extends AdbCommandBase {
-    #supportsShellV2: boolean;
-    get supportsShellV2(): boolean {
-        return this.#supportsShellV2;
+export class CmdNoneProtocolService extends AdbNoneProtocolSpawner {
+    #supportsAbbExec: boolean;
+    get supportsAbbExec(): boolean {
+        return this.#supportsAbbExec;
+    }
+
+    #supportsCmd: boolean;
+    get supportsCmd(): boolean {
+        return this.#supportsCmd;
+    }
+
+    get isSupported() {
+        return this.#supportsAbbExec || this.#supportsCmd;
     }
 
+    constructor(
+        adb: Adb,
+        fallback?:
+            | string
+            | Record<string, string>
+            | ((service: string) => string),
+    ) {
+        super(async (command) => {
+            if (this.#supportsAbbExec) {
+                return new AdbNoneProtocolProcessImpl(
+                    await adb.createSocket(`abb_exec:${command.join("\0")}\0`),
+                );
+            }
+
+            if (this.#supportsCmd) {
+                return adb.subprocess.noneProtocol.spawn(
+                    `cmd ${command.join(" ")}`,
+                );
+            }
+
+            if (typeof fallback === "function") {
+                fallback = fallback(command[0]!);
+            } else if (typeof fallback === "object") {
+                fallback = fallback[command[0]!];
+            }
+
+            if (!fallback) {
+                throw new Error("Unsupported");
+            }
+
+            command[0] = fallback;
+            return adb.subprocess.noneProtocol.spawn(command);
+        });
+
+        this.#supportsCmd = adb.canUseFeature(AdbFeature.Cmd);
+        this.#supportsAbbExec = adb.canUseFeature(AdbFeature.AbbExec);
+    }
+}
+
+export class CmdShellProtocolService extends AdbShellProtocolSpawner {
+    #adb: Adb;
+
     #supportsCmd: boolean;
     get supportsCmd(): boolean {
         return this.#supportsCmd;
@@ -28,86 +75,90 @@ export class Cmd extends AdbCommandBase {
         return this.#supportsAbb;
     }
 
-    #supportsAbbExec: boolean;
-    get supportsAbbExec(): boolean {
-        return this.#supportsAbbExec;
+    get isSupported() {
+        return (
+            this.#supportsAbb ||
+            (this.#supportsCmd && !!this.#adb.subprocess.shellProtocol)
+        );
     }
 
-    constructor(adb: Adb) {
-        super(adb);
-        this.#supportsShellV2 = adb.canUseFeature(AdbFeature.ShellV2);
+    constructor(
+        adb: Adb,
+        fallback?:
+            | string
+            | Record<string, string>
+            | ((service: string) => string),
+    ) {
+        super(async (command): Promise<AdbShellProtocolProcess> => {
+            if (this.#supportsAbb) {
+                return new AdbShellProtocolProcessImpl(
+                    await this.#adb.createSocket(`abb:${command.join("\0")}\0`),
+                );
+            }
+
+            if (!adb.subprocess.shellProtocol) {
+                throw new Error("Unsupported");
+            }
+
+            if (this.#supportsCmd) {
+                return adb.subprocess.shellProtocol.spawn(
+                    `cmd ${command.join(" ")}`,
+                );
+            }
+
+            if (typeof fallback === "function") {
+                fallback = fallback(command[0]!);
+            } else if (typeof fallback === "object") {
+                fallback = fallback[command[0]!];
+            }
+
+            if (!fallback) {
+                throw new Error("Unsupported");
+            }
+
+            command[0] = fallback;
+            return adb.subprocess.shellProtocol.spawn(command);
+        });
+
+        this.#adb = adb;
         this.#supportsCmd = adb.canUseFeature(AdbFeature.Cmd);
         this.#supportsAbb = adb.canUseFeature(AdbFeature.Abb);
-        this.#supportsAbbExec = adb.canUseFeature(AdbFeature.AbbExec);
     }
+}
 
-    /**
-     * Spawn a new `cmd` command. It will use ADB's `abb` command if available.
-     *
-     * @param shellProtocol
-     * Whether to use shell protocol. If `true`, `stdout` and `stderr` will be separated.
-     *
-     * `cmd` doesn't use PTY, so even when shell protocol is used,
-     * resizing terminal size and closing `stdin` are not supported.
-     * @param command The command to run.
-     * @param args The arguments to pass to the command.
-     * @returns An `AdbSubprocessProtocol` that provides output streams.
-     */
-    async spawn(
-        shellProtocol: boolean,
-        command: string,
-        ...args: string[]
-    ): Promise<AdbSubprocessProtocol> {
-        let supportsAbb: boolean;
-        let supportsCmd: boolean = this.#supportsCmd;
-        let service: string;
-        let Protocol: AdbSubprocessProtocolConstructor;
-        if (shellProtocol) {
-            supportsAbb = this.#supportsAbb;
-            supportsCmd &&= this.supportsShellV2;
-            service = "abb";
-            Protocol = AdbSubprocessShellProtocol;
-        } else {
-            supportsAbb = this.#supportsAbbExec;
-            service = "abb_exec";
-            Protocol = AdbSubprocessNoneProtocol;
-        }
+export class Cmd extends AdbServiceBase {
+    #noneProtocol: CmdNoneProtocolService | undefined;
+    get noneProtocol() {
+        return this.#noneProtocol;
+    }
 
-        if (supportsAbb) {
-            return new Protocol(
-                await this.adb.createSocket(
-                    `${service}:${command}\0${args.join("\0")}\0`,
-                ),
-            );
-        }
+    #shellProtocol: CmdShellProtocolService | undefined;
+    get shellProtocol() {
+        return this.#shellProtocol;
+    }
 
-        if (supportsCmd) {
-            return Protocol.raw(this.adb, `cmd ${command} ${args.join(" ")}`);
-        }
+    constructor(
+        adb: Adb,
+        fallback?:
+            | string
+            | Record<string, string>
+            | ((service: string) => string),
+    ) {
+        super(adb);
 
-        throw new Error("Not supported");
-    }
+        if (
+            adb.canUseFeature(AdbFeature.AbbExec) ||
+            adb.canUseFeature(AdbFeature.Cmd)
+        ) {
+            this.#noneProtocol = new CmdNoneProtocolService(adb, fallback);
+        }
 
-    async spawnAndWait(
-        command: string,
-        ...args: string[]
-    ): Promise<AdbSubprocessWaitResult> {
-        const process = await this.spawn(true, command, ...args);
-
-        const [stdout, stderr, exitCode] = await Promise.all([
-            process.stdout
-                .pipeThrough(new TextDecoderStream())
-                .pipeThrough(new ConcatStringStream()),
-            process.stderr
-                .pipeThrough(new TextDecoderStream())
-                .pipeThrough(new ConcatStringStream()),
-            process.exit,
-        ]);
-
-        return {
-            stdout,
-            stderr,
-            exitCode,
-        };
+        if (
+            adb.canUseFeature(AdbFeature.Abb) ||
+            (adb.canUseFeature(AdbFeature.Cmd) &&
+                adb.canUseFeature(AdbFeature.ShellV2))
+        ) {
+            this.#shellProtocol = new CmdShellProtocolService(adb, fallback);
+        }
     }
 }

package/src/demo-mode.ts

@@ -5,7 +5,7 @@
 // cspell: ignore sysui
 
 import type { Adb } from "@yume-chan/adb";
-import { AdbCommandBase } from "@yume-chan/adb";
+import { AdbServiceBase } from "@yume-chan/adb";
 
 import { Settings } from "./settings.js";
 
@@ -51,7 +51,7 @@ export const DemoModeStatusBarModes = [
 
 export type DemoModeStatusBarMode = (typeof DemoModeStatusBarModes)[number];
 
-export class DemoMode extends AdbCommandBase {
+export class DemoMode extends AdbServiceBase {
     #settings: Settings;
 
     constructor(adb: Adb) {
@@ -112,7 +112,7 @@ export class DemoMode extends AdbCommandBase {
         command: string,
         extra?: Record<string, string>,
     ): Promise<void> {
-        await this.adb.subprocess.spawnAndWaitLegacy([
+        await this.adb.subprocess.noneProtocol.spawnWaitText([
             "am",
             "broadcast",
             "-a",

package/src/dumpsys.ts

@@ -1,4 +1,4 @@
-import { AdbCommandBase } from "@yume-chan/adb";
+import { AdbServiceBase } from "@yume-chan/adb";
 
 const BatteryDumpFields: Record<
     string,
@@ -54,17 +54,17 @@ const Battery = {
     Health,
 };
 
-export class DumpSys extends AdbCommandBase {
+export class DumpSys extends AdbServiceBase {
     static readonly Battery = Battery;
 
     async diskStats() {
-        const output = await this.adb.subprocess.spawnAndWaitLegacy([
+        const result = await this.adb.subprocess.noneProtocol.spawnWaitText([
             "dumpsys",
             "diskstats",
         ]);
 
         function getSize(name: string) {
-            const match = output.match(
+            const match = result.match(
                 new RegExp(`${name}-Free: (\\d+)K / (\\d+)K`),
             );
             if (!match) {
@@ -91,7 +91,7 @@ export class DumpSys extends AdbCommandBase {
     }
 
     async battery(): Promise<DumpSys.Battery.Info> {
-        const output = await this.adb.subprocess.spawnAndWaitLegacy([
+        const result = await this.adb.subprocess.noneProtocol.spawnWaitText([
             "dumpsys",
             "battery",
         ]);
@@ -105,7 +105,7 @@ export class DumpSys extends AdbCommandBase {
             health: DumpSys.Battery.Health.Unknown,
         };
 
-        for (const line of output.split("\n")) {
+        for (const line of result.split("\n")) {
             const parts = line.split(":").map((part) => part.trim());
             if (parts.length !== 2) {
                 continue;

package/src/logcat.ts

@@ -1,7 +1,7 @@
 // cspell: ignore logcat
 // cspell: ignore usec
 
-import { AdbCommandBase, AdbSubprocessNoneProtocol } from "@yume-chan/adb";
+import { AdbServiceBase } from "@yume-chan/adb";
 import type { ReadableStream } from "@yume-chan/stream-extra";
 import {
     BufferedTransformStream,
@@ -80,19 +80,25 @@ export type LogcatFormat = (typeof LogcatFormat)[keyof typeof LogcatFormat];
 export interface LogcatFormatModifiers {
     microseconds?: boolean;
     nanoseconds?: boolean;
-    printable?: boolean;
     year?: boolean;
     timezone?: boolean;
     epoch?: boolean;
     monotonic?: boolean;
     uid?: boolean;
-    descriptive?: boolean;
 }
 
 export interface LogcatOptions {
-    dump?: boolean;
-    pid?: number;
-    ids?: LogId[];
+    dump?: boolean | undefined;
+    pid?: number | undefined;
+    ids?: LogId[] | undefined;
+    tail?: number | Date | undefined;
+}
+
+function formatTailTime(date: Date) {
+    // Tail time supports multiple formats,
+    // `sssss.mmm` is simplest to implement
+    const timestamp = date.getTime();
+    return ((timestamp / 1000) | 0) + "." + (timestamp % 1000);
 }
 
 const NANOSECONDS_PER_SECOND = /* #__PURE__ */ BigInt(1e9);
@@ -399,7 +405,7 @@ export interface LogSize {
     maxPayloadSize: number;
 }
 
-export class Logcat extends AdbCommandBase {
+export class Logcat extends AdbServiceBase {
     static logIdToName(id: LogId): string {
         return LogIdName[id]!;
     }
@@ -429,14 +435,14 @@ export class Logcat extends AdbCommandBase {
         /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed, (.*) (.*)B readable\), max entry is (.*) B, max payload is (.*) B/;
 
     async getLogSize(ids?: LogId[]): Promise<LogSize[]> {
-        const { stdout } = await this.adb.subprocess.spawn([
+        const process = await this.adb.subprocess.noneProtocol.spawn([
             "logcat",
             "-g",
             ...(ids ? ["-b", Logcat.joinLogId(ids)] : []),
         ]);
 
         const result: LogSize[] = [];
-        for await (const line of stdout
+        for await (const line of process.output
             .pipeThrough(new TextDecoderStream())
             .pipeThrough(new SplitStringStream("\n"))) {
             let match = line.match(Logcat.LOG_SIZE_REGEX_11);
@@ -488,7 +494,7 @@ export class Logcat extends AdbCommandBase {
             args.push("-b", Logcat.joinLogId(ids));
         }
 
-        await this.adb.subprocess.spawnAndWait(args);
+        await this.adb.subprocess.noneProtocol.spawnWaitText(args);
     }
 
     binary(options?: LogcatOptions): ReadableStream<AndroidLogEntry> {
@@ -503,14 +509,19 @@ export class Logcat extends AdbCommandBase {
             if (options?.ids) {
                 args.push("-b", Logcat.joinLogId(options.ids));
             }
+            if (options?.tail) {
+                args.push(
+                    "-t",
+                    typeof options.tail === "number"
+                        ? options.tail.toString()
+                        : formatTailTime(options.tail),
+                );
+            }
 
             // TODO: make `spawn` return synchronously with streams pending
             // so it's easier to chain them.
-            const { stdout } = await this.adb.subprocess.spawn(args, {
-                // PERF: None protocol is 150% faster then Shell protocol
-                protocols: [AdbSubprocessNoneProtocol],
-            });
-            return stdout;
+            const process = await this.adb.subprocess.noneProtocol.spawn(args);
+            return process.output;
         }).pipeThrough(
             new BufferedTransformStream((stream) => {
                 return deserializeAndroidLogEntry(stream);

package/src/overlay-display.ts

@@ -1,5 +1,5 @@
 import type { Adb } from "@yume-chan/adb";
-import { AdbCommandBase } from "@yume-chan/adb";
+import { AdbServiceBase } from "@yume-chan/adb";
 
 import { Settings } from "./settings.js";
 import { p } from "./string-format.js";
@@ -17,7 +17,7 @@ export interface OverlayDisplayDevice {
     showSystemDecorations: boolean;
 }
 
-export class OverlayDisplay extends AdbCommandBase {
+export class OverlayDisplay extends AdbServiceBase {
     #settings: Settings;
 
     static readonly SETTING_KEY = "overlay_display_devices";