drgame-cc 1.0.48 → 1.0.50

package/drscript/Define.ts

@@ -39,4 +39,13 @@ export enum AnalyticsEvent {
 export enum AnalyticsAction {
     Exposure = "exposure",
     Click = "click",
-}
+}
+
+/** 事件定义映射（element_position + 曝光/点击事件名） */
+export const AnalyticsEventMap: Record<AnalyticsEvent, { ep: string; expose: string; click?: string }> = {
+    [AnalyticsEvent.GameLoading]: { ep: "game_loading", expose: "game_loading_expose" },
+    [AnalyticsEvent.StartGameButton]: { ep: "start_game_button", expose: "start_game_expose", click: "start_game_click" },
+    [AnalyticsEvent.WatchVideoContinueButton]: { ep: "watch_video_continue_button", expose: "watch_video_continue_expose", click: "watch_video_continue_click" },
+    [AnalyticsEvent.ReplayButton]: { ep: "replay_button", expose: "replay_expose", click: "replay_click" },
+    [AnalyticsEvent.RewardVideoAd]: { ep: "reward_video_ad", expose: "ad_expose" },
+};

package/drscript/PlatformAdapter.ts

@@ -1,9 +1,8 @@
-import { AdEvent, AdPlatform, AdSdk, AdType } from "./ad-sdk/ad-sdk";
+import { AdEvent, AdPlatform, AdSdk, AdType, ActionType, Reporter } from "./ad-sdk/ad-sdk";
 import { BtnExtra } from "./component/BtnExtra";
 import HelperWin from "./component/HelperWin";
-import { AnalyticsAction, AnalyticsEvent, EVideoScene, FingerStyle } from "./Define";
+import { AnalyticsAction, AnalyticsEvent, AnalyticsEventMap, EVideoScene, FingerStyle } from "./Define";
 import FocusVisualLayer from "./focus/FocusVisualLayer";
-import GameAnalytics from "./GameAnalytics";
 import { Loader } from "./Loader";
 import { UIAdapter } from "./UIAdapter";
 import { WebBridge } from "./WebBridge";
@@ -26,51 +25,66 @@ export class PlatformAdapter {
     /** 初始化
      * @param cnName 中文名称
      * @param minigameID 小游戏ID
+     * @param focusIcon 焦点的样式
      */
     public static async init(cnName: string, minigameID: number, focusIcon: FingerStyle) {
+        // ── UI 初始化 ──
         FocusVisualLayer.setStyle(focusIcon);
         UIAdapter._zhName = cnName;
-        var platform: AdPlatform = AdPlatform.None;
         UIAdapter.webBridge = new WebBridge();
-        if (UIAdapter.webBridge.isAvailable()) {
-        } else if (this.isXiaomi) {
-            platform = AdPlatform.Xiaomi;
-        }
+        UIAdapter.init({ focusEnabled: true });
+
         this.contentId = minigameID.toString();
         console.log(`[sdk-version] ${UIAdapter.version}`);
-        UIAdapter.init({ focusEnabled: true });
 
-        GameAnalytics.init({
-            app_item: "25",
-            content_type: "游戏",
-            content_id: this.contentId,
-            content_title: cnName,
-        });
-        if (PlatformAdapter.isCocos) {
+        // ── Cocos 环境初始化 ──
+        if (this.isCocos) {
             UIAdapter.toastPool = new cc.NodePool();
             UIAdapter.prefab = await UIAdapter.loadPrefab('drres/prefab/Toast');
         }
-        let adapters: any = {};
-        adapters[platform] = { cpId: this.contentId };
-        await AdSdk.init({ platform: AdPlatform.Xiaomi, adapters: adapters });
-        AdSdk.onGameReady(UIAdapter.version);
+
+        // ── 初始化广告 SDK ──
+        await AdSdk.init({
+            platform: AdPlatform.Xiaomi,
+            adapters: { [AdPlatform.Xiaomi]: { cpId: this.contentId } },
+            reporter: {
+                app_item: "25",
+                content_type: "游戏",
+                content_id: this.contentId,
+                content_title: cnName,
+            },
+        });
+
+        // ── 注册广告事件 ──
         if (this.canWatchVideo) {
             AdSdk.on(AdEvent.Closed, (data: any) => {
-                if (!data.isCompleted) {
-                    PlatformAdapter.showTip("必须看完视频,才能获取奖励");
-                }
+                if (!data.isCompleted) this.showTip("必须看完视频,才能获取奖励");
             });
-            // 监听失败
             AdSdk.on(AdEvent.Error, (data: any) => {
-                PlatformAdapter.showTip(`广告暂不可用，请稍后再试(${data.message})`);
+                this.showTip(`广告暂不可用，请稍后再试(${data.message})`);
             });
         }
-        // 预加载激励视频广告，让 native 侧提前准备，减少首次拉取失败率
+
+        // ── 生命周期收尾 ──
+        AdSdk.onGameReady(UIAdapter.version);
         UIAdapter.hookLoadScene();
         UIAdapter.back.setFallback(() => UIAdapter.backHandler());
     }
 
-    private static get isXiaomi() {
+    // ========================================================================
+    // 属性
+    // ========================================================================
+
+    /** 是否 Cocos 环境 */
+    public static get isCocos() { return window['cc'] != undefined; }
+    /** 是否基座环境 */
+    public static get isWebBridge() { return UIAdapter.webBridge.isAvailable(); }
+    /** 是否可以观看视频 */
+    public static get canWatchVideo() { return this.isXiaomi; }
+    /** 是否 VIP 用户 */
+    public static get isVIP() { return UIAdapter._isVIP; }
+    /** 是否小米平台 */
+    public static get isXiaomi() {
         if (typeof window === 'undefined') return null;
         return window['AppBridge'] || null;
     }
@@ -102,14 +116,14 @@ export class PlatformAdapter {
         };
         let onSuccess = () => {
             try {
-                PlatformAdapter.report(AnalyticsEvent.RewardVideoAd, AnalyticsAction.Exposure);
+                this.report(AnalyticsEvent.RewardVideoAd, AnalyticsAction.Exposure);
                 callback && callback.call(target);
             } finally {
                 fireFinish();
             }
         };
 
-        if (PlatformAdapter.canWatchVideo) {
+        if (this.canWatchVideo) {
             // 监听奖励（用户完整看完广告触发）
             try {
                 const result = await AdSdk.requestAd({
@@ -156,8 +170,8 @@ export class PlatformAdapter {
      */
     public static registerButtonByName(name: string, parent: cc.Node = null) {
         if (!parent) parent = cc.director.getScene();
-        let button = PlatformAdapter.findChildByName(parent, name);
-        PlatformAdapter.registerButton(button);
+        let button = this.findChildByName(parent, name);
+        this.registerButton(button);
     }
 
     /**
@@ -167,7 +181,7 @@ export class PlatformAdapter {
      */
     public static focusButtonByName(name: string, parent: cc.Node = null) {
         if (!parent) parent = cc.director.getScene();
-        let button = PlatformAdapter.findChildByName(parent, name);
+        let button = this.findChildByName(parent, name);
         UIAdapter.focus.focus(button);
     }
 
@@ -184,7 +198,7 @@ export class PlatformAdapter {
     public static findChildByName(parent: cc.Node, name: string): cc.Node | null {
         if (parent.name === name) return parent;
         for (let i = 0; i < parent.children.length; i++) {
-            let result = PlatformAdapter.findChildByName(parent.children[i], name);
+            let result = this.findChildByName(parent.children[i], name);
             if (result) return result;
         }
         return null;
@@ -228,33 +242,50 @@ export class PlatformAdapter {
     // ========================================================================
 
     /**
-     * 上报事件（缓存）
+     * 上报事件
      * @param event 事件类型
      * @param action 操作类型，默认点击
      * @param adRequestId 广告请求ID
      */
     public static report(event: AnalyticsEvent, action: AnalyticsAction = AnalyticsAction.Click, adRequestId?: string) {
-        GameAnalytics.report(event, action, adRequestId);
+        const def = AnalyticsEventMap[event];
+        if (!def) {
+            console.warn("[PlatformAdapter] unsupported event", event);
+            return;
+        }
+        const eventName = action === AnalyticsAction.Exposure ? def.expose : def.click;
+        if (!eventName) {
+            console.warn("[PlatformAdapter] unsupported action", action, "for event", event);
+            return;
+        }
+        const reportItem: any = {
+            element_position: def.ep,
+            action_type: action === AnalyticsAction.Exposure ? ActionType.Exposure : ActionType.Click,
+            event_name: eventName,
+        };
+        if (event === AnalyticsEvent.RewardVideoAd && adRequestId) {
+            reportItem.ad_request_id = adRequestId;
+        }
+        // 由 Reporter 内部队列批量上报
+        Reporter.report(reportItem);
     }
 
     /** 批量上报事件 */
     public static reportBatch(events: AnalyticsEvent[]) {
-        GameAnalytics.reportBatch(events);
+        if (events.length === 0) return;
+        const items: any[] = [];
+        for (const e of events) {
+            const def = AnalyticsEventMap[e];
+            if (!def) continue;
+            items.push({
+                element_position: def.ep,
+                action_type: ActionType.Exposure,
+                event_name: def.expose,
+            });
+        }
+        if (items.length > 0) Reporter.reportBatch(items);
     }
 
-    // ========================================================================
-    // 属性
-    // ========================================================================
-
-    /** 是否 Cocos 环境 */
-    public static get isCocos() { return window['cc'] != undefined; }
-    /** 是否基座环境 */
-    public static get isWebBridge() { return UIAdapter.webBridge.isAvailable(); }
-    /** 是否可以观看视频 */
-    public static get canWatchVideo() { return this.isXiaomi; }
-    /** 是否 VIP 用户 */
-    public static get isVIP() { return UIAdapter._isVIP; }
-
     /** 显示帮助窗口 */
     public static async showHelperWin(url: string, cb: () => void) {
         var key = `${UIAdapter._zhName}-isFirst`;

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;
-};
+};

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

@@ -2,11 +2,15 @@
  * 数据上报模块 - 统一封装层
  *
  * 内部使用 supersetLewo 上报脚本，对外提供简洁的调用接口：
- *   Reporter.init(config)       — 初始化（设置项目编码、游戏ID等公共字段）
- *   Reporter.report(data)       — 单次上报
- *   Reporter.reportBatch(list)  — 批量上报
- *   Reporter.createDeviceId()   — 获取/生成设备ID
- *   Reporter.resetDeviceId()    — 重置设备ID
+ *   Reporter.init(config)             — 初始化
+ *   Reporter.report(data, immediate)  — 单次上报（默认加入队列批量发送）
+ *   Reporter.reportBatch(list)        — 批量上报
+ *   Reporter.flushQueue()             — 立即刷新队列
+ *   Reporter.reportAppStart()         — 启动事件
+ *   Reporter.reportSwitchBackground() — 切后台事件
+ *   Reporter.reportSwitchBack()       — 切回事件
+ *   Reporter.reportAppExit()          — 退出事件（自动计算游戏时长）
+ *   Reporter.updateUserInfo(info)     — 登录后更新用户信息
  */
 
 var supersetLewo = require('./superset-lewo');
@@ -20,8 +24,118 @@ var ActionType = {
   Exposure: '曝光',
   /** 点击 */
   Click: '点击',
+  /** 开始播放 */
+  StartPlay: '开始播放',
+  /** 结束播放（需上报时长 action_value） */
+  EndPlay: '结束播放',
+  /** 分享 */
+  Share: '分享',
+  /** 订购（需上报成功订购金额） */
+  Order: '订购',
+  /** 启动 */
+  Start: '启动',
+  /** 退出 */
+  Exit: '退出',
+  /** 切后台 */
+  SwitchBackground: '切后台',
+  /** 切回 */
+  SwitchBack: '切回',
 };
 
+// ────────────────────────────────────────
+// 内部队列管理（无需修改 supersetLewo）
+// ────────────────────────────────────────
+
+/** 配置接口地址 */
+var CONFIG_URL = 'http://sup.daoran.tv/bi-api/api/config/get';
+
+/** 事件队列 */
+var _eventQueue = [];
+/** 定时器句柄 */
+var _batchTimer = null;
+/** 每批最大条数 */
+var _perNum = 10;
+/** 发送间隔（秒） */
+var _spaceSec = 30;
+/** 队列模式是否已启用 */
+var _queueEnabled = false;
+
+/** 会话启动时间戳（毫秒），用于计算游戏时长 */
+var _sessionStartTime = 0;
+
+/** 额外用户信息（登录后填充，合并到上报 user 对象） */
+var _extraUserInfo = {};
+
+/**
+ * 修补 supersetLewo.getUserInfo，使登录后的额外字段能合并到 user 对象
+ * 避免修改 superset-lewo.js 源文件
+ */
+(function _patchGetUserInfo() {
+  var originalGetUserInfo = supersetLewo.getUserInfo;
+  supersetLewo.getUserInfo = function () {
+    var info = originalGetUserInfo();
+    // 合并额外字段（如 user_id、user_type 等）
+    for (var key in _extraUserInfo) {
+      if (_extraUserInfo.hasOwnProperty(key)) {
+        info[key] = _extraUserInfo[key];
+      }
+    }
+    return info;
+  };
+})();
+
+/**
+ * 刷新队列 —— 将队列中所有事件打包发送
+ */
+function _flushQueue() {
+  if (_eventQueue.length === 0) return;
+  var batch = _eventQueue.splice(0, _perNum);
+  supersetLewo.batchReporting(batch);
+}
+
+/**
+ * 添加单条事件到队列
+ */
+function _addToQueue(eventItem) {
+  _eventQueue.push(eventItem);
+  if (_eventQueue.length >= _perNum) {
+    _flushQueue();
+  }
+}
+
+/**
+ * 批量添加事件到队列
+ */
+function _addBatchToQueue(eventList) {
+  if (!Array.isArray(eventList) || eventList.length === 0) return;
+  for (var i = 0; i < eventList.length; i++) {
+    _eventQueue.push(eventList[i]);
+  }
+  if (_eventQueue.length >= _perNum) {
+    _flushQueue();
+  }
+}
+
+/**
+ * 启用队列定时刷新
+ */
+function _startQueueTimer() {
+  if (_queueEnabled) return;
+  _queueEnabled = true;
+  _batchTimer = setInterval(_flushQueue, _spaceSec * 1000);
+}
+
+/**
+ * 停止队列定时刷新
+ */
+function _stopQueueTimer() {
+  _queueEnabled = false;
+  if (_batchTimer) {
+    clearInterval(_batchTimer);
+    _batchTimer = null;
+  }
+}
+
 // ────────────────────────────────────────
 // Reporter 实现
 // ────────────────────────────────────────
@@ -33,6 +147,40 @@ var Reporter = {
   /** 公共字段缓存（初始化时设置，每次上报自动合并） */
   _commonInfo: {},
 
+  /**
+   * 从后端获取批量上报配置
+   * @param {Function} [callback] - 回调函数，接收 { perNum, spaceSec }
+   */
+  fetchReportConfig: function (callback) {
+    var self = this;
+    supersetLewo.ajax({
+      url: CONFIG_URL,
+      type: 'get',
+      dataType: 'json',
+      data: {},
+      success: function (xhr, rsp) {
+        if (rsp && rsp.code === 200 && rsp.data) {
+          var cfg = rsp.data;
+          _perNum = cfg.perNum || 10;
+          _spaceSec = cfg.spaceSec || 30;
+          if (typeof callback === 'function') {
+            callback({ perNum: _perNum, spaceSec: _spaceSec });
+          }
+        } else {
+          if (typeof callback === 'function') {
+            callback({ perNum: 10, spaceSec: 30 });
+          }
+        }
+      },
+      error: function (xhr, rsp) {
+        console.warn('[Reporter] fetchReportConfig failed, use defaults');
+        if (typeof callback === 'function') {
+          callback({ perNum: 10, spaceSec: 30 });
+        }
+      }
+    });
+  },
+
   /**
    * 初始化上报模块
    * @param {import('../types/interfaces').IReporterConfig} config
@@ -69,33 +217,46 @@ var Reporter = {
     }
 
     supersetLewo.initUserInfo({
-      os_type: "",          // 系统类型安卓
-      os_version: "",            // 安卓版本15
-      app_version: "1.0.0",        // APP版本号
-      app_item: config.app_item,              // 渠道编码
-      app_name: config.content_title,      // APP展示名称
-      app_project: config.content_id,          // 产品内部编码
-      province: "",             // 省份编码
-      city: "",                // 城市编码
-      uid: "",            // 登录用户UID，未登录填空""
-      user_id: "",         // 会员/游客ID，无则填空""
-      device_id: this._commonInfo.device_id,               // 设备唯一ID，没有或不传则自动生成
-      device_brand: "",      // 手机品牌小写
-      device_model: "",    // 手机完整型号
-      network_type: "",    // 蜂窝流量网络
-      carrier: ""              // 运营商
-      // device_id 不传，内部自动生成UUID填充，无需手动传入
+      os_type: config.os_type || "",                // 操作系统类型 android/ios
+      os_version: config.os_version || "",          // 操作系统版本号
+      app_version: config.app_version || "1.0.0",   // APP版本号
+      app_item: config.app_item || "",              // 渠道编码（项目编码）
+      app_name: config.app_name || config.content_title || "",  // APP名称
+      app_project: config.app_project || config.content_id || "", // 产品编码
+      province: config.province || "",              // 省份编码
+      city: config.city || "",                      // 城市编码
+      uid: config.uid || "",                        // 注册登录用户全局UID；游客/未登录填空字符串
+      user_id: config.user_id || "",                // 会员ID(memberId)，无则填空字符串，不用uid填充
+      device_id: this._commonInfo.device_id,        // 设备唯一ID
+      device_brand: config.device_brand || "",      // 设备品牌，小写
+      device_model: config.device_model || "",      // 设备型号
+      network_type: config.network_type || "",      // 网络类型：wifi/cellular
+      carrier: config.carrier || "",                // 运营商
+      promotion_flag: config.promotion_flag || "0", // 推广标识(ubp接口获取,1推广/0自然)
+      user_type: config.user_type || "0"            // 用户身份类型(0游客/1注册用户/2付费用户)
     });
 
     this._initialized = true;
+
+    // 记录启动时间
+    _sessionStartTime = Date.now();
+
+    // 异步拉取批量配置，拉取成功后启动队列
+    var self = this;
+    this.fetchReportConfig(function (batchCfg) {
+      _startQueueTimer();
+      console.log('[Reporter] Batch config:', batchCfg, '- Queue mode enabled');
+    });
+
     console.log('[Reporter] Initialized, reportUrl:', supersetLewo.config.reportUrl);
   },
 
   /**
    * 单次上报
-   * @param {import('../types/interfaces').IReportItem} data - 上报数据（下划线格式）
+   * @param {import('../types/interfaces').IReportItem} data - 上报数据
+   * @param {boolean} [immediate=false] - 是否立即发送（不经过队列）
    */
-  report: function (data) {
+  report: function (data, immediate) {
     if (!this._initialized) {
       console.warn('[Reporter] Not initialized. Call Reporter.init() first.');
       return;
@@ -120,15 +281,22 @@ var Reporter = {
       merged.device_id = supersetLewo.createDeviceId();
     }
 
-    supersetLewo.superBatchReport(merged);
+    if (immediate) {
+      // 立即发送（生命周期事件等需要及时上报的场景）
+      supersetLewo.superBatchReport(merged);
+    } else {
+      // 加入队列，凑批次后批量发送
+      _addToQueue(merged);
+    }
   },
 
   /**
    * 批量上报
-   * @param {Array<import('../types/interfaces').IReportItem>} dataList - 上报数据列表（下划线格式）
-   * @param {import('../types/interfaces').IReportItem} [commonInfo] - 可选公共字段（覆盖初始化的公共字段）
+   * @param {Array<import('../types/interfaces').IReportItem>} dataList - 上报数据列表
+   * @param {import('../types/interfaces').IReportItem} [commonInfo] - 可选公共字段
+   * @param {boolean} [immediate=false] - 是否立即发送（不经过队列）
    */
-  reportBatch: function (dataList, commonInfo) {
+  reportBatch: function (dataList, commonInfo, immediate) {
     if (!this._initialized) {
       console.warn('[Reporter] Not initialized. Call Reporter.init() first.');
       return;
@@ -158,7 +326,122 @@ var Reporter = {
       mergedCommon.device_id = supersetLewo.createDeviceId();
     }
 
-    supersetLewo.batchReporting(dataList, mergedCommon);
+    // 合并公共字段到各事件中
+    var items = [];
+    for (var i = 0; i < dataList.length; i++) {
+      var item = {};
+      for (key in mergedCommon) {
+        if (mergedCommon.hasOwnProperty(key)) {
+          item[key] = mergedCommon[key];
+        }
+      }
+      for (key in dataList[i]) {
+        if (dataList[i].hasOwnProperty(key)) {
+          item[key] = dataList[i][key];
+        }
+      }
+      items.push(item);
+    }
+
+    if (immediate) {
+      // 立即发送
+      supersetLewo.batchReporting(items);
+    } else {
+      // 加入队列
+      _addBatchToQueue(items);
+    }
+  },
+
+  /**
+   * 立即刷新队列，将队列中所有事件立即发送
+   */
+  flushQueue: function () {
+    _flushQueue();
+  },
+
+  /**
+   * 上报「启动」事件 - APP启动成功后调用，记录启动时间
+   */
+  reportAppStart: function () {
+    _sessionStartTime = Date.now();
+    this.report({
+      element_position: "AppLaunch",
+      position_name: "应用启动",
+      element_type: "page",
+      element_name: "app_start",
+      action_type: ActionType.Start,
+      action_value: ""
+    }, true);
+  },
+
+  /**
+   * 上报「切后台」事件 - APP切到后台时调用
+   * 计算当前时间与启动时间差，action_value传时间差（秒）
+   */
+  reportSwitchBackground: function () {
+    var duration = Math.floor((Date.now() - _sessionStartTime) / 1000);
+    this.report({
+      element_position: "AppBackground",
+      position_name: "应用切后台",
+      element_type: "page",
+      element_name: "app_switch_background",
+      action_type: ActionType.SwitchBackground,
+      action_value: String(duration)
+    }, true);
+  },
+
+  /**
+   * 上报「切回」事件 - APP从后台切回时调用，上报后更新启动时间
+   */
+  reportSwitchBack: function () {
+    this.report({
+      element_position: "AppForeground",
+      position_name: "应用切前台",
+      element_type: "page",
+      element_name: "app_switch_back",
+      action_type: ActionType.SwitchBack,
+      action_value: ""
+    }, true);
+    // 更新启动时间
+    _sessionStartTime = Date.now();
+  },
+
+  /**
+   * 上报「退出」事件 - APP退出前调用
+   * 计算当前时间与启动时间差，action_value传时间差（秒），给后台上传游戏时长
+   */
+  reportAppExit: function () {
+    // 先刷新队列中剩余事件
+    _flushQueue();
+
+    var duration = Math.floor((Date.now() - _sessionStartTime) / 1000);
+    this.report({
+      element_position: "AppExit",
+      position_name: "应用退出",
+      element_type: "page",
+      element_name: "app_exit",
+      action_type: ActionType.Exit,
+      action_value: String(duration)
+    }, true);
+    // 重置启动时间
+    _sessionStartTime = 0;
+  },
+
+  /**
+   * 更新用户信息（登录后调用，传入memberId等）
+   * @param {Object} userInfo - 用户信息，如 { user_id: 'nC650471', user_type: '1' }
+   */
+  updateUserInfo: function (userInfo) {
+    if (!userInfo) return;
+    // 更新公共字段（合并到 data 事件中）
+    this.setCommonInfo(userInfo);
+    // 更新额外用户信息（合并到上报的 user 对象中）
+    for (var key in userInfo) {
+      if (userInfo.hasOwnProperty(key)) {
+        _extraUserInfo[key] = userInfo[key];
+      }
+    }
+    console.log('[Reporter] updateUserInfo:', userInfo);
   },
 
   /**
@@ -214,4 +497,4 @@ var Reporter = {
 module.exports = {
   Reporter: Reporter,
   ActionType: ActionType,
-};
+};

package/drscript/ad-sdk/reporters/superset-lewo.js

@@ -571,4 +571,4 @@ supersetLewo.resetDeviceId();
 // CommonJS 模块导出（不改动上方 IIFE 逻辑）
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = supersetLewo;
-}
+}

package/drscript/ad-sdk/types/enums.d.ts

@@ -23,6 +23,7 @@ export declare enum AdEvent {
   Closed = 'closed',
   Reward = 'reward',
   Error = 'error',
+  Exit = 'exit',
 }
 
 /** 广告错误码（聚合层统一） */
@@ -62,4 +63,4 @@ export declare enum KeyCode {
 export declare enum KeyAction {
   Down = 'down',
   Up = 'up',
-}
+}

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

@@ -36,6 +36,8 @@ const AdEvent = {
   Reward: 'reward',
   /** 广告失败 */
   Error: 'error',
+  /** 退出确认（原生层确认退出） */
+  Exit: 'exit',
 };
 
 /** 广告错误码（聚合层统一） */
@@ -108,4 +110,4 @@ module.exports = {
   DevicePlatform,
   KeyCode,
   KeyAction,
-};
+};

package/drscript/ad-sdk/types/interfaces.d.ts

@@ -75,31 +75,71 @@ export interface IReporterConfig {
   content_id?: string;
   /** 游戏名 */
   content_title?: string;
+  /** 操作系统类型 android/ios */
+  os_type?: string;
+  /** 操作系统版本号 */
+  os_version?: string;
+  /** APP版本号 */
+  app_version?: string;
+  /** APP名称 */
+  app_name?: string;
+  /** 产品编码 */
+  app_project?: string;
+  /** 省份编码 */
+  province?: string;
+  /** 城市编码 */
+  city?: string;
+  /** 注册登录用户全局UID；游客/未登录填空字符串 */
+  uid?: string;
+  /** 会员ID(memberId)，无则填空字符串 */
+  user_id?: string;
+  /** 设备品牌，小写 */
+  device_brand?: string;
+  /** 设备型号 */
+  device_model?: string;
+  /** 网络类型：wifi/cellular */
+  network_type?: string;
+  /** 运营商 */
+  carrier?: string;
+  /** 推广标识(ubp接口获取,1推广/0自然) */
+  promotion_flag?: string;
+  /** 用户身份类型(0游客/1注册用户/2付费用户) */
+  user_type?: string;
 }
 
 /** 上报数据项（下划线字段格式） */
 export interface IReportItem {
-  /** 用户唯一标识（需要用户登录，产生UID） */
-  user_id?: string;
-  /** 设备唯一标识（设备号，如果无，则需要生成） */
-  device_id?: string;
-  /** 渠道编码 */
-  app_item?: string;
-  /** 内容类型（游戏固定上报"游戏"） */
-  content_type?: string;
-  /** 游戏 ID */
+  /** 产品定义元素位置编码 */
+  element_position?: string;
+  /** 元素位置中文名称 */
+  position_name?: string;
+  /** OMS后台页面编码，无则空 */
+  page_code?: string;
+  /** OMS后台页面名称，无则空 */
+  page_name?: string;
+  /** OMS后台楼层ID，无则空 */
+  floor_id?: string;
+  /** OMS后台楼层名称，无则空 */
+  floor_name?: string;
+  /** 元素类型枚举(page/vlist/plist/res/act/link等) */
+  element_type?: string;
+  /** 元素名称/标题 */
+  element_name?: string;
+  /** 最小颗粒度内容ID */
   content_id?: string;
-  /** 游戏名 */
+  /** 最小颗粒度内容标题 */
   content_title?: string;
-  /** 元素位置（埋点范围表对应的元素位置列） */
-  element_position?: string;
-  /** 行为类型：曝光 / 点击 */
+  /** 扩展属性1，补充附属信息 */
+  ext_attr1?: string;
+  /** 扩展属性2，补充附属ID */
+  ext_attr2?: string;
+  /** 行为枚举：曝光、点击、开始播放、结束播放、分享、订购、启动、退出、切后台 */
   action_type?: string;
-  /** 具体事件名（通过元素位置和行为生成事件名字） */
+  /** 行为值，时长填秒数，订购填金额（单位：分）；无时间跨度行为填空 */
+  action_value?: string;
+  /** 友盟需要上报的事件名（仅友盟使用） */
   event_name?: string;
-  /** 广告请求 ID（仅广告相关事件需要） */
-  ad_request_id?: string;
-  /** 客户端事件时间（yyyy-MM-dd HH:mm:ss，不传则自动生成） */
+  /** 事件发生时间，格式 yyyy-MM-dd HH:mm:ss，不传则自动生成 */
   event_time?: string;
 }
 
@@ -282,6 +322,8 @@ export interface IAdSdkConfig {
   customAdapters?: IAdAdapter[];
   /** 全局事件监听 */
   onEvent?: (event: AdEvent, data: IAdEventData) => void;
+  /** 数据上报配置（不传则不上报） */
+  reporter?: IReporterConfig;
 }
 
 /** 聚合广告 SDK 主接口 */
@@ -330,4 +372,4 @@ export interface IAdSdk {
 
   /** 销毁 SDK */
   destroy(): void;
-}
+}

package/drscript/component/ExitWin.ts

@@ -21,13 +21,15 @@ export default class ExitWin extends cc.Component {
     }
 
     private async onClickExit() {
-        if (PlatformAdapter.isWebBridge) {
-            PlatformAdapter.webBridge.callHandler("router/navigateBack", {}, (a) => { cc.log(a); });
-            return;
-        }
-        if (AdSdk.exitGame) {
+        console.log("onClickExit", PlatformAdapter.isXiaomi, PlatformAdapter.isWebBridge);
+        if (PlatformAdapter.isXiaomi) {
+            console.log("onClickExit Xiaomi");
             await AdSdk.exitGame();
+        } else if (PlatformAdapter.isWebBridge) {
+            console.log("onClickExit WebBridge");
+            PlatformAdapter.webBridge.callHandler("router/navigateBack", {}, (a) => { cc.log(a); });
         } else {
+            console.log("onClickExit Other");
             cc.game.end();
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drgame-cc",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "道然游戏适配包",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/drscript/BtnExtra.ts

@@ -1,17 +0,0 @@
-
-const { ccclass, property } = cc._decorator;
-
-@ccclass('BtnExtra')
-export class BtnExtra extends cc.Component {
-    @property({
-        type: cc.SpriteFrame,
-        tooltip: '悬停状态图片'
-    })
-    hoverSprite: cc.SpriteFrame = null;
-
-    @property({
-        type: cc.SpriteFrame,
-        tooltip: '普通状态图片'
-    })
-    normalSprite: cc.SpriteFrame = null;
-}

package/drscript/GameAnalytics.ts

@@ -1,150 +0,0 @@
-import { ActionType, Reporter, IReportItem } from "./ad-sdk/ad-sdk";
-import { AnalyticsEvent, AnalyticsAction } from "./Define";
-
-const REPORT_URL = "https://sup.daoran.tv/bi-api/api/game/lewo/batch";
-
-/** 事件定义：element_position + 曝光/点击事件名 */
-const EVENT_MAP: Record<AnalyticsEvent, { ep: string; expose: string; click?: string }> = {
-    [AnalyticsEvent.GameLoading]: { ep: "game_loading", expose: "game_loading_expose" },
-    [AnalyticsEvent.StartGameButton]: { ep: "start_game_button", expose: "start_game_expose", click: "start_game_click" },
-    [AnalyticsEvent.WatchVideoContinueButton]: { ep: "watch_video_continue_button", expose: "watch_video_continue_expose", click: "watch_video_continue_click" },
-    [AnalyticsEvent.ReplayButton]: { ep: "replay_button", expose: "replay_expose", click: "replay_click" },
-    [AnalyticsEvent.RewardVideoAd]: { ep: "reward_video_ad", expose: "ad_expose" },
-};
-
-export default class GameAnalytics {
-    private static initialized: boolean = false;
-    private static loadingReported: boolean = false;
-    private static reportedExposures: { [event: string]: boolean } = {};
-    private static reportInterval: number = 1000 * 30; // 30秒上报一次
-    private static reportMaxSize: number = 50;
-    private static reportKey = "game_analytics_report_cache";
-
-    public static init(config: {
-        app_item: string;
-        content_type?: string;
-        content_id?: string;
-        content_title?: string;
-    }): void {
-        if (GameAnalytics.initialized) return;
-
-        try {
-            Reporter.init({
-                report_url: REPORT_URL,
-                app_item: config.app_item,
-                content_type: config.content_type || "游戏",
-                content_id: config.content_id || "",
-                content_title: config.content_title || "",
-            });
-            GameAnalytics.initialized = true;
-            var httpReq = new XMLHttpRequest();
-            httpReq.open("POST", 'https://sup.daoran.tv/bi-api/api/config/get');
-            httpReq.setRequestHeader("Content-Type", "application/json");
-            httpReq.setRequestHeader("Accept", "application/json");
-            httpReq.send();
-            httpReq.onreadystatechange = () => {
-                if (httpReq.readyState === 4 && httpReq.status === 200) {
-                    console.log("[GameAnalytics] report batch success", httpReq.responseText);
-                }
-            };
-            setInterval(() => {
-                this.reportBatchCache();
-            }, this.reportInterval);
-        } catch (error) {
-            console.warn("[GameAnalytics] init failed", error);
-        }
-    }
-
-    public static reportLoadingOnce(): void {
-        if (this.loadingReported) return;
-        this.loadingReported = true;
-        this.report(AnalyticsEvent.GameLoading, AnalyticsAction.Exposure);
-    }
-
-    public static reportExposureOnce(event: AnalyticsEvent): void {
-        if (this.reportedExposures[event]) return;
-        this.reportedExposures[event] = true;
-        this.report(event, AnalyticsAction.Exposure);
-    }
-
-    public static report(
-        event: AnalyticsEvent,
-        action: AnalyticsAction,
-        adRequestId?: string
-    ): void {
-        if (!this.initialized) return;
-        const def = EVENT_MAP[event];
-        const eventName = action === AnalyticsAction.Exposure ? def.expose : def.click;
-        if (!def || !eventName) {
-            console.warn("[GameAnalytics] unsupported event/action", event, action);
-            return;
-        }
-
-        try {
-            const reportItem: any = {
-                element_position: def.ep,
-                action_type: action === AnalyticsAction.Exposure
-                    ? ActionType.Exposure
-                    : ActionType.Click,
-                event_name: eventName,
-            };
-            if (event === AnalyticsEvent.RewardVideoAd && adRequestId) {
-                reportItem.ad_request_id = adRequestId;
-            }
-            var reportCache: IReportItem[] = null;
-            const cache = localStorage.getItem(this.reportKey);
-            if (cache) {
-                reportCache = JSON.parse(cache);
-            }
-            if (reportCache) {
-                reportCache.push(reportItem);
-            } else {
-                reportCache = [reportItem];
-            }
-            localStorage.setItem(this.reportKey, JSON.stringify(reportCache));
-        } catch (error) {
-            console.warn("[GameAnalytics] report failed", error);
-        }
-    }
-
-    public static reportBatch(events: AnalyticsEvent[]): void {
-        if (!this.initialized || events.length === 0) return;
-        try {
-            const items: IReportItem[] = [];
-            for (const e of events) {
-                const def = EVENT_MAP[e];
-                if (!def) continue;
-                const item: any = {
-                    element_position: def.ep,
-                    action_type: ActionType.Exposure,
-                    event_name: def.expose,
-                    ad_request_id: "",
-                };
-                items.push(item);
-            }
-            if (items.length > 0) Reporter.reportBatch(items);
-        } catch (error) {
-            console.warn("[GameAnalytics] report failed", error);
-        }
-    }
-
-    private static reportBatchCache(): void {
-        if (!this.initialized) return;
-        var reportCache: IReportItem[] = null;
-        const cache = localStorage.getItem(this.reportKey);
-        if (cache) {
-            reportCache = JSON.parse(cache);
-        }
-        if (!reportCache || reportCache.length === 0) return;
-
-        try {
-            const reportItem = reportCache.splice(0, this.reportMaxSize);
-            Reporter.reportBatch(reportItem);
-        } catch (error) {
-            console.warn("[GameAnalytics] report failed", error);
-            reportCache = [];
-        } finally {
-            localStorage.setItem(this.reportKey, JSON.stringify(reportCache));
-        }
-    }
-}