@yume-chan/android-bin 0.0.19 → 0.0.21

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,91 @@
+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;
+        for (const line of output) {
+            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;
+            }
+        }
+
+        return {
+            acPowered,
+            usbPowered,
+            wirelessPowered,
+            level,
+            scale,
+            voltage,
+            current,
+        };
+    }
+}

package/src/index.ts

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

package/src/logcat.ts

@@ -10,7 +10,7 @@ import {
     WrapReadableStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
-import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+import type { AsyncExactReadable } from "@yume-chan/struct";
 import Struct, { decodeUtf8 } from "@yume-chan/struct";
 
 // `adb logcat` is an alias to `adb shell logcat`
@@ -80,6 +80,7 @@ export interface LogcatFormatModifiers {
 }
 
 export interface LogcatOptions {
+    dump?: boolean;
     pid?: number;
     ids?: LogId[];
 }
@@ -116,61 +117,49 @@ export interface AndroidLogEntry extends LoggerEntry {
     toString(format?: LogcatFormat, modifiers?: LogcatFormatModifiers): string;
 }
 
+function padZero(number: number, length: number) {
+    return number.toString().padStart(length, "0");
+}
+
 function formatSeconds(seconds: number, modifiers: LogcatFormatModifiers) {
     if (modifiers.monotonic) {
-        return seconds.toString().padStart(6);
+        return padZero(seconds, 6);
     }
 
     if (modifiers.epoch) {
-        return seconds.toString().padStart(19);
+        return padZero(seconds, 19);
     }
 
     const date = new Date(seconds * 1000);
 
+    const month = padZero(date.getMonth() + 1, 2);
+    const day = padZero(date.getDate(), 2);
+    const hour = padZero(date.getHours(), 2);
+    const minute = padZero(date.getMinutes(), 2);
+    const second = padZero(date.getSeconds(), 2);
+    const result = `${month}-${day} ${hour}:${minute}:${second}`;
+
     if (modifiers.year) {
-        // prettier-ignore
-        return `${
-            date.getFullYear().toString().padStart(4, "0")
-        }-${
-            (date.getMonth() + 1).toString().padStart(2, "0")
-        }-${
-            date.getDate().toString().padStart(2, "0")
-        } ${
-            date.getHours().toString().padStart(2, "0")
-        }:${
-            date.getMinutes().toString().padStart(2, "0")
-        }:${
-            date.getSeconds().toString().padStart(2, "0")
-        }`;
+        const year = padZero(date.getFullYear(), 4);
+        return `${year}-${result}`;
     }
 
-    // prettier-ignore
-    return `${
-        (date.getMonth() + 1).toString().padStart(2, "0")
-    }-${
-        date.getDate().toString().padStart(2, "0")
-    } ${
-        date.getHours().toString().padStart(2, "0")
-    }:${
-        date.getMinutes().toString().padStart(2, "0")
-    }:${
-        date.getSeconds().toString().padStart(2, "0")
-    }`;
+    return result;
 }
 
 function formatNanoseconds(
     nanoseconds: number,
-    modifiers: LogcatFormatModifiers
+    modifiers: LogcatFormatModifiers,
 ) {
     if (modifiers.nanoseconds) {
-        return nanoseconds.toString().padStart(9, "0");
+        return padZero(nanoseconds, 9);
     }
 
     if (modifiers.microseconds) {
-        return ((nanoseconds / 1000) | 0).toString().padStart(6, "0");
+        return padZero(nanoseconds / 1000, 6);
     }
 
-    return ((nanoseconds / 1000000) | 0).toString().padStart(3, "0");
+    return padZero(nanoseconds / 1000000, 3);
 }
 
 function formatTimezone(seconds: number, modifiers: LogcatFormatModifiers) {
@@ -198,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);
@@ -209,7 +198,7 @@ function formatTime(
 function formatUid(
     uid: number,
     modifiers: LogcatFormatModifiers,
-    suffix: string
+    suffix: string,
 ) {
     return modifiers.uid ? `${uid.toString().padStart(5)}${suffix}` : "";
 }
@@ -217,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) {
@@ -306,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);
@@ -318,7 +307,7 @@ function formatEntryWrapLine(
 function AndroidLogEntryToString(
     this: AndroidLogEntry,
     format: LogcatFormat = LogcatFormat.ThreadTime,
-    modifiers: LogcatFormatModifiers = {}
+    modifiers: LogcatFormatModifiers = {},
 ) {
     switch (format) {
         case LogcatFormat.Long:
@@ -360,15 +349,14 @@ function findTagEnd(payload: Uint8Array) {
 }
 
 export async function deserializeAndroidLogEntry(
-    stream: StructAsyncDeserializeStream
+    stream: AsyncExactReadable,
 ): Promise<AndroidLogEntry> {
-    const entry = (await LoggerEntry.deserialize(
-        stream
-    )) as unknown as AndroidLogEntry;
+    const entry = (await LoggerEntry.deserialize(stream)) as AndroidLogEntry;
     if (entry.headerSize !== LoggerEntry.size) {
-        await stream.read(entry.headerSize - LoggerEntry.size);
+        await stream.readExactly(entry.headerSize - LoggerEntry.size);
     }
-    let payload = await stream.read(entry.payloadSize);
+
+    let payload = await stream.readExactly(entry.payloadSize);
 
     // https://cs.android.com/android/platform/superproject/+/master:system/logging/logcat/logcat.cpp;l=193-194;drc=bbe77d66e7bee8bd1f0bc7e5492b5376b0207ef6
     // TODO: payload for some log IDs are in binary format.
@@ -395,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",
@@ -443,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),
@@ -465,24 +453,24 @@ 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[]) {
+    async clear(ids?: LogId[]) {
         await this.adb.subprocess.spawnAndWait([
             "logcat",
             "-c",
@@ -490,29 +478,30 @@ export class Logcat extends AdbCommandBase {
         ]);
     }
 
-    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);
-            })
+            }),
         );
     }
 }