@yume-chan/android-bin 0.0.17 → 0.0.19

package/src/logcat.ts

@@ -1,8 +1,17 @@
 // cspell: ignore logcat
-
-import { AdbCommandBase, AdbSubprocessNoneProtocol } from '@yume-chan/adb';
-import { BufferedTransformStream, DecodeUtf8Stream, SplitStringStream, WrapReadableStream, WritableStream, type ReadableStream } from '@yume-chan/stream-extra';
-import Struct, { decodeUtf8, StructAsyncDeserializeStream } from '@yume-chan/struct';
+// cspell: ignore usec
+
+import { AdbCommandBase, AdbSubprocessNoneProtocol } from "@yume-chan/adb";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import {
+    BufferedTransformStream,
+    DecodeUtf8Stream,
+    SplitStringStream,
+    WrapReadableStream,
+    WritableStream,
+} from "@yume-chan/stream-extra";
+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
@@ -34,17 +43,18 @@ export enum AndroidLogPriority {
 }
 
 // https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/logprint.cpp;l=140;drc=8dbf3b2bb6b6d1652d9797e477b9abd03278bb79
-export const AndroidLogPriorityToCharacter: Record<AndroidLogPriority, string> = {
-    [AndroidLogPriority.Unknown]: '?',
-    [AndroidLogPriority.Default]: '?',
-    [AndroidLogPriority.Verbose]: 'V',
-    [AndroidLogPriority.Debug]: 'D',
-    [AndroidLogPriority.Info]: 'I',
-    [AndroidLogPriority.Warn]: 'W',
-    [AndroidLogPriority.Error]: 'E',
-    [AndroidLogPriority.Fatal]: 'F',
-    [AndroidLogPriority.Silent]: 'S',
-};
+export const AndroidLogPriorityToCharacter: Record<AndroidLogPriority, string> =
+    {
+        [AndroidLogPriority.Unknown]: "?",
+        [AndroidLogPriority.Default]: "?",
+        [AndroidLogPriority.Verbose]: "V",
+        [AndroidLogPriority.Debug]: "D",
+        [AndroidLogPriority.Info]: "I",
+        [AndroidLogPriority.Warn]: "W",
+        [AndroidLogPriority.Error]: "E",
+        [AndroidLogPriority.Fatal]: "F",
+        [AndroidLogPriority.Silent]: "S",
+    };
 
 export enum LogcatFormat {
     Brief,
@@ -54,14 +64,15 @@ export enum LogcatFormat {
     Raw,
     Time,
     ThreadTime,
-    Long
+    Long,
 }
 
 export interface LogcatFormatModifiers {
-    usec?: boolean;
+    microseconds?: boolean;
+    nanoseconds?: boolean;
     printable?: boolean;
     year?: boolean;
-    zone?: boolean;
+    timezone?: boolean;
     epoch?: boolean;
     monotonic?: boolean;
     uid?: boolean;
@@ -76,55 +87,271 @@ export interface LogcatOptions {
 const NANOSECONDS_PER_SECOND = BigInt(1e9);
 
 // https://cs.android.com/android/platform/superproject/+/master:system/logging/liblog/include/log/log_read.h;l=39;drc=82b5738732161dbaafb2e2f25cce19cd26b9157d
-export const LoggerEntry =
-    new Struct({ littleEndian: true })
-        .uint16('payloadSize')
-        .uint16('headerSize')
-        .int32('pid')
-        .uint32('tid')
-        .uint32('second')
-        .uint32('nanoseconds')
-        .uint32('logId')
-        .uint32('uid')
-        .extra({
-            get timestamp() {
-                return BigInt(this.second) * NANOSECONDS_PER_SECOND + BigInt(this.nanoseconds);
-            },
-        });
-
-export type LoggerEntry = typeof LoggerEntry['TDeserializeResult'];
+export const LoggerEntry = new Struct({ littleEndian: true })
+    .uint16("payloadSize")
+    .uint16("headerSize")
+    .int32("pid")
+    .uint32("tid")
+    .uint32("seconds")
+    .uint32("nanoseconds")
+    .uint32("logId")
+    .uint32("uid")
+    .extra({
+        get timestamp() {
+            return (
+                BigInt(this.seconds) * NANOSECONDS_PER_SECOND +
+                BigInt(this.nanoseconds)
+            );
+        },
+    });
+
+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
 ) {
-    const uid = modifier?.uid ? `${entry.uid.toString().padStart(5)}:` : '';
+    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
+) {
+    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)
+            }(${
+                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 `${AndroidLogPriorityToCharacter[entry.priority]}/${entry.tag.padEnd(8)}(${uid}${entry.pid.toString().padStart(5)}): ${entry.message}`;
+            return formatEntryWrapLine(this, format, modifiers);
     }
 }
 
 function findTagEnd(payload: Uint8Array) {
-    for (const separator of [0, ' '.charCodeAt(0), ':'.charCodeAt(0)]) {
+    for (const separator of [0, " ".charCodeAt(0), ":".charCodeAt(0)]) {
         const index = payload.indexOf(separator);
         if (index !== -1) {
             return index;
         }
     }
 
-    const index = payload.findIndex(x => x >= 0x7f);
+    const index = payload.findIndex((x) => x >= 0x7f);
     if (index !== -1) {
         return index;
     }
@@ -132,8 +359,12 @@ function findTagEnd(payload: Uint8Array) {
     return payload.length;
 }
 
-export async function deserializeAndroidLogEntry(stream: StructAsyncDeserializeStream): Promise<AndroidLogEntry> {
-    const entry = await LoggerEntry.deserialize(stream) as unknown as AndroidLogEntry;
+export async function deserializeAndroidLogEntry(
+    stream: StructAsyncDeserializeStream
+): Promise<AndroidLogEntry> {
+    const entry = (await LoggerEntry.deserialize(
+        stream
+    )) as unknown as AndroidLogEntry;
     if (entry.headerSize !== LoggerEntry.size) {
         await stream.read(entry.headerSize - LoggerEntry.size);
     }
@@ -146,7 +377,11 @@ export async function deserializeAndroidLogEntry(stream: StructAsyncDeserializeS
     payload = payload.subarray(1);
     const tagEnd = findTagEnd(payload);
     entry.tag = decodeUtf8(payload.subarray(0, tagEnd));
-    entry.message = tagEnd < payload.length - 1 ? decodeUtf8(payload.subarray(tagEnd + 1)) : '';
+    entry.message =
+        tagEnd < payload.length - 1
+            ? decodeUtf8(payload.subarray(tagEnd + 1))
+            : "";
+    entry.toString = AndroidLogEntryToString;
     return entry;
 }
 
@@ -166,72 +401,92 @@ export class Logcat extends AdbCommandBase {
 
     public static logNameToId(name: string): LogId {
         const key = name[0]!.toUpperCase() + name.substring(1);
-        return (LogId as any)[key];
+        return LogId[key as keyof typeof LogId];
     }
 
     public static joinLogId(ids: LogId[]): string {
-        return ids.map(id => Logcat.logIdToName(id)).join(',');
+        return ids.map((id) => Logcat.logIdToName(id)).join(",");
     }
 
     public static parseSize(value: number, multiplier: string): number {
-        const MULTIPLIERS = ['', 'Ki', 'Mi', 'Gi'];
+        const MULTIPLIERS = ["", "Ki", "Mi", "Gi"];
         return value * 1024 ** (MULTIPLIERS.indexOf(multiplier) || 0);
     }
 
     // TODO: logcat: Support output format before Android 10
     // ref https://android-review.googlesource.com/c/platform/system/core/+/748128
-    public static readonly LOG_SIZE_REGEX_10 = /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed\), max entry is (.*) B, max payload is (.*) B/;
+    public static readonly LOG_SIZE_REGEX_10 =
+        /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed\), max entry is (.*) B, max payload is (.*) B/;
 
     // Android 11 added `readable` part
     // ref https://android-review.googlesource.com/c/platform/system/core/+/1390940
-    public static readonly LOG_SIZE_REGEX_11 = /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed, (.*) (.*)B readable\), max entry is (.*) B, max payload is (.*) B/;
+    public static readonly LOG_SIZE_REGEX_11 =
+        /(.*): ring buffer is (.*) (.*)B \((.*) (.*)B consumed, (.*) (.*)B readable\), max entry is (.*) B, max payload is (.*) B/;
 
     public async getLogSize(ids?: LogId[]): Promise<LogSize[]> {
         const { stdout } = await this.adb.subprocess.spawn([
-            'logcat',
-            '-g',
-            ...(ids ? ['-b', Logcat.joinLogId(ids)] : [])
+            "logcat",
+            "-g",
+            ...(ids ? ["-b", Logcat.joinLogId(ids)] : []),
         ]);
 
         const result: LogSize[] = [];
         await stdout
             .pipeThrough(new DecodeUtf8Stream())
-            .pipeThrough(new SplitStringStream('\n'))
-            .pipeTo(new WritableStream({
-                write(chunk) {
-                    let match = chunk.match(Logcat.LOG_SIZE_REGEX_11);
-                    if (match) {
-                        result.push({
-                            id: Logcat.logNameToId(match[1]!),
-                            size: Logcat.parseSize(Number.parseInt(match[2]!, 10), match[3]!),
-                            readable: Logcat.parseSize(Number.parseInt(match[6]!, 10), match[7]!),
-                            consumed: Logcat.parseSize(Number.parseInt(match[4]!, 10), match[5]!),
-                            maxEntrySize: parseInt(match[8]!, 10),
-                            maxPayloadSize: parseInt(match[9]!, 10),
-                        });
-                    }
-
-                    match = chunk.match(Logcat.LOG_SIZE_REGEX_10);
-                    if (match) {
-                        result.push({
-                            id: Logcat.logNameToId(match[1]!),
-                            size: Logcat.parseSize(Number.parseInt(match[2]!, 10), match[3]!),
-                            consumed: Logcat.parseSize(Number.parseInt(match[4]!, 10), match[5]!),
-                            maxEntrySize: parseInt(match[6]!, 10),
-                            maxPayloadSize: parseInt(match[7]!, 10),
-                        });
-                    }
-                },
-            }));
+            .pipeThrough(new SplitStringStream("\n"))
+            .pipeTo(
+                new WritableStream({
+                    write(chunk) {
+                        let match = chunk.match(Logcat.LOG_SIZE_REGEX_11);
+                        if (match) {
+                            result.push({
+                                id: Logcat.logNameToId(match[1]!),
+                                size: Logcat.parseSize(
+                                    Number.parseInt(match[2]!, 10),
+                                    match[3]!
+                                ),
+                                readable: Logcat.parseSize(
+                                    Number.parseInt(match[6]!, 10),
+                                    match[7]!
+                                ),
+                                consumed: Logcat.parseSize(
+                                    Number.parseInt(match[4]!, 10),
+                                    match[5]!
+                                ),
+                                maxEntrySize: parseInt(match[8]!, 10),
+                                maxPayloadSize: parseInt(match[9]!, 10),
+                            });
+                            return;
+                        }
+
+                        match = chunk.match(Logcat.LOG_SIZE_REGEX_10);
+                        if (match) {
+                            result.push({
+                                id: Logcat.logNameToId(match[1]!),
+                                size: Logcat.parseSize(
+                                    Number.parseInt(match[2]!, 10),
+                                    match[3]!
+                                ),
+                                consumed: Logcat.parseSize(
+                                    Number.parseInt(match[4]!, 10),
+                                    match[5]!
+                                ),
+                                maxEntrySize: parseInt(match[6]!, 10),
+                                maxPayloadSize: parseInt(match[7]!, 10),
+                            });
+                        }
+                    },
+                })
+            );
 
         return result;
     }
 
     public async clear(ids?: LogId[]) {
         await this.adb.subprocess.spawnAndWait([
-            'logcat',
-            '-c',
-            ...(ids ? ['-b', Logcat.joinLogId(ids)] : []),
+            "logcat",
+            "-c",
+            ...(ids ? ["-b", Logcat.joinLogId(ids)] : []),
         ]);
     }
 
@@ -239,18 +494,25 @@ export class Logcat extends AdbCommandBase {
         return new WrapReadableStream(async () => {
             // TODO: make `spawn` return synchronously with streams pending
             // so it's easier to chain them.
-            const { stdout } = await this.adb.subprocess.spawn([
-                'logcat',
-                '-B',
-                ...(options?.pid ? ['--pid', options.pid.toString()] : []),
-                ...(options?.ids ? ['-b', Logcat.joinLogId(options.ids)] : [])
-            ], {
-                // PERF: None protocol is 150% faster then Shell protocol
-                protocols: [AdbSubprocessNoneProtocol],
-            });
+            const { stdout } = await this.adb.subprocess.spawn(
+                [
+                    "logcat",
+                    "-B",
+                    ...(options?.pid ? ["--pid", options.pid.toString()] : []),
+                    ...(options?.ids
+                        ? ["-b", Logcat.joinLogId(options.ids)]
+                        : []),
+                ],
+                {
+                    // PERF: None protocol is 150% faster then Shell protocol
+                    protocols: [AdbSubprocessNoneProtocol],
+                }
+            );
             return stdout;
-        }).pipeThrough(new BufferedTransformStream(stream => {
-            return deserializeAndroidLogEntry(stream);
-        }));
+        }).pipeThrough(
+            new BufferedTransformStream((stream) => {
+                return deserializeAndroidLogEntry(stream);
+            })
+        );
     }
 }

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
+        );
+    }
+}