@yume-chan/android-bin 0.0.20 → 0.0.22

package/src/demo-mode.ts

@@ -52,57 +52,65 @@ export const DemoModeStatusBarModes = [
 export type DemoModeStatusBarMode = (typeof DemoModeStatusBarModes)[number];
 
 export class DemoMode extends AdbCommandBase {
-    private settings: Settings;
+    #settings: Settings;
 
     constructor(adb: Adb) {
         super(adb);
-        this.settings = new Settings(adb);
+        this.#settings = new Settings(adb);
     }
 
-    public static readonly AllowedSettingKey = "sysui_demo_allowed";
+    static readonly ALLOWED_SETTING_KEY = "sysui_demo_allowed";
 
     // Demo Mode actually doesn't have a setting indicates its enablement
     // However Developer Mode menu uses this key
     // So we can only try our best to guess if it's enabled
-    public static readonly EnabledSettingKey = "sysui_tuner_demo_on";
+    static readonly ENABLED_SETTING_KEY = "sysui_tuner_demo_on";
 
-    public async getAllowed(): Promise<boolean> {
-        const output = await this.settings.get(
+    async getAllowed(): Promise<boolean> {
+        const output = await this.#settings.get(
             "global",
-            DemoMode.AllowedSettingKey
+            DemoMode.ALLOWED_SETTING_KEY,
         );
-        return output.trim() === "1";
+        return output === "1";
     }
 
-    public async setAllowed(value: boolean): Promise<void> {
+    async setAllowed(value: boolean): Promise<void> {
         if (value) {
-            await this.settings.put("global", DemoMode.AllowedSettingKey, "1");
+            await this.#settings.put(
+                "global",
+                DemoMode.ALLOWED_SETTING_KEY,
+                "1",
+            );
         } else {
             await this.setEnabled(false);
-            await this.settings.delete("global", DemoMode.AllowedSettingKey);
+            await this.#settings.delete("global", DemoMode.ALLOWED_SETTING_KEY);
         }
     }
 
-    public async getEnabled(): Promise<boolean> {
-        const result = await this.settings.get(
+    async getEnabled(): Promise<boolean> {
+        const result = await this.#settings.get(
             "global",
-            DemoMode.EnabledSettingKey
+            DemoMode.ENABLED_SETTING_KEY,
         );
-        return result.trim() === "1";
+        return result === "1";
     }
 
-    public async setEnabled(value: boolean): Promise<void> {
+    async setEnabled(value: boolean): Promise<void> {
         if (value) {
-            await this.settings.put("global", DemoMode.EnabledSettingKey, "1");
+            await this.#settings.put(
+                "global",
+                DemoMode.ENABLED_SETTING_KEY,
+                "1",
+            );
         } else {
-            await this.settings.delete("global", DemoMode.EnabledSettingKey);
+            await this.#settings.delete("global", DemoMode.ENABLED_SETTING_KEY);
             await this.broadcast("exit");
         }
     }
 
-    public async broadcast(
+    async broadcast(
         command: string,
-        extra?: Record<string, string>
+        extra?: Record<string, string>,
     ): Promise<void> {
         await this.adb.subprocess.spawnAndWaitLegacy([
             "am",
@@ -122,31 +130,27 @@ export class DemoMode extends AdbCommandBase {
         ]);
     }
 
-    public async setBatteryLevel(level: number): Promise<void> {
+    async setBatteryLevel(level: number): Promise<void> {
         await this.broadcast("battery", { level: level.toString() });
     }
 
-    public async setBatteryCharging(value: boolean): Promise<void> {
+    async setBatteryCharging(value: boolean): Promise<void> {
         await this.broadcast("battery", { plugged: value.toString() });
     }
 
-    public async setPowerSaveMode(value: boolean): Promise<void> {
+    async setPowerSaveMode(value: boolean): Promise<void> {
         await this.broadcast("battery", { powersave: value.toString() });
     }
 
-    public async setAirplaneMode(show: boolean): Promise<void> {
+    async setAirplaneMode(show: boolean): Promise<void> {
         await this.broadcast("network", { airplane: show ? "show" : "hide" });
     }
 
-    public async setWifiSignalStrength(
-        value: DemoModeSignalStrength
-    ): Promise<void> {
+    async setWifiSignalStrength(value: DemoModeSignalStrength): Promise<void> {
         await this.broadcast("network", { wifi: "show", level: value });
     }
 
-    public async setMobileDataType(
-        value: DemoModeMobileDataType
-    ): Promise<void> {
+    async setMobileDataType(value: DemoModeMobileDataType): Promise<void> {
         for (let i = 0; i < 2; i += 1) {
             await this.broadcast("network", {
                 mobile: "show",
@@ -164,60 +168,60 @@ export class DemoMode extends AdbCommandBase {
         }
     }
 
-    public async setMobileSignalStrength(
-        value: DemoModeSignalStrength
+    async setMobileSignalStrength(
+        value: DemoModeSignalStrength,
     ): Promise<void> {
         await this.broadcast("network", { mobile: "show", level: value });
     }
 
-    public async setNoSimCardIcon(show: boolean): Promise<void> {
+    async setNoSimCardIcon(show: boolean): Promise<void> {
         await this.broadcast("network", { nosim: show ? "show" : "hide" });
     }
 
-    public async setStatusBarMode(mode: DemoModeStatusBarMode): Promise<void> {
+    async setStatusBarMode(mode: DemoModeStatusBarMode): Promise<void> {
         await this.broadcast("bars", { mode });
     }
 
-    public async setVibrateModeEnabled(value: boolean): Promise<void> {
+    async setVibrateModeEnabled(value: boolean): Promise<void> {
         // https://cs.android.com/android/platform/superproject/+/master:frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/DemoStatusIcons.java;l=103
         await this.broadcast("status", { volume: value ? "vibrate" : "hide" });
     }
 
-    public async setBluetoothConnected(value: boolean): Promise<void> {
+    async setBluetoothConnected(value: boolean): Promise<void> {
         // https://cs.android.com/android/platform/superproject/+/master:frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/DemoStatusIcons.java;l=114
         await this.broadcast("status", {
             bluetooth: value ? "connected" : "hide",
         });
     }
 
-    public async setLocatingIcon(show: boolean): Promise<void> {
+    async setLocatingIcon(show: boolean): Promise<void> {
         await this.broadcast("status", { location: show ? "show" : "hide" });
     }
 
-    public async setAlarmIcon(show: boolean): Promise<void> {
+    async setAlarmIcon(show: boolean): Promise<void> {
         await this.broadcast("status", { alarm: show ? "show" : "hide" });
     }
 
-    public async setSyncingIcon(show: boolean): Promise<void> {
+    async setSyncingIcon(show: boolean): Promise<void> {
         await this.broadcast("status", { sync: show ? "show" : "hide" });
     }
 
-    public async setMuteIcon(show: boolean): Promise<void> {
+    async setMuteIcon(show: boolean): Promise<void> {
         await this.broadcast("status", { mute: show ? "show" : "hide" });
     }
 
-    public async setSpeakerPhoneIcon(show: boolean): Promise<void> {
+    async setSpeakerPhoneIcon(show: boolean): Promise<void> {
         await this.broadcast("status", {
             speakerphone: show ? "show" : "hide",
         });
     }
 
-    public async setNotificationsVisibility(show: boolean): Promise<void> {
+    async setNotificationsVisibility(show: boolean): Promise<void> {
         // https://cs.android.com/android/platform/superproject/+/master:frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java;l=3131
         await this.broadcast("notifications", { visible: show.toString() });
     }
 
-    public async setTime(hour: number, minute: number): Promise<void> {
+    async setTime(hour: number, minute: number): Promise<void> {
         await this.broadcast("clock", {
             // cspell: disable-next-line
             hhmm:

package/src/dumpsys.ts

@@ -0,0 +1,129 @@
+import { AdbCommandBase } from "@yume-chan/adb";
+
+export class DumpSys extends AdbCommandBase {
+    async diskStats() {
+        const output = await this.adb.subprocess.spawnAndWaitLegacy([
+            "dumpsys",
+            "diskstats",
+        ]);
+
+        function getSize(name: string) {
+            const match = output.match(
+                new RegExp(`${name}-Free: (\\d+)K / (\\d+)K`),
+            );
+            if (!match) {
+                return [0, 0];
+            }
+            return [
+                Number.parseInt(match[1]!, 10) * 1024,
+                Number.parseInt(match[2]!, 10) * 1024,
+            ];
+        }
+
+        const [dataFree, dataTotal] = getSize("Data");
+        const [cacheFree, cacheTotal] = getSize("Cache");
+        const [systemFree, systemTotal] = getSize("System");
+
+        return {
+            dataFree,
+            dataTotal,
+            cacheFree,
+            cacheTotal,
+            systemFree,
+            systemTotal,
+        };
+    }
+
+    async battery() {
+        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;
+        for (const line of output.split("\n")) {
+            const parts = line.split(":");
+            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);
+                    break;
+                case "status":
+                    status = Number.parseInt(
+                        parts[1]!.trim(),
+                        10,
+                    ) as DumpSys.Battery.Status;
+                    break;
+                case "health":
+                    health = Number.parseInt(
+                        parts[1]!.trim(),
+                        10,
+                    ) as DumpSys.Battery.Health;
+                    break;
+            }
+        }
+
+        return {
+            acPowered,
+            usbPowered,
+            wirelessPowered,
+            level,
+            scale,
+            voltage,
+            current,
+            status,
+            health,
+        };
+    }
+}
+
+export namespace DumpSys {
+    export namespace Battery {
+        export enum Status {
+            Unknown = 1,
+            Charging,
+            Discharging,
+            NotCharging,
+            Full,
+        }
+
+        export enum Health {
+            Unknown = 1,
+            Good,
+            Overheat,
+            Dead,
+            OverVoltage,
+            UnspecifiedFailure,
+            Cold,
+        }
+    }
+}

package/src/index.ts

@@ -1,8 +1,14 @@
 // cspell: ignore logcat
 
+export * from "./am.js";
+export * from "./bu.js";
 export * from "./bug-report.js";
 export * from "./cmd.js";
 export * from "./demo-mode.js";
+export * from "./dumpsys.js";
+export * from "./intent.js";
 export * from "./logcat.js";
+export * from "./overlay-display.js";
 export * from "./pm.js";
 export * from "./settings.js";
+export * from "./string-format.js";

package/src/intent.ts

@@ -0,0 +1,63 @@
+export class IntentBuilder {
+    #action: string | undefined;
+    #categories: string[] = [];
+    #packageName: string | undefined;
+    #component: string | undefined;
+    #data: string | undefined;
+    #type: string | undefined;
+
+    setAction(action: string): this {
+        this.#action = action;
+        return this;
+    }
+
+    addCategory(category: string): this {
+        this.#categories.push(category);
+        return this;
+    }
+
+    setPackage(packageName: string): this {
+        this.#packageName = packageName;
+        return this;
+    }
+
+    setComponent(component: string): this {
+        this.#component = component;
+        return this;
+    }
+
+    setData(data: string): this {
+        this.#data = data;
+        return this;
+    }
+
+    build(): string[] {
+        const result: string[] = [];
+
+        if (this.#action) {
+            result.push("-a", this.#action);
+        }
+
+        for (const category of this.#categories) {
+            result.push("-c", category);
+        }
+
+        if (this.#packageName) {
+            result.push("-p", this.#packageName);
+        }
+
+        if (this.#component) {
+            result.push("-n", this.#component);
+        }
+
+        if (this.#data) {
+            result.push("-d", this.#data);
+        }
+
+        if (this.#type) {
+            result.push("-t", this.#type);
+        }
+
+        return result;
+    }
+}

package/src/logcat.ts

@@ -80,6 +80,7 @@ export interface LogcatFormatModifiers {
 }
 
 export interface LogcatOptions {
+    dump?: boolean;
     pid?: number;
     ids?: LogId[];
 }
@@ -148,7 +149,7 @@ function formatSeconds(seconds: number, modifiers: LogcatFormatModifiers) {
 
 function formatNanoseconds(
     nanoseconds: number,
-    modifiers: LogcatFormatModifiers
+    modifiers: LogcatFormatModifiers,
 ) {
     if (modifiers.nanoseconds) {
         return padZero(nanoseconds, 9);
@@ -186,7 +187,7 @@ function formatTimezone(seconds: number, modifiers: LogcatFormatModifiers) {
 function formatTime(
     seconds: number,
     nanoseconds: number,
-    modifiers: LogcatFormatModifiers
+    modifiers: LogcatFormatModifiers,
 ) {
     const secondsString = formatSeconds(seconds, modifiers);
     const nanosecondsString = formatNanoseconds(nanoseconds, modifiers);
@@ -197,7 +198,7 @@ function formatTime(
 function formatUid(
     uid: number,
     modifiers: LogcatFormatModifiers,
-    suffix: string
+    suffix: string,
 ) {
     return modifiers.uid ? `${uid.toString().padStart(5)}${suffix}` : "";
 }
@@ -205,7 +206,7 @@ function formatUid(
 function getFormatPrefix(
     entry: AndroidLogEntry,
     format: LogcatFormat,
-    modifiers: LogcatFormatModifiers
+    modifiers: LogcatFormatModifiers,
 ) {
     // https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/logprint.cpp;l=1415;drc=8dbf3b2bb6b6d1652d9797e477b9abd03278bb79
     switch (format) {
@@ -294,7 +295,7 @@ function getFormatSuffix(entry: AndroidLogEntry, format: LogcatFormat) {
 function formatEntryWrapLine(
     entry: AndroidLogEntry,
     format: LogcatFormat,
-    modifiers: LogcatFormatModifiers
+    modifiers: LogcatFormatModifiers,
 ) {
     const prefix = getFormatPrefix(entry, format, modifiers);
     const suffix = getFormatSuffix(entry, format);
@@ -306,7 +307,7 @@ function formatEntryWrapLine(
 function AndroidLogEntryToString(
     this: AndroidLogEntry,
     format: LogcatFormat = LogcatFormat.ThreadTime,
-    modifiers: LogcatFormatModifiers = {}
+    modifiers: LogcatFormatModifiers = {},
 ) {
     switch (format) {
         case LogcatFormat.Long:
@@ -348,7 +349,7 @@ function findTagEnd(payload: Uint8Array) {
 }
 
 export async function deserializeAndroidLogEntry(
-    stream: AsyncExactReadable
+    stream: AsyncExactReadable,
 ): Promise<AndroidLogEntry> {
     const entry = (await LoggerEntry.deserialize(stream)) as AndroidLogEntry;
     if (entry.headerSize !== LoggerEntry.size) {
@@ -382,35 +383,35 @@ export interface LogSize {
 }
 
 export class Logcat extends AdbCommandBase {
-    public static logIdToName(id: LogId): string {
+    static logIdToName(id: LogId): string {
         return LogId[id]!;
     }
 
-    public static logNameToId(name: string): LogId {
+    static logNameToId(name: string): LogId {
         const key = name[0]!.toUpperCase() + name.substring(1);
         return LogId[key as keyof typeof LogId];
     }
 
-    public static joinLogId(ids: LogId[]): string {
+    static joinLogId(ids: LogId[]): string {
         return ids.map((id) => Logcat.logIdToName(id)).join(",");
     }
 
-    public static parseSize(value: number, multiplier: string): number {
+    static parseSize(value: number, multiplier: string): number {
         const MULTIPLIERS = ["", "Ki", "Mi", "Gi"];
         return value * 1024 ** (MULTIPLIERS.indexOf(multiplier) || 0);
     }
 
     // TODO: logcat: Support output format before Android 10
     // ref https://android-review.googlesource.com/c/platform/system/core/+/748128
-    public static readonly LOG_SIZE_REGEX_10 =
+    static readonly LOG_SIZE_REGEX_10 =
         /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed\), max entry is (.*) B, max payload is (.*) B/;
 
     // Android 11 added `readable` part
     // ref https://android-review.googlesource.com/c/platform/system/core/+/1390940
-    public static readonly LOG_SIZE_REGEX_11 =
+    static readonly LOG_SIZE_REGEX_11 =
         /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed, (.*) (.*)B readable\), max entry is (.*) B, max payload is (.*) B/;
 
-    public async getLogSize(ids?: LogId[]): Promise<LogSize[]> {
+    async getLogSize(ids?: LogId[]): Promise<LogSize[]> {
         const { stdout } = await this.adb.subprocess.spawn([
             "logcat",
             "-g",
@@ -430,15 +431,15 @@ export class Logcat extends AdbCommandBase {
                                 id: Logcat.logNameToId(match[1]!),
                                 size: Logcat.parseSize(
                                     Number.parseInt(match[2]!, 10),
-                                    match[3]!
+                                    match[3]!,
                                 ),
                                 readable: Logcat.parseSize(
                                     Number.parseInt(match[6]!, 10),
-                                    match[7]!
+                                    match[7]!,
                                 ),
                                 consumed: Logcat.parseSize(
                                     Number.parseInt(match[4]!, 10),
-                                    match[5]!
+                                    match[5]!,
                                 ),
                                 maxEntrySize: parseInt(match[8]!, 10),
                                 maxPayloadSize: parseInt(match[9]!, 10),
@@ -452,54 +453,56 @@ export class Logcat extends AdbCommandBase {
                                 id: Logcat.logNameToId(match[1]!),
                                 size: Logcat.parseSize(
                                     Number.parseInt(match[2]!, 10),
-                                    match[3]!
+                                    match[3]!,
                                 ),
                                 consumed: Logcat.parseSize(
                                     Number.parseInt(match[4]!, 10),
-                                    match[5]!
+                                    match[5]!,
                                 ),
                                 maxEntrySize: parseInt(match[6]!, 10),
                                 maxPayloadSize: parseInt(match[7]!, 10),
                             });
                         }
                     },
-                })
+                }),
             );
 
         return result;
     }
 
-    public async clear(ids?: LogId[]) {
-        await this.adb.subprocess.spawnAndWait([
-            "logcat",
-            "-c",
-            ...(ids ? ["-b", Logcat.joinLogId(ids)] : []),
-        ]);
+    async clear(ids?: LogId[]) {
+        const args = ["logcat", "-c"];
+        if (ids && ids.length > 0) {
+            args.push("-b", Logcat.joinLogId(ids));
+        }
+
+        await this.adb.subprocess.spawnAndWait(args);
     }
 
-    public binary(options?: LogcatOptions): ReadableStream<AndroidLogEntry> {
+    binary(options?: LogcatOptions): ReadableStream<AndroidLogEntry> {
         return new WrapReadableStream(async () => {
+            const args = ["logcat", "-B"];
+            if (options?.dump) {
+                args.push("-d");
+            }
+            if (options?.pid) {
+                args.push("--pid", options.pid.toString());
+            }
+            if (options?.ids) {
+                args.push("-b", Logcat.joinLogId(options.ids));
+            }
+
             // TODO: make `spawn` return synchronously with streams pending
             // so it's easier to chain them.
-            const { stdout } = await this.adb.subprocess.spawn(
-                [
-                    "logcat",
-                    "-B",
-                    ...(options?.pid ? ["--pid", options.pid.toString()] : []),
-                    ...(options?.ids
-                        ? ["-b", Logcat.joinLogId(options.ids)]
-                        : []),
-                ],
-                {
-                    // PERF: None protocol is 150% faster then Shell protocol
-                    protocols: [AdbSubprocessNoneProtocol],
-                }
-            );
+            const { stdout } = await this.adb.subprocess.spawn(args, {
+                // PERF: None protocol is 150% faster then Shell protocol
+                protocols: [AdbSubprocessNoneProtocol],
+            });
             return stdout;
         }).pipeThrough(
             new BufferedTransformStream((stream) => {
                 return deserializeAndroidLogEntry(stream);
-            })
+            }),
         );
     }
 }