@yume-chan/android-bin 0.0.20 → 0.0.22

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

@@ -1,6 +1,7 @@
 // cspell:ignore dont
 // cspell:ignore instantapp
 // cspell:ignore apks
+// cspell:ignore versioncode
 
 import type { Adb } from "@yume-chan/adb";
 import {
@@ -9,9 +10,16 @@ import {
     escapeArg,
 } from "@yume-chan/adb";
 import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
-import { DecodeUtf8Stream, WrapReadableStream } from "@yume-chan/stream-extra";
+import {
+    ConcatStringStream,
+    DecodeUtf8Stream,
+    SplitStringStream,
+} from "@yume-chan/stream-extra";
 
 import { Cmd } from "./cmd.js";
+import type { IntentBuilder } from "./intent.js";
+import type { SingleUserOrAll } from "./utils.js";
+import { buildArguments } from "./utils.js";
 
 export enum PackageManagerInstallLocation {
     Auto,
@@ -96,7 +104,7 @@ export interface PackageManagerInstallOptions {
     /**
      * `--user`
      */
-    userId: number;
+    user: SingleUserOrAll;
     /**
      * `--install-location`
      */
@@ -163,7 +171,7 @@ export const PACKAGE_MANAGER_INSTALL_OPTIONS_MAP: Record<
     instantApp: "--instant",
     full: "--full",
     preload: "--preload",
-    userId: "--user",
+    user: "--user",
     installLocation: "--install-location",
     installReason: "--install-reason",
     forceUuid: "--force-uuid",
@@ -177,56 +185,107 @@ 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: SingleUserOrAll;
+    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 interface PackageManagerUninstallOptions {
+    keepData: boolean;
+    user: SingleUserOrAll;
+    versionCode: number;
+    splitNames: string[];
+}
+
+const PACKAGE_MANAGER_UNINSTALL_OPTIONS_MAP: Record<
+    keyof PackageManagerUninstallOptions,
+    string
+> = {
+    keepData: "-k",
+    user: "--user",
+    versionCode: "--versionCode",
+    splitNames: "",
+};
+
+export interface PackageManagerResolveActivityOptions {
+    user?: SingleUserOrAll;
+    intent: IntentBuilder;
+}
+
+const PACKAGE_MANAGER_RESOLVE_ACTIVITY_OPTIONS_MAP: Partial<
+    Record<keyof PackageManagerResolveActivityOptions, string>
+> = {
+    user: "--user",
+};
+
 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>
+    #buildInstallArguments(
+        options: Partial<PackageManagerInstallOptions> | undefined,
     ): string[] {
-        const args = ["pm", "install"];
-        if (options) {
-            for (const [key, value] of Object.entries(options)) {
-                if (value) {
-                    const option =
-                        PACKAGE_MANAGER_INSTALL_OPTIONS_MAP[
-                            key as keyof PackageManagerInstallOptions
-                        ];
-                    if (option) {
-                        args.push(option);
-                        switch (typeof value) {
-                            case "number":
-                                args.push(value.toString());
-                                break;
-                            case "string":
-                                args.push(value);
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        return args;
+        return buildArguments(
+            ["pm", "install"],
+            options,
+            PACKAGE_MANAGER_INSTALL_OPTIONS_MAP,
+        );
     }
 
-    public async install(
+    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>
-    ): Promise<ReadableStream<string>> {
+        options?: Partial<PackageManagerInstallOptions>,
+    ): Promise<void> {
         const sync = await this.adb.sync();
 
         const fileName = Math.random().toString().substring(2);
@@ -241,41 +300,195 @@ export class PackageManager extends AdbCommandBase {
             await sync.dispose();
         }
 
-        const args = this.buildInstallArgs(options);
+        // Starting from Android 7, `pm` is only a 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(" ")
-        );
-        return new WrapReadableStream({
-            start: () => process.stdout.pipeThrough(new DecodeUtf8Stream()),
-            close: async () => {
-                await this.adb.rm(filePath);
-            },
+        const process = await this.adb.subprocess.spawn(args.map(escapeArg), {
+            protocols: [AdbSubprocessNoneProtocol],
         });
+
+        const output = await process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new ConcatStringStream())
+            .then((output) => output.trim());
+
+        await this.adb.rm(filePath);
+
+        if (output !== "Success") {
+            throw new Error(output);
+        }
     }
 
-    public async installStream(
+    async installStream(
         size: number,
         stream: ReadableStream<Consumable<Uint8Array>>,
-        options?: Partial<PackageManagerInstallOptions>
-    ): Promise<ReadableStream<string>> {
-        if (!this._cmd.supportsCmd) {
-            return this.pushAndInstallStream(stream, options);
+        options?: Partial<PackageManagerInstallOptions>,
+    ): Promise<void> {
+        // 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) {
+            await this.pushAndInstallStream(stream, options);
+            return;
         }
 
-        // 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);
-        await stream.pipeTo(process.stdin);
-        return process.stdout.pipeThrough(new DecodeUtf8Stream());
+        const process = await this.#cmd.spawn(false, "package", ...args);
+
+        const output = process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new ConcatStringStream())
+            .then((output) => output.trim());
+
+        await Promise.all([
+            stream.pipeTo(process.stdin),
+            output.then((output) => {
+                if (output !== "Success") {
+                    throw new Error(output);
+                }
+            }),
+        ]);
     }
 
     // TODO: install: support split apk formats (`adb install-multiple`)
+
+    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 #cmdOrSubprocess(args: string[]) {
+        if (this.#cmd.supportsCmd) {
+            args.shift();
+            return await this.#cmd.spawn(false, "package", ...args);
+        }
+
+        return this.adb.subprocess.spawn(args);
+    }
+
+    async *listPackages(
+        options?: Partial<PackageManagerListPackagesOptions>,
+    ): AsyncGenerator<PackageManagerListPackagesResult, void, void> {
+        const args = buildArguments(
+            ["pm", "list", "packages"],
+            options,
+            PACKAGE_MANAGER_LIST_PACKAGES_OPTIONS_MAP,
+        );
+        if (options?.filter) {
+            args.push(options.filter);
+        }
+
+        const process = await this.#cmdOrSubprocess(args);
+        const reader = process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new SplitStringStream("\n"))
+            .getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            yield PackageManager.parsePackageListItem(value);
+        }
+    }
+
+    async uninstall(
+        packageName: string,
+        options?: Partial<PackageManagerUninstallOptions>,
+    ): Promise<void> {
+        const args = buildArguments(
+            ["pm", "uninstall"],
+            options,
+            PACKAGE_MANAGER_UNINSTALL_OPTIONS_MAP,
+        );
+        args.push(packageName);
+        if (options?.splitNames) {
+            args.push(...options.splitNames);
+        }
+
+        const process = await this.#cmdOrSubprocess(args);
+        const output = await process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new ConcatStringStream())
+            .then((output) => output.trim());
+        if (output !== "Success") {
+            throw new Error(output);
+        }
+    }
+
+    async resolveActivity(
+        options: PackageManagerResolveActivityOptions,
+    ): Promise<string | undefined> {
+        let args = buildArguments(
+            ["pm", "resolve-activity", "--components"],
+            options,
+            PACKAGE_MANAGER_RESOLVE_ACTIVITY_OPTIONS_MAP,
+        );
+
+        args = args.concat(options.intent.build());
+
+        const process = await this.#cmdOrSubprocess(args);
+        const output = await process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new ConcatStringStream())
+            .then((output) => output.trim());
+
+        if (output === "No activity found") {
+            return undefined;
+        }
+
+        return output;
+    }
 }