currentactivity 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Zech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# currentactivity
+> A command line tool to display the current activity for android
+
+## Feature
+1. show current window package name and activity name.
+2. show current display activity stack.
+3. show current display fragments in focused activity.
+
+## Installation
+
+```
+npm install -g currentactivity
+```
+
+## Preamble
+
+To use this cli tool, you need to install [adb](https://developer.android.com/studio/command-line/adb) first. If If you are using Mac OS, you can use homebrew to install adb.
+
+```
+brew install android-platform-tools
+```
+
+## Usage
+Exec `currentactivity` in your terminal.
+```
+currentactivity
+```
+That's it.
+
+## Changelog
+
+* 1.0.0
+  * Initial version
+
+## License
+
+MIT
+

package/build/extension.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+if (!Array.prototype.last) {
+    Array.prototype.last = function (n) {
+        return this[this.length - 1 - n];
+    };
+}
+if (!String.prototype.removeLast) {
+    String.prototype.removeLast = function (n) {
+        const end = this.length - n;
+        return this.substring(0, end);
+    };
+}

package/build/index.js

@@ -0,0 +1,303 @@
+#! /usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const table_1 = require("table");
+const treeify_1 = require("treeify");
+require("./extension");
+function printDumpInfo() {
+    var _a, _b, _c, _d, _e, _f;
+    return __awaiter(this, void 0, void 0, function* () {
+        // exec adb shell dumpsys window displays
+        const windowOutput = (0, child_process_1.execSync)("adb shell dumpsys window displays", {
+            encoding: "utf-8",
+        });
+        const windowLines = windowOutput.split("\n");
+        const currentFocusLine = findFirstLines(windowLines, "mCurrentFocus");
+        const currentWindow = (_b = (_a = currentFocusLine === null || currentFocusLine === void 0 ? void 0 : currentFocusLine.split(" ")) === null || _a === void 0 ? void 0 : _a.last(0)) === null || _b === void 0 ? void 0 : _b.removeLast(1);
+        const currentFocusAppLine = findFirstLines(windowLines, "mFocusedApp");
+        const currentActivity = (_c = currentFocusAppLine === null || currentFocusAppLine === void 0 ? void 0 : currentFocusAppLine.split(" ")) === null || _c === void 0 ? void 0 : _c.last(1);
+        const stackId = (_e = (_d = currentFocusAppLine === null || currentFocusAppLine === void 0 ? void 0 : currentFocusAppLine.split(" ")) === null || _d === void 0 ? void 0 : _d.last(0)) === null || _e === void 0 ? void 0 : _e.removeLast(1);
+        const currentApp = (_f = currentActivity === null || currentActivity === void 0 ? void 0 : currentActivity.split("/")) === null || _f === void 0 ? void 0 : _f.at(0);
+        const frameworkFragmentLines = Array();
+        const androidxFragmentLines = Array();
+        if (currentApp != undefined) {
+            const activityOutput = (0, child_process_1.execSync)("adb shell dumpsys activity " + currentApp, { encoding: "utf-8" });
+            const activityLines = activityOutput.split("\n");
+            // 1. find top activity
+            const activitesLines = findLines(activityLines, "ACTIVITY");
+            let sliceStart = 0;
+            let sliceEnd = activityLines.length - 1;
+            activitesLines.forEach((v, index) => {
+                if (currentActivity && v.content.indexOf(currentActivity) > 0) {
+                    sliceStart = v.index;
+                    if (index + 1 <= activitesLines.length - 1) {
+                        sliceEnd = activitesLines[index + 1].index;
+                    }
+                }
+            });
+            // 2. cut out the top activity lines
+            const topActivityLines = activityLines.slice(sliceStart, sliceEnd);
+            // 3. split into framework fragments and androidx fragments
+            const splitLine = findLastLines(topActivityLines, "Local FragmentActivity");
+            let frameworkLines;
+            let androidxLines;
+            if (splitLine != undefined) {
+                const splitLineIndex = topActivityLines.indexOf(splitLine);
+                frameworkLines = topActivityLines.slice(0, splitLineIndex);
+                androidxLines = topActivityLines.slice(splitLineIndex);
+            }
+            else {
+                frameworkLines = topActivityLines;
+            }
+            // 4. find all children of between "Active Fragments" and "Added Fragments" node
+            const frameworkRangeLines = findRangeLines(frameworkLines, "Active Fragments", "Added Fragments");
+            frameworkRangeLines.sort((a, b) => a.start.index - b.start.index);
+            frameworkRangeLines.forEach((v) => {
+                const firstFragmentLine = frameworkLines === null || frameworkLines === void 0 ? void 0 : frameworkLines.at(v.start.index + 1);
+                if (firstFragmentLine) {
+                    frameworkFragmentLines.push({
+                        content: firstFragmentLine,
+                        index: v.start.index + 1,
+                    });
+                }
+                frameworkLines === null || frameworkLines === void 0 ? void 0 : frameworkLines.forEach((item, index) => {
+                    if (firstFragmentLine &&
+                        spaceCount(item) == spaceCount(firstFragmentLine) &&
+                        index > v.start.index + 1 &&
+                        index < v.end.index) {
+                        frameworkFragmentLines.push({ content: item, index: index });
+                    }
+                });
+            });
+            if (androidxLines) {
+                const androidxRangeLines = findRangeLines(androidxLines, "Active Fragments", "Added Fragments");
+                androidxRangeLines.sort((a, b) => a.start.index - b.start.index);
+                androidxRangeLines.forEach((v) => {
+                    const firstFragmentLine = androidxLines === null || androidxLines === void 0 ? void 0 : androidxLines.at(v.start.index + 1);
+                    if (firstFragmentLine) {
+                        androidxFragmentLines.push({
+                            content: firstFragmentLine,
+                            index: v.start.index + 1,
+                        });
+                    }
+                    androidxLines === null || androidxLines === void 0 ? void 0 : androidxLines.forEach((item, index) => {
+                        if (firstFragmentLine &&
+                            spaceCount(item) == spaceCount(firstFragmentLine) &&
+                            index > v.start.index + 1 &&
+                            index < v.end.index) {
+                            androidxFragmentLines.push({ content: item, index: index });
+                        }
+                    });
+                });
+            }
+        }
+        console.clear();
+        // print current window
+        if (currentWindow) {
+            const windowTable = Array();
+            windowTable.push([currentWindow]);
+            console.log((0, table_1.table)(windowTable, {
+                header: { content: "current window", alignment: "center" },
+            }));
+        }
+        // print current activity stack
+        if (stackId != undefined) {
+            const stackLines = windowLines.filter((v) => {
+                const s = v.trim();
+                return s.startsWith("*") && s.indexOf(stackId) > 0;
+            });
+            const stacks = stackLines.map((v) => v.trim().split(" ")[3]);
+            if (stacks[0] != currentActivity) {
+                stacks.shift();
+            }
+            const statckTable = Array();
+            stacks.forEach((v) => statckTable.push([v]));
+            console.log("\n");
+            console.log((0, table_1.table)(statckTable, {
+                header: { content: "activity stack", alignment: "center" },
+            }));
+        }
+        // print current fragments which in focused activity
+        if (frameworkFragmentLines.length > 0 || androidxFragmentLines.length > 0) {
+            const fragmentTable = Array();
+            if (frameworkFragmentLines.length > 0) {
+                frameworkFragmentLines.sort((a, b) => a.index - b.index);
+                fragmentTable.push([
+                    "framework fragments",
+                    (0, treeify_1.asTree)(toTreeObject(listToTree(toTreeArray(frameworkFragmentLines))), true),
+                ]);
+            }
+            if (androidxFragmentLines.length > 0) {
+                androidxFragmentLines.sort((a, b) => a.index - b.index);
+                fragmentTable.push([
+                    "androidx fragments",
+                    (0, treeify_1.asTree)(toTreeObject(listToTree(toTreeArray(androidxFragmentLines))), true),
+                ]);
+            }
+            console.log("\n");
+            console.log((0, table_1.table)(fragmentTable, {
+                header: { content: "fragments", alignment: "center" },
+            }));
+        }
+    });
+}
+function toTreeArray(arr) {
+    const result = Array();
+    arr.forEach((v, index) => {
+        result.push({
+            id: index.toString(),
+            content: v.content.trim(),
+            parentId: findParentIndex(arr.map((item) => item.content), v.content)
+                .toString(),
+            children: null,
+        });
+    });
+    return result;
+}
+function findParentIndex(arr, target) {
+    const targetIndex = arr.indexOf(target);
+    if (targetIndex < 0)
+        return -1;
+    let parentIndex = -1;
+    for (let index = targetIndex; index >= 0; index--) {
+        const element = arr[index];
+        if (spaceCount(element) < spaceCount(target)) {
+            parentIndex = index;
+            break;
+        }
+    }
+    return parentIndex;
+}
+function findParent(arr, target) {
+    const targetIndex = arr.indexOf(target);
+    if (targetIndex < 0)
+        return undefined;
+    let parent = undefined;
+    for (let index = targetIndex; index >= 0; index--) {
+        const element = arr[index];
+        if (spaceCount(element) < spaceCount(target)) {
+            parent = element;
+            break;
+        }
+    }
+    return parent;
+}
+function listToTree(arr) {
+    var _a;
+    const map = {};
+    let node;
+    const roots = Array();
+    for (let index = 0; index < arr.length; index++) {
+        map[arr[index].id] = index;
+        arr[index].children = [];
+    }
+    for (let index = 0; index < arr.length; index++) {
+        node = arr[index];
+        if (node.parentId !== "-1") {
+            // if you have dangling branches check that map[node.parentId] exists
+            (_a = arr[map[node.parentId]].children) === null || _a === void 0 ? void 0 : _a.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+function toTreeObject(arr) {
+    const result = {};
+    arr.forEach((v) => {
+        if (v.children && v.children.length > 0) {
+            result[v.content.trim()] = toTreeObject(v.children);
+        }
+        else {
+            result[v.content.trim()] = null;
+        }
+    });
+    return result;
+}
+function findChildren(arr, target) {
+    const result = Array();
+    const targetIndex = arr.indexOf(target);
+    if (targetIndex < 0 || targetIndex == arr.length - 1)
+        return result;
+    const nextBrotherIndex = arr.findIndex((v, i) => spaceCount(v) == spaceCount(target) && i > targetIndex);
+    if (nextBrotherIndex == targetIndex + 1)
+        return result;
+    const firstChild = arr.at(targetIndex + 1);
+    if (firstChild) {
+        const range = arr.slice(targetIndex, nextBrotherIndex);
+        const children = range.filter((v) => spaceCount(v) == spaceCount(firstChild));
+        result.concat(children);
+    }
+    return result;
+}
+function spaceCount(value) {
+    const trim = value.trimStart();
+    return value.length - trim.length;
+}
+function findLines(lines, target) {
+    const result = Array();
+    lines.forEach((v, i) => {
+        if (v.indexOf(target) > 0) {
+            result.push({
+                content: v,
+                index: i,
+            });
+        }
+    });
+    return result;
+}
+function findFirstLines(lines, target) {
+    var _a;
+    return (_a = findLines(lines, target).at(0)) === null || _a === void 0 ? void 0 : _a.content;
+}
+function findLastLines(lines, target) {
+    var _a;
+    return (_a = findLines(lines, target).last(0)) === null || _a === void 0 ? void 0 : _a.content;
+}
+function findRangeLines(lines, start, end) {
+    const startLines = findLines(lines, start);
+    const endLines = findLines(lines, end);
+    const allLines = startLines.concat(endLines);
+    allLines.sort((a, b) => a.index - b.index);
+    const children = Array();
+    const stack = Array();
+    allLines.forEach((v) => {
+        if (startLines.some((line) => Object.is(line, v))) {
+            stack.push(v);
+        }
+        else {
+            const start = stack.pop();
+            if (start) {
+                children.push({
+                    start,
+                    end: v,
+                });
+            }
+        }
+    });
+    return children;
+}
+let oldActivity = "";
+function main(onCurrentWindowChanged) {
+    return __awaiter(this, void 0, void 0, function* () {
+        while (true) {
+            const currentActivity = (0, child_process_1.execSync)("adb shell dumpsys window displays | grep -E 'mCurrentFocus'", { encoding: "utf-8" });
+            if (oldActivity != currentActivity) {
+                onCurrentWindowChanged();
+                oldActivity = currentActivity;
+            }
+        }
+    });
+}
+main(() => printDumpInfo());

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "currentactivity",
+  "version": "1.0.0",
+  "description": "A command line tool to display the current activity for android.",
+  "main": "./build/index.js",
+  "scripts": {
+    "start": "tsc && node ./build/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Alluretears/currentactivity.git"
+  },
+  "keywords": [
+    "current activity",
+    "activity",
+    "fragment",
+    "android"
+  ],
+  "author": "Zech",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Alluretears/currentactivity/issues"
+  },
+  "homepage": "https://github.com/Alluretears/currentactivity#readme",
+  "bin": {
+    "currentactivity": "./build/index.js"
+  },
+  "devDependencies": {
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.5"
+  },
+  "dependencies": {
+    "table": "^6.8.0",
+    "treeify": "^1.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/@types/treeify.d.ts

@@ -0,0 +1,11 @@
+declare module "treeify" {
+  export interface TreeObject {
+    [k: string]: TreeValue;
+  }
+  export type TreeValue = string | TreeObject;
+  export function asTree(
+    treeObj: TreeObject,
+    showValues?: boolean,
+    hideFunctions?: boolean,
+  ): string;
+}

package/src/extension.ts

@@ -0,0 +1,23 @@
+declare global {
+  interface Array<T> {
+    last(n: number): T;
+  }
+
+  interface String {
+    removeLast(n: number): string;
+  }
+}
+if (!Array.prototype.last) {
+  Array.prototype.last = function <T>(n: number): T {
+    return this[this.length - 1 - n];
+  };
+}
+
+if (!String.prototype.removeLast) {
+  String.prototype.removeLast = function (n: number): string {
+    const end = this.length - n;
+    return this.substring(0, end);
+  };
+}
+
+export {};

package/src/index.ts

@@ -0,0 +1,371 @@
+#! /usr/bin/env node
+import { execSync } from "child_process";
+import { table } from "table";
+import { asTree } from "treeify";
+import "./extension";
+
+async function printDumpInfo() {
+  // exec adb shell dumpsys window displays
+  const windowOutput = execSync("adb shell dumpsys window displays", {
+    encoding: "utf-8",
+  });
+  const windowLines = windowOutput.split("\n");
+
+  const currentFocusLine = findFirstLines(windowLines, "mCurrentFocus");
+  const currentWindow = currentFocusLine?.split(" ")?.last(0)?.removeLast(1);
+
+  const currentFocusAppLine = findFirstLines(windowLines, "mFocusedApp");
+  const currentActivity = currentFocusAppLine?.split(" ")?.last(1);
+  const stackId = currentFocusAppLine?.split(" ")?.last(0)?.removeLast(1);
+  const currentApp = currentActivity?.split("/")?.at(0);
+
+  const frameworkFragmentLines = Array<Line>();
+  const androidxFragmentLines = Array<Line>();
+  if (currentApp != undefined) {
+    const activityOutput = execSync(
+      "adb shell dumpsys activity " + currentApp,
+      { encoding: "utf-8" },
+    );
+    const activityLines = activityOutput.split("\n");
+
+    // 1. find top activity
+    const activitesLines = findLines(activityLines, "ACTIVITY");
+    let sliceStart = 0;
+    let sliceEnd = activityLines.length - 1;
+    activitesLines.forEach((v, index) => {
+      if (currentActivity && v.content.indexOf(currentActivity) > 0) {
+        sliceStart = v.index;
+        if (index + 1 <= activitesLines.length - 1) {
+          sliceEnd = activitesLines[index + 1].index;
+        }
+      }
+    });
+
+    // 2. cut out the top activity lines
+    const topActivityLines = activityLines.slice(sliceStart, sliceEnd);
+    // 3. split into framework fragments and androidx fragments
+    const splitLine = findLastLines(
+      topActivityLines,
+      "Local FragmentActivity",
+    );
+    let frameworkLines: Array<string>;
+    let androidxLines: Array<string> | undefined;
+    if (splitLine != undefined) {
+      const splitLineIndex = topActivityLines.indexOf(splitLine);
+      frameworkLines = topActivityLines.slice(0, splitLineIndex);
+      androidxLines = topActivityLines.slice(splitLineIndex);
+    } else {
+      frameworkLines = topActivityLines;
+    }
+    // 4. find all children of between "Active Fragments" and "Added Fragments" node
+    const frameworkRangeLines = findRangeLines(
+      frameworkLines,
+      "Active Fragments",
+      "Added Fragments",
+    );
+    frameworkRangeLines.sort((a, b) => a.start.index - b.start.index);
+    frameworkRangeLines.forEach((v) => {
+      const firstFragmentLine = frameworkLines?.at(v.start.index + 1);
+      if (firstFragmentLine) {
+        frameworkFragmentLines.push({
+          content: firstFragmentLine,
+          index: v.start.index + 1,
+        });
+      }
+      frameworkLines?.forEach((item, index) => {
+        if (
+          firstFragmentLine &&
+          spaceCount(item) == spaceCount(firstFragmentLine) &&
+          index > v.start.index + 1 &&
+          index < v.end.index
+        ) {
+          frameworkFragmentLines.push({ content: item, index: index });
+        }
+      });
+    });
+
+    if (androidxLines) {
+      const androidxRangeLines = findRangeLines(
+        androidxLines,
+        "Active Fragments",
+        "Added Fragments",
+      );
+      androidxRangeLines.sort((a, b) => a.start.index - b.start.index);
+
+      androidxRangeLines.forEach((v) => {
+        const firstFragmentLine = androidxLines?.at(v.start.index + 1);
+        if (firstFragmentLine) {
+          androidxFragmentLines.push({
+            content: firstFragmentLine,
+            index: v.start.index + 1,
+          });
+        }
+        androidxLines?.forEach((item, index) => {
+          if (
+            firstFragmentLine &&
+            spaceCount(item) == spaceCount(firstFragmentLine) &&
+            index > v.start.index + 1 &&
+            index < v.end.index
+          ) {
+            androidxFragmentLines.push({ content: item, index: index });
+          }
+        });
+      });
+    }
+  }
+
+  console.clear();
+
+  // print current window
+  if (currentWindow) {
+    const windowTable = Array<Array<string>>();
+    windowTable.push([currentWindow]);
+    console.log(
+      table(windowTable, {
+        header: { content: "current window", alignment: "center" },
+      }),
+    );
+  }
+
+  // print current activity stack
+  if (stackId != undefined) {
+    const stackLines = windowLines.filter((v) => {
+      const s = v.trim();
+      return s.startsWith("*") && s.indexOf(stackId) > 0;
+    });
+    const stacks = stackLines.map((v) => v.trim().split(" ")[3]);
+    if (stacks[0] != currentActivity) {
+      stacks.shift();
+    }
+    const statckTable = Array<Array<string>>();
+    stacks.forEach((v) => statckTable.push([v]));
+    console.log("\n");
+    console.log(
+      table(statckTable, {
+        header: { content: "activity stack", alignment: "center" },
+      }),
+    );
+  }
+
+  // print current fragments which in focused activity
+  if (frameworkFragmentLines.length > 0 || androidxFragmentLines.length > 0) {
+    const fragmentTable = Array<Array<string>>();
+    if (frameworkFragmentLines.length > 0) {
+      frameworkFragmentLines.sort((a, b) => a.index - b.index);
+      fragmentTable.push([
+        "framework fragments",
+        asTree(
+          toTreeObject(listToTree(toTreeArray(frameworkFragmentLines))),
+          true,
+        ),
+      ]);
+    }
+    if (androidxFragmentLines.length > 0) {
+      androidxFragmentLines.sort((a, b) => a.index - b.index);
+      fragmentTable.push([
+        "androidx fragments",
+        asTree(
+          toTreeObject(listToTree(toTreeArray(androidxFragmentLines))),
+          true,
+        ),
+      ]);
+    }
+    console.log("\n");
+    console.log(
+      table(fragmentTable, {
+        header: { content: "fragments", alignment: "center" },
+      }),
+    );
+  }
+}
+
+type Tree = {
+  id: string;
+  content: string;
+  parentId: string;
+  children: Tree[] | null;
+};
+
+function toTreeArray(arr: Array<Line>): Array<Tree> {
+  const result = Array<Tree>();
+  arr.forEach((v, index) => {
+    result.push({
+      id: index.toString(),
+      content: v.content.trim(),
+      parentId: findParentIndex(arr.map((item) => item.content), v.content)
+        .toString(),
+      children: null,
+    });
+  });
+  return result;
+}
+
+function findParentIndex(
+  arr: Array<string>,
+  target: string,
+): number {
+  const targetIndex = arr.indexOf(target);
+  if (targetIndex < 0) return -1;
+  let parentIndex = -1;
+  for (let index = targetIndex; index >= 0; index--) {
+    const element = arr[index];
+    if (spaceCount(element) < spaceCount(target)) {
+      parentIndex = index;
+      break;
+    }
+  }
+  return parentIndex;
+}
+
+function findParent(arr: Array<string>, target: string): string | undefined {
+  const targetIndex = arr.indexOf(target);
+  if (targetIndex < 0) return undefined;
+  let parent = undefined;
+  for (let index = targetIndex; index >= 0; index--) {
+    const element = arr[index];
+    if (spaceCount(element) < spaceCount(target)) {
+      parent = element;
+      break;
+    }
+  }
+  return parent;
+}
+
+function listToTree(arr: Array<Tree>): Array<Tree> {
+  const map: { [k: string]: number } = {};
+  let node: Tree;
+  const roots = Array<Tree>();
+  for (let index = 0; index < arr.length; index++) {
+    map[arr[index].id] = index;
+    arr[index].children = [];
+  }
+  for (let index = 0; index < arr.length; index++) {
+    node = arr[index];
+    if (node.parentId !== "-1") {
+      // if you have dangling branches check that map[node.parentId] exists
+      arr[map[node.parentId]].children?.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+
+function toTreeObject(arr: Array<Tree>): { [k: string]: any } {
+  const result: { [k: string]: any } = {};
+  arr.forEach((v) => {
+    if (v.children && v.children.length > 0) {
+      result[v.content.trim()] = toTreeObject(v.children);
+    } else {
+      result[v.content.trim()] = null;
+    }
+  });
+  return result;
+}
+
+function findChildren(arr: Array<string>, target: string): Array<string> {
+  const result = Array<string>();
+  const targetIndex = arr.indexOf(target);
+  if (targetIndex < 0 || targetIndex == arr.length - 1) return result;
+  const nextBrotherIndex = arr.findIndex((v, i) =>
+    spaceCount(v) == spaceCount(target) && i > targetIndex
+  );
+  if (nextBrotherIndex == targetIndex + 1) return result;
+  const firstChild = arr.at(targetIndex + 1);
+  if (firstChild) {
+    const range = arr.slice(targetIndex, nextBrotherIndex);
+    const children = range.filter((v) =>
+      spaceCount(v) == spaceCount(firstChild)
+    );
+    result.concat(children);
+  }
+  return result;
+}
+
+function spaceCount(value: string): number {
+  const trim = value.trimStart();
+  return value.length - trim.length;
+}
+
+type Line = {
+  content: string;
+  index: number;
+};
+
+function findLines(
+  lines: Array<string>,
+  target: string,
+): Array<Line> {
+  const result = Array<Line>();
+  lines.forEach((v, i) => {
+    if (v.indexOf(target) > 0) {
+      result.push({
+        content: v,
+        index: i,
+      });
+    }
+  });
+  return result;
+}
+
+function findFirstLines(
+  lines: Array<string>,
+  target: string,
+): string | undefined {
+  return findLines(lines, target).at(0)?.content;
+}
+
+function findLastLines(
+  lines: Array<string>,
+  target: string,
+): string | undefined {
+  return findLines(lines, target).last(0)?.content;
+}
+
+type RangeLine = {
+  start: Line;
+  end: Line;
+};
+
+function findRangeLines(
+  lines: Array<string>,
+  start: string,
+  end: string,
+): Array<RangeLine> {
+  const startLines = findLines(lines, start);
+  const endLines = findLines(lines, end);
+  const allLines = startLines.concat(endLines);
+  allLines.sort((a, b) => a.index - b.index);
+  const children = Array<RangeLine>();
+  const stack = Array<Line>();
+  allLines.forEach((v) => {
+    if (startLines.some((line) => Object.is(line, v))) {
+      stack.push(v);
+    } else {
+      const start = stack.pop();
+      if (start) {
+        children.push({
+          start,
+          end: v,
+        });
+      }
+    }
+  });
+  return children;
+}
+
+let oldActivity = "";
+async function main(onCurrentWindowChanged: () => void) {
+  while (true) {
+    const currentActivity = execSync(
+      "adb shell dumpsys window displays | grep -E 'mCurrentFocus'",
+      { encoding: "utf-8" },
+    );
+    if (oldActivity != currentActivity) {
+      onCurrentWindowChanged();
+      oldActivity = currentActivity;
+    }
+  }
+}
+
+main(() => printDumpInfo());

package/tsconfig.json

@@ -0,0 +1,101 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./build",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": false,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}