frida-ui-runtime 2.0.0

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

@@ -0,0 +1,334 @@
+import Java from "../../java-runtime.js";
+import { API } from "../../api.js";
+import { EventEmitter } from "../../event-emitter.js";
+import { Logger } from "../../logger.js";
+import { dp } from "../style/style.js";
+import { createJavaListener } from "../../android-listener.js";
+import { ListenerRegistry } from "../../runtime/listener-registry.js";
+export class TabsView {
+    constructor(context, theme, initTabs, activeTabId) {
+        this.tabs = new Map();
+        this.logger = Logger.instance;
+        this.eventEmitter = new EventEmitter();
+        this.tabItemMap = new Map();
+        this.listeners = new ListenerRegistry();
+        this.context = context;
+        this.theme = theme;
+        this.initTabs = initTabs;
+        this.activeTabId = activeTabId;
+    }
+    createTabView(parentView) {
+        this.parentView = parentView;
+        if (this.tabs.size === 1 && this.tabs.has("default")) {
+            return;
+        }
+        this.tabItemMap.clear();
+        try {
+            const LinearLayout = API.LinearLayout;
+            const LinearLayoutParams = API.LinearLayoutParams;
+            const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+            const TextView = API.TextView;
+            const OnClickListener = API.OnClickListener;
+            const JString = API.JString;
+            const HorizontalScrollView = API.HorizontalScrollView;
+            const GradientDrawable = API.GradientDrawable;
+            const Gravity = API.Gravity;
+            const self = this;
+            const outerScroll = HorizontalScrollView.$new(this.context);
+            outerScroll.setHorizontalScrollBarEnabled(false);
+            outerScroll.setFillViewport(false);
+            outerScroll.setPadding(dp(this.context, 12), dp(this.context, 6), dp(this.context, 12), dp(this.context, 6));
+            const scrollLp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+            scrollLp.setMargins(0, 0, 0, 0);
+            outerScroll.setLayoutParams(scrollLp);
+            try {
+                outerScroll.setClipToPadding(false);
+            }
+            catch { }
+            try {
+                outerScroll.setClipChildren(false);
+            }
+            catch { }
+            const tabContainer = LinearLayout.$new(this.context);
+            tabContainer.setOrientation(0);
+            tabContainer.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            tabContainer.setPadding(0, 0, 0, 0);
+            this.tabContainer = tabContainer;
+            outerScroll.addView(tabContainer);
+            const tabBarRoot = LinearLayout.$new(this.context);
+            tabBarRoot.setOrientation(1);
+            tabBarRoot.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            this.tabScrollView = outerScroll;
+            const indicator = API.View.$new(this.context);
+            const indicatorLp = LinearLayoutParams.$new(dp(this.context, 0), dp(this.context, 2));
+            indicatorLp.setMargins(dp(this.context, 12), dp(this.context, 2), dp(this.context, 12), dp(this.context, 0));
+            indicator.setLayoutParams(indicatorLp);
+            indicator.setBackgroundColor(0xffffffff | 0);
+            this.tabIndicatorView = indicator;
+            tabBarRoot.addView(outerScroll);
+            tabBarRoot.addView(indicator);
+            this.tabView = tabBarRoot;
+            for (const [tabId, tabInfo] of this.tabs) {
+                const tabItem = LinearLayout.$new(this.context);
+                tabItem.setOrientation(1);
+                tabItem.setGravity(Gravity.CENTER.value);
+                try {
+                    tabItem.setBackground(null);
+                }
+                catch { }
+                try {
+                    tabItem.setBackgroundColor(0x00000000);
+                }
+                catch { }
+                tabItem.setPadding(dp(this.context, 12), dp(this.context, 6), dp(this.context, 12), dp(this.context, 0));
+                this.tabItemMap.set(tabId, tabItem);
+                const itemLp = LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+                itemLp.setMargins(0, 0, 0, 0);
+                tabItem.setLayoutParams(itemLp);
+                const label = TextView.$new(this.context);
+                label.setText.overload('java.lang.CharSequence').call(label, JString.$new(tabInfo.label));
+                label.setSingleLine(true);
+                label.setAllCaps(false);
+                label.setTextSize(2, this.theme.textSp.body);
+                label.setGravity(Gravity.CENTER.value);
+                try {
+                    label.setBackground(null);
+                }
+                catch {
+                    try {
+                        label.setBackgroundColor(0x00000000);
+                    }
+                    catch { }
+                }
+                const underline = API.View.$new(this.context);
+                const ulLp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, dp(this.context, 2));
+                ulLp.setMargins(0, dp(this.context, 6), 0, 0);
+                underline.setLayoutParams(ulLp);
+                underline.setBackgroundColor(this.theme.colors.accent);
+                underline.setVisibility(API.View.GONE.value);
+                tabItem.addView(label);
+                tabItem.addView(underline);
+                this.updateTabStyle(tabItem, tabId === this.activeTabId);
+                const tabClickListener = createJavaListener({
+                    key: "view-click",
+                    interfaceClass: OnClickListener,
+                    callbacks: {
+                        onClick: () => {
+                            self.selectTab(tabId);
+                        },
+                    },
+                });
+                this.listeners.add("tabs", () => tabClickListener.dispose());
+                tabItem.setOnClickListener(tabClickListener.instance);
+                tabContainer.addView(tabItem);
+            }
+            parentView.addView(this.tabView);
+        }
+        catch (error) {
+            this.logger.error("Failed to create tab view: " + error);
+        }
+    }
+    selectTab(tabId) {
+        if (!this.tabs.has(tabId) || tabId === this.activeTabId)
+            return;
+        const oldTabId = this.activeTabId;
+        this.activeTabId = tabId;
+        Java.scheduleOnMainThread(() => {
+            try {
+                const View = API.View;
+                for (const [id, tabInfo] of this.tabs) {
+                    const root = tabInfo.root;
+                    if (!root)
+                        continue;
+                    if (id === tabId) {
+                        root.setVisibility(View.VISIBLE.value);
+                        this.currentContentContainer = tabInfo.container;
+                        this.currentScrollView = tabInfo.scrollView;
+                    }
+                    else {
+                        root.setVisibility(View.GONE.value);
+                    }
+                }
+                this.refreshTabsUI();
+                this.eventEmitter.emit("tabChanged", tabId, oldTabId);
+            }
+            catch (error) {
+                Logger.instance.error(`Failed to switch to tab ${tabId}:`, error);
+            }
+        });
+    }
+    updateTabStyle(tabItem, isActive) {
+        try {
+            const View = API.View;
+            const TextView = API.TextView;
+            const label = Java.cast(tabItem.getChildAt(0), TextView);
+            const underline = tabItem.getChildAt(1);
+            if (isActive) {
+                label.setTextColor(this.theme.colors.text);
+                try {
+                    label.setTypeface(null, 1);
+                }
+                catch { }
+                underline.setVisibility(View.VISIBLE.value);
+            }
+            else {
+                label.setTextColor(this.theme.colors.subText);
+                try {
+                    label.setTypeface(null, 0);
+                }
+                catch { }
+                underline.setVisibility(View.GONE.value);
+            }
+        }
+        catch (e) {
+            Logger.instance.error(e);
+        }
+    }
+    updateTabIndicator(activeTabId) {
+        try {
+            if (!this.tabContainer || !this.tabIndicatorView || !this.tabScrollView)
+                return;
+            const tabIds = Array.from(this.tabs.keys());
+            const idx = tabIds.indexOf(activeTabId);
+            if (idx < 0)
+                return;
+            const child = this.tabContainer.getChildAt(idx);
+            if (!child)
+                return;
+            const indicator = this.tabIndicatorView;
+            const scroll = this.tabScrollView;
+            const runnable = createJavaListener({
+                key: "runnable",
+                interfaceClass: Java.use("java.lang.Runnable"),
+                callbacks: {
+                    run: () => {
+                        try {
+                            const width = child.getWidth();
+                            const leftInContainer = child.getLeft();
+                            const scrollX = scroll.getScrollX();
+                            const padL = scroll.getPaddingLeft();
+                            const lp = indicator.getLayoutParams();
+                            lp.width = width;
+                            lp.leftMargin = padL + leftInContainer - scrollX;
+                            indicator.setLayoutParams(lp);
+                        }
+                        catch { }
+                    },
+                },
+            });
+            this.listeners.add("tabs", () => runnable.dispose());
+            scroll.post(runnable.instance);
+        }
+        catch (e) { }
+    }
+    refreshTabsUI() {
+        try {
+            if (!this.tabItemMap)
+                return;
+            for (const [tabId, tabItem] of this.tabItemMap) {
+                this.updateTabStyle(tabItem, tabId === this.activeTabId);
+            }
+        }
+        catch (e) {
+            Logger.instance.error(e);
+        }
+    }
+    initializeTabs() {
+        this.tabs.clear();
+        if (this.initTabs && this.initTabs.length > 0) {
+            for (const tabDef of this.initTabs) {
+                this.tabs.set(tabDef.id, {
+                    label: tabDef.label,
+                    container: null,
+                    components: new Set(),
+                });
+            }
+            if (this.activeTabId && this.tabs.has(this.activeTabId)) {
+                this.activeTabId = this.activeTabId;
+            }
+            else if (this.initTabs.length > 0) {
+                this.activeTabId = this.initTabs[0].id;
+            }
+        }
+        else {
+            this.tabs.set("default", {
+                label: "Default",
+                container: null,
+                components: new Set(),
+            });
+            this.activeTabId = "default";
+        }
+    }
+    createTabContainer() {
+        const ScrollView = API.ScrollView;
+        const LinearLayout = API.LinearLayout;
+        const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+        const LinearLayoutParams = API.LinearLayoutParams;
+        const View = API.View;
+        const tabRootsWrapper = LinearLayout.$new(this.context);
+        tabRootsWrapper.setOrientation(LinearLayout.VERTICAL.value);
+        tabRootsWrapper.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+        if (!this.tabs || this.tabs.size === 0) {
+            Logger.instance.warn("[FloatMenu] tabs is empty, tab container will be blank.");
+        }
+        let firstTabId = null;
+        let firstTabInfo = null;
+        for (const [tabId, tabInfo] of this.tabs) {
+            if (!firstTabId) {
+                firstTabId = tabId;
+                firstTabInfo = tabInfo;
+            }
+            const sv = ScrollView.$new(this.context);
+            sv.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, 0, 1.0));
+            try {
+                sv.setBackgroundColor(0x00000000);
+            }
+            catch (e) { }
+            try {
+                sv.setFillViewport(true);
+                sv.setVerticalScrollBarEnabled(false);
+            }
+            catch (e) { }
+            const tabContainer = LinearLayout.$new(this.context);
+            tabContainer.setOrientation(LinearLayout.VERTICAL.value);
+            tabContainer.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            sv.addView(tabContainer);
+            if (tabId === this.activeTabId) {
+                sv.setVisibility(View.VISIBLE.value);
+                this.currentContentContainer = tabContainer;
+                this.currentScrollView = sv;
+            }
+            else {
+                sv.setVisibility(View.GONE.value);
+            }
+            tabInfo.container = tabContainer;
+            tabInfo.scrollView = sv;
+            tabInfo.root = sv;
+            tabRootsWrapper.addView(sv);
+        }
+        if ((!this.currentContentContainer || !this.currentScrollView) &&
+            firstTabId &&
+            firstTabInfo) {
+            this.activeTabId = firstTabId;
+            if (firstTabInfo.root)
+                firstTabInfo.root.setVisibility(View.VISIBLE.value);
+            this.currentContentContainer = firstTabInfo.container;
+            this.currentScrollView = firstTabInfo.scrollView;
+        }
+        this.parentView.addView(tabRootsWrapper);
+    }
+    destroy() {
+        this.listeners.clearAll();
+        this.eventEmitter.removeAllListeners();
+        this.tabItemMap.clear();
+        this.tabs.clear();
+        this.tabContainer = null;
+        this.tabView = null;
+        this.tabScrollView = null;
+        this.tabIndicatorView = null;
+        this.currentContentContainer = null;
+        this.currentScrollView = null;
+        this.parentView = null;
+        this.menuPanelView = null;
+    }
+}

package/lib/constant-config.d.ts

@@ -0,0 +1,5 @@
+export declare class ConstantConfig {
+    static screenWidth: number;
+    static screenHeight: number;
+    static isDev: boolean;
+}

package/lib/constant-config.js

@@ -0,0 +1,3 @@
+export class ConstantConfig {
+}
+ConstantConfig.isDev = false;

package/lib/event-emitter.d.ts

@@ -0,0 +1,10 @@
+type Listener = (...args: any[]) => void;
+export declare class EventEmitter {
+    private events;
+    on(event: string, listener: Listener): () => void;
+    off(event: string, listener: Listener): void;
+    emit(event: string, ...args: any[]): void;
+    once(event: string, listener: Listener): () => void;
+    removeAllListeners(event?: string): void;
+}
+export {};

package/lib/event-emitter.js

@@ -0,0 +1,52 @@
+import { Logger } from "./logger.js";
+export class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event).push(listener);
+        return () => this.off(event, listener);
+    }
+    off(event, listener) {
+        const listeners = this.events.get(event);
+        if (!listeners)
+            return;
+        const index = listeners.indexOf(listener);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+    }
+    emit(event, ...args) {
+        const listeners = this.events.get(event);
+        if (!listeners)
+            return;
+        listeners.slice().forEach((listener) => {
+            setImmediate(() => {
+                try {
+                    listener(...args);
+                }
+                catch (error) {
+                    Logger.instance.error(`Error in event listener for ${event}:`, error);
+                }
+            });
+        });
+    }
+    once(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener(...args);
+        };
+        return this.on(event, onceWrapper);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+    }
+}

package/lib/float-menu.d.ts

@@ -0,0 +1,103 @@
+import { UIComponent } from "./component/ui-components.js";
+import { Logger } from "./logger.js";
+import { Theme } from "./component/style/theme.js";
+import { LifecycleState } from "./runtime/lifecycle-controller.js";
+export interface TabDefinition {
+    id: string;
+    label: string;
+}
+export interface FloatMenuIconOptions {
+    base64: string;
+    width?: number;
+    height?: number;
+}
+export interface FloatMenuOptions {
+    version?: string;
+    width?: number;
+    height?: number;
+    x?: number;
+    y?: number;
+    icon?: FloatMenuIconOptions;
+    permissionDeniedMessage?: string;
+    logMaxLines?: number;
+    theme?: Theme;
+    title?: string;
+    tabs?: TabDefinition[];
+    activeTab?: string;
+}
+export type MenuPresentation = "icon" | "menu";
+export type FloatMenuSetup = (menu: FloatMenu) => void | Promise<void>;
+export interface FloatMenuSnapshot {
+    activeTabId: string;
+    presentation: MenuPresentation;
+    components: Record<string, unknown>;
+}
+export declare class FloatMenu {
+    static waitForReady(timeoutMs?: number): Promise<any>;
+    static create(options?: FloatMenuOptions, timeoutMs?: number): Promise<FloatMenu>;
+    static launch(options?: FloatMenuOptions, setup?: FloatMenuSetup, timeoutMs?: number): Promise<FloatMenu>;
+    options: FloatMenuOptions;
+    private headerView;
+    private headerComponent;
+    private iconView;
+    private readonly components;
+    private readonly componentListeners;
+    private readonly lifecycle;
+    private pendingComponents;
+    private eventEmitter;
+    private isIconMode;
+    private _context;
+    private lastTouchX;
+    private lastTouchY;
+    private screenWidth;
+    private screenHeight;
+    private readonly iconWidth;
+    private readonly iconHeight;
+    private menuWindowParams;
+    private iconWindowParams;
+    private iconContainerWin;
+    private iconAttached;
+    private menuAttached;
+    private lastPresentation;
+    private menuContainerWin;
+    private menuPanelView;
+    logger: Logger;
+    private tabsView;
+    get context(): any;
+    private _windowManager;
+    get windowManager(): any;
+    private constructor();
+    get state(): LifecycleState;
+    private runOnMainThread;
+    private reportAsyncFailure;
+    private enforceNonFocusableWindow;
+    private addDragListener;
+    private createMenuContainerWindow;
+    private updatePosition;
+    private createIconWindow;
+    private canDrawOverlays;
+    private showToastNow;
+    private concealFromHeader;
+    private mountInternal;
+    private presentInternal;
+    mount(): Promise<void>;
+    present(mode?: MenuPresentation): Promise<void>;
+    conceal(): Promise<void>;
+    toggle(): Promise<void>;
+    private detachWindows;
+    private bindComponentEvents;
+    private processPendingComponents;
+    private prepareComponentView;
+    dispose(): Promise<void>;
+    toast(msg: string, duration?: 0 | 1): Promise<void>;
+    addComponent(component: UIComponent, tabId?: string): Promise<void>;
+    addNestedComponent(ownerId: string, component: UIComponent, container: any): Promise<void>;
+    attachNestedComponent(ownerId: string, component: UIComponent, container: any): void;
+    removeComponent(id: string): Promise<void>;
+    getComponent<T extends UIComponent>(id: string): T | undefined;
+    setComponentValue(id: string, value: any): void;
+    captureState(): FloatMenuSnapshot;
+    restoreState(snapshot: FloatMenuSnapshot): Promise<void>;
+    on(event: string, callback: (...args: any[]) => void): () => void;
+    off(event: string, callback: (...args: any[]) => void): void;
+}