frida-ui-runtime 2.0.0

package/lib/component/input.js

@@ -0,0 +1,342 @@
+import Java from "../java-runtime.js";
+import { API } from "../api.js";
+import { Logger } from "../logger.js";
+import { applyStyle, dp } from "./style/style.js";
+import { UIComponent } from "./ui-components.js";
+import { getOverlayWindowType } from "../android-runtime.js";
+import { createJavaListener, disposeJavaListenerOwner, } from "../android-listener.js";
+function setDialogOverlayType(dialog) {
+    try {
+        const window = dialog.getWindow();
+        if (!window)
+            return;
+        const LayoutParams = API.LayoutParams;
+        window.setType(getOverlayWindowType(LayoutParams));
+    }
+    catch (e) {
+        Logger.instance.warn(`[Input] Failed to set dialog overlay type: ${e}`);
+    }
+}
+class BaseInputButton extends UIComponent {
+    constructor(id, title, hint) {
+        super(id);
+        this.isShowDialog = false;
+        this.title = title;
+        this.hint = hint;
+    }
+    createBaseView(context) {
+        const LinearLayout = API.LinearLayout;
+        const LinearLayoutParams = API.LinearLayoutParams;
+        const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+        const TextView = API.TextView;
+        const Gravity = API.Gravity;
+        const String = API.JString;
+        const root = LinearLayout.$new(context);
+        root.setOrientation(LinearLayout.HORIZONTAL.value);
+        root.setGravity(Gravity.CENTER_VERTICAL.value);
+        applyStyle(root, "inputButton", this.menu.options.theme);
+        const labelView = TextView.$new(context);
+        labelView.setText.overload('java.lang.CharSequence').call(labelView, this.buildDisplayText());
+        applyStyle(labelView, "text", this.menu.options.theme);
+        labelView.setTextSize(2, 14);
+        try {
+            labelView.setTypeface(null, 1);
+        }
+        catch (_e) { }
+        labelView.setSingleLine(true);
+        labelView.setGravity(Gravity.LEFT.value | Gravity.CENTER_VERTICAL.value);
+        labelView.setLayoutParams(LinearLayoutParams.$new(0, ViewGroupLayoutParams.WRAP_CONTENT.value, 1.0));
+        const iconView = TextView.$new(context);
+        iconView.setText.overload('java.lang.CharSequence').call(iconView, "✎");
+        iconView.setTextColor(this.menu.options.theme.colors.accent);
+        iconView.setTextSize(2, 16);
+        iconView.setGravity(Gravity.CENTER.value);
+        const iconLp = LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+        iconLp.leftMargin = dp(context, 12);
+        iconView.setLayoutParams(iconLp);
+        root.addView(labelView);
+        root.addView(iconView);
+        this.view = root;
+        this.buttonView = root;
+        this.buttonLabelView = labelView;
+        this.buttonIconView = iconView;
+    }
+    refreshButtonText() {
+        if (!this.buttonLabelView)
+            return;
+        Java.scheduleOnMainThread(() => {
+            const String = API.JString;
+            this.buttonLabelView.setText.overload('java.lang.CharSequence').call(this.buttonLabelView, this.buildDisplayText());
+        });
+    }
+}
+export class NumberInput extends BaseInputButton {
+    constructor(id, initialValue = 0, title = "请输入数值", hint = "请输入数值") {
+        super(id, title, hint);
+        this.min = null;
+        this.max = null;
+        this.value = initialValue;
+    }
+    buildDisplayText() {
+        const hasValue = this.value !== null &&
+            this.value !== undefined &&
+            !isNaN(this.value);
+        return hasValue
+            ? `${this.title}: ${this.value}`
+            : `${this.title}: ${this.hint}`;
+    }
+    createView(context) {
+        this.createBaseView(context);
+        const self = this;
+        const clickListener = createJavaListener({
+            key: "view-click",
+            interfaceClass: API.OnClickListener,
+            callbacks: {
+                onClick: () => {
+                    if (self.isShowDialog)
+                        return;
+                    self.isShowDialog = true;
+                    self.showDialog(context);
+                },
+            },
+        });
+        this.own(() => clickListener.dispose());
+        this.buttonView.setClickable(true);
+        this.buttonView.setOnClickListener(clickListener.instance);
+    }
+    updateView() {
+        this.applyConstraints();
+        this.refreshButtonText();
+    }
+    showDialog(context) {
+        Java.scheduleOnMainThread(() => {
+            try {
+                const AlertDialogBuilder = API.AlertDialogBuilder;
+                const EditText = API.EditText;
+                const JString = API.JString;
+                const LinearLayout = API.LinearLayout;
+                const LinearLayoutParams = API.LinearLayoutParams;
+                const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+                const InputType = Java.use("android.text.InputType");
+                const TextViewBufferType = API.TextViewBufferType;
+                const builder = AlertDialogBuilder.$new(context);
+                builder.setTitle(JString.$new(this.title));
+                const input = EditText.$new(context);
+                input.setHint(JString.$new(this.hint));
+                const text = this.value === null ||
+                    this.value === undefined ||
+                    isNaN(this.value)
+                    ? ""
+                    : String(this.value);
+                input.setText.overload('java.lang.CharSequence', 'android.widget.TextView$BufferType').call(input, JString.$new(text), TextViewBufferType.NORMAL.value);
+                try {
+                    input.setInputType(InputType.TYPE_CLASS_NUMBER.value |
+                        InputType.TYPE_NUMBER_FLAG_SIGNED.value |
+                        InputType.TYPE_NUMBER_FLAG_DECIMAL.value);
+                }
+                catch (_e) { }
+                const lp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+                input.setLayoutParams(lp);
+                const container = LinearLayout.$new(context);
+                container.setPadding(dp(context, 16), dp(context, 12), dp(context, 16), dp(context, 8));
+                container.addView(input);
+                builder.setView(container);
+                const self = this;
+                const dialogListenerOwner = `NumberInput:${this.id}:dialog:${Date.now()}:${Math.random()}`;
+                const releaseDialogListeners = this.own(() => disposeJavaListenerOwner(dialogListenerOwner));
+                builder.setPositiveButton(JString.$new("确认"), createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnClickListener,
+                    callbacks: {
+                        onClick: (_dialog, _which) => {
+                            self.isShowDialog = false;
+                            try {
+                                const raw = Java.cast(input.getText(), Java.use("java.lang.CharSequence")).toString() + "";
+                                const parsed = parseFloat(raw.trim());
+                                if (!isNaN(parsed)) {
+                                    self.value = parsed;
+                                    self.applyConstraints();
+                                    self.refreshButtonText();
+                                    self.emit("valueChanged", self.value);
+                                    if (self.handler)
+                                        self.handler(self.value);
+                                }
+                            }
+                            catch (e) {
+                                Logger.instance.error(`[NumberInput:${self.id}] ${e}`);
+                            }
+                        },
+                    },
+                }).instance);
+                builder.setNegativeButton(JString.$new("取消"), createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnClickListener,
+                    callbacks: {
+                        onClick: (_dialog, _which) => {
+                            self.isShowDialog = false;
+                        },
+                    },
+                }).instance);
+                const dialog = builder.create();
+                const dismissListener = createJavaListener({
+                    key: "dialog-dismiss",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnDismissListener,
+                    callbacks: {
+                        onDismiss: releaseDialogListeners,
+                    },
+                });
+                dialog.setOnDismissListener(dismissListener.instance);
+                setDialogOverlayType(dialog);
+                dialog.show();
+            }
+            catch (e) {
+                this.isShowDialog = false;
+                Logger.instance.error(`[NumberInput:${this.id}] Failed to show dialog: ${e}`);
+            }
+        });
+    }
+    onValueChange(handler) {
+        this.handler = handler;
+    }
+    applyConstraints() {
+        let constrained = this.value;
+        if (this.min !== null)
+            constrained = Math.max(this.min, constrained);
+        if (this.max !== null)
+            constrained = Math.min(this.max, constrained);
+        this.value = constrained;
+    }
+    setHint(hint) {
+        this.hint = hint;
+    }
+    setConstraints(min, max) {
+        this.min = min;
+        this.max = max;
+        this.applyConstraints();
+        this.refreshButtonText();
+    }
+    getNumber() {
+        return this.value;
+    }
+    setNumber(value) {
+        this.value = value;
+        this.applyConstraints();
+        this.refreshButtonText();
+    }
+}
+export class TextInput extends BaseInputButton {
+    constructor(id, initialValue = "", title = "请输入文本", hint = "请输入文本") {
+        super(id, title, hint);
+        this.value = initialValue;
+    }
+    buildDisplayText() {
+        const text = ((this.value ?? "") + "").trim();
+        return text.length > 0
+            ? `${this.title}: ${text}`
+            : `${this.title}: ${this.hint}`;
+    }
+    createView(context) {
+        this.createBaseView(context);
+        const self = this;
+        const clickListener = createJavaListener({
+            key: "view-click",
+            interfaceClass: API.OnClickListener,
+            callbacks: {
+                onClick: () => {
+                    if (self.isShowDialog)
+                        return;
+                    self.isShowDialog = true;
+                    self.showDialog(context);
+                },
+            },
+        });
+        this.own(() => clickListener.dispose());
+        this.buttonView.setClickable(true);
+        this.buttonView.setOnClickListener(clickListener.instance);
+    }
+    updateView() {
+        this.refreshButtonText();
+    }
+    emitValue(value) {
+        this.emit("valueChanged", value);
+    }
+    onValueChange(handler) {
+        this.handler = handler;
+    }
+    showDialog(context) {
+        Java.scheduleOnMainThread(() => {
+            try {
+                const AlertDialogBuilder = API.AlertDialogBuilder;
+                const EditText = API.EditText;
+                const String = API.JString;
+                const TextViewBufferType = API.TextViewBufferType;
+                const LinearLayoutParams = API.LinearLayoutParams;
+                const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+                const LinearLayout = API.LinearLayout;
+                const builder = AlertDialogBuilder.$new(context);
+                builder.setTitle(String.$new(this.title));
+                const input = EditText.$new(context);
+                input.setHint(String.$new(this.hint));
+                input.setText.overload('java.lang.CharSequence', 'android.widget.TextView$BufferType').call(input, String.$new(this.value ?? ""), TextViewBufferType.NORMAL.value);
+                const lp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+                input.setLayoutParams(lp);
+                const container = LinearLayout.$new(context);
+                container.setPadding(dp(context, 16), dp(context, 12), dp(context, 16), dp(context, 8));
+                container.addView(input);
+                builder.setView(container);
+                const self = this;
+                const dialogListenerOwner = `TextInput:${this.id}:dialog:${Date.now()}:${Math.random()}`;
+                const releaseDialogListeners = this.own(() => disposeJavaListenerOwner(dialogListenerOwner));
+                builder.setPositiveButton(String.$new("确认"), createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnClickListener,
+                    callbacks: {
+                        onClick: (_dialog, _which) => {
+                            self.isShowDialog = false;
+                            const text = Java.cast(input.getText(), Java.use("java.lang.CharSequence")).toString() + "";
+                            self.value = text.trim();
+                            self.refreshButtonText();
+                            self.emit("valueChanged", self.value);
+                            if (self.handler)
+                                self.handler(self.value);
+                        },
+                    },
+                }).instance);
+                builder.setNegativeButton(String.$new("取消"), createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnClickListener,
+                    callbacks: {
+                        onClick: (_dialog, _which) => {
+                            self.isShowDialog = false;
+                        },
+                    },
+                }).instance);
+                const dialog = builder.create();
+                const dismissListener = createJavaListener({
+                    key: "dialog-dismiss",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnDismissListener,
+                    callbacks: {
+                        onDismiss: releaseDialogListeners,
+                    },
+                });
+                dialog.setOnDismissListener(dismissListener.instance);
+                setDialogOverlayType(dialog);
+                dialog.show();
+            }
+            catch (e) {
+                this.isShowDialog = false;
+                Logger.instance.error(`[TextInput:${this.id}] Failed to show dialog: ${e}`);
+            }
+        });
+    }
+    setText(text) {
+        this.value = text ?? "";
+        this.refreshButtonText();
+    }
+}

package/lib/component/selector.d.ts

@@ -0,0 +1,31 @@
+import { UIComponent } from "./ui-components.js";
+export declare class Selector extends UIComponent {
+    private title;
+    private items;
+    private selectedIndex;
+    private handler?;
+    private context;
+    private titleView;
+    private valueView;
+    constructor(id: string, title: string, items: {
+        label: string;
+        [key: string]: any;
+    }[], selectedIndex?: number, handler?: (value: any) => void);
+    getValue(): {
+        label: string;
+        [key: string]: any;
+    };
+    onValueChange(handler: (value: any) => void): void;
+    protected createView(context: any): void;
+    private getSelectedLabel;
+    private getDisplayText;
+    private showSelectDialog;
+    private refreshUi;
+    protected updateView(): void;
+    setItems(items: {
+        label: string;
+        [key: string]: any;
+    }[]): void;
+    getSelectedIndex(): number;
+    setTitle(title: string): void;
+}

package/lib/component/selector.js

@@ -0,0 +1,246 @@
+import Java from "../java-runtime.js";
+import { API } from "../api.js";
+import { Logger } from "../logger.js";
+import { applyStyle, dp } from "./style/style.js";
+import { UIComponent } from "./ui-components.js";
+import { deferSafe } from "../runtime/safe-runtime.js";
+import { getOverlayWindowType } from "../android-runtime.js";
+import { createJavaListener } from "../android-listener.js";
+export class Selector extends UIComponent {
+    constructor(id, title, items, selectedIndex = 0, handler) {
+        super(id);
+        this.title = title;
+        this.items = items ?? [];
+        this.selectedIndex = Math.max(0, Math.min(selectedIndex, Math.max(0, this.items.length - 1)));
+        this.value = this.items.length > 0 ? this.items[this.selectedIndex] : null;
+        this.handler = handler;
+    }
+    getValue() {
+        return this.value;
+    }
+    onValueChange(handler) {
+        this.handler = handler;
+    }
+    createView(context) {
+        this.context = context;
+        const LinearLayout = API.LinearLayout;
+        const LinearLayoutParams = API.LinearLayoutParams;
+        const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+        const TextView = API.TextView;
+        const Gravity = API.Gravity;
+        const String = API.JString;
+        const OnClickListener = API.OnClickListener;
+        const theme = this.menu.options.theme;
+        const root = LinearLayout.$new(context);
+        root.setOrientation(LinearLayout.VERTICAL.value);
+        root.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+        const titleView = TextView.$new(context);
+        titleView.setText.overload('java.lang.CharSequence').call(titleView, this.title);
+        applyStyle(titleView, "caption", theme);
+        try {
+            titleView.setTypeface(null, 1);
+        }
+        catch (_e) { }
+        try {
+            titleView.setAllCaps(true);
+        }
+        catch (_e) { }
+        try {
+            titleView.setLetterSpacing(0.04);
+        }
+        catch (_e) { }
+        const titleLp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+        titleLp.setMargins(0, 0, 0, dp(context, 8));
+        titleView.setLayoutParams(titleLp);
+        const triggerRow = LinearLayout.$new(context);
+        triggerRow.setOrientation(LinearLayout.HORIZONTAL.value);
+        triggerRow.setGravity(Gravity.CENTER_VERTICAL.value);
+        applyStyle(triggerRow, "row", theme);
+        triggerRow.setPadding(dp(context, 14), dp(context, 14), dp(context, 14), dp(context, 14));
+        const valueView = TextView.$new(context);
+        valueView.setText.overload('java.lang.CharSequence').call(valueView, this.getDisplayText());
+        applyStyle(valueView, "text", theme);
+        valueView.setTextSize(2, 14);
+        try {
+            valueView.setTypeface(null, 1);
+        }
+        catch (_e) { }
+        valueView.setSingleLine(true);
+        valueView.setGravity(Gravity.LEFT.value | Gravity.CENTER_VERTICAL.value);
+        valueView.setLayoutParams(LinearLayoutParams.$new(0, ViewGroupLayoutParams.WRAP_CONTENT.value, 1.0));
+        const arrowView = TextView.$new(context);
+        arrowView.setText.overload('java.lang.CharSequence').call(arrowView, "⌄");
+        arrowView.setTextColor(theme.colors.accent);
+        arrowView.setTextSize(2, 18);
+        try {
+            arrowView.setTypeface(null, 1);
+        }
+        catch (_e) { }
+        arrowView.setGravity(Gravity.CENTER.value);
+        const arrowLp = LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+        arrowLp.leftMargin = dp(context, 12);
+        arrowView.setLayoutParams(arrowLp);
+        triggerRow.addView(valueView);
+        triggerRow.addView(arrowView);
+        const self = this;
+        const clickListener = createJavaListener({
+            key: "view-click",
+            interfaceClass: OnClickListener,
+            callbacks: {
+                onClick: (_v) => {
+                    self.showSelectDialog();
+                },
+            },
+        });
+        this.own(() => clickListener.dispose());
+        triggerRow.setClickable(true);
+        triggerRow.setOnClickListener(clickListener.instance);
+        root.addView(titleView);
+        root.addView(triggerRow);
+        this.titleView = titleView;
+        this.valueView = valueView;
+        this.view = root;
+        this.refreshUi();
+    }
+    getSelectedLabel() {
+        if (this.selectedIndex >= 0 &&
+            this.selectedIndex < this.items.length &&
+            this.items[this.selectedIndex]) {
+            return this.items[this.selectedIndex].label ?? "";
+        }
+        return "";
+    }
+    getDisplayText() {
+        const item = this.getSelectedLabel();
+        if (!this.title && !item)
+            return "";
+        if (!this.title)
+            return item;
+        return `${item}`;
+    }
+    showSelectDialog() {
+        if (!this.context || this.items.length === 0)
+            return;
+        Java.scheduleOnMainThread(() => {
+            try {
+                const AlertDialogBuilder = API.AlertDialogBuilder ?? Java.use("android.app.AlertDialog$Builder");
+                const String = API.JString;
+                const DialogInterfaceOnClickListener = API.DialogInterfaceOnClickListener ??
+                    Java.use("android.content.DialogInterface$OnClickListener");
+                const WindowManagerLayoutParams = Java.use("android.view.WindowManager$LayoutParams");
+                const labels = this.items.map((item) => String.$new(item.label));
+                const javaItems = Java.array("java.lang.CharSequence", labels);
+                const self = this;
+                const itemClickListener = createJavaListener({
+                    key: "dialog-click",
+                    interfaceClass: DialogInterfaceOnClickListener,
+                    callbacks: {
+                        onClick: (dialog, which) => {
+                            self.selectedIndex = which;
+                            self.value = self.items[which];
+                            self.refreshUi();
+                            self.emit("valueChanged", self.value);
+                            if (self.handler) {
+                                deferSafe(`Selector:${self.id}:valueChanged`, () => self.handler(self.value));
+                            }
+                            try {
+                                dialog.dismiss();
+                            }
+                            catch (_e) { }
+                        },
+                    },
+                });
+                const builder = AlertDialogBuilder.$new(this.context);
+                builder.setTitle(String.$new(this.title));
+                builder.setItems(javaItems, itemClickListener.instance);
+                const dialog = builder.create();
+                const dismissListener = createJavaListener({
+                    key: "dialog-dismiss",
+                    interfaceClass: API.DialogInterfaceOnDismissListener,
+                    callbacks: { onDismiss: () => releaseDialogListeners() },
+                });
+                const releaseDialogListeners = this.own(() => {
+                    itemClickListener.dispose();
+                    dismissListener.dispose();
+                });
+                dialog.setOnDismissListener(dismissListener.instance);
+                try {
+                    const window = dialog.getWindow();
+                    if (window) {
+                        window.setType(getOverlayWindowType(WindowManagerLayoutParams));
+                    }
+                }
+                catch (e) {
+                    Logger.instance.warn(`[Selector:${this.id}] Failed to set dialog overlay type: ${e}`);
+                }
+                dialog.show();
+                try {
+                    const window = dialog.getWindow();
+                    if (window) {
+                        const dialogWidth = dp(this.context, 380);
+                        window.setLayout(dialogWidth, WindowManagerLayoutParams.WRAP_CONTENT.value);
+                    }
+                }
+                catch (e) {
+                    Logger.instance.warn(`[Selector:${this.id}] Failed to resize dialog: ${e}`);
+                }
+            }
+            catch (error) {
+                Logger.instance.error(`[Selector:${this.id}] Failed to show selector dialog: ${error}`);
+            }
+        });
+    }
+    refreshUi() {
+        if (!this.view)
+            return;
+        Java.scheduleOnMainThread(() => {
+            try {
+                const String = API.JString;
+                if (this.valueView) {
+                    this.valueView.setText.overload('java.lang.CharSequence').call(this.valueView, this.getDisplayText());
+                }
+            }
+            catch (error) {
+                Logger.instance.error(`[Selector:${this.id}] Failed to refresh UI: ${error}`);
+            }
+        });
+    }
+    updateView() {
+        if (!this.view) {
+            Logger.instance.warn(`[Selector:${this.id}] Cannot update view - view not initialized`);
+            return;
+        }
+        const index = this.items.findIndex((value) => value && this.value && value.label == this.value.label);
+        if (index !== -1) {
+            this.selectedIndex = index;
+        }
+        this.refreshUi();
+    }
+    setItems(items) {
+        this.items = items ?? [];
+        if (this.items.length === 0) {
+            this.selectedIndex = -1;
+            this.value = null;
+        }
+        else {
+            if (this.selectedIndex < 0 || this.selectedIndex >= this.items.length) {
+                this.selectedIndex = 0;
+            }
+            this.value = this.items[this.selectedIndex];
+        }
+        this.refreshUi();
+    }
+    getSelectedIndex() {
+        return this.selectedIndex;
+    }
+    setTitle(title) {
+        this.title = title;
+        if (!this.titleView)
+            return;
+        Java.scheduleOnMainThread(() => {
+            const String = API.JString;
+            this.titleView.setText.overload('java.lang.CharSequence').call(this.titleView, title);
+            this.refreshUi();
+        });
+    }
+}

package/lib/component/slider.d.ts

@@ -0,0 +1,18 @@
+import { UIComponent } from "./ui-components.js";
+export declare class Slider extends UIComponent {
+    private min;
+    private max;
+    private step;
+    private label;
+    private handler?;
+    constructor(id: string, label: string, min: number, max: number, initialValue?: number, step?: number, handler?: (value: number) => void);
+    protected createView(context: any): void;
+    onValueChange(handler: (value: number) => void): void;
+    protected updateView(): void;
+    setLabel(label: string): void;
+    setRange(min: number, max: number, step?: number): void;
+    private calculateSeekBarMax;
+    private valueToProgress;
+    private progressToValue;
+    private clampToStep;
+}