drgame-cc 1.0.45 → 1.0.47

package/drscript/focus/FocusManager.ts

@@ -1,116 +1,73 @@
-import { TvUiDirection } from "../config/TvUiConfig";
-import KeyCodeAdapter, { TvRemoteKey } from "../input/KeyCodeAdapter";
-import FocusScope from "./FocusScope";
-
-export interface FocusOptions {
-    root?: cc.Node;
-    scopeId?: string;
-    focusId?: string;
-    iconKey?: string;
-    up?: string;
-    down?: string;
-    left?: string;
-    right?: string;
-    onClick?: Function;
-    onFocus?: Function;
-    onBlur?: Function;
-    focusScale?: number;
-    showCursor?: boolean;
-}
-
-export interface FocusCursorOptions {
-    basePath?: string;
-    normalPath?: string;
-    focusPath?: string;
-    corner?: string;
-    width?: number;
-    height?: number;
-    offsetX?: number;
-    offsetY?: number;
-}
+import { KeyCode } from "../ad-sdk/ad-sdk";
 
 export interface FocusRuntimeItem {
     node: cc.Node;
-    root?: cc.Node;
-    scopeId: string;
-    focusId: string;
-    iconKey?: string;
-    up?: string;
-    down?: string;
-    left?: string;
-    right?: string;
-    onClick?: Function;
     onFocus?: Function;
     onBlur?: Function;
-    component?: any;
-    baseScaleX: number;
-    baseScaleY: number;
+    onClick?: Function;
     focusScale: number;
     showCursor: boolean;
+    offset: cc.Vec2;
 }
 
 type FocusListener = (item: FocusRuntimeItem | null, previous?: FocusRuntimeItem | null) => void;
 
+interface ScopeInfo {
+    scopeId: string;
+    lastNodeUuid: string;
+    /** 绑定的窗口/场景节点（用于返回键自动处理） */
+    node?: cc.Node;
+    /** 节点类型 */
+    nodeType?: "window" | "scene";
+    /** 自定义返回回调 */
+    onBack?: () => boolean | void;
+}
+
 export default class FocusManager {
     private static readonly FOCUS_SCALE_ACTION_TAG: number = 9911;
     private static readonly BASE_SCALE_X_KEY: string = "__tvFocusBaseScaleX";
     private static readonly BASE_SCALE_Y_KEY: string = "__tvFocusBaseScaleY";
     private static items: FocusRuntimeItem[] = [];
-    private static itemMap: { [focusId: string]: FocusRuntimeItem } = {};
-    private static currentFocusId: string = "";
-    private static scopes: FocusScope[] = [new FocusScope("page")];
-    private static activeScopeId: string = "page";
+    private static itemMap: { [uuid: string]: FocusRuntimeItem } = {};
+    private static scopeMap: { [uuid: string]: string } = {};
+    private static currentNodeUuid: string = "";
+    private static scopes: ScopeInfo[] = [];
+    private static activeScopeId: string = "";
     private static listeners: FocusListener[] = [];
-    private static cursorOptions: FocusCursorOptions | null = null;
 
-    public static setCursor(options: FocusCursorOptions | null) {
-        this.cursorOptions = options;
-    }
+    private static readonly DEFAULT_FOCUS_SCALE = 1.08;
 
-    public static getCursor(): FocusCursorOptions | null {
-        return this.cursorOptions;
-    }
-
-    public static register(target: cc.Node | any, options: FocusOptions = {}) {
+    public static register(target: cc.Node | any, options: { scopeId?: string; onFocus?: Function; onBlur?: Function; onClick?: Function; focusScale?: number; showCursor?: boolean; offset?: cc.Vec2 } = {}): void {
         let node = this.resolveNode(target);
         if (!node) return;
         let component = this.resolveComponent(target, node);
-        let previousItem = this.findItemByNode(node);
-        let previousBaseScale = previousItem ? { x: previousItem.baseScaleX, y: previousItem.baseScaleY } : null;
         this.unregister(node);
 
-        let focusId = options.focusId || (component && component.focusId) || node.uuid || this.createFocusId(node);
-        this.unregisterById(focusId);
-        let baseScale = this.getNodeBaseScale(node, previousBaseScale);
+        let uuid = node.uuid;
+        this.getNodeBaseScale(node);
+
+        let scopeId = options.scopeId || (component && component.scopeId) || this.activeScopeId;
+        this.scopeMap[uuid] = scopeId;
 
         let item: FocusRuntimeItem = {
             node: node,
-            root: options.root,
-            scopeId: options.scopeId || (component && component.scopeId) || this.activeScopeId || "page",
-            focusId: focusId,
-            iconKey: options.iconKey || (component && component.iconKey) || "",
-            up: options.up || (component && component.up) || "",
-            down: options.down || (component && component.down) || "",
-            left: options.left || (component && component.left) || "",
-            right: options.right || (component && component.right) || "",
-            onClick: options.onClick,
             onFocus: options.onFocus || (component && component.onFocus),
             onBlur: options.onBlur || (component && component.onBlur),
-            component: component,
-            baseScaleX: baseScale.x,
-            baseScaleY: baseScale.y,
-            focusScale: options.focusScale || (component && component.focusScale) || 1.08,
-            showCursor: options.showCursor !== false
+            onClick: options.onClick,
+            focusScale: options.focusScale || (component && component.focusScale) || this.DEFAULT_FOCUS_SCALE,
+            showCursor: options.showCursor !== false,
+            offset: options.offset || cc.v2(0, 0)
         };
 
         this.items.push(item);
-        this.itemMap[item.focusId] = item;
+        this.itemMap[uuid] = item;
         this.ensureFocus();
     }
 
     public static unregister(target: cc.Node | any) {
         let node = this.resolveNode(target);
         if (!node) return;
+        delete this.scopeMap[node.uuid];
         for (let i = this.items.length - 1; i >= 0; i--) {
             if (this.items[i].node == node) {
                 this.removeItemAt(i);
@@ -123,21 +80,25 @@ export default class FocusManager {
         if (!root) return;
         for (let i = this.items.length - 1; i >= 0; i--) {
             let item = this.items[i];
-            if (item.root == root || this.isChildOf(item.node, root)) {
+            if (this.isChildOf(item.node, root)) {
+                delete this.scopeMap[item.node.uuid];
                 this.removeItemAt(i);
             }
         }
         this.ensureFocus();
     }
 
-    public static unregisterById(focusId: string) {
-        if (!focusId) return;
+    private static unregisterByUuid(uuid: string) {
+        if (!uuid) return;
         for (let i = this.items.length - 1; i >= 0; i--) {
-            if (this.items[i].focusId == focusId) this.removeItemAt(i);
+            if (this.items[i].node.uuid == uuid) {
+                delete this.scopeMap[uuid];
+                this.removeItemAt(i);
+            }
         }
     }
 
-    public static registerButtons(root: cc.Node, options: FocusOptions = {}) {
+    public static registerButtons(root: cc.Node) {
         if (!root) return;
         this.unregisterByRoot(root);
         this.walk(root, (node: cc.Node) => {
@@ -145,31 +106,36 @@ export default class FocusManager {
             let button = node.getComponent(cc.Button);
             if (!button) return;
             this.register(node, {
-                root: root,
-                scopeId: options.scopeId || this.activeScopeId,
-                iconKey: options.iconKey,
-                focusScale: options.focusScale || 1.08,
+                scopeId: this.activeScopeId,
+                focusScale: this.DEFAULT_FOCUS_SCALE,
                 onClick: () => this.invokeButton(button)
             });
         });
+
         this.ensureFocus();
     }
 
-    public static pushScope(scopeId: string, root?: cc.Node, firstFocus?: string | cc.Node) {
+    public static pushScope(scopeId: string, options?: { node?: cc.Node; nodeType?: "window" | "scene"; onBack?: () => boolean | void; skipEnsureFocus?: boolean }) {
         scopeId = scopeId || "modal";
         let currentScope = this.getActiveScope();
-        if (currentScope) currentScope.lastFocusId = this.currentFocusId;
+        if (currentScope) currentScope.lastNodeUuid = this.currentNodeUuid;
         for (let i = 0; i < this.scopes.length; i++) {
             if (this.scopes[i].scopeId == scopeId) {
                 this.scopes.splice(i, 1);
                 break;
             }
         }
-        this.scopes.push(new FocusScope(scopeId, root));
+        this.scopes.push({ scopeId, lastNodeUuid: "", node: options?.node, nodeType: options?.nodeType, onBack: options?.onBack });
         this.activeScopeId = scopeId;
-        this.setFocusById("", true);
-        if (firstFocus) this.focus(firstFocus);
-        this.ensureFocus();
+        this.clearFocus();
+        if (!options?.skipEnsureFocus) this.ensureFocus();
+    }
+
+    /** 移除作用域并清理其下所有注册焦点 */
+    public static removeScope(node: cc.Node) {
+        if (!node) return;
+        this.popScope(node.uuid);
+        this.unregisterByRoot(node);
     }
 
     public static popScope(scopeId?: string) {
@@ -181,50 +147,77 @@ export default class FocusManager {
                 break;
             }
         }
+        // 清理已弹出作用域下的所有条目
+        for (let i = this.items.length - 1; i >= 0; i--) {
+            if (this.scopeMap[this.items[i].node.uuid] == target) {
+                this.removeItemAt(i);
+            }
+        }
         let active = this.scopes[this.scopes.length - 1];
-        this.activeScopeId = active ? active.scopeId : "page";
-        let restored = active && active.lastFocusId ? this.focus(active.lastFocusId) : false;
+        this.activeScopeId = active ? active.scopeId : "";
+        let restored = active && active.lastNodeUuid ? this.focus(active.lastNodeUuid) : false;
         if (!restored) {
-            this.setFocusById("", true);
+            this.clearFocus();
             this.ensureFocus();
         }
     }
 
+    /** 获取最顶层绑定了节点的作用域 */
+    public static getTopNodeScope(): ScopeInfo | null {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].node) return this.scopes[i];
+        }
+        return null;
+    }
+
+    /** 获取所有作用域（只读副本） */
+    public static getScopes(): ReadonlyArray<ScopeInfo> {
+        return this.scopes;
+    }
+
     public static reset() {
         let old = this.getCurrentFocusItem();
         if (old) this.setFocusVisual(old, false, true);
         this.items = [];
         this.itemMap = {};
-        this.currentFocusId = "";
-        this.scopes = [new FocusScope("page")];
-        this.activeScopeId = "page";
+        this.scopeMap = {};
+        this.currentNodeUuid = "";
+        this.scopes = [];
+        this.activeScopeId = "";
         this.emitFocusChanged(null, old);
     }
 
-    public static focus(target: string | cc.Node): boolean {
+    public static focus(target: string | cc.Node, silent: boolean = false): boolean {
         this.cleanup();
         if (!target) return false;
-        let item: FocusRuntimeItem | null = null;
-        if (typeof target == "string") {
-            item = this.itemMap[target];
-        } else {
-            for (let i = 0; i < this.items.length; i++) {
-                if (this.items[i].node == target) {
-                    item = this.items[i];
-                    break;
-                }
+        let uuid = typeof target == "string" ? target : target.uuid;
+        let item = this.itemMap[uuid];
+        if (!item || !this.isItemActive(item) || !this.isInActiveScope(item)) return false;
+
+        let previous: FocusRuntimeItem | null = this.getCurrentFocusItem();
+        if (uuid == this.currentNodeUuid && uuid) {
+            let current = this.getCurrentFocusItem();
+            if (current) {
+                this.setFocusVisual(current, true);
+                // 总是触发位置更新，即使静默模式也要更新视觉位置
+                this.emitFocusChanged(current, previous || current);
             }
+            return true;
         }
-        if (!item || !this.isItemActive(item) || !this.isInActiveScope(item)) return false;
-        this.setFocusById(item.focusId);
+        if (previous) this.setFocusVisual(previous, false);
+        this.currentNodeUuid = uuid || "";
+        let current: FocusRuntimeItem | null = this.getCurrentFocusItem();
+        if (current) {
+            let scope = this.getActiveScope();
+            if (scope) scope.lastNodeUuid = current.node.uuid;
+            this.setFocusVisual(current, true);
+        }
+        // 总是触发位置更新，确保视觉层收到通知
+        this.emitFocusChanged(current, previous);
         return true;
     }
 
-    public static focusNode(node: cc.Node): boolean {
-        return this.focus(node);
-    }
-
-    public static move(direction: TvUiDirection): boolean {
+    public static move(direction: KeyCode): boolean {
         this.cleanup();
         let current = this.getCurrentFocusItem();
         if (!current) {
@@ -232,22 +225,19 @@ export default class FocusManager {
             return !!this.getCurrentFocusItem();
         }
 
-        let explicitId = current[direction];
-        if (explicitId && this.focus(explicitId)) return true;
-
         let vector = this.getDirectionVector(direction);
-        let currentCenter = this.getWorldCenter(current.node);
+        let currentCenter = this.getWorldCenter(current.node).add(current.offset);
         let best: FocusRuntimeItem | null = null;
         let bestScore = Number.MAX_VALUE;
 
         for (let i = 0; i < this.items.length; i++) {
             let item = this.items[i];
             if (item == current || !this.isItemActive(item) || !this.isInActiveScope(item)) continue;
-            let center = this.getWorldCenter(item.node);
+            let center = this.getWorldCenter(item.node).add(item.offset);
             let dx = center.x - currentCenter.x;
             let dy = center.y - currentCenter.y;
-            if (vector.x != 0 && dx * vector.x <= 8) continue;
-            if (vector.y != 0 && dy * vector.y <= 8) continue;
+            if (vector.x != 0 && dx * vector.x <= 0) continue;
+            if (vector.y != 0 && dy * vector.y <= 0) continue;
             let primary = vector.x != 0 ? Math.abs(dx) : Math.abs(dy);
             let secondary = vector.x != 0 ? Math.abs(dy) : Math.abs(dx);
             let score = primary + secondary * 2;
@@ -258,7 +248,7 @@ export default class FocusManager {
         }
 
         if (best) {
-            this.setFocusById(best.focusId);
+            this.focus(best.node.uuid);
             return true;
         }
         return this.moveByOrder(direction == "left" || direction == "down" ? -1 : 1);
@@ -272,40 +262,18 @@ export default class FocusManager {
             item.onClick();
             return true;
         }
-        if (item.component && item.component.onConfirm) {
-            item.component.onConfirm();
+        let focusItem = item.node.getComponent("FocusItem") as any;
+        if (focusItem && focusItem.onConfirm) {
+            focusItem.onConfirm();
             return true;
         }
         this.invokeButton(item.node.getComponent(cc.Button));
         return true;
     }
 
-    public static back(): boolean {
-        return false;
-    }
-
-    public static handleKey(keyCode: number): boolean {
-        let key = KeyCodeAdapter.toRemoteKey(keyCode);
-        if (key == TvRemoteKey.Ok) return this.confirm();
-        if (key == TvRemoteKey.Left) return this.move("left");
-        if (key == TvRemoteKey.Right) return this.move("right");
-        if (key == TvRemoteKey.Up) return this.move("up");
-        if (key == TvRemoteKey.Down) return this.move("down");
-        if (key == TvRemoteKey.Back) return this.back();
-        return false;
-    }
-
-    public static clickCurrent(): boolean {
-        return this.confirm();
-    }
-
     public static getCurrentFocusItem(): FocusRuntimeItem | null {
-        let item = this.itemMap[this.currentFocusId];
-        return this.isItemActive(item) ? item : null;
-    }
-
-    public static getActiveScopeId(): string {
-        return this.activeScopeId;
+        let item = this.itemMap[this.currentNodeUuid];
+        return (item && this.isItemActive(item) && this.isInActiveScope(item)) ? item : null;
     }
 
     public static onFocusChanged(listener: FocusListener) {
@@ -318,34 +286,20 @@ export default class FocusManager {
         if (index >= 0) this.listeners.splice(index, 1);
     }
 
-    private static setFocusById(focusId: string, silent: boolean = false) {
-        if (focusId == this.currentFocusId && focusId) {
-            let current = this.getCurrentFocusItem();
-            if (current && !silent) {
-                this.setFocusVisual(current, true);
-                this.emitFocusChanged(current, current);
-            }
-            return;
-        }
+    public static clearFocus() {
         let previous: FocusRuntimeItem | null = this.getCurrentFocusItem();
         if (previous) this.setFocusVisual(previous, false);
-        this.currentFocusId = focusId || "";
-        let current: FocusRuntimeItem | null = this.getCurrentFocusItem();
-        if (current) {
-            let scope = this.getActiveScope();
-            if (scope) scope.lastFocusId = current.focusId;
-            this.setFocusVisual(current, true);
-        }
-        if (!silent) this.emitFocusChanged(current, previous);
-        if (silent && previous) this.emitFocusChanged(null, previous);
+        this.currentNodeUuid = "";
+        if (previous) this.emitFocusChanged(null, previous);
     }
 
     private static setFocusVisual(item: FocusRuntimeItem, focused: boolean, immediate: boolean = false) {
         if (!item || !item.node || !item.node.isValid) return;
         this.setButtonSpriteVisual(item, focused);
         item.node.stopActionByTag(this.FOCUS_SCALE_ACTION_TAG);
-        let targetScaleX = focused ? item.baseScaleX * item.focusScale : item.baseScaleX;
-        let targetScaleY = focused ? item.baseScaleY * item.focusScale : item.baseScaleY;
+        let baseScale = this.getNodeBaseScale(item.node);
+        let targetScaleX = focused ? baseScale.x * item.focusScale : baseScale.x;
+        let targetScaleY = focused ? baseScale.y * item.focusScale : baseScale.y;
         if (immediate) {
             item.node.setScale(targetScaleX, targetScaleY);
         } else {
@@ -353,8 +307,8 @@ export default class FocusManager {
             action.setTag(this.FOCUS_SCALE_ACTION_TAG);
             item.node.runAction(action);
         }
-        if (focused && item.onFocus) item.onFocus.call(item.component || item.node);
-        if (!focused && item.onBlur) item.onBlur.call(item.component || item.node);
+        if (focused && item.onFocus) item.onFocus();
+        if (!focused && item.onBlur) item.onBlur();
     }
 
     private static setButtonSpriteVisual(item: FocusRuntimeItem, focused: boolean) {
@@ -368,18 +322,34 @@ export default class FocusManager {
         if (spriteFrame) sprite.spriteFrame = spriteFrame;
     }
 
+    private static _ensureFocusRetry: number = 0;
+    private static readonly _ENSURE_FOCUS_MAX_RETRY = 3;
+
     private static ensureFocus() {
         this.cleanup();
         if (this.getCurrentFocusItem()) return;
         let activeScope = this.getActiveScope();
-        if (activeScope && activeScope.lastFocusId && this.focus(activeScope.lastFocusId)) return;
+        if (activeScope && activeScope.lastNodeUuid && this.focus(activeScope.lastNodeUuid)) return;
         for (let i = 0; i < this.items.length; i++) {
             let item = this.items[i];
             if (this.isItemActive(item) && this.isInActiveScope(item)) {
-                this.setFocusById(item.focusId);
+                this.focus(item.node.uuid);
+                this._ensureFocusRetry = 0;
                 return;
             }
         }
+        // 有注册的按钮但暂无活跃节点，可能是节点尚未完全初始化，延迟重试
+        if (this.items.length > 0 && this._ensureFocusRetry < this._ENSURE_FOCUS_MAX_RETRY) {
+            this._ensureFocusRetry++;
+            setTimeout(() => {
+                this.ensureFocus();
+            }, 50);
+            return;
+        }
+        // 超过重试次数/无注册项，清除焦点状态
+        this._ensureFocusRetry = 0;
+        this.currentNodeUuid = "";
+        this.emitFocusChanged(null, null);
     }
 
     private static moveByOrder(step: number): boolean {
@@ -390,13 +360,13 @@ export default class FocusManager {
         if (activeItems.length <= 0) return false;
         let index = 0;
         for (let i = 0; i < activeItems.length; i++) {
-            if (activeItems[i].focusId == this.currentFocusId) {
+            if (activeItems[i].node.uuid == this.currentNodeUuid) {
                 index = i;
                 break;
             }
         }
         let next = (index + step + activeItems.length) % activeItems.length;
-        this.setFocusById(activeItems[next].focusId);
+        this.focus(activeItems[next].node.uuid);
         return true;
     }
 
@@ -404,10 +374,11 @@ export default class FocusManager {
         let item = this.items[index];
         if (!item) return;
         this.setFocusVisual(item, false, true);
-        delete this.itemMap[item.focusId];
+        delete this.itemMap[item.node.uuid];
+        delete this.scopeMap[item.node.uuid];
         this.items.splice(index, 1);
-        if (this.currentFocusId == item.focusId) {
-            this.currentFocusId = "";
+        if (this.currentNodeUuid == item.node.uuid) {
+            this.currentNodeUuid = "";
             this.emitFocusChanged(null, item);
         }
     }
@@ -426,10 +397,10 @@ export default class FocusManager {
     }
 
     private static isInActiveScope(item?: FocusRuntimeItem | null): boolean {
-        return !!item && item.scopeId == this.activeScopeId;
+        return !!item && this.scopeMap[item.node.uuid] == this.activeScopeId;
     }
 
-    private static getActiveScope(): FocusScope | null {
+    private static getActiveScope(): ScopeInfo | null {
         for (let i = this.scopes.length - 1; i >= 0; i--) {
             if (this.scopes[i].scopeId == this.activeScopeId) return this.scopes[i];
         }
@@ -441,10 +412,10 @@ export default class FocusManager {
         return cc.v2(box.x + box.width / 2, box.y + box.height / 2);
     }
 
-    private static getDirectionVector(direction: TvUiDirection): cc.Vec2 {
-        if (direction == "left") return cc.v2(-1, 0);
-        if (direction == "right") return cc.v2(1, 0);
-        if (direction == "up") return cc.v2(0, 1);
+    private static getDirectionVector(direction: KeyCode): cc.Vec2 {
+        if (direction == KeyCode.Left) return cc.v2(-1, 0);
+        if (direction == KeyCode.Right) return cc.v2(1, 0);
+        if (direction == KeyCode.Up) return cc.v2(0, 1);
         return cc.v2(0, -1);
     }
 
@@ -479,15 +450,7 @@ export default class FocusManager {
         return target;
     }
 
-    private static findItemByNode(node: cc.Node): FocusRuntimeItem | null {
-        if (!node) return null;
-        for (let i = 0; i < this.items.length; i++) {
-            if (this.items[i].node == node) return this.items[i];
-        }
-        return null;
-    }
-
-    private static getNodeBaseScale(node: cc.Node, preferred?: { x: number, y: number } | null): { x: number, y: number } {
+    private static getNodeBaseScale(node: cc.Node): { x: number, y: number } {
         let nodeAny: any = node as any;
         let storedX = nodeAny[this.BASE_SCALE_X_KEY];
         let storedY = nodeAny[this.BASE_SCALE_Y_KEY];
@@ -495,7 +458,7 @@ export default class FocusManager {
             return { x: storedX, y: storedY };
         }
 
-        let baseScale = preferred || {
+        let baseScale = {
             x: this.readScale(node, "scaleX"),
             y: this.readScale(node, "scaleY")
         };
@@ -516,10 +479,6 @@ export default class FocusManager {
         return typeof value == "number" && isFinite(value);
     }
 
-    private static createFocusId(node: cc.Node): string {
-        return "focus_" + (node.name || "node") + "_" + this.items.length;
-    }
-
     private static walk(node: cc.Node, visitor: (node: cc.Node) => void) {
         visitor(node);
         for (let i = 0; i < node.childrenCount; i++) {
@@ -535,4 +494,4 @@ export default class FocusManager {
         }
         return false;
     }
-}
+}