@yume-chan/android-bin 0.0.18 → 0.0.19

package/src/logcat.ts

@@ -1,18 +1,17 @@
 // cspell: ignore logcat
+// cspell: ignore usec
 
 import { AdbCommandBase, AdbSubprocessNoneProtocol } from "@yume-chan/adb";
+import type { ReadableStream } from "@yume-chan/stream-extra";
 import {
     BufferedTransformStream,
     DecodeUtf8Stream,
     SplitStringStream,
     WrapReadableStream,
     WritableStream,
-    type ReadableStream,
 } from "@yume-chan/stream-extra";
-import Struct, {
-    decodeUtf8,
-    type StructAsyncDeserializeStream,
-} from "@yume-chan/struct";
+import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+import Struct, { decodeUtf8 } from "@yume-chan/struct";
 
 // `adb logcat` is an alias to `adb shell logcat`
 // so instead of adding to core library, it's implemented here
@@ -69,10 +68,11 @@ export enum LogcatFormat {
 }
 
 export interface LogcatFormatModifiers {
-    usec?: boolean;
+    microseconds?: boolean;
+    nanoseconds?: boolean;
     printable?: boolean;
     year?: boolean;
-    zone?: boolean;
+    timezone?: boolean;
     epoch?: boolean;
     monotonic?: boolean;
     uid?: boolean;
@@ -92,44 +92,254 @@ export const LoggerEntry = new Struct({ littleEndian: true })
     .uint16("headerSize")
     .int32("pid")
     .uint32("tid")
-    .uint32("second")
+    .uint32("seconds")
     .uint32("nanoseconds")
     .uint32("logId")
     .uint32("uid")
     .extra({
         get timestamp() {
             return (
-                BigInt(this.second) * NANOSECONDS_PER_SECOND +
+                BigInt(this.seconds) * NANOSECONDS_PER_SECOND +
                 BigInt(this.nanoseconds)
             );
         },
     });
 
-export type LoggerEntry = typeof LoggerEntry["TDeserializeResult"];
+export type LoggerEntry = (typeof LoggerEntry)["TDeserializeResult"];
 
 // https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/logprint.cpp;drc=bbe77d66e7bee8bd1f0bc7e5492b5376b0207ef6;bpv=0
 export interface AndroidLogEntry extends LoggerEntry {
     priority: AndroidLogPriority;
     tag: string;
     message: string;
+
+    toString(format?: LogcatFormat, modifiers?: LogcatFormatModifiers): string;
 }
 
-// https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/logprint.cpp;l=1415;drc=8dbf3b2bb6b6d1652d9797e477b9abd03278bb79
-export function formatAndroidLogEntry(
-    entry: AndroidLogEntry,
-    format: LogcatFormat = LogcatFormat.Brief,
-    modifier?: LogcatFormatModifiers
+function formatSeconds(seconds: number, modifiers: LogcatFormatModifiers) {
+    if (modifiers.monotonic) {
+        return seconds.toString().padStart(6);
+    }
+
+    if (modifiers.epoch) {
+        return seconds.toString().padStart(19);
+    }
+
+    const date = new Date(seconds * 1000);
+
+    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")
+        }`;
+    }
+
+    // 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")
+    }`;
+}
+
+function formatNanoseconds(
+    nanoseconds: number,
+    modifiers: LogcatFormatModifiers
+) {
+    if (modifiers.nanoseconds) {
+        return nanoseconds.toString().padStart(9, "0");
+    }
+
+    if (modifiers.microseconds) {
+        return ((nanoseconds / 1000) | 0).toString().padStart(6, "0");
+    }
+
+    return ((nanoseconds / 1000000) | 0).toString().padStart(3, "0");
+}
+
+function formatTimezone(seconds: number, modifiers: LogcatFormatModifiers) {
+    if (!modifiers.timezone || modifiers.monotonic || modifiers.epoch) {
+        return "";
+    }
+
+    const date = new Date(seconds * 1000);
+    const offset = date.getTimezoneOffset();
+    const sign = offset <= 0 ? "+" : "-";
+    const absolute = Math.abs(offset);
+    const hours = (absolute / 60) | 0;
+    const minutes = absolute % 60;
+
+    // prettier-ignore
+    return ` ${
+        sign
+    }${
+        hours.toString().padStart(2, "0")
+    }:${
+        minutes.toString().padStart(2, "0")
+    }`;
+}
+
+function formatTime(
+    seconds: number,
+    nanoseconds: number,
+    modifiers: LogcatFormatModifiers
+) {
+    const secondsString = formatSeconds(seconds, modifiers);
+    const nanosecondsString = formatNanoseconds(nanoseconds, modifiers);
+    const zoneString = formatTimezone(seconds, modifiers);
+    return `${secondsString}.${nanosecondsString}${zoneString}`;
+}
+
+function formatUid(
+    uid: number,
+    modifiers: LogcatFormatModifiers,
+    suffix: string
 ) {
-    const uid = modifier?.uid ? `${entry.uid.toString().padStart(5)}:` : "";
+    return modifiers.uid ? `${uid.toString().padStart(5)}${suffix}` : "";
+}
 
+function getFormatPrefix(
+    entry: AndroidLogEntry,
+    format: LogcatFormat,
+    modifiers: LogcatFormatModifiers
+) {
+    // https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/logprint.cpp;l=1415;drc=8dbf3b2bb6b6d1652d9797e477b9abd03278bb79
     switch (format) {
         // TODO: implement other formats
+        case LogcatFormat.Tag:
+            // prettier-ignore
+            return `${
+                AndroidLogPriorityToCharacter[entry.priority]
+            }/${
+                entry.tag.padEnd(8)
+            }: `;
+        case LogcatFormat.Process:
+            // prettier-ignore
+            return `${
+                AndroidLogPriorityToCharacter[entry.priority]
+            }(${
+                formatUid(entry.uid, modifiers, ":")
+            }${
+                entry.pid.toString().padStart(5)
+            }) `;
+        case LogcatFormat.Thread:
+            // prettier-ignore
+            return `${
+                AndroidLogPriorityToCharacter[entry.priority]
+            }(${
+                formatUid(entry.uid, modifiers, ":")
+            }${
+                entry.pid.toString().padStart(5)
+            }:${
+                entry.tid.toString().padStart(5)
+            }) `;
+        case LogcatFormat.Raw:
+            return "";
+        case LogcatFormat.Time:
+            // prettier-ignore
+            return `${
+                formatTime(entry.seconds, entry.nanoseconds, modifiers)
+            } ${
+                AndroidLogPriorityToCharacter[entry.priority]
+            }/${
+                entry.tag.padEnd(8)
+            }(${
+                formatUid(entry.uid, modifiers, ":")
+            }${
+                entry.pid.toString().padStart(5)
+            }): `;
+        case LogcatFormat.ThreadTime:
+            // prettier-ignore
+            return `${
+                formatTime(entry.seconds, entry.nanoseconds, modifiers)
+            } ${
+                formatUid(entry.uid, modifiers, " ")
+            }${
+                entry.pid.toString().padStart(5)
+            } ${
+                entry.tid.toString().padStart(5)
+            } ${
+                AndroidLogPriorityToCharacter[entry.priority]
+            } ${
+                entry.tag.toString().padEnd(8)
+            }: `;
+        case LogcatFormat.Brief:
         default:
+            // prettier-ignore
             return `${
                 AndroidLogPriorityToCharacter[entry.priority]
-            }/${entry.tag.padEnd(8)}(${uid}${entry.pid
-                .toString()
-                .padStart(5)}): ${entry.message}`;
+            }/${
+                entry.tag.padEnd(8)
+            }(${
+                formatUid(entry.uid, modifiers, ":")
+            }${
+                entry.pid.toString().padStart(5)
+            }): `;
+    }
+}
+
+function getFormatSuffix(entry: AndroidLogEntry, format: LogcatFormat) {
+    switch (format) {
+        case LogcatFormat.Process:
+            return `  (${entry.tag})`;
+        default:
+            return "";
+    }
+}
+
+function formatEntryWrapLine(
+    entry: AndroidLogEntry,
+    format: LogcatFormat,
+    modifiers: LogcatFormatModifiers
+) {
+    const prefix = getFormatPrefix(entry, format, modifiers);
+    const suffix = getFormatSuffix(entry, format);
+    return (
+        prefix + entry.message.replaceAll("\n", suffix + "\n" + prefix) + suffix
+    );
+}
+
+function AndroidLogEntryToString(
+    this: AndroidLogEntry,
+    format: LogcatFormat = LogcatFormat.ThreadTime,
+    modifiers: LogcatFormatModifiers = {}
+) {
+    switch (format) {
+        case LogcatFormat.Long:
+            // prettier-ignore
+            return `[ ${
+                formatTime(this.seconds, this.nanoseconds, modifiers)
+            } ${
+                formatUid(this.uid, modifiers, ":")
+            }${
+                this.pid.toString().padStart(5)
+            }:${
+                this.tid.toString().padStart(5)
+            } ${
+                AndroidLogPriorityToCharacter[this.priority]
+            }/${
+                this.tag.padEnd(8)
+            } ]\n${
+                this.message
+            }\n`;
+        default:
+            return formatEntryWrapLine(this, format, modifiers);
     }
 }
 
@@ -171,6 +381,7 @@ export async function deserializeAndroidLogEntry(
         tagEnd < payload.length - 1
             ? decodeUtf8(payload.subarray(tagEnd + 1))
             : "";
+    entry.toString = AndroidLogEntryToString;
     return entry;
 }
 
@@ -245,6 +456,7 @@ export class Logcat extends AdbCommandBase {
                                 maxEntrySize: parseInt(match[8]!, 10),
                                 maxPayloadSize: parseInt(match[9]!, 10),
                             });
+                            return;
                         }
 
                         match = chunk.match(Logcat.LOG_SIZE_REGEX_10);

package/src/overlay-display.ts

@@ -0,0 +1,115 @@
+import type { Adb } from "@yume-chan/adb";
+import { AdbCommandBase } from "@yume-chan/adb";
+
+import { Settings } from "./settings.js";
+
+export interface OverlayDisplayDeviceMode {
+    width: number;
+    height: number;
+    density: number;
+}
+
+export interface OverlayDisplayDevice {
+    modes: OverlayDisplayDeviceMode[];
+    secure: boolean;
+    ownContentOnly: boolean;
+    showSystemDecorations: boolean;
+}
+
+export class OverlayDisplay extends AdbCommandBase {
+    private settings: Settings;
+
+    public static readonly OVERLAY_DISPLAY_DEVICES_KEY =
+        "overlay_display_devices";
+
+    constructor(adb: Adb) {
+        super(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;
+    }
+
+    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(
+            "global",
+            OverlayDisplay.OVERLAY_DISPLAY_DEVICES_KEY,
+            settingString
+        );
+    }
+}

package/src/pm.ts

@@ -0,0 +1,281 @@
+// cspell:ignore dont
+// cspell:ignore instantapp
+// cspell:ignore apks
+
+import type { Adb } from "@yume-chan/adb";
+import {
+    AdbCommandBase,
+    AdbSubprocessNoneProtocol,
+    escapeArg,
+} from "@yume-chan/adb";
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+import { DecodeUtf8Stream, WrapReadableStream } from "@yume-chan/stream-extra";
+
+import { Cmd } from "./cmd.js";
+
+export enum PackageManagerInstallLocation {
+    Auto,
+    InternalOnly,
+    PreferExternal,
+}
+
+export enum PackageManagerInstallReason {
+    Unknown,
+    AdminPolicy,
+    DeviceRestore,
+    DeviceSetup,
+    UserRequest,
+}
+
+// https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/pm/PackageManagerShellCommand.java;l=3046;drc=6d14d35d0241f6fee145f8e54ffd77252e8d29fd
+export interface PackageManagerInstallOptions {
+    /**
+     * `-R`
+     */
+    skipExisting: boolean;
+    /**
+     * `-i`
+     */
+    installerPackageName: string;
+    /**
+     * `-t`
+     */
+    allowTest: boolean;
+    /**
+     * `-f`
+     */
+    internalStorage: boolean;
+    /**
+     * `-d`
+     */
+    requestDowngrade: boolean;
+    /**
+     * `-g`
+     */
+    grantRuntimePermissions: boolean;
+    /**
+     * `--restrict-permissions`
+     */
+    restrictPermissions: boolean;
+    /**
+     * `--dont-kill`
+     */
+    doNotKill: boolean;
+    /**
+     * `--originating-uri`
+     */
+    originatingUri: string;
+    /**
+     * `--referrer`
+     */
+    refererUri: string;
+    /**
+     * `-p`
+     */
+    inheritFrom: string;
+    /**
+     * `--pkg`
+     */
+    packageName: string;
+    /**
+     * `--abi`
+     */
+    abi: string;
+    /**
+     * `--ephemeral`/`--instant`/`--instantapp`
+     */
+    instantApp: boolean;
+    /**
+     * `--full`
+     */
+    full: boolean;
+    /**
+     * `--preload`
+     */
+    preload: boolean;
+    /**
+     * `--user`
+     */
+    userId: number;
+    /**
+     * `--install-location`
+     */
+    installLocation: PackageManagerInstallLocation;
+    /**
+     * `--install-reason`
+     */
+    installReason: PackageManagerInstallReason;
+    /**
+     * `--force-uuid`
+     */
+    forceUuid: string;
+    /**
+     * `--apex`
+     */
+    apex: boolean;
+    /**
+     * `--force-non-staged`
+     */
+    forceNonStaged: boolean;
+    /**
+     * `--staged`
+     */
+    staged: boolean;
+    /**
+     * `--force-queryable`
+     */
+    forceQueryable: boolean;
+    /**
+     * `--enable-rollback`
+     */
+    enableRollback: boolean;
+    /**
+     * `--staged-ready-timeout`
+     */
+    stagedReadyTimeout: number;
+    /**
+     * `--skip-verification`
+     */
+    skipVerification: boolean;
+    /**
+     * `--bypass-low-target-sdk-block`
+     */
+    bypassLowTargetSdkBlock: boolean;
+}
+
+export const PACKAGE_MANAGER_INSTALL_OPTIONS_MAP: Record<
+    keyof PackageManagerInstallOptions,
+    string
+> = {
+    skipExisting: "-R",
+    installerPackageName: "-i",
+    allowTest: "-t",
+    internalStorage: "-f",
+    requestDowngrade: "-d",
+    grantRuntimePermissions: "-g",
+    restrictPermissions: "--restrict-permissions",
+    doNotKill: "--dont-kill",
+    originatingUri: "--originating-uri",
+    refererUri: "--referrer",
+    inheritFrom: "-p",
+    packageName: "--pkg",
+    abi: "--abi",
+    instantApp: "--instant",
+    full: "--full",
+    preload: "--preload",
+    userId: "--user",
+    installLocation: "--install-location",
+    installReason: "--install-reason",
+    forceUuid: "--force-uuid",
+    apex: "--apex",
+    forceNonStaged: "--force-non-staged",
+    staged: "--staged",
+    forceQueryable: "--force-queryable",
+    enableRollback: "--enable-rollback",
+    stagedReadyTimeout: "--staged-ready-timeout",
+    skipVerification: "--skip-verification",
+    bypassLowTargetSdkBlock: "--bypass-low-target-sdk-block",
+};
+
+export class PackageManager extends AdbCommandBase {
+    private _cmd: Cmd;
+
+    public constructor(adb: Adb) {
+        super(adb);
+        this._cmd = new Cmd(adb);
+    }
+
+    private buildInstallArgs(
+        options?: Partial<PackageManagerInstallOptions>
+    ): 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;
+    }
+
+    public async install(
+        apks: string[],
+        options?: Partial<PackageManagerInstallOptions>
+    ): Promise<string> {
+        const args = this.buildInstallArgs(options);
+        // WIP: old version of pm doesn't support multiple apks
+        args.push(...apks);
+        return await this.adb.subprocess.spawnAndWaitLegacy(args);
+    }
+
+    public async pushAndInstallStream(
+        stream: ReadableStream<Consumable<Uint8Array>>,
+        options?: Partial<PackageManagerInstallOptions>
+    ): Promise<ReadableStream<string>> {
+        const sync = await this.adb.sync();
+
+        const fileName = Math.random().toString().substring(2);
+        const filePath = `/data/local/tmp/${fileName}.apk`;
+
+        try {
+            await sync.write({
+                filename: filePath,
+                file: stream,
+            });
+        } finally {
+            await sync.dispose();
+        }
+
+        const args = this.buildInstallArgs(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);
+            },
+        });
+    }
+
+    public async installStream(
+        size: number,
+        stream: ReadableStream<Consumable<Uint8Array>>,
+        options?: Partial<PackageManagerInstallOptions>
+    ): Promise<ReadableStream<string>> {
+        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`
+        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());
+    }
+
+    // TODO: install: support split apk formats (`adb install-multiple`)
+}