@yume-chan/android-bin 0.0.19 → 0.0.21

package/src/overlay-display.ts

@@ -2,6 +2,7 @@ import type { Adb } from "@yume-chan/adb";
 import { AdbCommandBase } from "@yume-chan/adb";
 
 import { Settings } from "./settings.js";
+import { p } from "./string-format.js";
 
 export interface OverlayDisplayDeviceMode {
     width: number;
@@ -17,99 +18,95 @@ export interface OverlayDisplayDevice {
 }
 
 export class OverlayDisplay extends AdbCommandBase {
-    private settings: Settings;
-
-    public static readonly OVERLAY_DISPLAY_DEVICES_KEY =
-        "overlay_display_devices";
+    #settings: Settings;
+
+    static readonly SETTING_KEY = "overlay_display_devices";
+
+    static readonly SETTING_FORMAT = p.separated(
+        ";",
+        p.sequence(
+            {
+                name: "modes",
+                format: p.separated(
+                    "|",
+                    p.sequence(
+                        { name: "width", format: p.digits() },
+                        p.literal("x"),
+                        { name: "height", format: p.digits() },
+                        p.literal("/"),
+                        { name: "density", format: p.digits() },
+                    ),
+                    1,
+                ),
+            },
+            {
+                name: "flags",
+                format: p.map(
+                    p.repeated(
+                        p.sequence(p.literal(","), {
+                            name: "flag",
+                            format: p.union(
+                                p.literal("secure"),
+                                p.literal("own_content_only"),
+                                p.literal("show_system_decorations"),
+                            ),
+                        }),
+                    ),
+                    (value) => value.map((item) => item.flag),
+                    (value) => value.map((item) => ({ flag: item })),
+                ),
+            },
+        ),
+    );
 
     constructor(adb: Adb) {
         super(adb);
-        this.settings = new Settings(adb);
+        this.#settings = new Settings(adb);
     }
 
-    public async get() {
-        const devices: OverlayDisplayDevice[] = [];
-
-        const settingString = await this.settings.get(
-            "global",
-            OverlayDisplay.OVERLAY_DISPLAY_DEVICES_KEY
-        );
-
-        for (const displayString of settingString.split(";")) {
-            const [modesString, ...flagStrings] = displayString.split(",");
-
-            if (!modesString) {
-                continue;
-            }
-
-            const device: OverlayDisplayDevice = {
-                modes: [],
-                secure: false,
-                ownContentOnly: false,
-                showSystemDecorations: false,
-            };
-            for (const modeString of modesString.split("|")) {
-                const match = modeString.match(/(\d+)x(\d+)\/(\d+)/);
-                if (!match) {
-                    continue;
-                }
-                device.modes.push({
-                    width: parseInt(match[1]!, 10),
-                    height: parseInt(match[2]!, 10),
-                    density: parseInt(match[3]!, 10),
-                });
-            }
-            if (device.modes.length === 0) {
-                continue;
-            }
-
-            for (const flagString of flagStrings) {
-                switch (flagString) {
-                    case "secure":
-                        device.secure = true;
-                        break;
-                    case "own_content_only":
-                        device.ownContentOnly = true;
-                        break;
-                    case "show_system_decorations":
-                        device.showSystemDecorations = true;
-                        break;
-                }
-            }
-            devices.push(device);
-        }
-
-        return devices;
+    async get() {
+        return OverlayDisplay.SETTING_FORMAT.parse({
+            value: await this.#settings.get(
+                "global",
+                OverlayDisplay.SETTING_KEY,
+            ),
+            position: 0,
+        }).map((device) => ({
+            modes: device.modes,
+            secure: device.flags.includes("secure"),
+            ownContentOnly: device.flags.includes("own_content_only"),
+            showSystemDecorations: device.flags.includes(
+                "show_system_decorations",
+            ),
+        }));
     }
 
-    public async set(devices: OverlayDisplayDevice[]) {
-        let settingString = "";
-        for (const device of devices) {
-            if (settingString) {
-                settingString += ";";
-            }
-
-            settingString += device.modes
-                .map((mode) => `${mode.width}x${mode.height}/${mode.density}`)
-                .join("|");
-
-            if (device.secure) {
-                settingString += ",secure";
-            }
-
-            if (device.ownContentOnly) {
-                settingString += ",own_content_only";
-            }
-
-            if (device.showSystemDecorations) {
-                settingString += ",show_system_decorations";
-            }
-        }
-
-        await this.settings.put(
+    async set(devices: OverlayDisplayDevice[]) {
+        await this.#settings.put(
             "global",
-            OverlayDisplay.OVERLAY_DISPLAY_DEVICES_KEY,
-            settingString
+            OverlayDisplay.SETTING_KEY,
+            OverlayDisplay.SETTING_FORMAT.stringify(
+                devices.map((device) => {
+                    const flags: (
+                        | "secure"
+                        | "own_content_only"
+                        | "show_system_decorations"
+                    )[] = [];
+                    if (device.secure) {
+                        flags.push("secure");
+                    }
+                    if (device.ownContentOnly) {
+                        flags.push("own_content_only");
+                    }
+                    if (device.showSystemDecorations) {
+                        flags.push("show_system_decorations");
+                    }
+                    return {
+                        modes: device.modes,
+                        flags,
+                    };
+                }),
+            ),
         );
     }
 }

package/src/pm.ts

@@ -177,25 +177,65 @@ export const PACKAGE_MANAGER_INSTALL_OPTIONS_MAP: Record<
     bypassLowTargetSdkBlock: "--bypass-low-target-sdk-block",
 };
 
+export interface PackageManagerListPackagesOptions {
+    listDisabled: boolean;
+    listEnabled: boolean;
+    showSourceDir: boolean;
+    showInstaller: boolean;
+    listSystem: boolean;
+    showUid: boolean;
+    listThirdParty: boolean;
+    showVersionCode: boolean;
+    listApexOnly: boolean;
+    user: "all" | "current" | number;
+    uid: number;
+    filter: string;
+}
+
+export const PACKAGE_MANAGER_LIST_PACKAGES_OPTIONS_MAP: Record<
+    keyof PackageManagerListPackagesOptions,
+    string
+> = {
+    listDisabled: "-d",
+    listEnabled: "-e",
+    showSourceDir: "-f",
+    showInstaller: "-i",
+    listSystem: "-s",
+    showUid: "-U",
+    listThirdParty: "-3",
+    showVersionCode: "--show-versioncode",
+    listApexOnly: "--apex-only",
+    user: "--user",
+    uid: "--uid",
+    filter: "",
+};
+
+export interface PackageManagerListPackagesResult {
+    packageName: string;
+    sourceDir?: string | undefined;
+    versionCode?: number | undefined;
+    installer?: string | undefined;
+    uid?: number | undefined;
+}
+
 export class PackageManager extends AdbCommandBase {
-    private _cmd: Cmd;
+    #cmd: Cmd;
 
-    public constructor(adb: Adb) {
+    constructor(adb: Adb) {
         super(adb);
-        this._cmd = new Cmd(adb);
+        this.#cmd = new Cmd(adb);
     }
 
-    private buildInstallArgs(
-        options?: Partial<PackageManagerInstallOptions>
+    #buildArguments<T>(
+        commands: string[],
+        options: Partial<T> | undefined,
+        map: Record<keyof T, string>,
     ): string[] {
-        const args = ["pm", "install"];
+        const args = ["pm", ...commands];
         if (options) {
             for (const [key, value] of Object.entries(options)) {
                 if (value) {
-                    const option =
-                        PACKAGE_MANAGER_INSTALL_OPTIONS_MAP[
-                            key as keyof PackageManagerInstallOptions
-                        ];
+                    const option = map[key as keyof T];
                     if (option) {
                         args.push(option);
                         switch (typeof value) {
@@ -213,19 +253,29 @@ export class PackageManager extends AdbCommandBase {
         return args;
     }
 
-    public async install(
+    #buildInstallArguments(
+        options: Partial<PackageManagerInstallOptions> | undefined,
+    ): string[] {
+        return this.#buildArguments(
+            ["install"],
+            options,
+            PACKAGE_MANAGER_INSTALL_OPTIONS_MAP,
+        );
+    }
+
+    async install(
         apks: string[],
-        options?: Partial<PackageManagerInstallOptions>
+        options?: Partial<PackageManagerInstallOptions>,
     ): Promise<string> {
-        const args = this.buildInstallArgs(options);
+        const args = this.#buildInstallArguments(options);
         // WIP: old version of pm doesn't support multiple apks
         args.push(...apks);
         return await this.adb.subprocess.spawnAndWaitLegacy(args);
     }
 
-    public async pushAndInstallStream(
+    async pushAndInstallStream(
         stream: ReadableStream<Consumable<Uint8Array>>,
-        options?: Partial<PackageManagerInstallOptions>
+        options?: Partial<PackageManagerInstallOptions>,
     ): Promise<ReadableStream<string>> {
         const sync = await this.adb.sync();
 
@@ -241,11 +291,15 @@ export class PackageManager extends AdbCommandBase {
             await sync.dispose();
         }
 
-        const args = this.buildInstallArgs(options);
+        // Starting from Android 7, `pm` is a only wrapper for `cmd package`,
+        // and `cmd package` launches faster than `pm`.
+        // But `cmd package` can't read `/data/local/tmp` folder due to SELinux policy,
+        // so installing a file must use `pm`.
+        const args = this.#buildInstallArguments(options);
         args.push(filePath);
         const process = await AdbSubprocessNoneProtocol.raw(
             this.adb,
-            args.map(escapeArg).join(" ")
+            args.map(escapeArg).join(" "),
         );
         return new WrapReadableStream({
             start: () => process.stdout.pipeThrough(new DecodeUtf8Stream()),
@@ -255,27 +309,95 @@ export class PackageManager extends AdbCommandBase {
         });
     }
 
-    public async installStream(
+    async installStream(
         size: number,
         stream: ReadableStream<Consumable<Uint8Array>>,
-        options?: Partial<PackageManagerInstallOptions>
+        options?: Partial<PackageManagerInstallOptions>,
     ): Promise<ReadableStream<string>> {
-        if (!this._cmd.supportsCmd) {
+        // Android 7 added both `cmd` command and streaming install support,
+        // we can't detect whether `pm` supports streaming install,
+        // so we detect `cmd` command support instead.
+        if (!this.#cmd.supportsCmd) {
             return this.pushAndInstallStream(stream, options);
         }
 
-        // Android 7 added `cmd package` and piping apk to stdin,
-        // the source code suggests using `cmd package` over `pm`, but didn't say why.
-        // However, `cmd package install` can't read `/data/local/tmp` folder due to SELinux policy,
-        // so even ADB today is still using `pm install` for non-streaming installs.
-        const args = this.buildInstallArgs(options);
-        // Remove `pm` from args, final command will be `cmd package install`
+        const args = this.#buildInstallArguments(options);
+        // Remove `pm` from args, final command will starts with `cmd package install`
         args.shift();
         args.push("-S", size.toString());
-        const process = await this._cmd.spawn(false, "package", ...args);
+        const process = await this.#cmd.spawn(false, "package", ...args);
         await stream.pipeTo(process.stdin);
         return process.stdout.pipeThrough(new DecodeUtf8Stream());
     }
 
+    static parsePackageListItem(
+        line: string,
+    ): PackageManagerListPackagesResult {
+        line = line.substring("package:".length);
+
+        let packageName: string;
+        let sourceDir: string | undefined;
+        let versionCode: number | undefined;
+        let installer: string | undefined;
+        let uid: number | undefined;
+
+        // Parse backwards
+        let index = line.indexOf(" uid:");
+        if (index !== -1) {
+            uid = Number.parseInt(line.substring(index + " uid:".length), 10);
+            line = line.substring(0, index);
+        }
+
+        index = line.indexOf(" installer=");
+        if (index !== -1) {
+            installer = line.substring(index + " installer=".length);
+            line = line.substring(0, index);
+        }
+
+        index = line.indexOf(" versionCode:");
+        if (index !== -1) {
+            versionCode = Number.parseInt(
+                line.substring(index + " versionCode:".length),
+                10,
+            );
+            line = line.substring(0, index);
+        }
+
+        // `sourceDir` may contain `=` so use `lastIndexOf`
+        index = line.lastIndexOf("=");
+        if (index !== -1) {
+            sourceDir = line.substring(0, index);
+            packageName = line.substring(index + "=".length);
+        } else {
+            packageName = line;
+        }
+
+        return {
+            packageName,
+            sourceDir,
+            versionCode,
+            installer,
+            uid,
+        };
+    }
+
+    async listPackages(
+        options?: Partial<PackageManagerListPackagesOptions>,
+    ): Promise<PackageManagerListPackagesResult[]> {
+        const args = this.#buildArguments(
+            ["list", "packages"],
+            options,
+            PACKAGE_MANAGER_LIST_PACKAGES_OPTIONS_MAP,
+        );
+        if (options?.filter) {
+            args.push(options.filter);
+        }
+        const output = await this.adb.subprocess.spawnAndWaitLegacy(args);
+        return output
+            .split("\n")
+            .filter((line) => !!line)
+            .map((line) => PackageManager.parsePackageListItem(line));
+    }
+
     // TODO: install: support split apk formats (`adb install-multiple`)
 }

package/src/settings.ts

@@ -1,78 +1,127 @@
+import type { Adb, AdbSubprocessWaitResult } from "@yume-chan/adb";
 import { AdbCommandBase } from "@yume-chan/adb";
 
+import { Cmd } from "./cmd.js";
+
 export type SettingsNamespace = "system" | "secure" | "global";
 
-export type SettingsResetMode =
-    | "untrusted_defaults"
-    | "untrusted_clear"
-    | "trusted_defaults";
+export enum SettingsResetMode {
+    UntrustedDefaults = "untrusted_defaults",
+    UntrustedClear = "untrusted_clear",
+    TrustedDefaults = "trusted_defaults",
+}
+
+export interface SettingsOptions {
+    user?: number | "current";
+}
+
+export interface SettingsPutOptions extends SettingsOptions {
+    tag?: string;
+    makeDefault?: boolean;
+}
 
 // frameworks/base/packages/SettingsProvider/src/com/android/providers/settings/SettingsService.java
 export class Settings extends AdbCommandBase {
-    // TODO: `--user <user>` argument
+    #cmd: Cmd;
 
-    public base(
-        command: string,
+    constructor(adb: Adb) {
+        super(adb);
+        this.#cmd = new Cmd(adb);
+    }
+
+    async base(
+        verb: string,
         namespace: SettingsNamespace,
+        options: SettingsOptions | undefined,
         ...args: string[]
-    ) {
-        return this.adb.subprocess.spawnAndWaitLegacy([
-            "settings",
-            command,
-            namespace,
-            ...args,
-        ]);
+    ): Promise<string> {
+        let command = ["settings"];
+
+        if (options?.user !== undefined) {
+            command.push("--user", options.user.toString());
+        }
+
+        command.push(verb, namespace);
+        command = command.concat(args);
+
+        let output: AdbSubprocessWaitResult;
+        if (this.#cmd.supportsCmd) {
+            output = await this.#cmd.spawnAndWait(
+                command[0]!,
+                ...command.slice(1),
+            );
+        } else {
+            output = await this.adb.subprocess.spawnAndWait(command);
+        }
+
+        if (output.stderr) {
+            throw new Error(output.stderr);
+        }
+
+        return output.stdout;
     }
 
-    public get(namespace: SettingsNamespace, key: string) {
-        return this.base("get", namespace, key);
+    async get(
+        namespace: SettingsNamespace,
+        key: string,
+        options?: SettingsOptions,
+    ) {
+        const output = await this.base("get", namespace, options, key);
+        // Remove last \n
+        return output.substring(0, output.length - 1);
     }
 
-    public delete(namespace: SettingsNamespace, key: string) {
-        return this.base("delete", namespace, key);
+    async delete(
+        namespace: SettingsNamespace,
+        key: string,
+        options?: SettingsOptions,
+    ): Promise<void> {
+        await this.base("delete", namespace, options, key);
     }
 
-    public put(
+    async put(
         namespace: SettingsNamespace,
         key: string,
         value: string,
-        tag?: string,
-        makeDefault?: boolean
-    ) {
-        return this.base(
-            "put",
-            namespace,
-            key,
-            value,
-            ...(tag ? [tag] : []),
-            ...(makeDefault ? ["default"] : [])
-        );
+        options?: SettingsPutOptions,
+    ): Promise<void> {
+        const args = [key, value];
+        if (options?.tag) {
+            args.push(options.tag);
+        }
+        if (options?.makeDefault) {
+            args.push("default");
+        }
+        await this.base("put", namespace, options, ...args);
     }
 
-    public reset(
+    reset(
         namespace: SettingsNamespace,
-        mode: SettingsResetMode
-    ): Promise<string>;
-    public reset(
+        mode: SettingsResetMode,
+        options?: SettingsOptions,
+    ): Promise<void>;
+    reset(
         namespace: SettingsNamespace,
         packageName: string,
-        tag?: string
-    ): Promise<string>;
-    public reset(
+        tag?: string,
+        options?: SettingsOptions,
+    ): Promise<void>;
+    async reset(
         namespace: SettingsNamespace,
         modeOrPackageName: string,
-        tag?: string
-    ): Promise<string> {
-        return this.base(
-            "reset",
-            namespace,
-            modeOrPackageName,
-            ...(tag ? [tag] : [])
-        );
-    }
-
-    public async list(namespace: SettingsNamespace): Promise<string[]> {
-        const output = await this.base("list", namespace);
-        return output.split("\n");
+        tagOrOptions?: string | SettingsOptions,
+        options?: SettingsOptions,
+    ): Promise<void> {
+        const args = [modeOrPackageName];
+        if (
+            modeOrPackageName === SettingsResetMode.UntrustedDefaults ||
+            modeOrPackageName === SettingsResetMode.UntrustedClear ||
+            modeOrPackageName === SettingsResetMode.TrustedDefaults
+        ) {
+            options = tagOrOptions as SettingsOptions;
+        } else if (typeof tagOrOptions === "string") {
+            args.push(tagOrOptions);
+        }
+        await this.base("reset", namespace, options, ...args);
     }
 }