@yume-chan/android-bin 0.0.21 → 0.0.23

package/src/pm.ts

@@ -1,17 +1,21 @@
 // cspell:ignore dont
 // cspell:ignore instantapp
 // cspell:ignore apks
+// cspell:ignore versioncode
 
 import type { Adb } from "@yume-chan/adb";
-import {
-    AdbCommandBase,
-    AdbSubprocessNoneProtocol,
-    escapeArg,
-} from "@yume-chan/adb";
+import { AdbCommandBase, 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 +100,7 @@ export interface PackageManagerInstallOptions {
     /**
      * `--user`
      */
-    userId: number;
+    user: SingleUserOrAll;
     /**
      * `--install-location`
      */
@@ -163,7 +167,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",
@@ -187,7 +191,7 @@ export interface PackageManagerListPackagesOptions {
     listThirdParty: boolean;
     showVersionCode: boolean;
     listApexOnly: boolean;
-    user: "all" | "current" | number;
+    user: SingleUserOrAll;
     uid: number;
     filter: string;
 }
@@ -218,6 +222,39 @@ export interface PackageManagerListPackagesResult {
     uid?: number | undefined;
 }
 
+export interface PackageManagerUninstallOptions {
+    keepData: boolean;
+    user: SingleUserOrAll;
+    versionCode: number;
+    /**
+     * Only remove the specified splits, not the entire app
+     *
+     * On Android 10 and lower, only one split name can be specified.
+     */
+    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 {
     #cmd: Cmd;
 
@@ -226,48 +263,32 @@ export class PackageManager extends AdbCommandBase {
         this.#cmd = new Cmd(adb);
     }
 
-    #buildArguments<T>(
-        commands: string[],
-        options: Partial<T> | undefined,
-        map: Record<keyof T, string>,
-    ): string[] {
-        const args = ["pm", ...commands];
-        if (options) {
-            for (const [key, value] of Object.entries(options)) {
-                if (value) {
-                    const option = map[key as keyof T];
-                    if (option) {
-                        args.push(option);
-                        switch (typeof value) {
-                            case "number":
-                                args.push(value.toString());
-                                break;
-                            case "string":
-                                args.push(value);
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        return args;
-    }
-
     #buildInstallArguments(
+        command: string,
         options: Partial<PackageManagerInstallOptions> | undefined,
     ): string[] {
-        return this.#buildArguments(
-            ["install"],
+        const args = buildArguments(
+            ["pm", command],
             options,
             PACKAGE_MANAGER_INSTALL_OPTIONS_MAP,
         );
+        if (!options?.skipExisting) {
+            // Compatibility with old versions of pm
+            args.push("-r");
+        }
+        return args;
     }
 
+    /**
+     * Install the apk file.
+     *
+     * @param apks Path to the apk file. It must exist on the device. On Android 10 and lower, only one apk can be specified.
+     */
     async install(
         apks: string[],
         options?: Partial<PackageManagerInstallOptions>,
     ): Promise<string> {
-        const args = this.#buildInstallArguments(options);
+        const args = this.#buildInstallArguments("install", options);
         // WIP: old version of pm doesn't support multiple apks
         args.push(...apks);
         return await this.adb.subprocess.spawnAndWaitLegacy(args);
@@ -276,7 +297,7 @@ export class PackageManager extends AdbCommandBase {
     async pushAndInstallStream(
         stream: ReadableStream<Consumable<Uint8Array>>,
         options?: Partial<PackageManagerInstallOptions>,
-    ): Promise<ReadableStream<string>> {
+    ): Promise<void> {
         const sync = await this.adb.sync();
 
         const fileName = Math.random().toString().substring(2);
@@ -291,43 +312,58 @@ export class PackageManager extends AdbCommandBase {
             await sync.dispose();
         }
 
-        // Starting from Android 7, `pm` is a only wrapper for `cmd package`,
+        // 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);
+        const args = this.#buildInstallArguments("install", 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);
-            },
-        });
+
+        try {
+            const output = await this.adb.subprocess
+                .spawnAndWaitLegacy(args.map(escapeArg))
+                .then((output) => output.trim());
+
+            if (output !== "Success") {
+                throw new Error(output);
+            }
+        } finally {
+            await this.adb.rm(filePath);
+        }
     }
 
     async installStream(
         size: number,
         stream: ReadableStream<Consumable<Uint8Array>>,
         options?: Partial<PackageManagerInstallOptions>,
-    ): Promise<ReadableStream<string>> {
+    ): 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) {
-            return this.pushAndInstallStream(stream, options);
+            await this.pushAndInstallStream(stream, options);
+            return;
         }
 
-        const args = this.#buildInstallArguments(options);
+        const args = this.#buildInstallArguments("install", 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 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);
+                }
+            }),
+        ]);
     }
 
     static parsePackageListItem(
@@ -381,23 +417,229 @@ export class PackageManager extends AdbCommandBase {
         };
     }
 
-    async listPackages(
+    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>,
-    ): Promise<PackageManagerListPackagesResult[]> {
-        const args = this.#buildArguments(
-            ["list", "packages"],
+    ): 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 output = await this.adb.subprocess.spawnAndWaitLegacy(args);
-        return output
-            .split("\n")
-            .filter((line) => !!line)
-            .map((line) => PackageManager.parsePackageListItem(line));
+
+        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);
+        }
     }
 
-    // TODO: install: support split apk formats (`adb install-multiple`)
+    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;
+    }
+
+    /**
+     * Creates a new install session.
+     *
+     * Install sessions are used to install apps with multiple splits, but it can also be used to install a single apk.
+     *
+     * Install sessions was added in Android 5.0 (API level 21).
+     *
+     * @param options Options for the install session
+     * @returns ID of the new install session
+     */
+    async sessionCreate(options?: Partial<PackageManagerInstallOptions>) {
+        const args = this.#buildInstallArguments("install-create", options);
+
+        const process = await this.#cmdOrSubprocess(args);
+        const output = await process.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(new ConcatStringStream())
+            .then((output) => output.trim());
+
+        const sessionIdString = output.match(/.*\[(\d+)\].*/);
+        if (!sessionIdString) {
+            throw new Error("Failed to create install session");
+        }
+
+        return Number.parseInt(sessionIdString[1]!, 10);
+    }
+
+    async sessionAddSplit(sessionId: number, splitName: string, path: string) {
+        const args: string[] = [
+            "pm",
+            "install-write",
+            sessionId.toString(),
+            splitName,
+            path,
+        ];
+
+        const output = await this.adb.subprocess
+            .spawnAndWaitLegacy(args)
+            .then((output) => output.trim());
+        if (!output.startsWith("Success")) {
+            throw new Error(output);
+        }
+    }
+
+    async sessionAddSplitStream(
+        sessionId: number,
+        splitName: string,
+        size: number,
+        stream: ReadableStream<Consumable<Uint8Array>>,
+    ) {
+        const args: string[] = [
+            "pm",
+            "install-write",
+            "-S",
+            size.toString(),
+            sessionId.toString(),
+            splitName,
+            "-",
+        ];
+
+        const process = await this.#cmdOrSubprocess(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.startsWith("Success")) {
+                    throw new Error(output);
+                }
+            }),
+        ]);
+    }
+
+    async sessionCommit(sessionId: number) {
+        const args: string[] = ["pm", "install-commit", sessionId.toString()];
+        const output = await this.adb.subprocess
+            .spawnAndWaitLegacy(args)
+            .then((output) => output.trim());
+        if (output !== "Success") {
+            throw new Error(output);
+        }
+    }
+
+    async sessionAbandon(sessionId: number) {
+        const args: string[] = ["pm", "install-abandon", sessionId.toString()];
+        const output = await this.adb.subprocess
+            .spawnAndWaitLegacy(args)
+            .then((output) => output.trim());
+        if (output !== "Success") {
+            throw new Error(output);
+        }
+    }
+}
+
+export class PackageManagerInstallSession {
+    static async create(
+        packageManager: PackageManager,
+        options?: Partial<PackageManagerInstallOptions>,
+    ) {
+        const id = await packageManager.sessionCreate(options);
+        return new PackageManagerInstallSession(packageManager, id);
+    }
+
+    #packageManager: PackageManager;
+
+    #id: number;
+    get id() {
+        return this.#id;
+    }
+
+    constructor(packageManager: PackageManager, id: number) {
+        this.#packageManager = packageManager;
+        this.#id = id;
+    }
+
+    addSplit(splitName: string, path: string) {
+        return this.#packageManager.sessionAddSplit(this.#id, splitName, path);
+    }
+
+    addSplitStream(
+        splitName: string,
+        size: number,
+        stream: ReadableStream<Consumable<Uint8Array>>,
+    ) {
+        return this.#packageManager.sessionAddSplitStream(
+            this.#id,
+            splitName,
+            size,
+            stream,
+        );
+    }
+
+    commit() {
+        return this.#packageManager.sessionCommit(this.#id);
+    }
+
+    abandon() {
+        return this.#packageManager.sessionAbandon(this.#id);
+    }
 }

package/src/settings.ts

@@ -2,6 +2,7 @@ import type { Adb, AdbSubprocessWaitResult } from "@yume-chan/adb";
 import { AdbCommandBase } from "@yume-chan/adb";
 
 import { Cmd } from "./cmd.js";
+import type { SingleUser } from "./utils.js";
 
 export type SettingsNamespace = "system" | "secure" | "global";
 
@@ -12,7 +13,7 @@ export enum SettingsResetMode {
 }
 
 export interface SettingsOptions {
-    user?: number | "current";
+    user?: SingleUser;
 }
 
 export interface SettingsPutOptions extends SettingsOptions {

package/src/utils.ts

@@ -0,0 +1,29 @@
+export function buildArguments<T>(
+    commands: string[],
+    options: Partial<T> | undefined,
+    map: Partial<Record<keyof T, string>>,
+): string[] {
+    const args = commands;
+    if (options) {
+        for (const [key, value] of Object.entries(options)) {
+            if (value) {
+                const option = map[key as keyof T];
+                if (option) {
+                    args.push(option);
+                    switch (typeof value) {
+                        case "number":
+                            args.push(value.toString());
+                            break;
+                        case "string":
+                            args.push(value);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    return args;
+}
+
+export type SingleUser = number | "current";
+export type SingleUserOrAll = SingleUser | "all";