frida-ui-runtime 2.0.0

package/lib/component/text.js

@@ -0,0 +1,36 @@
+import Java from "../java-runtime.js";
+import { API } from "../api.js";
+import { applyStyle } from "./style/style.js";
+import { UIComponent } from "./ui-components.js";
+export class TextView extends UIComponent {
+    constructor(id, content, kind = "normal", size) {
+        super(id);
+        this.value = content;
+        this.kind = kind;
+        this.size = size;
+    }
+    createView(context) {
+        const TextView = API.TextView;
+        const Html = API.Html;
+        const Gravity = API.Gravity;
+        this.view = TextView.$new(context);
+        applyStyle(this.view, this.kind === "note" ? "noteText" : "text", this.menu.options.theme);
+        if (this.size != null) {
+            this.view.setTextSize(2, this.size);
+        }
+        this.view.setGravity(Gravity.LEFT.value);
+        this.view.setText(Html.fromHtml(this.value));
+    }
+    updateView() {
+        if (!this.view)
+            return;
+        Java.scheduleOnMainThread(() => {
+            const Html = API.Html;
+            this.view.setText(Html.fromHtml(this.value));
+        });
+    }
+    setText(content) {
+        this.value = content;
+        this.updateView();
+    }
+}

package/lib/component/ui-components.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from "../event-emitter.js";
+import { FloatMenu } from "../float-menu.js";
+export declare abstract class UIComponent {
+    protected emitter: EventEmitter;
+    protected view: any;
+    protected value: any;
+    protected id: string;
+    private initialized;
+    private attached;
+    private disposed;
+    private disposers;
+    protected menu: FloatMenu;
+    constructor(id: string);
+    setMenu(menu: FloatMenu): void;
+    apply(role: any, theme: any): void;
+    getView(): any;
+    getValue(): any;
+    getId(): string;
+    setValue(value: any): void;
+    on(event: string, listener: (...args: any[]) => void): () => void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    protected emit(event: string, ...args: any[]): void;
+    protected abstract createView(context: any): void;
+    initialize(context: any, menu?: FloatMenu): void;
+    protected abstract updateView(): void;
+    protected own(dispose: () => void): () => void;
+    attach(_container?: any): void;
+    detach(): void;
+    captureState(): any;
+    restoreState(state: any): void;
+    dispose(): void;
+    get isInitialized(): boolean;
+    get isAttached(): boolean;
+}

package/lib/component/ui-components.js

@@ -0,0 +1,108 @@
+import Java from "../java-runtime.js";
+import { EventEmitter } from "../event-emitter.js";
+import { applyStyle } from "./style/style.js";
+export class UIComponent {
+    constructor(id) {
+        this.emitter = new EventEmitter();
+        this.initialized = false;
+        this.attached = false;
+        this.disposed = false;
+        this.disposers = new Set();
+        this.id = id;
+    }
+    setMenu(menu) {
+        this.menu = menu;
+    }
+    apply(role, theme) {
+        if (!this.view)
+            return;
+        Java.scheduleOnMainThread(() => applyStyle(this.view, role, theme));
+    }
+    getView() {
+        return this.view;
+    }
+    getValue() {
+        return this.value;
+    }
+    getId() {
+        return this.id;
+    }
+    setValue(value) {
+        if (this.disposed)
+            throw new Error(`Component ${this.id} is disposed`);
+        this.value = value;
+        if (this.initialized)
+            this.updateView();
+    }
+    on(event, listener) {
+        return this.emitter.on(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    emit(event, ...args) {
+        this.emitter.emit(event, ...args);
+    }
+    initialize(context, menu) {
+        if (this.disposed)
+            throw new Error(`Component ${this.id} is disposed`);
+        if (this.initialized)
+            return;
+        if (menu)
+            this.menu = menu;
+        this.createView(context);
+        this.initialized = true;
+    }
+    own(dispose) {
+        if (this.disposed) {
+            dispose();
+            return () => { };
+        }
+        let active = true;
+        const release = () => {
+            if (!active)
+                return;
+            active = false;
+            this.disposers.delete(release);
+            dispose();
+        };
+        this.disposers.add(release);
+        return release;
+    }
+    attach(_container) {
+        if (this.disposed)
+            throw new Error(`Component ${this.id} is disposed`);
+        this.attached = true;
+    }
+    detach() {
+        this.attached = false;
+    }
+    captureState() {
+        return this.value;
+    }
+    restoreState(state) {
+        this.setValue(state);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.detach();
+        for (const dispose of Array.from(this.disposers).reverse()) {
+            try {
+                dispose();
+            }
+            catch { }
+        }
+        this.disposers.clear();
+        this.emitter.removeAllListeners();
+        this.view = null;
+        this.initialized = false;
+        this.disposed = true;
+    }
+    get isInitialized() {
+        return this.initialized;
+    }
+    get isAttached() {
+        return this.attached;
+    }
+}

package/lib/component/views/header-view.d.ts

@@ -0,0 +1,20 @@
+import { Theme } from "../style/theme.js";
+export interface HeaderViewOptions {
+    context: any;
+    parent: any;
+    logMaxLines?: number;
+    title: string;
+    version: string;
+}
+export declare class HeaderView {
+    private readonly theme;
+    private headerDragView;
+    private logViewWindow;
+    private readonly listeners;
+    constructor(theme: Theme);
+    createView(options: HeaderViewOptions, callbacks: {
+        onMinimize: () => void;
+        onHide: () => void;
+    }): any;
+    destroy(): void;
+}

package/lib/component/views/header-view.js

@@ -0,0 +1,198 @@
+import { API } from "../../api.js";
+import { Logger } from "../../logger.js";
+import { dp } from "../style/style.js";
+import { LogViewWindow } from "./log-view.js";
+import { createJavaListener } from "../../android-listener.js";
+import { ListenerRegistry } from "../../runtime/listener-registry.js";
+export class HeaderView {
+    constructor(theme) {
+        this.logViewWindow = null;
+        this.listeners = new ListenerRegistry();
+        this.theme = theme;
+    }
+    createView(options, callbacks) {
+        const { context, parent, logMaxLines, title, version } = options;
+        try {
+            const LinearLayout = API.LinearLayout;
+            const LinearLayoutParams = API.LinearLayoutParams;
+            const TextView = API.TextView;
+            const JString = API.JString;
+            const GradientDrawable = API.GradientDrawable;
+            const Gravity = API.Gravity;
+            const PAD_H = dp(context, 10);
+            const PAD_V = dp(context, 8);
+            const BTN_SIZE = dp(context, 34);
+            const BTN_RADIUS = dp(context, 10);
+            const createIconCharBtn = (ch, isDanger = false) => {
+                const btn = TextView.$new(context);
+                btn.setText.overload('java.lang.CharSequence').call(btn, JString.$new(ch));
+                btn.setGravity(Gravity.CENTER.value);
+                btn.setSingleLine(true);
+                btn.setTextSize(2, this.theme.textSp.title);
+                btn.setTextColor(isDanger ? this.theme.colors.accent : this.theme.colors.text);
+                const lp = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+                btn.setLayoutParams(lp);
+                const touchListener = createJavaListener({
+                    key: "view-touch",
+                    interfaceClass: API.OnTouchListener,
+                    fallback: { onTouch: false },
+                    callbacks: {
+                        onTouch: (v, ev) => {
+                            try {
+                                const MotionEvent = API.MotionEvent;
+                                const action = ev.getAction();
+                                if (action === MotionEvent.ACTION_DOWN.value)
+                                    v.setAlpha(0.6);
+                                else if (action === MotionEvent.ACTION_UP.value ||
+                                    action === MotionEvent.ACTION_CANCEL.value) {
+                                    v.setAlpha(1.0);
+                                }
+                            }
+                            catch { }
+                            return false;
+                        },
+                    },
+                });
+                this.listeners.add("header", () => touchListener.dispose());
+                btn.setOnTouchListener(touchListener.instance);
+                const d = GradientDrawable.$new();
+                d.setCornerRadius(BTN_RADIUS);
+                d.setColor(0x00000000);
+                btn.setBackgroundDrawable(d);
+                btn.setPadding(dp(context, 6), dp(context, 6), dp(context, 6), dp(context, 6));
+                return btn;
+            };
+            const headerLp = LinearLayoutParams.$new(LinearLayoutParams.MATCH_PARENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            const headerRoot = LinearLayout.$new(context);
+            headerRoot.setOrientation(1);
+            headerRoot.setLayoutParams(headerLp);
+            const headerRow = LinearLayout.$new(context);
+            headerRow.setOrientation(0);
+            headerRow.setGravity(Gravity.CENTER_VERTICAL.value);
+            headerRow.setPadding(PAD_H, PAD_V, PAD_H, PAD_V);
+            this.headerDragView = headerRow;
+            try {
+                this.headerDragView.setBackgroundColor(0x00000000);
+            }
+            catch { }
+            const divider = API.View.$new(context);
+            const divLp = LinearLayoutParams.$new(LinearLayoutParams.MATCH_PARENT.value, dp(context, 1));
+            divider.setLayoutParams(divLp);
+            divider.setBackgroundColor(this.theme.colors.divider);
+            const leftBox = LinearLayout.$new(context);
+            leftBox.setOrientation(0);
+            leftBox.setGravity(Gravity.CENTER_VERTICAL.value);
+            const leftLp = LinearLayoutParams.$new(0, LinearLayoutParams.WRAP_CONTENT.value, 1.0);
+            leftBox.setLayoutParams(leftLp);
+            const icon = TextView.$new(context);
+            icon.setText.overload('java.lang.CharSequence').call(icon, JString.$new("▸"));
+            icon.setTextColor(this.theme.colors.accent);
+            icon.setTextSize(2, this.theme.textSp.title);
+            icon.setPadding(0, 0, dp(context, 8), 0);
+            const titleView = TextView.$new(context);
+            titleView.setText.overload('java.lang.CharSequence').call(titleView, JString.$new(title));
+            titleView.setSingleLine(true);
+            titleView.setTypeface(null, 1);
+            titleView.setTextColor(this.theme.colors.text);
+            titleView.setTextSize(2, this.theme.textSp.title);
+            const ver = TextView.$new(context);
+            ver.setText.overload('java.lang.CharSequence').call(ver, JString.$new(version));
+            ver.setSingleLine(true);
+            ver.setTextSize(2, this.theme.textSp.caption);
+            ver.setTextColor(this.theme.colors.accent);
+            const badgeBg = GradientDrawable.$new();
+            badgeBg.setCornerRadius(dp(context, 8));
+            badgeBg.setColor(0x22000000);
+            badgeBg.setStroke(dp(context, 1), this.theme.colors.divider);
+            ver.setBackgroundDrawable(badgeBg);
+            ver.setPadding(dp(context, 8), dp(context, 4), dp(context, 8), dp(context, 4));
+            const verLp = LinearLayoutParams.$new(LinearLayoutParams.WRAP_CONTENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            verLp.setMargins(dp(context, 10), 0, 0, 0);
+            ver.setLayoutParams(verLp);
+            leftBox.addView(icon);
+            leftBox.addView(titleView);
+            leftBox.addView(ver);
+            const rightBox = LinearLayout.$new(context);
+            rightBox.setOrientation(0);
+            rightBox.setGravity(Gravity.CENTER_VERTICAL.value);
+            const rightLp = LinearLayoutParams.$new(LinearLayoutParams.WRAP_CONTENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            rightBox.setLayoutParams(rightLp);
+            const logView = new LogViewWindow(context, this.theme, logMaxLines);
+            this.logViewWindow = logView;
+            logView.setOnCloseButtonClick(() => {
+                logButton.setText.overload('java.lang.CharSequence').call(logButton, API.JString.$new("L"));
+            });
+            const logButton = createIconCharBtn("L", false);
+            const logClickListener = createJavaListener({
+                key: "view-click",
+                interfaceClass: API.OnClickListener,
+                callbacks: {
+                    onClick: () => {
+                        if (logView.isLogWindowVisible) {
+                            logView.closeLogWindow();
+                            logButton.setText.overload('java.lang.CharSequence').call(logButton, API.JString.$new("L"));
+                        }
+                        else {
+                            logView.openLogWindow();
+                            logButton.setText.overload('java.lang.CharSequence').call(logButton, API.JString.$new("←"));
+                        }
+                    },
+                },
+            });
+            this.listeners.add("header", () => logClickListener.dispose());
+            logButton.setOnClickListener(logClickListener.instance);
+            const minButton = createIconCharBtn("—", false);
+            const minimizeClickListener = createJavaListener({
+                key: "view-click",
+                interfaceClass: API.OnClickListener,
+                callbacks: {
+                    onClick: () => {
+                        callbacks.onMinimize();
+                    },
+                },
+            });
+            this.listeners.add("header", () => minimizeClickListener.dispose());
+            minButton.setOnClickListener(minimizeClickListener.instance);
+            const hideButton = createIconCharBtn("X", true);
+            const hideClickListener = createJavaListener({
+                key: "view-click",
+                interfaceClass: API.OnClickListener,
+                callbacks: {
+                    onClick: () => {
+                        callbacks.onHide();
+                    },
+                },
+            });
+            this.listeners.add("header", () => hideClickListener.dispose());
+            hideButton.setOnClickListener(hideClickListener.instance);
+            const lp1 = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+            lp1.setMargins(0, 0, dp(context, 4), 0);
+            logButton.setLayoutParams(lp1);
+            const lp2 = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+            lp2.setMargins(0, 0, dp(context, 4), 0);
+            minButton.setLayoutParams(lp2);
+            const lp3 = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+            lp3.setMargins(0, 0, 0, 0);
+            hideButton.setLayoutParams(lp3);
+            rightBox.addView(logButton);
+            rightBox.addView(minButton);
+            rightBox.addView(hideButton);
+            headerRoot.addView(headerRow);
+            headerRoot.addView(divider);
+            headerRow.addView(leftBox);
+            headerRow.addView(rightBox);
+            parent.addView(headerRoot);
+            return this.headerDragView;
+        }
+        catch (error) {
+            Logger.instance.error("Failed to create header view: " + error);
+            return null;
+        }
+    }
+    destroy() {
+        this.listeners.clearAll();
+        this.logViewWindow?.destroy();
+        this.logViewWindow = null;
+        this.headerDragView = null;
+    }
+}

package/lib/component/views/log-view.d.ts

@@ -0,0 +1,41 @@
+export declare class LogViewWindow {
+    private menu;
+    private context;
+    private windowManager;
+    private theme;
+    private logMaxLines;
+    private windowRoot;
+    private windowParams;
+    private titleDragHandle;
+    private logView;
+    private isCreated;
+    private isCreating;
+    private isAttached;
+    isLogWindowVisible: boolean;
+    private _loggerUnsub;
+    private _logMaxLinesCache;
+    private _logRing;
+    private _logHead;
+    private _logSize;
+    private _logPending;
+    private _logFlushScheduled;
+    private _onCloseButtonClick;
+    private enforceNonFocusableWindow;
+    private readonly listeners;
+    private width?;
+    private height?;
+    lastTouchX: any;
+    lastTouchY: any;
+    constructor(context: any, theme: any, menu: any, logMaxLines?: number, onCloseButtonClick?: () => void);
+    setOnCloseButtonClick(callback: (() => void) | null): void;
+    private bindLoggerToLogViewOnce;
+    private addLogToView;
+    private buildWindowType;
+    private createWindowOnce;
+    private attachWindowIfNeeded;
+    private addDragListener;
+    private updatePosition;
+    openLogWindow(): void;
+    closeLogWindow(): void;
+    destroy(): void;
+}