frida-ui-runtime 2.0.0

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

@@ -0,0 +1,511 @@
+import Java from "../../java-runtime.js";
+import { API } from "../../api.js";
+import { ConstantConfig } from "../../constant-config.js";
+import { Logger } from "../../logger.js";
+import { logicalToWindow, windowToLogical } from "../../utils.js";
+import { ensureWindowNotFocusable, getOverlayWindowType, getWindowManager, } from "../../android-runtime.js";
+import { dp } from "../style/style.js";
+import { createJavaListener } from "../../android-listener.js";
+import { ListenerRegistry } from "../../runtime/listener-registry.js";
+export class LogViewWindow {
+    enforceNonFocusableWindow() {
+        if (!this.windowParams)
+            return false;
+        const changed = ensureWindowNotFocusable(this.windowParams, API.LayoutParams);
+        try {
+            this.windowRoot?.clearFocus?.();
+        }
+        catch { }
+        return changed;
+    }
+    constructor(context, theme, menu, logMaxLines = 100, onCloseButtonClick) {
+        this.windowRoot = null;
+        this.windowParams = null;
+        this.titleDragHandle = null;
+        this.logView = null;
+        this.isCreated = false;
+        this.isCreating = false;
+        this.isAttached = false;
+        this.isLogWindowVisible = false;
+        this._loggerUnsub = null;
+        this._logMaxLinesCache = 0;
+        this._logRing = null;
+        this._logHead = 0;
+        this._logSize = 0;
+        this._logPending = [];
+        this._logFlushScheduled = false;
+        this._onCloseButtonClick = null;
+        this.listeners = new ListenerRegistry();
+        this.context = context;
+        this.theme = theme;
+        this.menu = menu;
+        this.logMaxLines = logMaxLines;
+        this._onCloseButtonClick = onCloseButtonClick ?? null;
+        this.windowManager = getWindowManager(Java, this.context);
+    }
+    setOnCloseButtonClick(callback) {
+        this._onCloseButtonClick = callback ?? null;
+    }
+    bindLoggerToLogViewOnce() {
+        if (this._loggerUnsub)
+            return;
+        this._loggerUnsub = Logger.instance.onLog((items) => {
+            for (let i = 0; i < items.length; i++) {
+                const it = items[i];
+                this.addLogToView(it.level, it.message, it.ts);
+            }
+        }, true);
+    }
+    addLogToView(level, message, ts) {
+        if (!this.logView)
+            return;
+        const maxLines = this.logMaxLines | 0;
+        if (maxLines <= 0)
+            return;
+        if (!this._logRing || this._logMaxLinesCache !== maxLines) {
+            this._logMaxLinesCache = maxLines;
+            this._logRing = new Array(maxLines);
+            this._logHead = 0;
+            this._logSize = 0;
+            this._logPending.length = 0;
+            this._logFlushScheduled = false;
+            try {
+                this.logView.setText.overload('java.lang.CharSequence').call(this.logView, API.JString.$new(""));
+            }
+            catch { }
+        }
+        const t = new Date(ts).toTimeString().substring(0, 8);
+        this._logPending.push(`[${t}:${level}] ${message}`);
+        if (this._logFlushScheduled)
+            return;
+        this._logFlushScheduled = true;
+        Java.scheduleOnMainThread(() => {
+            this._logFlushScheduled = false;
+            if (!this.logView || !this._logRing)
+                return;
+            const pending = this._logPending;
+            this._logPending = [];
+            for (const line of pending) {
+                this._logRing[this._logHead] = line;
+                this._logHead = (this._logHead + 1) % this._logMaxLinesCache;
+                if (this._logSize < this._logMaxLinesCache)
+                    this._logSize++;
+            }
+            let out = "";
+            const start = (this._logHead - this._logSize + this._logMaxLinesCache) %
+                this._logMaxLinesCache;
+            for (let i = 0; i < this._logSize; i++) {
+                const idx = (start + i) % this._logMaxLinesCache;
+                const s = this._logRing[idx];
+                if (s == null)
+                    continue;
+                out += s;
+                if (i !== this._logSize - 1)
+                    out += "\n";
+            }
+            try {
+                this.logView.setText.overload('java.lang.CharSequence').call(this.logView, API.JString.$new(out));
+            }
+            catch (e) {
+                Logger.instance.error("flush log text failed: " + e);
+            }
+        });
+    }
+    buildWindowType() {
+        const LayoutParams = API.LayoutParams;
+        return getOverlayWindowType(LayoutParams);
+    }
+    createWindowOnce() {
+        if (this.isCreated || this.isCreating || this.windowRoot)
+            return;
+        this.isCreating = true;
+        const self = this;
+        const LinearLayout = API.LinearLayout;
+        const LinearLayoutParams = API.LinearLayoutParams;
+        const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+        const TextView = API.TextView;
+        const ScrollView = API.ScrollView;
+        const GradientDrawable = API.GradientDrawable;
+        const Gravity = API.Gravity;
+        const JString = API.JString;
+        const LayoutParams = API.LayoutParams;
+        const View = API.View;
+        const FrameLayout = API.FrameLayout;
+        const FrameLayoutParams = API.FrameLayoutParams;
+        const PixelFormat = Java.use("android.graphics.PixelFormat");
+        try {
+            const root = FrameLayout.$new(this.context);
+            const parentLp = FrameLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value);
+            root.setLayoutParams(parentLp);
+            root.setBackgroundColor(0x00000000);
+            root.setClickable(false);
+            root.setFocusable(false);
+            const panel = LinearLayout.$new(this.context);
+            panel.setOrientation(LinearLayout.VERTICAL.value);
+            panel.setClickable(true);
+            panel.setFocusable(false);
+            const rootLp = FrameLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value);
+            panel.setLayoutParams(rootLp);
+            const rootBg = GradientDrawable.$new();
+            rootBg.setCornerRadius(dp(this.context, 12));
+            rootBg.setColor(0xb80b1324 | 0);
+            rootBg.setStroke(dp(this.context, 1.2), 0xff1f63ff | 0);
+            panel.setBackgroundDrawable(rootBg);
+            try {
+                panel.setElevation(100010);
+                panel.setTranslationZ(100010);
+            }
+            catch { }
+            const header = LinearLayout.$new(this.context);
+            header.setOrientation(LinearLayout.HORIZONTAL.value);
+            header.setGravity(Gravity.CENTER_VERTICAL.value);
+            header.setPadding(dp(this.context, 14), dp(this.context, 11), dp(this.context, 14), dp(this.context, 11));
+            const headerBg = GradientDrawable.$new();
+            headerBg.setColor(0xcc102347 | 0);
+            headerBg.setCornerRadii([
+                dp(this.context, 12),
+                dp(this.context, 12),
+                dp(this.context, 12),
+                dp(this.context, 12),
+                0,
+                0,
+                0,
+                0,
+            ]);
+            header.setBackgroundDrawable(headerBg);
+            const title = TextView.$new(this.context);
+            title.setText.overload('java.lang.CharSequence').call(title, JString.$new("系统日志"));
+            title.setTextColor(0xff1f7bff | 0);
+            try {
+                title.setTypeface(null, 1);
+            }
+            catch { }
+            title.setTextSize(2, this.theme?.textSp?.title ?? 15);
+            title.setLayoutParams(LinearLayoutParams.$new(0, ViewGroupLayoutParams.WRAP_CONTENT.value, 1.0));
+            const dots = TextView.$new(this.context);
+            dots.setText.overload('java.lang.CharSequence').call(dots, JString.$new("●  ●  ●"));
+            dots.setTextColor(0xff4a5e80 | 0);
+            dots.setTextSize(2, this.theme?.textSp?.caption ?? 11);
+            header.addView(title);
+            header.addView(dots);
+            const scrollView = ScrollView.$new(this.context);
+            scrollView.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, 0, 1.0));
+            try {
+                scrollView.setFillViewport(true);
+                scrollView.setVerticalScrollBarEnabled(false);
+                scrollView.setBackgroundColor(0x00000000);
+            }
+            catch { }
+            const logText = TextView.$new(this.context);
+            logText.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            logText.setTextColor(0xffeaf2ff | 0);
+            logText.setTextSize(2, this.theme?.textSp?.body ?? 13);
+            logText.setPadding(dp(this.context, 14), dp(this.context, 12), dp(this.context, 14), dp(this.context, 12));
+            logText.setLineSpacing(0, 1.08);
+            logText.setText.overload('java.lang.CharSequence').call(logText, JString.$new(""));
+            scrollView.addView(logText);
+            const footer = LinearLayout.$new(this.context);
+            footer.setOrientation(LinearLayout.HORIZONTAL.value);
+            footer.setGravity(Gravity.END.value | Gravity.CENTER_VERTICAL.value);
+            footer.setPadding(dp(this.context, 12), dp(this.context, 10), dp(this.context, 12), dp(this.context, 10));
+            const footerBg = GradientDrawable.$new();
+            footerBg.setColor(0xb8101d36 | 0);
+            footer.setBackgroundDrawable(footerBg);
+            const clearBtn = TextView.$new(this.context);
+            clearBtn.setText.overload('java.lang.CharSequence').call(clearBtn, JString.$new("清除"));
+            try {
+                clearBtn.setTypeface(null, 1);
+            }
+            catch { }
+            clearBtn.setTextColor(0xff9aaaca | 0);
+            clearBtn.setTextSize(2, this.theme?.textSp?.caption ?? 12);
+            clearBtn.setGravity(Gravity.CENTER.value);
+            clearBtn.setPadding(dp(this.context, 18), dp(this.context, 9), dp(this.context, 18), dp(this.context, 9));
+            const clearBg = GradientDrawable.$new();
+            clearBg.setCornerRadius(dp(this.context, 6));
+            clearBg.setColor(0x00112233 | 0);
+            clearBtn.setBackgroundDrawable(clearBg);
+            const closeBtn = TextView.$new(this.context);
+            closeBtn.setText.overload('java.lang.CharSequence').call(closeBtn, JString.$new("隐藏"));
+            try {
+                closeBtn.setTypeface(null, 1);
+            }
+            catch { }
+            closeBtn.setTextColor(0xffffffff | 0);
+            closeBtn.setTextSize(2, this.theme?.textSp?.caption ?? 12);
+            closeBtn.setGravity(Gravity.CENTER.value);
+            closeBtn.setPadding(dp(this.context, 20), dp(this.context, 10), dp(this.context, 20), dp(this.context, 10));
+            const closeBg = GradientDrawable.$new();
+            closeBg.setCornerRadius(dp(this.context, 6));
+            closeBg.setColor(0xff1b66ff | 0);
+            closeBg.setStroke(dp(this.context, 1), 0xff2f86ff | 0);
+            closeBtn.setBackgroundDrawable(closeBg);
+            const clearLp = LinearLayoutParams.$new(LinearLayoutParams.WRAP_CONTENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            clearLp.setMargins(0, 0, dp(this.context, 10), 0);
+            clearBtn.setLayoutParams(clearLp);
+            footer.addView(clearBtn);
+            footer.addView(closeBtn);
+            panel.addView(header);
+            panel.addView(scrollView);
+            panel.addView(footer);
+            root.addView(panel, rootLp);
+            const width = dp(this.context, 320);
+            const height = dp(this.context, 290);
+            this.width = width;
+            this.height = height;
+            const params = LayoutParams.$new(width, height, 0, 0, this.buildWindowType(), LayoutParams.FLAG_NOT_FOCUSABLE.value |
+                LayoutParams.FLAG_NOT_TOUCH_MODAL.value, PixelFormat.TRANSLUCENT.value);
+            this.logView = logText;
+            this.windowRoot = root;
+            this.windowParams = params;
+            this.titleDragHandle = header;
+            this.isCreated = true;
+            const clearClickListener = createJavaListener({
+                key: "view-click",
+                interfaceClass: API.OnClickListener,
+                callbacks: {
+                    onClick: () => {
+                        try {
+                            self._logRing = new Array(self._logMaxLinesCache || self.logMaxLines);
+                            self._logHead = 0;
+                            self._logSize = 0;
+                            self._logPending.length = 0;
+                            if (self.logView) {
+                                self.logView.setText.overload('java.lang.CharSequence').call(self.logView, JString.$new(""));
+                            }
+                        }
+                        catch (e) {
+                            Logger.instance.error("clear log failed: " + e);
+                        }
+                    },
+                },
+            });
+            this.listeners.add("log-window", () => clearClickListener.dispose());
+            clearBtn.setOnClickListener(clearClickListener.instance);
+            const closeClickListener = createJavaListener({
+                key: "view-click",
+                interfaceClass: API.OnClickListener,
+                callbacks: {
+                    onClick: () => {
+                        self.closeLogWindow();
+                        try {
+                            if (self._onCloseButtonClick) {
+                                self._onCloseButtonClick();
+                            }
+                        }
+                        catch (e) {
+                            Logger.instance.error("close callback failed: " + e);
+                        }
+                    },
+                },
+            });
+            this.listeners.add("log-window", () => closeClickListener.dispose());
+            closeBtn.setOnClickListener(closeClickListener.instance);
+            try {
+                root.setVisibility(View.GONE.value);
+            }
+            catch { }
+            this.addDragListener(this.titleDragHandle, this.windowRoot, this.windowParams, () => this.isLogWindowVisible);
+            this.bindLoggerToLogViewOnce();
+        }
+        catch (e) {
+            Logger.instance.error("create log window ui failed: " + e);
+            this.isCreated = false;
+            this.windowRoot = null;
+            this.windowParams = null;
+            this.titleDragHandle = null;
+            this.logView = null;
+        }
+        finally {
+            this.isCreating = false;
+        }
+    }
+    attachWindowIfNeeded() {
+        const self = this;
+        const View = API.View;
+        if (!this.windowRoot || !this.windowParams)
+            return;
+        if (this.isAttached)
+            return;
+        Java.scheduleOnMainThread(() => {
+            try {
+                if (!self.windowRoot || !self.windowParams || self.isAttached)
+                    return;
+                self.enforceNonFocusableWindow();
+                self.windowManager.addView(self.windowRoot, self.windowParams);
+                self.isAttached = true;
+                if (self.isLogWindowVisible) {
+                    try {
+                        self.windowRoot.setVisibility(View.VISIBLE.value);
+                    }
+                    catch { }
+                }
+            }
+            catch (e) {
+                Logger.instance.error("attach log window failed: " + e);
+            }
+        });
+    }
+    addDragListener(targetView, window, winParams, isShowing) {
+        const OnTouchListener = API.OnTouchListener;
+        const MotionEvent = API.MotionEvent;
+        targetView.setClickable(true);
+        const getBounds = () => {
+            const w = this.width;
+            const h = this.height;
+            return {
+                left: 0,
+                top: -40,
+                right: ConstantConfig.screenWidth - w,
+                bottom: ConstantConfig.screenHeight - h,
+            };
+        };
+        const self = this;
+        let isDragging = false;
+        const DRAG_THRESHOLD = 5;
+        let touchOffsetX = 0;
+        let touchOffsetY = 0;
+        const touchListener = createJavaListener({
+            key: "view-touch",
+            interfaceClass: OnTouchListener,
+            fallback: { onTouch: false },
+            callbacks: {
+                onTouch: (_v, event) => {
+                    const action = event.getAction();
+                    switch (action) {
+                        case MotionEvent.ACTION_DOWN.value: {
+                            isDragging = false;
+                            const rawX = event.getRawX();
+                            const rawY = event.getRawY();
+                            const startWx = winParams.x.value;
+                            const startWy = winParams.y.value;
+                            touchOffsetX = rawX - startWx;
+                            touchOffsetY = rawY - startWy;
+                            self.lastTouchX = rawX;
+                            self.lastTouchY = rawY;
+                            return true;
+                        }
+                        case MotionEvent.ACTION_MOVE.value: {
+                            const rawX = event.getRawX();
+                            const rawY = event.getRawY();
+                            const dx = rawX - self.lastTouchX;
+                            const dy = rawY - self.lastTouchY;
+                            if (!isDragging &&
+                                (Math.abs(dx) > DRAG_THRESHOLD || Math.abs(dy) > DRAG_THRESHOLD)) {
+                                isDragging = true;
+                            }
+                            if (isDragging) {
+                                let wx = rawX - touchOffsetX;
+                                let wy = rawY - touchOffsetY;
+                                const p = windowToLogical(wx, wy, self.width, self.height);
+                                let newX = p.x;
+                                let newY = p.y;
+                                const bounds = getBounds();
+                                newX = Math.max(bounds.left, Math.min(bounds.right, newX));
+                                newY = Math.max(bounds.top, Math.min(bounds.bottom, newY));
+                                if (isShowing()) {
+                                    self.updatePosition(window, winParams, { x: newX, y: newY });
+                                }
+                            }
+                            return true;
+                        }
+                        case MotionEvent.ACTION_UP.value:
+                        case MotionEvent.ACTION_CANCEL.value: {
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+            },
+        });
+        this.listeners.add("log-window", () => touchListener.dispose());
+        targetView.setOnTouchListener(touchListener.instance);
+    }
+    updatePosition(window, winParams, newPos) {
+        const { x: wx, y: wy } = logicalToWindow(newPos.x, newPos.y, this.width, this.height);
+        winParams.x.value = wx | 0;
+        winParams.y.value = wy | 0;
+        Java.scheduleOnMainThread(() => {
+            this.enforceNonFocusableWindow();
+            this.windowManager.updateViewLayout(window, winParams);
+        });
+    }
+    openLogWindow() {
+        const self = this;
+        const View = API.View;
+        this.isLogWindowVisible = true;
+        this.createWindowOnce();
+        this.attachWindowIfNeeded();
+        Java.scheduleOnMainThread(() => {
+            try {
+                if (!self.windowRoot)
+                    return;
+                const flagsChanged = self.enforceNonFocusableWindow();
+                self.windowRoot.setVisibility(View.VISIBLE.value);
+                if (self.isAttached) {
+                    try {
+                        if (flagsChanged) {
+                            self.windowManager.updateViewLayout(self.windowRoot, self.windowParams);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            catch (e) {
+                Logger.instance.error("open log window failed: " + e);
+            }
+        });
+    }
+    closeLogWindow() {
+        this.isLogWindowVisible = false;
+        if (!this.windowRoot)
+            return;
+        const self = this;
+        const View = API.View;
+        Java.scheduleOnMainThread(() => {
+            try {
+                if (!self.windowRoot)
+                    return;
+                const flagsChanged = self.enforceNonFocusableWindow();
+                if (flagsChanged && self.isAttached) {
+                    self.windowManager.updateViewLayout(self.windowRoot, self.windowParams);
+                }
+                self.windowRoot.setVisibility(View.GONE.value);
+            }
+            catch (e) {
+                Logger.instance.error("close log window failed: " + e);
+            }
+        });
+    }
+    destroy() {
+        const self = this;
+        this.isLogWindowVisible = false;
+        this.listeners.clearAll();
+        if (this._loggerUnsub) {
+            try {
+                this._loggerUnsub();
+            }
+            catch { }
+            this._loggerUnsub = null;
+        }
+        Java.scheduleOnMainThread(() => {
+            try {
+                if (self.windowRoot && self.isAttached) {
+                    self.windowManager.removeView(self.windowRoot);
+                }
+            }
+            catch (e) {
+                Logger.instance.error("destroy remove log window failed: " + e);
+            }
+            finally {
+                self.windowRoot = null;
+                self.windowParams = null;
+                self.titleDragHandle = null;
+                self.logView = null;
+                self.isCreated = false;
+                self.isCreating = false;
+                self.isAttached = false;
+            }
+        });
+    }
+}

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

@@ -0,0 +1,41 @@
+import { Logger } from "../../logger.js";
+import { Theme } from "../style/theme.js";
+interface TabDefinition {
+    id: string;
+    label: string;
+}
+export declare class TabsView {
+    private context;
+    private parentView;
+    private theme;
+    tabContainer: any;
+    tabs: Map<string, {
+        label: string;
+        container: any;
+        root?: any;
+        scrollView?: any;
+        components: Set<string>;
+    }>;
+    activeTabId: any;
+    tabView: any;
+    menuPanelView: any;
+    logger: Logger;
+    initTabs: TabDefinition[];
+    currentContentContainer: any;
+    currentScrollView: any;
+    private eventEmitter;
+    tabScrollView: any;
+    tabIndicatorView: any;
+    private tabItemMap;
+    private readonly listeners;
+    constructor(context: any, theme: Theme, initTabs: TabDefinition[], activeTabId?: string);
+    createTabView(parentView: any): void;
+    selectTab(tabId: string): void;
+    private updateTabStyle;
+    private updateTabIndicator;
+    private refreshTabsUI;
+    initializeTabs(): void;
+    createTabContainer(): void;
+    destroy(): void;
+}
+export {};