drgame-cc 1.0.49 → 1.0.52

package/drscript/UIAdapter.ts

@@ -1,8 +1,7 @@
 import FocusManager from "./focus/FocusManager";
-import FocusVisualLayer from "./focus/FocusVisualLayer";
 import { AdSdk } from "./ad-sdk/ad-sdk";
 import { WebBridge } from "./WebBridge";
-import { BtnExtra } from "./component/BtnExtra";
+import BtnExtra from "./component/BtnExtra";
 import AlertTip from "./component/AlertTip";
 import { Loader } from "./Loader";
 import { KeyAdapter } from "./KeyAdapter";
@@ -15,10 +14,7 @@ export class UIAdapter {
     public static focus = FocusManager;
 
     // ---- 内部配置 ----
-    private static _focusZIndex: number = 800;
-    private static _focusEnabled: boolean = true;
-
-    private static visualLayer: FocusVisualLayer | null = null;
+    private static _initialized: boolean = false;
 
     // ---- 桥接 / 状态 ----
     public static webBridge: WebBridge;
@@ -48,78 +44,82 @@ export class UIAdapter {
         reset: () => { UIAdapter.backHandlers = []; UIAdapter.backFallback = null; },
     };
 
-    private static removeBackHandler(handler: () => boolean | void) {
-        for (let i = UIAdapter.backHandlers.length - 1; i >= 0; i--) {
-            if (UIAdapter.backHandlers[i] === handler) UIAdapter.backHandlers.splice(i, 1);
-        }
-    }
-
-    private static handleBack(): boolean {
-        for (let i = UIAdapter.backHandlers.length - 1; i >= 0; i--) {
-            const h = UIAdapter.backHandlers[i];
-            if (!h) continue;
-            if (h() !== false) return true;
-        }
-        if (UIAdapter.backFallback) return UIAdapter.backFallback() !== false;
-        return false;
-    }
-
     // ========================================================================
     // 初始化
     // ========================================================================
-    public static init(options?: {
-        focusZIndex?: number;
-        focusEnabled?: boolean;
-        enableInput?: boolean;
-        enableLifecycle?: boolean;
-    }) {
-        if (UIAdapter.visualLayer) return;
-
-        if (options) {
-            if (options.focusZIndex !== undefined) UIAdapter._focusZIndex = options.focusZIndex;
-            if (options.focusEnabled !== undefined) UIAdapter._focusEnabled = options.focusEnabled;
-        }
+    public static init() {
+        if (this._initialized) return;
+        this._initialized = true;
 
-        // 同步给 FocusVisualLayer
-        FocusVisualLayer.setFocusZIndex(UIAdapter._focusZIndex);
+        this.webBridge = new WebBridge();
+        FocusManager.setFocusZIndex(800);
+        FocusManager.initVisualLayer();
 
-        // 焦点视觉层
-        if (UIAdapter._focusEnabled) {
-            const scene = cc.director.getScene();
-            UIAdapter.visualLayer = FocusVisualLayer.create(scene);
-        }
+        KeyAdapter.onBack = () => this.handleBack();
+        KeyAdapter.init();
 
-        // 输入（委托给 KeyAdapter）
-        if (options?.enableInput !== false) {
-            KeyAdapter.onBack = () => UIAdapter.handleBack();
-            KeyAdapter.init();
-        }
+        cc.game.on(cc.game.EVENT_HIDE, this.onGameHide, this);
+        cc.game.on(cc.game.EVENT_SHOW, this.onGameShow, this);
+
+        this.hookLoadScene();
+        this.back.setFallback(() => this.backHandler());
+        this.initToast();
+
+        // 自动注册当前场景下的所有按钮
+        this.autoRegisterScene();
+    }
 
-        // 生命周期
-        if (options?.enableLifecycle !== false) {
-            cc.game.on(cc.game.EVENT_HIDE, UIAdapter.onGameHide, UIAdapter);
-            cc.game.on(cc.game.EVENT_SHOW, UIAdapter.onGameShow, UIAdapter);
+    /** 自动注册当前场景的按钮 */
+    private static autoRegisterScene() {
+        let scene = cc.director.getScene();
+        if (scene && scene.uuid) {
+            // 先清理场景已注册的失效 items
+            FocusManager.unregisterByRoot(scene);
+            // 注册所有 Button
+            FocusManager.registerButtons(scene);
+            // 查找 BtnExtra
+            this.findBtnExtra(scene);
         }
     }
 
+    private static async initToast() {
+        if (window['cc'] == undefined) return;
+        this.toastPool = new cc.NodePool();
+        this.prefab = await this.loadPrefab('drres/prefab/Toast');
+    }
+
     public static destroy() {
-        cc.game.off(cc.game.EVENT_HIDE, UIAdapter.onGameHide, UIAdapter);
-        cc.game.off(cc.game.EVENT_SHOW, UIAdapter.onGameShow, UIAdapter);
+        if (!this._initialized) return;
+        this._initialized = false;
+
+        cc.game.off(cc.game.EVENT_HIDE, this.onGameHide, this);
+        cc.game.off(cc.game.EVENT_SHOW, this.onGameShow, this);
         FocusManager.reset();
         KeyAdapter.destroy();
-        UIAdapter.backHandlers = [];
-        UIAdapter.backFallback = null;
-        if (UIAdapter.visualLayer && UIAdapter.visualLayer.node) {
-            cc.game?.removePersistRootNode?.(UIAdapter.visualLayer.node);
-            UIAdapter.visualLayer.node.destroy();
-        }
-        UIAdapter.visualLayer = null;
+        this.backHandlers = [];
+        this.backFallback = null;
     }
 
     // ========================================================================
     // 内部实现（供 PlatformAdapter 委托调用）
     // ========================================================================
 
+    private static removeBackHandler(handler: () => boolean | void) {
+        for (let i = this.backHandlers.length - 1; i >= 0; i--) {
+            if (this.backHandlers[i] === handler) this.backHandlers.splice(i, 1);
+        }
+    }
+
+    private static handleBack(): boolean {
+        for (let i = this.backHandlers.length - 1; i >= 0; i--) {
+            const h = this.backHandlers[i];
+            if (!h) continue;
+            if (h() !== false) return true;
+        }
+        if (this.backFallback) return this.backFallback() !== false;
+        return false;
+    }
+
     static loadPrefab(path: string): Promise<cc.Prefab> {
         return new Promise((resolve, reject) => {
             cc.loader.loadRes(path, cc.Prefab, (err, prefab) => {
@@ -130,11 +130,11 @@ export class UIAdapter {
     }
 
     static showTip(text: string, dur = 1500) {
-        if (!UIAdapter.toastPool || !UIAdapter.prefab) return;
-        let node = UIAdapter.toastPool.get();
+        if (!this.toastPool || !this.prefab) return;
+        let node = this.toastPool.get();
         let toastComp: AlertTip | null = null;
         if (node == null) {
-            node = cc.instantiate(UIAdapter.prefab);
+            node = cc.instantiate(this.prefab);
             toastComp = node.getComponent(AlertTip);
         } else {
             toastComp = node.getComponent(AlertTip);
@@ -143,13 +143,13 @@ export class UIAdapter {
             cc.director.getScene().addChild(node, cc.macro.MAX_ZINDEX);
         }
         node.setPosition(cc.v2(cc.winSize.width / 2, cc.winSize.height / 2));
-
+        node.active = true;
         if (toastComp) toastComp.show(text);
         setTimeout(() => {
             if (toastComp) {
                 toastComp.hide(() => {
                     if (node && node.isValid) {
-                        UIAdapter.toastPool.put(node);
+                        this.toastPool.put(node);
                     }
                 });
             }
@@ -159,79 +159,73 @@ export class UIAdapter {
 
     /** 显示预制体场景（压入预制体场景栈，返回键可回溯） */
     static showScene(scene: cc.Node, onBack?: () => boolean | void) {
-        let currentTop = UIAdapter.focus.getTopNodeScope();
+        let currentTop = this.focus.getTopNodeScope();
         if (currentTop && currentTop.nodeType === "scene" && currentTop.node && currentTop.node !== scene && currentTop.node.isValid) {
             currentTop.node.active = false;
         }
         scene.active = true;
-        // 先切换 scope，确保 activeScopeId 正确
-        UIAdapter.focus.pushScope(scene.uuid, {
+        this.focus.pushScope(scene.uuid, {
             node: scene,
             nodeType: "scene",
             onBack: onBack,
             skipEnsureFocus: true
         });
-        // 再注册按钮，registerButtons 内部会调用 ensureFocus
-        UIAdapter.focus.registerButtons(scene);
-        UIAdapter.findBtnExtra(scene);
+        this.focus.registerButtons(scene);
+        this.findBtnExtra(scene);
     }
 
     /** 关闭预制体场景（从栈中移除，不销毁） */
     static hideScene(scene: cc.Node) {
-        UIAdapter.focus.removeScope(scene);
+        this.focus.removeScope(scene);
         scene.active = false;
     }
 
     /** 打开界面注册导航按钮 */
     static showWindow(window: cc.Node, onBack?: () => boolean | void) {
-        // 先切换 scope，确保 activeScopeId 正确
-        UIAdapter.focus.pushScope(window.uuid, {
+        this.focus.pushScope(window.uuid, {
             node: window,
             nodeType: "window",
             onBack: onBack,
             skipEnsureFocus: true
         });
-        // 再注册按钮，registerButtons 内部会调用 ensureFocus
-        UIAdapter.focus.registerButtons(window);
-        UIAdapter.findBtnExtra(window);
+        this.focus.registerButtons(window);
+        this.findBtnExtra(window);
     }
 
     /** 关闭界面取消注册按钮事件 */
     static hideWindow(window: cc.Node) {
-        UIAdapter.focus.removeScope(window);
+        this.focus.removeScope(window);
     }
 
     /** 刷新界面按钮事件 */
     static refreshFocus(window: cc.Node) {
-        UIAdapter.focus.registerButtons(window);
-        UIAdapter.findBtnExtra(window);
+        this.focus.registerButtons(window);
+        this.findBtnExtra(window);
     }
 
     /** 返回键处理逻辑 */
     static backHandler(): boolean {
-        let top = UIAdapter.focus.getTopNodeScope();
+        let top = this.focus.getTopNodeScope();
         if (top && top.node) {
             let node = top.node;
             if (!node.isValid) {
-                UIAdapter.focus.popScope(top.scopeId);
+                this.focus.popScope(top.scopeId);
                 return true;
             }
 
-            // 1. 优先用自定义 onBack
             if (top.onBack) {
                 let handled = top.onBack() !== false;
                 if (handled) {
-                    UIAdapter.focus.removeScope(node);
+                    this.focus.removeScope(node);
                 }
                 return true;
             }
 
             if (top.nodeType === "window") {
-                UIAdapter.focus.removeScope(node);
+                this.focus.removeScope(node);
                 node.destroy();
             } else {
-                // 检查是否是最后一个场景
-                let scopes = UIAdapter.focus.getScopes();
+                let scopes = this.focus.getScopes();
                 let hasPrev = false;
                 for (let i = scopes.length - 1; i >= 1; i--) {
                     if (scopes[i].node && scopes[i].scopeId !== top.scopeId) {
@@ -240,14 +234,12 @@ export class UIAdapter {
                     }
                 }
                 if (!hasPrev) {
-                    // 最后一个场景，直接弹出退出确认
-                    UIAdapter.showExitWin();
+                    this.showExitWin();
                     return true;
                 }
-                // 不是最后一个场景，正常关闭
-                UIAdapter.focus.removeScope(node);
+                this.focus.removeScope(node);
                 node.active = false;
-                let prev = UIAdapter.focus.getTopNodeScope();
+                let prev = this.focus.getTopNodeScope();
                 if (prev && prev.node && prev.node.isValid) {
                     prev.node.active = true;
                 }
@@ -255,13 +247,12 @@ export class UIAdapter {
             return true;
         }
 
-        // 没有界面节点，走原生场景栈
-        if (UIAdapter.sceneStack.length > 0) {
-            let prevScene = UIAdapter.sceneStack.pop();
+        if (this.sceneStack.length > 0) {
+            let prevScene = this.sceneStack.pop();
             cc.director.loadScene(prevScene);
             return true;
         }
-        UIAdapter.showExitWin();
+        this.showExitWin();
         return true;
     }
 
@@ -271,8 +262,7 @@ export class UIAdapter {
         exitWin.parent = cc.director.getScene();
         exitWin.setPosition(cc.v2(cc.winSize.width / 2, cc.winSize.height / 2));
 
-        // 直接注册焦点，不依赖 ExitWin.onEnable 的间接调用
-        UIAdapter.focus.pushScope(exitWin.uuid, {
+        this.focus.pushScope(exitWin.uuid, {
             node: exitWin,
             nodeType: "window",
             onBack: () => {
@@ -280,19 +270,23 @@ export class UIAdapter {
             },
             skipEnsureFocus: true
         });
-        UIAdapter.focus.registerButtons(exitWin);
-        UIAdapter.findBtnExtra(exitWin);
+        this.focus.registerButtons(exitWin);
+        this.findBtnExtra(exitWin);
     }
 
-    /** 拦截 loadScene 自动记录场景栈 */
-    static hookLoadScene() {
+    /** 拦截 loadScene 自动记录场景栈，并在新场景加载后自动注册按钮 */
+    private static hookLoadScene() {
         const origLoadScene = cc.director.loadScene.bind(cc.director);
         cc.director.loadScene = (sceneName: string, onLaunched?: () => void) => {
             let currentScene = cc.director.getScene();
             if (currentScene && currentScene.name && currentScene.name !== sceneName) {
-                UIAdapter.sceneStack.push(currentScene.name);
+                this.sceneStack.push(currentScene.name);
             }
-            return origLoadScene(sceneName, onLaunched);
+            return origLoadScene(sceneName, () => {
+                // 新场景加载后自动注册按钮
+                this.autoRegisterScene();
+                if (onLaunched) onLaunched();
+            });
         };
     }
 
@@ -303,7 +297,7 @@ export class UIAdapter {
             let btnExtra = child.getComponent(BtnExtra);
             if (btnExtra) {
                 let sprite = child.getComponent(cc.Sprite);
-                UIAdapter.focus.register(child, {
+                this.focus.register(child, {
                     onFocus: () => {
                         if (sprite) sprite.spriteFrame = btnExtra.hoverSprite;
                     },
@@ -312,7 +306,7 @@ export class UIAdapter {
                     }
                 });
             }
-            UIAdapter.findBtnExtra(child);
+            this.findBtnExtra(child);
         }
     }
 

package/drscript/ad-sdk/ad-sdk.js

@@ -98,6 +98,11 @@ class AdSdkImpl {
       });
     }
 
+    // 桥接适配器的退出事件 → 调用 reporter 上报退出
+    adapter.on(AdEvent.Exit, function () {
+      Reporter.reportAppExit();
+    });
+
     // 桥接适配器的按键事件
     if (adapter.onKeyEvent) {
       self._adapterKeyHandler = function (keyEvent) {
@@ -112,8 +117,16 @@ class AdSdkImpl {
       adapter.onKeyEvent(self._adapterKeyHandler);
     }
 
+    // 自动初始化数据上报模块（传入 reporter 配置，无配置时使用空对象默认初始化）
+    Reporter.init(config.reporter || {});
+
     this._initialized = true;
     console.log('[AdSdk] Initialized with platform: ' + config.platform);
+
+    // 上报「启动」事件
+    Reporter.reportAppStart();
+
+    console.log('[AdSdk] Lifecycle reporting bound.');
   }
 
   /**
@@ -164,18 +177,20 @@ class AdSdkImpl {
     }
   }
 
-  /** 通知游戏暂停 */
+  /** 通知游戏暂停（自动上报切后台） */
   onGamePause() {
     this._ensureInit();
+    Reporter.reportSwitchBackground();
     const adapter = this._getAdapter();
     if (adapter.onGamePause) {
       adapter.onGamePause();
     }
   }
 
-  /** 通知游戏恢复 */
+  /** 通知游戏恢复（自动上报切回） */
   onGameResume() {
     this._ensureInit();
+    Reporter.reportSwitchBack();
     const adapter = this._getAdapter();
     if (adapter.onGameResume) {
       adapter.onGameResume();
@@ -183,11 +198,12 @@ class AdSdkImpl {
   }
 
   /**
-   * 退出游戏
+   * 退出游戏（自动上报退出事件后执行实际退出）
    * @returns {Promise<void>}
    */
   async exitGame() {
     this._ensureInit();
+    // 通知适配器执行退出，适配器的 onExitConfirmed 回调会触发上报
     const adapter = this._getAdapter();
     if (adapter.exitGame) {
       return adapter.exitGame();
@@ -319,4 +335,4 @@ module.exports = {
   // 类
   XiaomiAdapter,
   EventEmitter,
-};
+};

package/drscript/ad-sdk/adapters/xiaomi-adapter.js

@@ -420,6 +420,9 @@ class XiaomiAdapter {
 
       // ── 退出确认 ──
       case 'onExitConfirmed': {
+        // 触发退出回调事件，供 SDK 层调用 reporter 上报
+        this._emitter.emit(AdEvent.Exit, {});
+
         if (this._exitResolve) {
           this._exitResolve();
           this._exitResolve = null;
@@ -446,4 +449,4 @@ class XiaomiAdapter {
   }
 }
 
-module.exports = { XiaomiAdapter };
+module.exports = { XiaomiAdapter };

package/drscript/ad-sdk/reporters/reporter.d.ts

@@ -10,18 +10,48 @@ export declare const ActionType: {
   Exposure: '曝光';
   /** 点击 */
   Click: '点击';
+  /** 开始播放 */
+  StartPlay: '开始播放';
+  /** 结束播放（需上报时长 action_value） */
+  EndPlay: '结束播放';
+  /** 分享 */
+  Share: '分享';
+  /** 订购（需上报成功订购金额） */
+  Order: '订购';
+  /** 启动 */
+  Start: '启动';
+  /** 退出 */
+  Exit: '退出';
+  /** 切后台 */
+  SwitchBackground: '切后台';
+  /** 切回 */
+  SwitchBack: '切回';
 };
 
+/** 批量上报配置 */
+export interface IBatchConfig {
+  /** 每批最大条数 */
+  perNum: number;
+  /** 发送间隔（秒） */
+  spaceSec: number;
+}
+
 /** 数据上报模块（单例） */
 export declare const Reporter: {
   /** 初始化上报模块 */
   init(config: IReporterConfig): void;
 
+  /** 从后端获取批量上报配置 */
+  fetchReportConfig(callback?: (config: IBatchConfig) => void): void;
+
   /** 单次上报 */
-  report(data: IReportItem): void;
+  report(data: IReportItem, immediate?: boolean): void;
 
   /** 批量上报 */
-  reportBatch(dataList: IReportItem[], commonInfo?: IReportItem): void;
+  reportBatch(dataList: IReportItem[], commonInfo?: IReportItem, immediate?: boolean): void;
+
+  /** 立即刷新队列，将队列中所有事件立即发送 */
+  flushQueue(): void;
 
   /** 获取或创建设备唯一ID */
   createDeviceId(): string;
@@ -35,6 +65,21 @@ export declare const Reporter: {
   /** 获取当前公共字段 */
   getCommonInfo(): Partial<IReportItem>;
 
+  /** 更新用户信息（登录后调用，传入memberId） */
+  updateUserInfo(userInfo: Record<string, string>): void;
+
+  /** 上报「启动」事件 */
+  reportAppStart(): void;
+
+  /** 上报「切后台」事件 */
+  reportSwitchBackground(): void;
+
+  /** 上报「切回」事件 */
+  reportSwitchBack(): void;
+
+  /** 上报「退出」事件 */
+  reportAppExit(): void;
+
   /** 获取底层上报实例（高级用法） */
   readonly instance: any;
-};
+};