@yume-chan/android-bin 0.0.23 → 1.0.0

package/src/bug-report.ts

@@ -6,9 +6,9 @@ import { AdbCommandBase, AdbSubprocessShellProtocol } from "@yume-chan/adb";
 import type { AbortSignal, ReadableStream } from "@yume-chan/stream-extra";
 import {
     AbortController,
-    DecodeUtf8Stream,
     PushReadableStream,
     SplitStringStream,
+    TextDecoderStream,
     WrapReadableStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
@@ -32,15 +32,15 @@ export interface BugReportZOptions {
 }
 
 export class BugReport extends AdbCommandBase {
-    static VERSION_REGEX = /(\d+)\.(\d+)/;
+    static VERSION_REGEX: RegExp = /(\d+)\.(\d+)/;
 
-    static BEGIN_REGEX = /BEGIN:(.*)/;
+    static BEGIN_REGEX: RegExp = /BEGIN:(.*)/;
 
-    static PROGRESS_REGEX = /PROGRESS:(.*)\/(.*)/;
+    static PROGRESS_REGEX: RegExp = /PROGRESS:(.*)\/(.*)/;
 
-    static OK_REGEX = /OK:(.*)/;
+    static OK_REGEX: RegExp = /OK:(.*)/;
 
-    static FAIL_REGEX = /FAIL:(.*)/;
+    static FAIL_REGEX: RegExp = /FAIL:(.*)/;
 
     /**
      * Queries the device's bugreport capabilities.
@@ -101,7 +101,7 @@ export class BugReport extends AdbCommandBase {
      *
      * Should be `true` for Android version <= 11.
      */
-    get supportsBugReport() {
+    get supportsBugReport(): boolean {
         return this.#supportsBugReport;
     }
 
@@ -111,7 +111,7 @@ export class BugReport extends AdbCommandBase {
      *
      * Will be `undefined` if BugReportZ is not supported.
      */
-    get bugReportZVersion() {
+    get bugReportZVersion(): string | undefined {
         return this.#bugReportZVersion;
     }
 
@@ -121,7 +121,7 @@ export class BugReport extends AdbCommandBase {
      *
      * Should be `true` for Android version >= 7.
      */
-    get supportsBugReportZ() {
+    get supportsBugReportZ(): boolean {
         return this.#supportsBugReportZ;
     }
 
@@ -131,7 +131,7 @@ export class BugReport extends AdbCommandBase {
      *
      * Should be `true` for Android version >= 8.
      */
-    get supportsBugReportZProgress() {
+    get supportsBugReportZProgress(): boolean {
         return this.#supportsBugReportZProgress;
     }
 
@@ -141,7 +141,7 @@ export class BugReport extends AdbCommandBase {
      *
      * Should be `true` for Android version >= 12.
      */
-    get supportsBugReportZStream() {
+    get supportsBugReportZStream(): boolean {
         return this.#supportsBugReportZStream;
     }
 
@@ -185,7 +185,7 @@ export class BugReport extends AdbCommandBase {
      */
     async bugReportZ(options?: BugReportZOptions): Promise<string> {
         if (options?.signal?.aborted) {
-            throw options?.signal.reason ?? new Error("Aborted");
+            throw options?.signal.reason as Error;
         }
 
         if (!this.#supportsBugReportZ) {
@@ -211,37 +211,33 @@ export class BugReport extends AdbCommandBase {
         let filename: string | undefined;
         let error: string | undefined;
 
-        await process.stdout
-            .pipeThrough(new DecodeUtf8Stream())
-            .pipeThrough(new SplitStringStream("\n"))
-            .pipeTo(
-                new WritableStream<string>({
-                    write(line) {
-                        // `BEGIN:` and `PROGRESS:` only appear when `-p` is specified.
-                        let match = line.match(BugReport.PROGRESS_REGEX);
-                        if (match) {
-                            options?.onProgress?.(match[1]!, match[2]!);
-                        }
-
-                        match = line.match(BugReport.BEGIN_REGEX);
-                        if (match) {
-                            filename = match[1]!;
-                        }
-
-                        match = line.match(BugReport.OK_REGEX);
-                        if (match) {
-                            filename = match[1];
-                        }
-
-                        match = line.match(BugReport.FAIL_REGEX);
-                        if (match) {
-                            // Don't report error now
-                            // We want to gather all output.
-                            error = match[1];
-                        }
-                    },
-                }),
-            );
+        for await (const line of process.stdout
+            .pipeThrough(new TextDecoderStream())
+            // Each chunk should contain one or several full lines
+            .pipeThrough(new SplitStringStream("\n"))) {
+            // `BEGIN:` and `PROGRESS:` only appear when `-p` is specified.
+            let match = line.match(BugReport.PROGRESS_REGEX);
+            if (match) {
+                options?.onProgress?.(match[1]!, match[2]!);
+            }
+
+            match = line.match(BugReport.BEGIN_REGEX);
+            if (match) {
+                filename = match[1]!;
+            }
+
+            match = line.match(BugReport.OK_REGEX);
+            if (match) {
+                filename = match[1];
+            }
+
+            match = line.match(BugReport.FAIL_REGEX);
+            if (match) {
+                // Don't report error now
+                // We want to gather all output.
+                error = match[1];
+            }
+        }
 
         if (error) {
             throw new Error(error);
@@ -278,7 +274,7 @@ export class BugReport extends AdbCommandBase {
                     controller.error(e);
                 });
             process.stderr
-                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new TextDecoderStream())
                 .pipeTo(
                     new WritableStream({
                         write(chunk) {

package/src/cmd.ts

@@ -10,26 +10,26 @@ import {
     AdbSubprocessNoneProtocol,
     AdbSubprocessShellProtocol,
 } from "@yume-chan/adb";
-import { ConcatStringStream, DecodeUtf8Stream } from "@yume-chan/stream-extra";
+import { ConcatStringStream, TextDecoderStream } from "@yume-chan/stream-extra";
 
 export class Cmd extends AdbCommandBase {
     #supportsShellV2: boolean;
-    get supportsShellV2() {
+    get supportsShellV2(): boolean {
         return this.#supportsShellV2;
     }
 
     #supportsCmd: boolean;
-    get supportsCmd() {
+    get supportsCmd(): boolean {
         return this.#supportsCmd;
     }
 
     #supportsAbb: boolean;
-    get supportsAbb() {
+    get supportsAbb(): boolean {
         return this.#supportsAbb;
     }
 
     #supportsAbbExec: boolean;
-    get supportsAbbExec() {
+    get supportsAbbExec(): boolean {
         return this.#supportsAbbExec;
     }
 
@@ -41,6 +41,18 @@ export class Cmd extends AdbCommandBase {
         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,
@@ -84,10 +96,10 @@ export class Cmd 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/dumpsys.ts

@@ -1,6 +1,62 @@
 import { AdbCommandBase } from "@yume-chan/adb";
 
+const BatteryDumpFields: Record<
+    string,
+    {
+        type: "number" | "boolean" | "string";
+        field: keyof DumpSys.Battery.Info;
+    }
+> = {
+    "AC powered": { type: "boolean", field: "acPowered" },
+    "USB powered": { type: "boolean", field: "usbPowered" },
+    "Wireless powered": { type: "boolean", field: "wirelessPowered" },
+    "Dock powered": { type: "boolean", field: "dockPowered" },
+    "Max charging current": {
+        type: "number",
+        field: "maxChargingCurrent",
+    },
+    "Max charging voltage": {
+        type: "number",
+        field: "maxChargingVoltage",
+    },
+    "Charge counter": { type: "number", field: "chargeCounter" },
+    status: { type: "number", field: "status" },
+    health: { type: "number", field: "health" },
+    present: { type: "boolean", field: "present" },
+    level: { type: "number", field: "level" },
+    scale: { type: "number", field: "scale" },
+    voltage: { type: "number", field: "voltage" },
+    temperature: { type: "number", field: "temperature" },
+    technology: { type: "string", field: "technology" },
+    current: { type: "number", field: "current" },
+};
+
+const Status = {
+    Unknown: 1,
+    Charging: 2,
+    Discharging: 3,
+    NotCharging: 4,
+    Full: 5,
+} as const;
+
+const Health = {
+    Unknown: 1,
+    Good: 2,
+    Overheat: 3,
+    Dead: 4,
+    OverVoltage: 5,
+    UnspecifiedFailure: 6,
+    Cold: 7,
+} as const;
+
+const Battery = {
+    Status,
+    Health,
+};
+
 export class DumpSys extends AdbCommandBase {
+    static readonly Battery = Battery;
+
     async diskStats() {
         const output = await this.adb.subprocess.spawnAndWaitLegacy([
             "dumpsys",
@@ -34,96 +90,74 @@ export class DumpSys extends AdbCommandBase {
         };
     }
 
-    async battery() {
+    async battery(): Promise<DumpSys.Battery.Info> {
         const output = await this.adb.subprocess.spawnAndWaitLegacy([
             "dumpsys",
             "battery",
         ]);
 
-        let acPowered = false;
-        let usbPowered = false;
-        let wirelessPowered = false;
-        let level: number | undefined;
-        let scale: number | undefined;
-        let voltage: number | undefined;
-        let current: number | undefined;
-        let status: DumpSys.Battery.Status | undefined;
-        let health: DumpSys.Battery.Health | undefined;
+        const info: DumpSys.Battery.Info = {
+            acPowered: false,
+            usbPowered: false,
+            wirelessPowered: false,
+            dockPowered: false,
+            status: DumpSys.Battery.Status.Unknown,
+            health: DumpSys.Battery.Health.Unknown,
+        };
+
         for (const line of output.split("\n")) {
-            const parts = line.split(":");
+            const parts = line.split(":").map((part) => part.trim());
             if (parts.length !== 2) {
                 continue;
             }
 
-            switch (parts[0]!.trim()) {
-                case "AC powered":
-                    acPowered = parts[1]!.trim() === "true";
-                    break;
-                case "USB powered":
-                    usbPowered = parts[1]!.trim() === "true";
-                    break;
-                case "Wireless powered":
-                    wirelessPowered = parts[1]!.trim() === "true";
-                    break;
-                case "level":
-                    level = Number.parseInt(parts[1]!.trim(), 10);
-                    break;
-                case "scale":
-                    scale = Number.parseInt(parts[1]!.trim(), 10);
-                    break;
-                case "voltage":
-                    voltage = Number.parseInt(parts[1]!.trim(), 10);
-                    break;
-                case "current now":
-                    current = Number.parseInt(parts[1]!.trim(), 10);
+            const field = BatteryDumpFields[parts[0]!];
+            if (!field) {
+                continue;
+            }
+
+            switch (field.type) {
+                case "boolean":
+                    info[field.field] = (parts[1]!.trim() === "true") as never;
                     break;
-                case "status":
-                    status = Number.parseInt(
+                case "number":
+                    info[field.field] = Number.parseInt(
                         parts[1]!.trim(),
                         10,
-                    ) as DumpSys.Battery.Status;
+                    ) as never;
                     break;
-                case "health":
-                    health = Number.parseInt(
-                        parts[1]!.trim(),
-                        10,
-                    ) as DumpSys.Battery.Health;
+                case "string":
+                    info[field.field] = parts[1]! as never;
                     break;
             }
         }
 
-        return {
-            acPowered,
-            usbPowered,
-            wirelessPowered,
-            level,
-            scale,
-            voltage,
-            current,
-            status,
-            health,
-        };
+        return info;
     }
 }
 
 export namespace DumpSys {
     export namespace Battery {
-        export enum Status {
-            Unknown = 1,
-            Charging,
-            Discharging,
-            NotCharging,
-            Full,
-        }
+        export type Status = (typeof Status)[keyof typeof Status];
+        export type Health = (typeof Health)[keyof typeof Health];
 
-        export enum Health {
-            Unknown = 1,
-            Good,
-            Overheat,
-            Dead,
-            OverVoltage,
-            UnspecifiedFailure,
-            Cold,
+        export interface Info {
+            acPowered: boolean;
+            usbPowered: boolean;
+            wirelessPowered: boolean;
+            dockPowered: boolean;
+            maxChargingCurrent?: number;
+            maxChargingVoltage?: number;
+            chargeCounter?: number;
+            status: Status;
+            health: Health;
+            present?: boolean;
+            level?: number;
+            scale?: number;
+            voltage?: number;
+            temperature?: number;
+            technology?: string;
+            current?: number;
         }
     }
 }

package/src/intent.ts

@@ -5,6 +5,7 @@ export class IntentBuilder {
     #component: string | undefined;
     #data: string | undefined;
     #type: string | undefined;
+    #stringExtras = new Map<string, string>();
 
     setAction(action: string): this {
         this.#action = action;
@@ -31,6 +32,11 @@ export class IntentBuilder {
         return this;
     }
 
+    addStringExtra(key: string, value: string): this {
+        this.#stringExtras.set(key, value);
+        return this;
+    }
+
     build(): string[] {
         const result: string[] = [];
 
@@ -58,6 +64,10 @@ export class IntentBuilder {
             result.push("-t", this.#type);
         }
 
+        for (const [key, value] of this.#stringExtras) {
+            result.push("--es", key, value);
+        }
+
         return result;
     }
 }