frida-ui-runtime 2.0.0

package/lib/api.js

@@ -0,0 +1,156 @@
+import Java from "./java-runtime.js";
+export const API = {
+    get ImageView() {
+        return Java.use("android.widget.ImageView");
+    },
+    get ImageViewScaleType() {
+        return Java.use("android.widget.ImageView$ScaleType");
+    },
+    get FrameLayoutParams() {
+        return Java.use("android.widget.FrameLayout$LayoutParams");
+    },
+    get PopupWindow() {
+        return Java.use("android.widget.PopupWindow");
+    },
+    get PopupWindowOnDismissListener() {
+        return Java.use("android.widget.PopupWindow$OnDismissListener");
+    },
+    get Gravity() {
+        return Java.use("android.view.Gravity");
+    },
+    get DialogMultiChoiceListener() {
+        return Java.use("android.content.DialogInterface$OnMultiChoiceClickListener");
+    },
+    get DialogClickListener() {
+        return Java.use("android.content.DialogInterface$OnClickListener");
+    },
+    get HorizontalScrollView() {
+        return Java.use("android.widget.HorizontalScrollView");
+    },
+    get Context() {
+        return Java.use("android.content.Context");
+    },
+    get GradientDrawable() {
+        return Java.use("android.graphics.drawable.GradientDrawable");
+    },
+    get BitmapFactory() {
+        return Java.use("android.graphics.BitmapFactory");
+    },
+    get Base64() {
+        return Java.use("android.util.Base64");
+    },
+    get Button() {
+        return Java.use("android.widget.Button");
+    },
+    get Color() {
+        return Java.use("android.graphics.Color");
+    },
+    get ViewManager() {
+        return Java.use("android.view.ViewManager");
+    },
+    get JString() {
+        return Java.use("java.lang.String");
+    },
+    get View() {
+        return Java.use("android.view.View");
+    },
+    get GridLayout() {
+        return Java.use("android.widget.GridLayout");
+    },
+    get CheckBox() {
+        return Java.use("android.widget.CheckBox");
+    },
+    get SeekBar() {
+        return Java.use("android.widget.SeekBar");
+    },
+    get Html() {
+        return Java.use("android.text.Html");
+    },
+    get SeekBarOnSeekBarChangeListener() {
+        return Java.use("android.widget.SeekBar$OnSeekBarChangeListener");
+    },
+    get AdapterViewOnItemSelectedListener() {
+        return Java.use("android.widget.AdapterView$OnItemSelectedListener");
+    },
+    get Spinner() {
+        return Java.use("android.widget.Spinner");
+    },
+    get ArrayAdapter() {
+        return Java.use("android.widget.ArrayAdapter");
+    },
+    get R_layout() {
+        return Java.use("android.R$layout");
+    },
+    get DialogInterfaceOnClickListener() {
+        return Java.use("android.content.DialogInterface$OnClickListener");
+    },
+    get DialogInterfaceOnDismissListener() {
+        return Java.use("android.content.DialogInterface$OnDismissListener");
+    },
+    get AlertDialogBuilder() {
+        return Java.use("android.app.AlertDialog$Builder");
+    },
+    get AlertDialog() {
+        return Java.use("android.app.AlertDialog");
+    },
+    get OnTouchListener() {
+        return Java.use("android.view.View$OnTouchListener");
+    },
+    get MotionEvent() {
+        return Java.use("android.view.MotionEvent");
+    },
+    get EditText() {
+        return Java.use("android.widget.EditText");
+    },
+    get Point() {
+        return Java.use("android.graphics.Point");
+    },
+    get DisplayMetrics() {
+        return Java.use("android.util.DisplayMetrics");
+    },
+    get TextViewBufferType() {
+        return Java.use("android.widget.TextView$BufferType");
+    },
+    get InputType() {
+        return Java.use("android.text.InputType");
+    },
+    get GridLayoutParams() {
+        return Java.use("android.widget.GridLayout$LayoutParams");
+    },
+    get Switch() {
+        return Java.use("android.widget.Switch");
+    },
+    get OnCheckedChangeListener() {
+        return Java.use("android.widget.CompoundButton$OnCheckedChangeListener");
+    },
+    get CompoundButtonOnCheckedChangeListener() {
+        return Java.use("android.widget.CompoundButton$OnCheckedChangeListener");
+    },
+    get TextView() {
+        return Java.use("android.widget.TextView");
+    },
+    get OnClickListener() {
+        return Java.use("android.view.View$OnClickListener");
+    },
+    get FrameLayout() {
+        return Java.use("android.widget.FrameLayout");
+    },
+    get ViewGroupLayoutParams() {
+        return Java.use("android.view.ViewGroup$LayoutParams");
+    },
+    get LayoutParams() {
+        return Java.use("android.view.WindowManager$LayoutParams");
+    },
+    get BuildVERSION() {
+        return Java.use("android.os.Build$VERSION");
+    },
+    get LinearLayout() {
+        return Java.use("android.widget.LinearLayout");
+    },
+    get LinearLayoutParams() {
+        return Java.use("android.widget.LinearLayout$LayoutParams");
+    },
+    get ScrollView() {
+        return Java.use("android.widget.ScrollView");
+    },
+};

package/lib/component/button.d.ts

@@ -0,0 +1,11 @@
+import { UIComponent } from "./ui-components.js";
+export declare class Button extends UIComponent {
+    private label;
+    private handler?;
+    private kind;
+    constructor(id: string, label: string, kind?: "primary" | "danger", handler?: () => void);
+    protected createView(context: any): void;
+    protected updateView(): void;
+    setLabel(label: string): void;
+    onClick(handler: () => void): void;
+}

package/lib/component/button.js

@@ -0,0 +1,61 @@
+import Java from "../java-runtime.js";
+import { API } from "../api.js";
+import { Logger } from "../logger.js";
+import { deferSafe } from "../runtime/safe-runtime.js";
+import { createJavaListener } from "../android-listener.js";
+import { applyStyle } from "./style/style.js";
+import { UIComponent } from "./ui-components.js";
+export class Button extends UIComponent {
+    constructor(id, label, kind = "primary", handler) {
+        super(id);
+        this.kind = "primary";
+        this.label = label;
+        this.kind = kind;
+        this.handler = handler;
+        this.value = null;
+    }
+    createView(context) {
+        const Button = API.Button;
+        const String = API.JString;
+        const Gravity = API.Gravity;
+        this.view = Button.$new(context);
+        this.view.setText.overload('java.lang.CharSequence').call(this.view, this.label);
+        applyStyle(this.view, this.kind === "danger" ? "dangerButton" : "primaryButton", this.menu.options.theme);
+        try {
+            this.view.setGravity(Gravity.CENTER.value);
+        }
+        catch (_e) { }
+        const OnClickListener = API.OnClickListener;
+        const self = this;
+        const clickListener = createJavaListener({
+            key: "view-click",
+            interfaceClass: OnClickListener,
+            callbacks: {
+                onClick: (_v) => {
+                    self.emit("click");
+                    if (self.handler) {
+                        deferSafe(`Button:${self.id}:click`, self.handler);
+                    }
+                },
+            },
+        });
+        this.own(() => clickListener.dispose());
+        this.view.setOnClickListener(clickListener.instance);
+    }
+    updateView() {
+    }
+    setLabel(label) {
+        this.label = label;
+        if (!this.view) {
+            Logger.instance.warn(`[Button:${this.id}] Cannot set label - view not initialized`);
+            return;
+        }
+        Java.scheduleOnMainThread(() => {
+            const String = API.JString;
+            this.view.setText.overload('java.lang.CharSequence').call(this.view, label);
+        });
+    }
+    onClick(handler) {
+        this.handler = handler;
+    }
+}

package/lib/component/category.d.ts

@@ -0,0 +1,9 @@
+import { UIComponent } from "./ui-components.js";
+export declare class Category extends UIComponent {
+    private label;
+    private labelView;
+    constructor(id: string, label: string);
+    protected createView(context: any): void;
+    protected updateView(): void;
+    setLabel(label: string): void;
+}

package/lib/component/category.js

@@ -0,0 +1,57 @@
+import Java from "../java-runtime.js";
+import { API } from "../api.js";
+import { applyStyle, dp } from "./style/style.js";
+import { UIComponent } from "./ui-components.js";
+export class Category extends UIComponent {
+    constructor(id, label) {
+        super(id);
+        this.label = label;
+        this.value = label;
+    }
+    createView(context) {
+        const LinearLayout = API.LinearLayout;
+        const LinearLayoutParams = API.LinearLayoutParams;
+        const ViewGroupLayoutParams = API.ViewGroupLayoutParams;
+        const TextView = API.TextView;
+        const View = API.View;
+        const Gravity = API.Gravity;
+        const String = API.JString;
+        const theme = this.menu.options.theme;
+        const root = LinearLayout.$new(context);
+        root.setOrientation(LinearLayout.HORIZONTAL.value);
+        root.setGravity(Gravity.CENTER_VERTICAL.value);
+        root.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+        root.setPadding(dp(context, 2), dp(context, 10), dp(context, 2), dp(context, 8));
+        const indicator = View.$new(context);
+        const indicatorLp = LinearLayoutParams.$new(dp(context, 3), dp(context, 14));
+        indicatorLp.setMargins(0, 0, dp(context, 10), 0);
+        indicator.setLayoutParams(indicatorLp);
+        const GradientDrawable = API.GradientDrawable;
+        const indicatorBg = GradientDrawable.$new();
+        indicatorBg.setColor(theme.colors.accent | 0);
+        indicatorBg.setCornerRadius(dp(context, 2));
+        indicator.setBackground(indicatorBg);
+        const labelView = TextView.$new(context);
+        labelView.setText.overload('java.lang.CharSequence').call(labelView, this.label);
+        applyStyle(labelView, "category", theme);
+        const textLp = LinearLayoutParams.$new(0, ViewGroupLayoutParams.WRAP_CONTENT.value, 1.0);
+        labelView.setLayoutParams(textLp);
+        root.addView(indicator);
+        root.addView(labelView);
+        this.labelView = labelView;
+        this.view = root;
+    }
+    updateView() {
+        if (!this.labelView)
+            return;
+        Java.scheduleOnMainThread(() => {
+            const String = API.JString;
+            this.labelView.setText.overload('java.lang.CharSequence').call(this.labelView, this.value);
+        });
+    }
+    setLabel(label) {
+        this.label = label;
+        this.value = label;
+        this.updateView();
+    }
+}

package/lib/component/checkBox.d.ts

@@ -0,0 +1,33 @@
+import { UIComponent } from "./ui-components.js";
+export interface CheckBoxOption {
+    id: string;
+    label: string;
+    [key: string]: any;
+}
+export declare class CheckBoxGroup extends UIComponent {
+    private optionsMap;
+    private title;
+    private changeHandler?;
+    private valueChangeHandler?;
+    private maxDisplayCount;
+    private titleView;
+    private valueView;
+    private arrowView;
+    private triggerRow;
+    constructor(id: string, title: string, options: CheckBoxOption[], initialChecked?: string[]);
+    onChangeHandler(handler: (value: CheckBoxOption[], item?: {
+        id: string;
+        checked: boolean;
+    }) => void): void;
+    onValueChangeHandler(handler: (value: CheckBoxOption[]) => void): void;
+    setMaxDisplayCount(n: number): void;
+    protected createView(context: any): void;
+    private openMultiSelectDialog;
+    protected updateView(): void;
+    private getDisplayText;
+    getCheckedValues(): CheckBoxOption[];
+    setChecked(id: string, checked: boolean): void;
+    setCheckedValues(checkedIds: string[]): void;
+    getOptions(): CheckBoxOption[];
+    setTitle(title: string): void;
+}

package/lib/component/checkBox.js

@@ -0,0 +1,276 @@
+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, disposeJavaListenerOwner, } from "../android-listener.js";
+export class CheckBoxGroup extends UIComponent {
+    constructor(id, title, options, initialChecked = []) {
+        super(id);
+        this.optionsMap = new Map();
+        this.maxDisplayCount = 3;
+        this.title = title;
+        for (const opt of options) {
+            const checked = initialChecked.includes(opt.id);
+            this.optionsMap.set(opt.id, { ...opt, checked });
+        }
+        this.value = this.getCheckedValues();
+    }
+    onChangeHandler(handler) {
+        this.changeHandler = handler;
+    }
+    onValueChangeHandler(handler) {
+        this.valueChangeHandler = handler;
+    }
+    setMaxDisplayCount(n) {
+        this.maxDisplayCount = Math.max(1, n);
+        this.updateView();
+    }
+    createView(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: () => {
+                    self.openMultiSelectDialog(context);
+                },
+            },
+        });
+        this.own(() => clickListener.dispose());
+        triggerRow.setClickable(true);
+        triggerRow.setOnClickListener(clickListener.$new());
+        root.addView(titleView);
+        root.addView(triggerRow);
+        this.view = root;
+        this.titleView = titleView;
+        this.valueView = valueView;
+        this.arrowView = arrowView;
+        this.triggerRow = triggerRow;
+    }
+    openMultiSelectDialog(context) {
+        Java.scheduleOnMainThread(() => {
+            let releaseDialogListeners = () => { };
+            try {
+                const AlertDialogBuilder = API.AlertDialogBuilder;
+                const String = API.JString;
+                const opts = Array.from(this.optionsMap.values());
+                const labels = opts.map((o) => o.label);
+                const checkedArr = opts.map((o) => !!o.checked);
+                const csArray = Java.array("java.lang.CharSequence", labels.map((s) => String.$new(s)));
+                const boolArray = Java.array("boolean", checkedArr);
+                const DialogMultiChoiceListener = API.DialogMultiChoiceListener;
+                const DialogClickListener = API.DialogClickListener;
+                const self = this;
+                const dialogListenerOwner = `CheckBoxGroup:${this.id}:dialog:${Date.now()}:${Math.random()}`;
+                releaseDialogListeners = this.own(() => disposeJavaListenerOwner(dialogListenerOwner));
+                const multiListener = createJavaListener({
+                    key: "dialog-multi-choice",
+                    owner: dialogListenerOwner,
+                    interfaceClass: DialogMultiChoiceListener,
+                    callbacks: {
+                        onClick: (_dialog, which, isChecked) => {
+                            const opt = opts[which];
+                            self.optionsMap.set(opt.id, { ...opt, checked: isChecked });
+                            self.value = self.getCheckedValues();
+                            self.emit("change", self.value, { id: opt.id, checked: isChecked });
+                            if (self.changeHandler) {
+                                deferSafe(`CheckBoxGroup:${self.id}:change`, () => self.changeHandler(self.value, {
+                                    id: opt.id,
+                                    checked: isChecked,
+                                }));
+                            }
+                        },
+                    },
+                });
+                const okListener = createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: DialogClickListener,
+                    callbacks: {
+                        onClick: (dialog, _which) => {
+                            self.value = self.getCheckedValues();
+                            self.updateView();
+                            self.emit("valueChanged", self.value);
+                            if (self.valueChangeHandler) {
+                                deferSafe(`CheckBoxGroup:${self.id}:valueChanged`, () => self.valueChangeHandler(self.value));
+                            }
+                            dialog.dismiss();
+                        },
+                    },
+                });
+                const cancelListener = createJavaListener({
+                    key: "dialog-click",
+                    owner: dialogListenerOwner,
+                    interfaceClass: DialogClickListener,
+                    callbacks: {
+                        onClick: (dialog, _which) => {
+                            dialog.dismiss();
+                        },
+                    },
+                });
+                const builder = AlertDialogBuilder.$new(context);
+                builder.setTitle(String.$new(this.title || "请选择"));
+                builder.setMultiChoiceItems(csArray, boolArray, multiListener.$new());
+                builder.setPositiveButton(String.$new("确定"), okListener.$new());
+                builder.setNegativeButton(String.$new("取消"), cancelListener.$new());
+                const dialog = builder.create();
+                const dismissListener = createJavaListener({
+                    key: "dialog-dismiss",
+                    owner: dialogListenerOwner,
+                    interfaceClass: API.DialogInterfaceOnDismissListener,
+                    callbacks: { onDismiss: releaseDialogListeners },
+                });
+                dialog.setOnDismissListener(dismissListener.instance);
+                const WindowManagerLP = API.LayoutParams;
+                const win = dialog.getWindow();
+                if (win) {
+                    win.setType(getOverlayWindowType(WindowManagerLP));
+                    win.addFlags(WindowManagerLP.FLAG_NOT_TOUCH_MODAL.value);
+                }
+                dialog.show();
+            }
+            catch (error) {
+                releaseDialogListeners();
+                Logger.instance.error(`[CheckBoxGroup:${this.id}] Failed to show dialog: ${error}`);
+            }
+        });
+    }
+    updateView() {
+        if (!this.valueView)
+            return;
+        Java.scheduleOnMainThread(() => {
+            const String = API.JString;
+            this.valueView.setText.overload('java.lang.CharSequence').call(this.valueView, this.getDisplayText());
+        });
+    }
+    getDisplayText() {
+        const selected = this.getCheckedValues();
+        if (selected.length === 0) {
+            return `请选择`;
+        }
+        const labels = selected.map((x) => x.label);
+        if (labels.length <= this.maxDisplayCount) {
+            return `${labels.join("、")}`;
+        }
+        const shown = labels.slice(0, this.maxDisplayCount).join("、");
+        const rest = labels.length - this.maxDisplayCount;
+        return `${shown} +${rest}`;
+    }
+    getCheckedValues() {
+        return Array.from(this.optionsMap.values()).filter((op) => op.checked);
+    }
+    setChecked(id, checked) {
+        if (!this.optionsMap.has(id)) {
+            Logger.instance.warn(`[CheckBoxGroup:${this.id}] Option with id "${id}" not found`);
+            return;
+        }
+        const opt = this.optionsMap.get(id);
+        this.optionsMap.set(id, { ...opt, checked });
+        this.value = this.getCheckedValues();
+        this.updateView();
+        this.emit("change", this.value, { id, checked });
+        this.emit("valueChanged", this.value);
+        if (this.changeHandler) {
+            deferSafe(`CheckBoxGroup:${this.id}:change`, () => this.changeHandler(this.value, { id: opt.id, checked }));
+        }
+        if (this.valueChangeHandler) {
+            deferSafe(`CheckBoxGroup:${this.id}:valueChanged`, () => this.valueChangeHandler(this.value));
+        }
+    }
+    setCheckedValues(checkedIds) {
+        for (const [id, opt] of this.optionsMap.entries()) {
+            this.optionsMap.set(id, { ...opt, checked: false });
+        }
+        for (const id of checkedIds) {
+            if (this.optionsMap.has(id)) {
+                const opt = this.optionsMap.get(id);
+                this.optionsMap.set(id, { ...opt, checked: true });
+            }
+        }
+        this.value = this.getCheckedValues();
+        this.updateView();
+        this.emit("change", this.value);
+        this.emit("valueChanged", this.value);
+        if (this.changeHandler) {
+            deferSafe(`CheckBoxGroup:${this.id}:change`, () => this.changeHandler(this.value));
+        }
+        if (this.valueChangeHandler) {
+            deferSafe(`CheckBoxGroup:${this.id}:valueChanged`, () => this.valueChangeHandler(this.value));
+        }
+    }
+    getOptions() {
+        return Array.from(this.optionsMap.values()).slice();
+    }
+    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.updateView();
+        });
+    }
+}

package/lib/component/collapsible.d.ts

@@ -0,0 +1,19 @@
+import { UIComponent } from "./ui-components.js";
+export declare class Collapsible extends UIComponent {
+    private title;
+    private expanded;
+    private contentContainer;
+    private arrowView;
+    pendingChildren: UIComponent[];
+    constructor(id: string, title: string, expanded?: boolean);
+    protected createView(context: any): void;
+    protected updateView(): void;
+    toggle(): void;
+    expand(): void;
+    collapse(): void;
+    setTitle(title: string): void;
+    addChild(component: UIComponent): void;
+    addChildren(components: UIComponent[]): void;
+    removeChildView(view: any): void;
+    clearChildren(): void;
+}