@yume-chan/android-bin 0.0.0-20240714132542

package/src/dumpsys.ts

@@ -0,0 +1,153 @@
+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" },
+};
+
+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(): Promise<DumpSys.Battery.Info> {
+        const output = await this.adb.subprocess.spawnAndWaitLegacy([
+            "dumpsys",
+            "battery",
+        ]);
+
+        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(":").map((part) => part.trim());
+            if (parts.length !== 2) {
+                continue;
+            }
+
+            const field = BatteryDumpFields[parts[0]!];
+            if (!field) {
+                continue;
+            }
+
+            switch (field.type) {
+                case "boolean":
+                    info[field.field] = (parts[1]!.trim() === "true") as never;
+                    break;
+                case "number":
+                    info[field.field] = Number.parseInt(
+                        parts[1]!.trim(),
+                        10,
+                    ) as never;
+                    break;
+                case "string":
+                    info[field.field] = parts[1]! as never;
+                    break;
+            }
+        }
+
+        return info;
+    }
+}
+
+export namespace DumpSys {
+    export namespace Battery {
+        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;
+        }
+
+        export enum Status {
+            Unknown = 1,
+            Charging,
+            Discharging,
+            NotCharging,
+            Full,
+        }
+
+        export enum Health {
+            Unknown = 1,
+            Good,
+            Overheat,
+            Dead,
+            OverVoltage,
+            UnspecifiedFailure,
+            Cold,
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +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,73 @@
+export class IntentBuilder {
+    #action: string | undefined;
+    #categories: string[] = [];
+    #packageName: string | undefined;
+    #component: string | undefined;
+    #data: string | undefined;
+    #type: string | undefined;
+    #stringExtras = new Map<string, string>();
+
+    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;
+    }
+
+    addStringExtra(key: string, value: string): this {
+        this.#stringExtras.set(key, value);
+        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);
+        }
+
+        for (const [key, value] of this.#stringExtras) {
+            result.push("--es", key, value);
+        }
+
+        return result;
+    }
+}