keytops-game-framework 1.0.26 → 2.0.0

package/dist/index.js

@@ -881,1155 +881,1492 @@ Storage.created = false;
  */
 const storage = new Storage();
 
-var InternalProperty;
-(function (InternalProperty) {
-    /**设备系统版本 */
-    InternalProperty["DEVICE_SYSTEM"] = "_ds_";
-    /**设备操作系统类型 */
-    InternalProperty["DEVICE_PLATFORM"] = "_dp_";
-    /**设备手机品牌 */
-    InternalProperty["DEVICE_BRAND"] = "_db_";
-    /**设备手机型号 */
-    InternalProperty["DEVICE_MODEL"] = "_dm_";
-    /**宿主名称 */
-    InternalProperty["HOST_NAME"] = "_hn_";
-    /**宿主版本 */
-    InternalProperty["HOST_VERSION"] = "_hv_";
-    /**启动时间 */
-    InternalProperty["LAUNCH_TIME"] = "_lt_";
-    /**启动次数 */
-    InternalProperty["LAUNCH_TIMES"] = "_lts_";
-    /**安装时间 */
-    InternalProperty["INSTALL_TIME"] = "_it_";
-    /**app运载（安装）时长 */
-    InternalProperty["DURATION_OF_INSTALL"] = "_doi_";
-    /**app运行(启动）时长 */
-    InternalProperty["DURATION_OF_LAUNCH"] = "_dol_";
-    /**累积登录天数 */
-    InternalProperty["LOGIN_DAYS"] = "_lds_";
-    /**安装来源type */
-    InternalProperty["INSTALL_SCENE"] = "_is_";
-    /**安装来源source */
-    InternalProperty["INSTALL_CHANNEL"] = "_ic_";
-    /**启动来源场景 */
-    InternalProperty["LAUNCH_SCENE"] = "_ls_";
-    /**启动来源渠道 */
-    InternalProperty["LAUNCH_CHANNEL"] = "_lc_";
-    /**事件计时时长 */
-    InternalProperty["DURATION"] = "_dt_";
-    /**游戏版本 */
-    InternalProperty["APP_VERSION"] = "_av_";
-})(InternalProperty || (InternalProperty = {}));
-class EmptyAnalyticsSender {
-    /**
-     * @param [exclude] 其他排除的上报日志, 默认不排除
-     */
-    constructor(exclude) {
-        this._exclude = exclude || [];
-    }
-    /**
-     * 设置排除
-     * @param excludeList 排除事件名称或者名称列表。
-     */
-    exclude(...excludeList) {
-        this._exclude = excludeList.concat();
-    }
-    sendAble(eventName) {
-        if (this._exclude && this._exclude.indexOf(eventName) != -1) {
-            return false;
-        }
-        return true;
-    }
-    send(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
-    }
-}
 /**
- * 统计分析能力
+ * 通用计时器实现。
+ * 使用 setInterval 驱动 Timer 的内部更新循环。
  */
-class AnalyticsAble {
+class TimerImpl {
     constructor() {
-        this._inited = false;
-        this._hasSetDefaultProperty = false;
-        this._debugMode = false;
-        this._senderList = [];
-        this._dynamicCalls = [];
+        this._intervalMap = new WeakMap();
     }
-    get inited() { return this._inited; }
+    enable(timer) {
+        if (this._intervalMap.has(timer)) {
+            return;
+        }
+        const intervalId = setInterval(() => {
+            timer["_update"]();
+        }, 100);
+        this._intervalMap.set(timer, intervalId);
+    }
+}
+
+class MathUtils {
     /**
-     * 初始化
+     * 随机
+     * @param min
+     * @param max
      */
-    init(senders, debugMode = false) {
-        if (this._inited)
-            return this;
-        this._debugMode = debugMode;
-        App.onShow(this._onAppShow, this);
-        App.onHide(this._onAppHide, this);
-        this._initSenderList(senders);
-        this._inited = true;
-        return this;
+    static random(min, max) {
+        this.seed = (this.seed * 9301 + 49297) % 233280;
+        let c = this.seed / (233280.0);
+        return min + c * (max - min);
     }
-    _initSenderList(senders) {
-        for (let i = 0; i < senders.length; i++) {
-            const sender = senders[i];
-            this._senderList.push(sender);
-        }
+    /**
+     * 随机整数值
+     * @param min
+     * @param max
+     */
+    static randomInt(min, max) {
+        return Math.floor(this.random(min, max + 0.999));
     }
     /**
-     * 设置排除
-     * @param excludeEvents 排除事件名称或者名称列表。
-     * @param senderClass [可选] 特定的SenderClass
+     * 随机唯一稳定值
+     * @param min
+     * @param max
+     * @param clear  是否清除唯一记录
      */
-    setExclude(excludeEvents, senderClass) {
-        for (let i = 0; i < this._senderList.length; i++) {
-            const sender = this._senderList[i];
-            if (!senderClass || sender instanceof senderClass) {
-                if (typeof excludeEvents === "string") {
-                    sender.exclude(excludeEvents);
-                }
-                else {
-                    sender.exclude(...excludeEvents);
-                }
+    static randomOnlyInt(min, max, clear) {
+        if (clear) {
+            this.onlyMap.clear();
+        }
+        let value = this.randomInt(min, max);
+        let tryCount = (max - min) * 2;
+        let tryIndex = 0;
+        while (this.onlyMap.has(value)) {
+            value = this.randomInt(min, max);
+            if (tryIndex > tryCount) {
+                console.error("所有唯一值已取完");
+                return 0;
             }
+            tryIndex++;
         }
+        this.onlyMap.set(value, true);
+        return value;
     }
-    _onAppShow() {
-        this.time("app_hide");
-        this.report("app_show", publisher.publisher.enterOptions.getAllOption());
+    /**
+     * 获取两点间的角度
+     * @param p1 点1
+     * @param p2 点2
+     */
+    static getAngle(p1, p2) {
+        return Math.atan((p2.y - p1.y) / (p2.x - p1.x));
     }
-    _onAppHide() {
-        this.report("app_hide");
+    /**
+     * 获取两点间的距离
+     * @param p1 点1
+     * @param p2 点2
+     */
+    static getDistance(p1, p2) {
+        return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
     }
     /**
-     * 设置所有上报事件的基础属性
+     * 将角度转为弧度
+     * @param angle 角度
      */
-    _setDefaultProperty() {
-        if (this._hasSetDefaultProperty) {
-            return;
-        }
-        //设备信息
-        let deviceInfo = publisher.device.deviceInfo;
-        this.setProperty(InternalProperty.DEVICE_SYSTEM, deviceInfo.system);
-        this.setProperty(InternalProperty.DEVICE_PLATFORM, deviceInfo.platform);
-        this.setProperty(InternalProperty.DEVICE_BRAND, deviceInfo.brand);
-        this.setProperty(InternalProperty.DEVICE_MODEL, deviceInfo.model);
-        //宿主信息
-        let hostInfo = publisher.device.hostInfo;
-        this.setProperty(InternalProperty.HOST_NAME, hostInfo.name);
-        this.setProperty(InternalProperty.HOST_VERSION, hostInfo.version);
-        //安装时间
-        this.setProperty(InternalProperty.INSTALL_TIME, Math.floor(App.installTime / 1000));
-        //启动时间
-        this.setProperty(InternalProperty.LAUNCH_TIME, Math.floor(App.launchTime / 1000));
-        //启动次数
-        this.setProperty(InternalProperty.LAUNCH_TIMES, App.launchTimes);
-        //游戏版本
-        this.setProperty(InternalProperty.APP_VERSION, publisher.publisher.appVersion);
-        this.setDynamicProperties(() => {
-            let dynamicData = {};
-            //app运载（安装）时长
-            dynamicData[InternalProperty.DURATION_OF_INSTALL] = Math.floor(App.durationOfInstall / 1000);
-            //app运行(启动）时长
-            dynamicData[InternalProperty.DURATION_OF_LAUNCH] = Math.floor(App.durationOfLaunch / 1000);
-            return dynamicData;
-        });
-        //累积登录天数
-        this.userSet(InternalProperty.LOGIN_DAYS, storage.loginDays);
-        //安装来源type
-        this.userSet(InternalProperty.INSTALL_SCENE, publisher.publisher.installOptions.channelScene);
-        //安装来源source
-        this.userSet(InternalProperty.INSTALL_CHANNEL, publisher.publisher.installOptions.channelSource);
-        //启动来源场景
-        this.userSet(InternalProperty.LAUNCH_SCENE, publisher.publisher.enterOptions.channelScene);
-        //启动来源渠道
-        this.userSet(InternalProperty.LAUNCH_CHANNEL, publisher.publisher.enterOptions.channelSource);
-        this._hasSetDefaultProperty = true;
+    static angleToRadian(angle) {
+        return angle * Math.PI / 180;
     }
     /**
-     * 设置事件公共属性
-     * @param key 公共属性key
-     * @param value
+     * 求旋转后的点坐标
+     * @param angle         角度
+     * @param point         旋转前的坐标点
+     * @param result
      */
-    setProperty(key, value) {
-        if (!this._staticProperties) {
-            this._staticProperties = {};
-        }
-        if (typeof value === "boolean") {
-            value = value ? 1 : 0;
+    static getRotationPoint(angle, pointOrDir, result) {
+        if (result == null) {
+            result = { x: 0, y: 0 };
         }
-        if (this._debugMode && Object.prototype.hasOwnProperty.call(this._staticProperties, key)) {
-            console.warn(`静态公共属性中已经存在${key}:${this._staticProperties[key]}, 将替换为${value}`);
+        //角度转弧度
+        angle = angle * (Math.PI / 180);
+        result.x = Math.cos(angle) * pointOrDir.x - Math.sin(angle) * pointOrDir.y;
+        result.y = Math.cos(angle) * pointOrDir.y + Math.sin(angle) * pointOrDir.x;
+        return result;
+    }
+}
+/**
+ * 随机种子
+ */
+MathUtils.seed = 10;
+/**
+ * 唯一记录
+ */
+MathUtils.onlyMap = new Map();
+
+class StringUtils {
+    static random(length, chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+        var result = '';
+        for (var i = length; i > 0; --i) {
+            result += chars[Math.floor(Math.random() * chars.length)];
         }
-        this._staticProperties[key] = value;
+        return result;
     }
     /**
-     * 删除事件的公共属性
-     * @param key
+     * 判断是否是远程资源
+     * @param url
      * @returns
      */
-    unsetProperty(key) {
-        if (this._staticProperties) {
-            return delete this._staticProperties[key];
+    static isRemote(url) {
+        if (url.indexOf("http://") == 0 || url.indexOf("https://") == 0) {
+            return true;
         }
         return false;
     }
     /**
-     * 设置事件公共动态属性,上报事件时会触发回调函数，并把返回的AnalyticsData加入到事件属性中
-     * @param dynamicCall 动态属性的生成函数，事件上报时实时调用
+     * 是否为空
+     * @param str
      */
-    setDynamicProperties(dynamicCall) {
-        this._dynamicCalls.push(dynamicCall);
-    }
-    /**
-     * 对于一般的用户属性，您可以调用 userSet 来进行设置。
-     * 使用该接口上传的属性将会覆盖原有的属性值，如果之前不存在该用户属性，则会新建该用户属性，类型与传入属性的类型一致。
-     * 用户名为例：
-     * ```
-     * // username为TA
-     * userSet("username", "TA");
-     * //username为TE
-     * userSet("username", "TE");
-     * ```
-     * @param key 属性key
-     * @param value
+    static isEmpty(str) {
+        if (str == null || str == undefined || str.length == 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+    * 替换全部字符串
+    * @param string src 源串
+    * @param string from_ch 被替换的字符
+    * @param string to_ch 替换的字符
+    *
+    * @return string 结果字符串
+    */
+    static replaceAll(src, from_ch, to_ch) {
+        let regExp = new RegExp(from_ch, "g");
+        return src.replace(regExp, to_ch);
+    }
+    /**
+     * 参数替换
+     *  @param  str
+     *  @param  rest
+     *
+     *  @example
+     *
+     *  var str:string = "here is some info '{0}' and {1}";
+     *  trace(StringUtil.substitute(str, 15.4, true));
+     *
+     *  // this will output the following string:
+     *  // "here is some info '15.4' and true"
      */
-    userSet(key, value) {
-        if (!this._userProperties) {
-            this._userProperties = {};
+    static format(str, ...rest) {
+        if (str == null)
+            return '';
+        // Replace all of the parameters in the msg string.
+        var len = rest.length;
+        var args;
+        if (len == 1 && rest[0] instanceof Array) {
+            args = rest[0];
+            len = args.length;
         }
-        if (typeof value === "boolean") {
-            value = value ? 1 : 0;
+        else {
+            args = rest;
         }
-        if (this._debugMode && Object.prototype.hasOwnProperty.call(this._userProperties, key)) {
-            console.warn(`用户属性中已经存在${key}:${this._userProperties[key]}, 将替换为${value}`);
+        for (var i = 0; i < len; i++) {
+            str = str.replace(new RegExp("\\{" + i + "\\}", "g"), args[i]);
         }
-        this._userProperties[key] = value;
+        return str;
     }
     /**
-     * 如果您要上传的用户属性只要设置一次，则可以调用 userSetOnce 来进行设置。
-     * 当该属性之前已经有值的时候，将会忽略这条信息，比如设置首次付费时间：
-     * ```
-     * //first_payment_time为2018-01-01 01:23:45.678
-     * userOnce("first_payment_time", "2018-01-01 01:23:45.678");
-     * //first_payment_time仍然为2018-01-01 01:23:45.678
-     * userOnce("first_payment_time", "2018-12-31 01:23:45.678");
-     *   ```
-     * @param key 属性key
-     * @param value
+     *
+     * 格式化数字
+     * @param amount 目标数字
+     * @param format 支持{1:"", 100:"百", 1000:"千", 10000:"万", 100000:"十万", 1000000:"百万", 10000000:"千万", 100000000:"亿", 1000000000000:"兆"}等
      * @returns
      */
-    userOnce(key, value) {
-        if (!this._userOnceProperties) {
-            this._userOnceProperties = {};
+    static formatNumber(amount, format) {
+        if (!format || amount == 0) {
+            return `${amount}`;
         }
-        if (typeof value === "boolean") {
-            value = value ? 1 : 0;
+        let formatKey = [];
+        for (const key in format) {
+            if (format.hasOwnProperty(key)) {
+                formatKey.push(Number(key));
+            }
         }
-        if (Object.prototype.hasOwnProperty.call(this._userOnceProperties, key)) {
-            this._debugMode && console.info(`用户属性中已经存在once属性${key}:${this._userOnceProperties[key]}`);
-            return;
+        if (!formatKey || formatKey.length == 0) {
+            return `${amount}`;
         }
-        let storageValue = storage.getUValue(`analytics_user_once_${key}`, "");
-        if (storageValue != null && storageValue != "") {
-            this._debugMode && console.info(`用户属性中已经存在once属性${key}:${storageValue}`);
-            this._userOnceProperties[key] = typeof value === "number" ? Number(storageValue) : storageValue;
-            return;
+        formatKey.sort((a, b) => b - a);
+        let result = [];
+        let total = amount;
+        for (let i = 0; i < formatKey.length; i++) {
+            const key = formatKey[i];
+            let count = Math.floor(Math.abs(total / key)) * (total / Math.abs(total));
+            if (count == 0) {
+                continue;
+            }
+            total = total % key;
+            result.push(`${count}${format[key]}`);
         }
-        storage.setUValue(`analytics_user_once_${key}`, value);
-        this._userOnceProperties[key] = value;
+        return result.length ? result.join("") : `${amount}`;
     }
     /**
-     *设置用户累积属性，当您要上传数值型的属性时，您可以调用 userAdd 来对该属性进行累加操作，
-     * 如果该属性还未被设置，则会赋值 0 后再进行计算。
-     * 如果传入负值，等同于减法操作。
-     * ```
-     * userAdd("total_revenue", 30); //此时total_revenue为30
-     * userAdd("total_revenue", 648); //此时total_revenue为678
-     * ```
-     * @param key 累积属性key
-     * @param value 累积的偏移值
+     * 带自动补全的秒数格式。
+     * @param second 秒数
+     * @param format 格式化文本
+     * @param pad 填充文本，默认为“0”
+     * @example
+     * formatSecond(86400, "ddd天hh小时mm分ss秒")=>"001天00小时00分00秒"
+     * formatSecond(86400, "dd天hh小时mm分ss秒")=>"01天00小时00分00秒"
+     * formatSecond(86400, "hh小时mm分ss秒")=>"24小时00分00秒"
+     * formatSecond(86400, "mm分ss秒")=>"1440分00秒"
+     * @returns
      */
-    userAdd(key, value) {
-        if (!this._userAddProperties) {
-            this._userAddProperties = {};
-        }
-        if (typeof value === "boolean") {
-            value = value ? 1 : 0;
+    static formatSecond(second, format, pad = "0") {
+        const formatArr = [
+            { unit: 86400, regExp: /D{2,}/i },
+            { unit: 3600, regExp: /H{1,2}/i },
+            { unit: 60, regExp: /m{1,2}/i },
+            { unit: 1, regExp: /s{1,2}/i },
+        ];
+        for (let i = 0; i < formatArr.length; i++) {
+            const element = formatArr[i];
+            let match = element.regExp.exec(format);
+            if (match) {
+                format = format.replace(element.regExp, Math.floor(second / element.unit).toFixed(0).padStart(match[0].length, pad));
+                second = second % element.unit;
+            }
         }
-        let total = Number(this._userAddProperties[key] || storage.getUValue(`analytics_user_add_${key}`, 0) || 0);
-        this._userAddProperties[key] = total + value;
-        storage.setUValue(`analytics_user_add_${key}`, total + value);
+        return format;
     }
     /**
-     * 移除用户属性。当您要清空用户的用户属性值时，您可以调用 userUnset 来对指定属性进行清空操作，如果该属性还未在集群中被创建，则 user_unset 不会创建该属性
-     * @param key
+     * 带自动补全的时间戳格式化
+     * @param milliseconds
+     * @param format
+     * @param pad 填充文本，默认为“0”
+     * @returns
      */
-    userUnset(key) {
-        this._userProperties && delete this._userProperties[key];
-        this._userOnceProperties && delete this._userOnceProperties[key];
-        this._userAddProperties && delete this._userAddProperties[key];
-        storage.removeUValue(`analytics_user_once_${key}`);
-        storage.removeUValue(`analytics_user_add_${key}`);
+    static formatTimestamp(milliseconds, format, pad = "0") {
+        let date = new Date(milliseconds);
+        date.getHours();
+        const formatArr = [
+            { r: /Y{4}/, to: date.getFullYear() },
+            { r: /M{1,2}/, to: date.getMonth() + 1 },
+            { r: /D{1,2}/, to: date.getDate() },
+            { r: /H{1,2}/, to: date.getHours() },
+            { r: /m{1,2}/, to: date.getMinutes() },
+            { r: /s{1,2}/, to: date.getSeconds() },
+        ];
+        for (let i = 0; i < formatArr.length; i++) {
+            const element = formatArr[i];
+            let match = element.r.exec(format);
+            if (match) {
+                format = format.replace(element.r, element.to.toString().padStart(match[0].length, "0"));
+            }
+        }
+        return format;
+    }
+}
+
+/**
+ * 对象池
+ */
+class Pool {
+    constructor(clazz, maxCount) {
+        /**池中闲置对象 */
+        this._cacheStack = new Array();
+        /**正在使用的对象 */
+        this._usingArray = new Array();
+        /**池中对象最大数 */
+        this._maxCount = 0;
+        this._class = clazz;
+        if (!this._class) {
+            throw new Error("构造函数不能为空！");
+        }
+        this._maxCount = maxCount == undefined ? Number.MAX_SAFE_INTEGER : maxCount;
     }
     /**
-     * 上报错误
-     * @param error 错误信息
-     */
-    error(error) {
-        this.report("app_error", { error: error });
+    * 在池中的对象
+    */
+    get count() {
+        return this._cacheStack.length;
     }
     /**
-     * 开始事件计时
-     * 如果您需要记录某个事件的持续时长，可以调用 timeEvent 来开始计时。
-     * 配置您想要计时的事件名称，当您上传该事件时，将会自动在您的事件属性中加入 _dt_ 这一属性来表示记录的时长，单位为秒。
-     * 需要注意的是，同一个事件名只能有一个在计时的任务。
-     * @param eventName
+     * 使用中的数量
      */
-    time(eventName, once = true, offset = 0) {
-        this._timeEvents = this._timeEvents || new Map();
-        this._debugMode && this._timeEvents.has(eventName) && console.warn(`已经存在${eventName}的计时,将被重置。`);
-        this.cancelTime(eventName);
-        this._timeEvents.set(eventName, { start: App.durationOfLaunch, once: once, offset: offset });
+    get usingCount() {
+        return this._usingArray.length;
     }
     /**
-     * 取消事件计时
-     * @param eventName
+     * 分配
      * @returns
      */
-    cancelTime(eventName) {
-        return this._timeEvents && this._timeEvents.has(eventName) && this._timeEvents.delete(eventName);
+    allocate(createData) {
+        if (this.count + this.usingCount < this._maxCount) {
+            let element = this._cacheStack.length > 0 ? this._cacheStack.pop() : (typeof createData === 'function' ? createData() : new this._class(createData));
+            this._usingArray.push(element);
+            return element;
+        }
+        throw new Error("对象池最大数量超出：" + this._maxCount);
     }
     /**
-     * 上报事件
-     * @param eventName 事件名称
-     * @param data 事件数据
+     * 回收到池中
+     * @param value
+     * @returns
      */
-    report(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._sendAble(eventName)) {
-                this._debugMode && console.log(`[Analytics] ${eventName}事件不上报`);
-                return;
-            }
-            if (!data) {
-                this._debugMode && console.warn(`[Analytics] ${eventName}无上报事件数据`);
-                data = {};
-            }
-            else {
-                data = Object.assign({}, data);
-            }
-            this._setDefaultProperty();
-            for (let i = 0; i < this._dynamicCalls.length; i++) {
-                const call = this._dynamicCalls[i];
-                this._copyToData(eventName, data, call());
-            }
-            this._copyToData(eventName, data, this._userProperties);
-            this._copyToData(eventName, data, this._userAddProperties);
-            this._copyToData(eventName, data, this._userOnceProperties);
-            this._copyToData(eventName, data, this._staticProperties);
-            if (this._timeEvents && this._timeEvents.has(eventName)) {
-                let timeInfo = this._timeEvents.get(eventName);
-                let duration = Math.floor((App.durationOfLaunch - timeInfo.start + timeInfo.offset) / 1000 * 100) / 100;
-                data[InternalProperty.DURATION] = duration;
-                timeInfo.once && this._timeEvents.delete(eventName);
-            }
-            this._debugMode && console.log("[Analytics]", eventName, JSON.stringify(data));
-            return this._sendReport(eventName, data);
-        });
+    recover(value) {
+        if (this._cacheStack.indexOf(value) > -1) {
+            throw new Error("重复回收！");
+        }
+        let index = this._usingArray.indexOf(value);
+        if (index < 0) {
+            throw new Error("对象不属于改对象池！");
+        }
+        //重置
+        value.reset();
+        this._usingArray.splice(index, 1);
+        this._cacheStack.push(value);
     }
-    _sendAble(eventName) {
-        for (let i = 0; i < this._senderList.length; i++) {
-            const sender = this._senderList[i];
-            if (sender.sendAble(eventName)) {
-                return true;
-            }
+    /**
+     * 批量回收
+     * @param list
+     */
+    recoverList(list) {
+        for (let index = 0; index < list.length; index++) {
+            const element = list[index];
+            this.recover(element);
         }
-        return false;
     }
-    _copyToData(eventName, data, target) {
-        for (const key in target) {
-            if (Object.prototype.hasOwnProperty.call(target, key)) {
-                const value = target[key];
-                if (data[key] == undefined) {
-                    data[key] = value;
-                }
-                else {
-                    console.warn(`[Analytics] 事件${eventName}存在重复属性${key}=${data[key]}`);
-                }
-            }
+    /**
+     * 将所有使用中的对象都回收到池中
+     */
+    recoverAll() {
+        for (let index = 0; index < this._usingArray.length; index++) {
+            const element = this._usingArray[index];
+            this.recover(element);
         }
     }
-    _sendReport(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Promise.all(this._senderList.map((sender) => {
-                return sender.send(eventName, data);
-            })).then();
-        });
+    destroy() {
+        this.recoverAll();
+        for (let index = 0; index < this._cacheStack.length; index++) {
+            const element = this._cacheStack[index];
+            element.destroy();
+        }
+        this._cacheStack.length = 0;
+        this._cacheStack = null;
+        this._usingArray.length = 0;
+        this._usingArray = null;
     }
 }
 
-const ALI_ANALYTICS_EVENT_CACHE = "ALI_ANALYTICS_EVENT_CACHE";
 /**
- * 内部阿里云日志事件上报器
+ * <p><code>Handler</code> 是事件处理器类。</p>
+ * <p>推荐使用 Handler.create() 方法从对象池创建，减少对象创建消耗。创建的 Handler 对象不再使用后，可以使用 Handler.recover() 将其回收到对象池，回收后不要再使用此对象，否则会导致不可预料的错误。</p>
+ * <p><b>注意：</b>由于鼠标事件也用本对象池，不正确的回收及调用，可能会影响鼠标事件的执行。</p>
  */
-class ALiAnalyticsSender extends EmptyAnalyticsSender {
+class Handler {
     /**
-     *
-     * @param project
-     * @param logstore
-     * @param host
-     * @param exclude
-     * @param cd
-     * @param count
+     * 根据指定的属性值，创建一个 <code>Handler</code> 类的实例。
+     * @param	caller 执行域。
+     * @param	method 处理函数。
+     * @param	args 函数参数。
+     * @param	once 是否只执行一次。
      */
-    constructor(config, exclude) {
-        super(exclude);
-        this._eventCache = [];
-        this._index = 0;
-        this._storageKey = ALI_ANALYTICS_EVENT_CACHE;
-        this._index = 0;
-        this._setConfig(config);
-        this._eventCache = this._loadStoredEvents();
-        this._tracker = window['SLS_Tracker'] && new window['SLS_Tracker']({
-            host: config.host || "cn-hangzhou.log.aliyuncs.com",
-            project: config.project,
-            logstore: config.logstore,
-            time: config.cd,
-            count: config.count, // 定义数据条数，默认是10条，number类型，选填
-        });
-        this._addListen();
-        this._startLoop();
-        this._doReport();
+    constructor(caller = null, method = null, args = null, once = false) {
+        /** 表示是否只执行一次。如果为true，回调后执行recover()进行回收，回收后会被再利用，默认为false 。*/
+        this.once = false;
+        /**@private */
+        this._id = 0;
+        this.setTo(caller, method, args, once);
     }
-    _setConfig(config) {
-        config.cd = config.cd || 2;
-        config.count = config.count || 5;
-        this._config = config;
+    /**
+     * 设置此对象的指定属性值。
+     * @param	caller 执行域(this)。
+     * @param	method 回调方法。
+     * @param	args 携带的参数。
+     * @param	once 是否只执行一次，如果为true，执行后执行recover()进行回收。
+     * @return  返回 handler 本身。
+     */
+    setTo(caller, method, args, once = false) {
+        this._id = Handler._gid++;
+        this.caller = caller;
+        this.method = method;
+        this.args = args;
+        this.once = once;
+        return this;
     }
-    _loadStoredEvents() {
-        const storedValue = storage.getGValue(this._storageKey, []);
-        const events = Array.isArray(storedValue) ? storedValue : [];
-        if (events.length > 0) {
-            storage.removeGValue(this._storageKey);
-        }
-        return events;
+    /**
+     * 执行处理器。
+     */
+    run() {
+        if (this.method == null)
+            return null;
+        var id = this._id;
+        var result = this.method.apply(this.caller, this.args);
+        this._id === id && this.once && this.recover();
+        return result;
     }
-    _storeEvents(events) {
-        if (!events.length) {
-            storage.removeGValue(this._storageKey);
-            return;
-        }
-        storage.setGValue(this._storageKey, events);
+    /**
+     * 执行处理器，并携带额外数据。
+     * @param	data 附加的回调数据，可以是单数据或者Array(作为多参)。
+     */
+    runWith(data) {
+        if (this.method == null)
+            return null;
+        var id = this._id;
+        if (data == null)
+            var result = this.method.apply(this.caller, this.args);
+        else if (!this.args && !data.unshift)
+            result = this.method.call(this.caller, data);
+        else if (this.args)
+            result = this.method.apply(this.caller, this.args.concat(data));
+        else
+            result = this.method.apply(this.caller, data);
+        this._id === id && this.once && this.recover();
+        return result;
     }
-    _startLoop() {
-        timer.loop((this._config.cd || 2) * 1000, this, this._doReport, [this._config.count]);
+    /**
+     * 清理对象引用。
+     */
+    clear() {
+        this.caller = null;
+        this.method = null;
+        this.args = null;
+        return this;
     }
-    _addListen() {
-        App.onHide(() => {
-            this._doReport(this._eventCache.length, true);
-        });
-        App.onShow(this._restoreEvents, this);
+    reset() {
+        this.clear();
     }
-    _restoreEvents() {
-        const eventsInLocalStore = this._loadStoredEvents();
-        if (eventsInLocalStore.length > 0) {
-            this._eventCache.unshift(...eventsInLocalStore);
-            console.log(`[ALiAnalyticsSender] 恢复本地events(length:${eventsInLocalStore.length}, total:${this._eventCache.length})`);
-        }
+    destroy() {
+        this.clear();
     }
-    _doReport(maxCount = 5, store = false) {
-        if (this._eventCache.length <= 0) {
-            return false;
-        }
-        if (!this._tracker) {
-            return false;
-        }
-        const events = this._eventCache.splice(0, Math.min(this._eventCache.length, maxCount));
-        try {
-            this._tracker.sendBatchLogsImmediate(events);
-            return true;
-        }
-        catch (e) {
-            if (!store) {
-                this._eventCache.unshift(...events);
-                console.log(`[ALiAnalyticsSender] 事件发送失败,恢复事件到队列,等待下次发送。`);
-            }
-            else {
-                this._storeEvents([...events, ...this._eventCache]);
-                this._eventCache.length = 0;
-                console.log(`[ALiAnalyticsSender] 事件发送失败,存储到缓存，等待下次切回游戏。`);
-            }
-            return false;
+    /**
+     * 清理并回收到 Handler 对象池内。
+     */
+    recover() {
+        if (this._id > 0) {
+            this._id = 0;
+            Handler._pool.recover(this);
         }
     }
-    send(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            data['_event'] = eventName;
-            let msg_data = {
-                appid: publisher.appId,
-                openid: storage.userId || publisher.login.openID || "",
-                deviceid: App.deviceId,
-                sessionid: App.sessionId,
-                level: ++this._index,
-                data: JSON.stringify(data),
-                event: eventName,
-                timestamp: this._config.timestampCall() || Date.now()
-            };
-            this._eventCache.push(msg_data);
-        });
+    equal(value) {
+        return value === this;
     }
-}
-
-var DimensionType;
-(function (DimensionType) {
-    DimensionType[DimensionType["ACTIVITY"] = 0] = "ACTIVITY";
-    DimensionType[DimensionType["AD"] = 1] = "AD";
-    DimensionType[DimensionType["PAYMENT"] = 2] = "PAYMENT";
-    DimensionType[DimensionType["SOCIAL"] = 3] = "SOCIAL";
-    DimensionType[DimensionType["PLAYER_ABILITY"] = 4] = "PLAYER_ABILITY";
-    DimensionType[DimensionType["LEVEL_STATS"] = 5] = "LEVEL_STATS";
-})(DimensionType || (DimensionType = {}));
-
-class BaseDimension {
-    constructor(name) {
-        this._data = {};
-        this._initialized = false;
-        this._dirty = false;
-        this._name = name;
+    /**
+     * 从对象池内创建一个Handler，默认会执行一次并立即回收，如果不需要自动回收，设置once参数为false。
+     * @param	caller 执行域(this)。
+     * @param	method 回调方法。
+     * @param	args 携带的参数。
+     * @param	once 是否只执行一次，如果为true，回调后执行recover()进行回收，默认为true。
+     * @return  返回创建的handler实例。
+     */
+    static create(caller, method, args = null, once = true) {
+        return Handler._pool.allocate().setTo(caller, method, args, once);
     }
-    get name() {
-        return this._name;
+}
+/**@private handler对象池*/
+Handler._pool = new Pool(Handler);
+/**@private */
+Handler._gid = 1;
+
+var InternalProperty;
+(function (InternalProperty) {
+    /**设备系统版本 */
+    InternalProperty["DEVICE_SYSTEM"] = "device_system";
+    /**设备操作系统类型 */
+    InternalProperty["DEVICE_PLATFORM"] = "device_platform";
+    /**设备手机品牌 */
+    InternalProperty["DEVICE_BRAND"] = "device_brand";
+    /**设备手机型号 */
+    InternalProperty["DEVICE_MODEL"] = "device_model";
+    /**宿主名称 */
+    InternalProperty["HOST_NAME"] = "host_name";
+    /**宿主版本 */
+    InternalProperty["HOST_VERSION"] = "host_version";
+    /**启动时间 */
+    InternalProperty["LAUNCH_TIME"] = "launch_time";
+    /**启动次数 */
+    InternalProperty["LAUNCH_TIMES"] = "launch_times";
+    /**安装时间 */
+    InternalProperty["INSTALL_TIME"] = "install_time";
+    /**app运载（安装）时长 */
+    InternalProperty["DURATION_OF_INSTALL"] = "duration_of_install";
+    /**app运行(启动）时长 */
+    InternalProperty["DURATION_OF_LAUNCH"] = "duration_of_launch";
+    /**累积登录天数 */
+    InternalProperty["LOGIN_DAYS"] = "login_days";
+    /**安装来源type */
+    InternalProperty["INSTALL_SCENE"] = "install_scene";
+    /**安装来源source */
+    InternalProperty["INSTALL_CHANNEL"] = "install_channel";
+    /**启动来源场景 */
+    InternalProperty["LAUNCH_SCENE"] = "launch_scene";
+    /**启动来源渠道 */
+    InternalProperty["LAUNCH_CHANNEL"] = "launch_channel";
+    /**事件计时时长 */
+    InternalProperty["DURATION"] = "duration";
+    /**游戏版本 */
+    InternalProperty["APP_VERSION"] = "app_version";
+})(InternalProperty || (InternalProperty = {}));
+class EmptyAnalyticsSender {
+    /**
+     * @param [exclude] 其他排除的上报日志, 默认不排除
+     */
+    constructor(exclude) {
+        this._exclude = exclude || [];
     }
-    _ensureInit() {
-        if (!this._initialized) {
-            this._loadFromStorage();
-            this._initialized = true;
-        }
+    /**
+     * 设置排除
+     * @param excludeList 排除事件名称或者名称列表。
+     */
+    exclude(...excludeList) {
+        this._exclude = excludeList.concat();
     }
-    _loadFromStorage() {
-        const key = `dim_${this._name}`;
-        const data = storage.getUValue(key, "");
-        if (data) {
-            try {
-                this._data = this._decompress(data);
-            }
-            catch (e) {
-                console.error(`加载维度${this._name}失败:`, e);
-                this._data = {};
-            }
+    sendAble(eventName) {
+        if (this._exclude && this._exclude.indexOf(eventName) != -1) {
+            return false;
         }
+        return true;
     }
-    _saveToStorage() {
+    send(eventName, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._dirty)
-                return;
-            const key = `dim_${this._name}`;
-            const compressed = this._compress(this._data);
-            storage.setUValue(key, compressed);
-            this._dirty = false;
-        });
-    }
-    _updateValue(key, value) {
-        this._ensureInit();
-        this._data[key] = value;
-        this._dirty = true;
-        this._saveToStorage();
-    }
-    _incrementValue(key, delta = 1) {
-        this._ensureInit();
-        this._data[key] = (this._data[key] || 0) + delta;
-        this._dirty = true;
-        this._saveToStorage();
-    }
-    _getValue(key, defaultValue = 0) {
-        var _a;
-        this._ensureInit();
-        return (_a = this._data[key]) !== null && _a !== void 0 ? _a : defaultValue;
-    }
-    getData() {
-        this._ensureInit();
-        return Object.assign({}, this._data);
-    }
-    _compress(data) {
-        return Object.entries(data)
-            .map(([k, v]) => `${k}:${v}`)
-            .join(',');
-    }
-    _decompress(str) {
-        const data = {};
-        if (!str)
-            return data;
-        str.split(',').forEach(pair => {
-            const [k, v] = pair.split(':');
-            if (k && v !== undefined) {
-                data[k] = Number(v);
-            }
         });
-        return data;
-    }
-    clear() {
-        this._data = {};
-        this._dirty = true;
-        this._saveToStorage();
     }
 }
-
-var AdDataKey;
-(function (AdDataKey) {
-    // 累计展示次数
-    AdDataKey["SHOW_COUNT"] = "sc";
-    // 展示天数
-    AdDataKey["SHOW_DAYS"] = "sd";
-    // 累计完成次数
-    AdDataKey["COMPLETE_COUNT"] = "cpc";
-    // 最后展示天数
-    AdDataKey["LAST_SHOW_DAY"] = "lsd";
-    // 今日展示次数
-    AdDataKey["TODAY_SHOW_COUNT"] = "tsc";
-    // 首次展示时间（相对安装时间，秒）
-    AdDataKey["FIRST_SHOW_TIME"] = "fst";
-    // 上次展示时间（相对安装时间，秒）
-    AdDataKey["LAST_SHOW_TIME"] = "lst";
-    // 平均展示间隔（秒）
-    AdDataKey["AVG_SHOW_INTERVAL"] = "asi";
-    // 今日平均展示间隔（秒）
-    AdDataKey["TODAY_AVG_SHOW_INTERVAL"] = "tasi";
-})(AdDataKey || (AdDataKey = {}));
-const AD_METRIC_ORDER_V1 = [
-    'AD.show_count',
-    'AD.show_days',
-    'AD.complete_count',
-    'AD.last_show_day',
-    'AD.today_show_count',
-    'AD.first_show_time',
-    'AD.last_show_time',
-    'AD.avg_show_interval',
-    'AD.today_avg_show_interval',
-    'AD.avg_show_per_day',
-    'AD.avg_complete_per_day',
-];
 /**
- * 广告维度,记录广告展示次数、完成次数、展示天数、展示间隔等信息
+ * 统计分析能力
  */
-class AdDimension extends BaseDimension {
+class AnalyticsAble {
     constructor() {
-        super(DimensionType[DimensionType.AD]);
-        this._todayPrevShowTime = 0; // 内存中记录今日上次展示时间（相对启动），用于计算今日间隔
-        this._checkAndResetDailyData();
+        this._inited = false;
+        this._hasSetDefaultProperty = false;
+        this._debugMode = false;
+        this._senderList = [];
+        this._dynamicCalls = [];
+        this._userId = null;
+        this._hasSetUserId = false;
     }
+    get inited() { return this._inited; }
     /**
-     * 检测并重置今日数据（仅在新的一天的新启动时）
+     * 初始化
      */
-    _checkAndResetDailyData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._ensureInit();
-            const today = App.daysInstall;
-            const lastDay = this._getValue(AdDataKey.LAST_SHOW_DAY, -1);
-            // 只有在新的一天才重置今日数据
-            if (lastDay !== -1 && lastDay !== today) {
-                this._updateValue(AdDataKey.TODAY_SHOW_COUNT, 0);
-                this._updateValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
-                this._todayPrevShowTime = 0;
-            }
-        });
+    init(senders, debugMode = false) {
+        if (this._inited)
+            return this;
+        this._debugMode = debugMode;
+        App.onShow(this._onAppShow, this);
+        App.onHide(this._onAppHide, this);
+        this._initSenderList(senders);
+        this._inited = true;
+        return this;
     }
-    recordShow() {
-        const showCount = this._getValue(AdDataKey.SHOW_COUNT, 0);
-        const prevShowTime = this._getValue(AdDataKey.LAST_SHOW_TIME, 0);
-        this._incrementValue(AdDataKey.SHOW_COUNT);
-        this._incrementValue(AdDataKey.TODAY_SHOW_COUNT);
-        const today = App.daysInstall;
-        const lastDay = this._getValue(AdDataKey.LAST_SHOW_DAY, -1);
-        // 更新展示天数和最后展示天数
-        if (lastDay !== today) {
-            this._incrementValue(AdDataKey.SHOW_DAYS);
-            this._updateValue(AdDataKey.LAST_SHOW_DAY, today);
-        }
-        // 记录当前展示时间（相对安装时间）
-        const currentTime = Math.floor(App.durationOfInstall / 1000);
-        const currentLaunchTime = Math.floor(App.durationOfLaunch / 1000);
-        // 计算总体平均间隔（从第二次展示开始）
-        if (showCount > 0 && prevShowTime > 0) {
-            const interval = currentTime - prevShowTime;
-            const oldAvg = this._getValue(AdDataKey.AVG_SHOW_INTERVAL, 0);
-            // 增量平均公式: 新平均 = 旧平均 + (本次值 - 旧平均) / 新的数据个数
-            const newAvg = Math.floor(oldAvg + (interval - oldAvg) / showCount);
-            this._updateValue(AdDataKey.AVG_SHOW_INTERVAL, newAvg);
+    _initSenderList(senders) {
+        for (let i = 0; i < senders.length; i++) {
+            const sender = senders[i];
+            this._senderList.push(sender);
+            this._syncSenderUserState(sender);
         }
-        // 计算今日平均间隔（从今日第二次展示开始）
-        const todayShowCount = this._getValue(AdDataKey.TODAY_SHOW_COUNT, 0);
-        if (todayShowCount > 1 && this._todayPrevShowTime > 0) {
-            const todayInterval = currentLaunchTime - this._todayPrevShowTime;
-            const oldTodayAvg = this._getValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
-            // 今日间隔数 = 今日展示次数 - 1
-            const newTodayAvg = Math.floor(oldTodayAvg + (todayInterval - oldTodayAvg) / (todayShowCount - 1));
-            this._updateValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, newTodayAvg);
+    }
+    _usesSenderUserProperties(sender) {
+        if (sender.userPropertyMode !== "sender") {
+            return false;
         }
-        // 记录首次展示时间（仅首次）
-        if (showCount === 0) {
-            this._updateValue(AdDataKey.FIRST_SHOW_TIME, currentTime);
+        if (typeof sender.setUserProperty === "function") {
+            return true;
         }
-        // 更新时间记录
-        this._updateValue(AdDataKey.LAST_SHOW_TIME, currentTime);
-        this._todayPrevShowTime = currentLaunchTime;
+        this._debugMode && console.error("[Analytics] userPropertyMode=sender 的 Sender 必须实现 setUserProperty，已回退为 event 模式。");
+        return false;
     }
-    recordComplete() {
-        this._incrementValue(AdDataKey.COMPLETE_COUNT);
+    _getUserProperties() {
+        return Object.assign({}, this._userOnceProperties || {}, this._userAddProperties || {}, this._userProperties || {});
     }
-    /**
-     * 获取日均展示次数
-     */
-    get avgShowPerDay() {
-        const total = this._getValue(AdDataKey.SHOW_COUNT, 0);
-        const days = this._getValue(AdDataKey.SHOW_DAYS, 0);
-        return days > 0 ? Math.floor(total / days) : 0;
-    }
-    /**
-     * 获取日均完成次数
-     */
-    get avgCompletePerDay() {
-        const total = this._getValue(AdDataKey.COMPLETE_COUNT, 0);
-        const days = this._getValue(AdDataKey.SHOW_DAYS, 0);
-        return days > 0 ? Math.floor(total / days) : 0;
+    _syncSenderUserState(sender) {
+        if (this._hasSetUserId && typeof sender.setUserId === "function") {
+            sender.setUserId(this._userId);
+        }
+        if (!this._usesSenderUserProperties(sender)) {
+            return;
+        }
+        const properties = this._getUserProperties();
+        for (const key in properties) {
+            if (Object.prototype.hasOwnProperty.call(properties, key)) {
+                sender.setUserProperty(key, properties[key]);
+            }
+        }
     }
-    /**
-     * 获取平均广告展示间隔（秒）
-     * 使用增量平均算法计算相邻两次展示的平均间隔
-     */
-    get avgShowInterval() {
-        return this._getValue(AdDataKey.AVG_SHOW_INTERVAL, 0);
+    _notifyUserProperty(key, value) {
+        for (let i = 0; i < this._senderList.length; i++) {
+            const sender = this._senderList[i];
+            if (this._usesSenderUserProperties(sender)) {
+                sender.setUserProperty(key, value);
+            }
+        }
     }
     /**
-     * 获取今日平均广告展示间隔（秒）
-     * 使用增量平均算法计算今日相邻两次展示的平均间隔
+     * 设置排除
+     * @param excludeEvents 排除事件名称或者名称列表。
+     * @param senderClass [可选] 特定的SenderClass
      */
-    get todayAvgShowInterval() {
-        return this._getValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
-    }
-    getMetrics(order = [
-        AdDataKey.SHOW_COUNT,
-        AdDataKey.SHOW_DAYS,
-        AdDataKey.COMPLETE_COUNT,
-        AdDataKey.LAST_SHOW_DAY,
-        AdDataKey.TODAY_SHOW_COUNT,
-        AdDataKey.FIRST_SHOW_TIME,
-        AdDataKey.LAST_SHOW_TIME,
-        AdDataKey.AVG_SHOW_INTERVAL,
-        AdDataKey.TODAY_AVG_SHOW_INTERVAL
-    ]) {
-        this._ensureInit();
-        const result = [];
-        for (const key of order) {
-            result.push(this._getValue(key, 0));
+    setExclude(excludeEvents, senderClass) {
+        for (let i = 0; i < this._senderList.length; i++) {
+            const sender = this._senderList[i];
+            if (!senderClass || sender instanceof senderClass) {
+                if (typeof excludeEvents === "string") {
+                    sender.exclude(excludeEvents);
+                }
+                else {
+                    sender.exclude(...excludeEvents);
+                }
+            }
         }
-        result.push(this.avgShowPerDay);
-        result.push(this.avgCompletePerDay);
-        return result;
     }
-}
-
-var ADType;
-(function (ADType) {
-    ADType[ADType["BANNER"] = 0] = "BANNER";
-    ADType[ADType["INTERSTITIAL"] = 1] = "INTERSTITIAL";
-    ADType[ADType["REWARD_VIDEO"] = 2] = "REWARD_VIDEO";
-    ADType[ADType["NATIVE"] = 3] = "NATIVE";
-})(ADType || (ADType = {}));
-var ADEvent;
-(function (ADEvent) {
-    ADEvent[ADEvent["LOAD"] = 0] = "LOAD";
-    ADEvent[ADEvent["LOAD_COMPLETE"] = 1] = "LOAD_COMPLETE";
-    ADEvent[ADEvent["LOAD_FAIL"] = 2] = "LOAD_FAIL";
-    ADEvent[ADEvent["SHOW"] = 3] = "SHOW";
-    ADEvent[ADEvent["SHOW_COMPLETE"] = 4] = "SHOW_COMPLETE";
-    ADEvent[ADEvent["SHOW_FAIL"] = 5] = "SHOW_FAIL";
-    ADEvent[ADEvent["CLOSE_BY_USER"] = 6] = "CLOSE_BY_USER";
-})(ADEvent || (ADEvent = {}));
-class ADBehaviorReporter {
-    constructor(baseAble) {
-        this.baseAble = baseAble;
-        this._groupCount = {};
+    _onAppShow() {
+        this.time("app_hide");
+        this.report("app_show", publisher.publisher.enterOptions.getAllOption());
+    }
+    _onAppHide() {
+        this.report("app_hide");
     }
     /**
-     * 重置单个模块的广告计数
-     * @param group 模块名称，默认为game
+     * 设置所有上报事件的基础属性
      */
-    resetGroupCount(group = "game") {
-        this._groupCount[group] = 0;
+    _setDefaultProperty() {
+        if (this._hasSetDefaultProperty) {
+            return;
+        }
+        //设备信息
+        let deviceInfo = publisher.device.deviceInfo;
+        this.setProperty(InternalProperty.DEVICE_SYSTEM, deviceInfo.system);
+        this.setProperty(InternalProperty.DEVICE_PLATFORM, deviceInfo.platform);
+        this.setProperty(InternalProperty.DEVICE_BRAND, deviceInfo.brand);
+        this.setProperty(InternalProperty.DEVICE_MODEL, deviceInfo.model);
+        //宿主信息
+        let hostInfo = publisher.device.hostInfo;
+        this.setProperty(InternalProperty.HOST_NAME, hostInfo.name);
+        this.setProperty(InternalProperty.HOST_VERSION, hostInfo.version);
+        //安装时间
+        this.setProperty(InternalProperty.INSTALL_TIME, Math.floor(App.installTime / 1000));
+        //启动时间
+        this.setProperty(InternalProperty.LAUNCH_TIME, Math.floor(App.launchTime / 1000));
+        //启动次数
+        this.setProperty(InternalProperty.LAUNCH_TIMES, App.launchTimes);
+        //游戏版本
+        this.setProperty(InternalProperty.APP_VERSION, publisher.publisher.appVersion);
+        this.setDynamicProperties(() => {
+            let dynamicData = {};
+            //app运载（安装）时长
+            dynamicData[InternalProperty.DURATION_OF_INSTALL] = Math.floor(App.durationOfInstall / 1000);
+            //app运行(启动）时长
+            dynamicData[InternalProperty.DURATION_OF_LAUNCH] = Math.floor(App.durationOfLaunch / 1000);
+            return dynamicData;
+        });
+        //累积登录天数
+        this.userSet(InternalProperty.LOGIN_DAYS, storage.loginDays);
+        //安装来源type
+        this.userSet(InternalProperty.INSTALL_SCENE, publisher.publisher.installOptions.channelScene);
+        //安装来源source
+        this.userSet(InternalProperty.INSTALL_CHANNEL, publisher.publisher.installOptions.channelSource);
+        //启动来源场景
+        this.userSet(InternalProperty.LAUNCH_SCENE, publisher.publisher.enterOptions.channelScene);
+        //启动来源渠道
+        this.userSet(InternalProperty.LAUNCH_CHANNEL, publisher.publisher.enterOptions.channelSource);
+        this._hasSetDefaultProperty = true;
     }
     /**
-     * 开始加载广告
-     * @param type 广告类型
-     * @param from 广告来源
-     * @param msg 广告失败原因
+     * 设置事件公共属性
+     * @param key 公共属性key
+     * @param value
      */
-    onStartLoad(type, from, msg) {
-        this.report(type, ADEvent.LOAD, from, msg);
+    setProperty(key, value) {
+        if (!this._staticProperties) {
+            this._staticProperties = {};
+        }
+        if (typeof value === "boolean") {
+            value = value ? 1 : 0;
+        }
+        if (this._debugMode && Object.prototype.hasOwnProperty.call(this._staticProperties, key)) {
+            console.warn(`静态公共属性中已经存在${key}:${this._staticProperties[key]}, 将替换为${value}`);
+        }
+        this._staticProperties[key] = value;
     }
     /**
-     * 广告加载完成
-     * @param type 广告类型
-     * @param from 广告来源
+     * 删除事件的公共属性
+     * @param key
+     * @returns
      */
-    onLoadComplete(type, from) {
-        this.report(type, ADEvent.LOAD_COMPLETE, from);
+    unsetProperty(key) {
+        if (this._staticProperties) {
+            return delete this._staticProperties[key];
+        }
+        return false;
     }
     /**
-     * 广告加载失败
-     * @param type 广告类型
-     * @param from 广告来源
-     * @param msg 广告失败原因
+     * 设置事件公共动态属性,上报事件时会触发回调函数，并把返回的AnalyticsData加入到事件属性中
+     * @param dynamicCall 动态属性的生成函数，事件上报时实时调用
      */
-    onLoadFail(type, from, msg) {
-        this.report(type, ADEvent.LOAD_FAIL, from, msg);
+    setDynamicProperties(dynamicCall) {
+        this._dynamicCalls.push(dynamicCall);
     }
     /**
-     * 显示广告
-     * @param type 广告类型
-     * @param from 广告来源
+     * 设置平台用户标识。该值不会自动作为事件参数发送。
      */
-    onShow(type, from) {
-        this.report(type, ADEvent.SHOW, from);
+    setUserId(userId) {
+        this._userId = userId;
+        this._hasSetUserId = true;
+        for (let i = 0; i < this._senderList.length; i++) {
+            const sender = this._senderList[i];
+            if (typeof sender.setUserId === "function") {
+                sender.setUserId(userId);
+            }
+        }
     }
     /**
-     * 广告显示完成
-     * @param type 广告类型
-     * @param from 广告来源
+     * 对于一般的用户属性，您可以调用 userSet 来进行设置。
+     * 使用该接口上传的属性将会覆盖原有的属性值，如果之前不存在该用户属性，则会新建该用户属性，类型与传入属性的类型一致。
+     * 用户名为例：
+     * ```
+     * // username为TA
+     * userSet("username", "TA");
+     * //username为TE
+     * userSet("username", "TE");
+     * ```
+     * @param key 属性key
+     * @param value
      */
-    onShowComplete(type, from) {
-        this.report(type, ADEvent.SHOW_COMPLETE, from);
+    userSet(key, value) {
+        if (!this._userProperties) {
+            this._userProperties = {};
+        }
+        if (typeof value === "boolean") {
+            value = value ? 1 : 0;
+        }
+        if (this._debugMode && Object.prototype.hasOwnProperty.call(this._userProperties, key)) {
+            console.warn(`用户属性中已经存在${key}:${this._userProperties[key]}, 将替换为${value}`);
+        }
+        this._userProperties[key] = value;
+        this._notifyUserProperty(key, value);
     }
     /**
-     * 广告显示失败
-     * @param type 广告类型
-     * @param from 广告来源
-     * @param msg 广告失败原因
+     * 如果您要上传的用户属性只要设置一次，则可以调用 userSetOnce 来进行设置。
+     * 当该属性之前已经有值的时候，将会忽略这条信息，比如设置首次付费时间：
+     * ```
+     * //first_payment_time为2018-01-01 01:23:45.678
+     * userOnce("first_payment_time", "2018-01-01 01:23:45.678");
+     * //first_payment_time仍然为2018-01-01 01:23:45.678
+     * userOnce("first_payment_time", "2018-12-31 01:23:45.678");
+     *   ```
+     * @param key 属性key
+     * @param value
+     * @returns
      */
-    onShowFail(type, from, msg) {
-        this.report(type, ADEvent.SHOW_FAIL, from, msg);
+    userOnce(key, value) {
+        if (!this._userOnceProperties) {
+            this._userOnceProperties = {};
+        }
+        if (typeof value === "boolean") {
+            value = value ? 1 : 0;
+        }
+        if (Object.prototype.hasOwnProperty.call(this._userOnceProperties, key)) {
+            this._debugMode && console.info(`用户属性中已经存在once属性${key}:${this._userOnceProperties[key]}`);
+            return;
+        }
+        let storageValue = storage.getUValue(`analytics_user_once_${key}`, "");
+        if (storageValue != null && storageValue != "") {
+            this._debugMode && console.info(`用户属性中已经存在once属性${key}:${storageValue}`);
+            this._userOnceProperties[key] = typeof value === "number" ? Number(storageValue) : storageValue;
+            this._notifyUserProperty(key, this._userOnceProperties[key]);
+            return;
+        }
+        storage.setUValue(`analytics_user_once_${key}`, value);
+        this._userOnceProperties[key] = value;
+        this._notifyUserProperty(key, value);
     }
     /**
-     * 用户关闭广告
-     * @param type 广告类型
-     * @param from 广告来源
-     */
-    onCloseByUser(type, from) {
-        this.report(type, ADEvent.CLOSE_BY_USER, from);
-    }
-    /**
-     * 上报广告事件
-     * @param type 广告类型
-     * @param event 广告事件
-     * @param from 广告来源
-     * @param msg 广告失败原因
+     *设置用户累积属性，当您要上传数值型的属性时，您可以调用 userAdd 来对该属性进行累加操作，
+     * 如果该属性还未被设置，则会赋值 0 后再进行计算。
+     * 如果传入负值，等同于减法操作。
+     * ```
+     * userAdd("total_revenue", 30); //此时total_revenue为30
+     * userAdd("total_revenue", 648); //此时total_revenue为678
+     * ```
+     * @param key 累积属性key
+     * @param value 累积的偏移值
      */
-    report(type, event, from, msg) {
-        from = from || {};
-        const group = from.group || "game";
-        from.group && delete from.group;
-        from._adtype = type;
-        from._adevent = event;
-        if (!this._groupCount[group]) {
-            this._groupCount[group] = 0;
-        }
-        from.count = event == ADEvent.SHOW_COMPLETE ? ++this._groupCount[group] : this._groupCount[group];
-        if (msg) {
-            from.msg = msg;
+    userAdd(key, value) {
+        if (!this._userAddProperties) {
+            this._userAddProperties = {};
         }
-        this.baseAble.report("ad", from);
-    }
-}
-
-/**
- * 对象池
- */
-class Pool {
-    constructor(clazz, maxCount) {
-        /**池中闲置对象 */
-        this._cacheStack = new Array();
-        /**正在使用的对象 */
-        this._usingArray = new Array();
-        /**池中对象最大数 */
-        this._maxCount = 0;
-        this._class = clazz;
-        if (!this._class) {
-            throw new Error("构造函数不能为空！");
+        if (typeof value === "boolean") {
+            value = value ? 1 : 0;
         }
-        this._maxCount = maxCount == undefined ? Number.MAX_SAFE_INTEGER : maxCount;
+        let total = Number(this._userAddProperties[key] || storage.getUValue(`analytics_user_add_${key}`, 0) || 0);
+        this._userAddProperties[key] = total + value;
+        storage.setUValue(`analytics_user_add_${key}`, total + value);
+        this._notifyUserProperty(key, total + value);
     }
     /**
-    * 在池中的对象
-    */
-    get count() {
-        return this._cacheStack.length;
+     * 移除用户属性。当您要清空用户的用户属性值时，您可以调用 userUnset 来对指定属性进行清空操作，如果该属性还未在集群中被创建，则 user_unset 不会创建该属性
+     * @param key
+     */
+    userUnset(key) {
+        this._userProperties && delete this._userProperties[key];
+        this._userOnceProperties && delete this._userOnceProperties[key];
+        this._userAddProperties && delete this._userAddProperties[key];
+        storage.removeUValue(`analytics_user_once_${key}`);
+        storage.removeUValue(`analytics_user_add_${key}`);
+        this._notifyUserProperty(key, null);
     }
     /**
-     * 使用中的数量
+     * 上报错误
+     * @param error 错误信息
      */
-    get usingCount() {
-        return this._usingArray.length;
+    error(error) {
+        this.report("app_error", { error: error });
     }
     /**
-     * 分配
-     * @returns
+     * 开始事件计时
+     * 如果您需要记录某个事件的持续时长，可以调用 timeEvent 来开始计时。
+     * 配置您想要计时的事件名称，当您上传该事件时，将会自动在您的事件属性中加入 duration 属性来表示记录的时长，单位为秒。
+     * 需要注意的是，同一个事件名只能有一个在计时的任务。
+     * @param eventName
      */
-    allocate(createData) {
-        if (this.count + this.usingCount < this._maxCount) {
-            let element = this._cacheStack.length > 0 ? this._cacheStack.pop() : (typeof createData === 'function' ? createData() : new this._class(createData));
-            this._usingArray.push(element);
-            return element;
-        }
-        throw new Error("对象池最大数量超出：" + this._maxCount);
+    time(eventName, once = true, offset = 0) {
+        this._timeEvents = this._timeEvents || new Map();
+        this._debugMode && this._timeEvents.has(eventName) && console.warn(`已经存在${eventName}的计时,将被重置。`);
+        this.cancelTime(eventName);
+        this._timeEvents.set(eventName, { start: App.durationOfLaunch, once: once, offset: offset });
     }
     /**
-     * 回收到池中
-     * @param value
+     * 取消事件计时
+     * @param eventName
      * @returns
      */
-    recover(value) {
-        if (this._cacheStack.indexOf(value) > -1) {
-            throw new Error("重复回收！");
-        }
-        let index = this._usingArray.indexOf(value);
-        if (index < 0) {
-            throw new Error("对象不属于改对象池！");
-        }
-        //重置
-        value.reset();
-        this._usingArray.splice(index, 1);
-        this._cacheStack.push(value);
+    cancelTime(eventName) {
+        return this._timeEvents && this._timeEvents.has(eventName) && this._timeEvents.delete(eventName);
     }
     /**
-     * 批量回收
-     * @param list
+     * 上报事件
+     * @param eventName 事件名称
+     * @param data 事件数据
      */
-    recoverList(list) {
-        for (let index = 0; index < list.length; index++) {
-            const element = list[index];
-            this.recover(element);
-        }
+    report(eventName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._sendAble(eventName)) {
+                this._debugMode && console.log(`[Analytics] ${eventName}事件不上报`);
+                return;
+            }
+            if (!data) {
+                this._debugMode && console.warn(`[Analytics] ${eventName}无上报事件数据`);
+                data = {};
+            }
+            else {
+                data = Object.assign({}, data);
+            }
+            this._setDefaultProperty();
+            for (let i = 0; i < this._dynamicCalls.length; i++) {
+                const call = this._dynamicCalls[i];
+                this._copyToData(eventName, data, call());
+            }
+            this._copyToData(eventName, data, this._staticProperties);
+            if (this._timeEvents && this._timeEvents.has(eventName)) {
+                let timeInfo = this._timeEvents.get(eventName);
+                let duration = Math.floor((App.durationOfLaunch - timeInfo.start + timeInfo.offset) / 1000 * 100) / 100;
+                data[InternalProperty.DURATION] = duration;
+                timeInfo.once && this._timeEvents.delete(eventName);
+            }
+            this._debugMode && console.log("[Analytics]", eventName, JSON.stringify(data));
+            return this._sendReport(eventName, data);
+        });
     }
-    /**
-     * 将所有使用中的对象都回收到池中
-     */
-    recoverAll() {
-        for (let index = 0; index < this._usingArray.length; index++) {
-            const element = this._usingArray[index];
-            this.recover(element);
+    _sendAble(eventName) {
+        for (let i = 0; i < this._senderList.length; i++) {
+            const sender = this._senderList[i];
+            if (sender.sendAble(eventName)) {
+                return true;
+            }
         }
+        return false;
     }
-    destroy() {
-        this.recoverAll();
-        for (let index = 0; index < this._cacheStack.length; index++) {
-            const element = this._cacheStack[index];
-            element.destroy();
+    _copyToData(eventName, data, target) {
+        for (const key in target) {
+            if (Object.prototype.hasOwnProperty.call(target, key)) {
+                const value = target[key];
+                if (data[key] == undefined) {
+                    data[key] = value;
+                }
+                else {
+                    console.warn(`[Analytics] 事件${eventName}存在重复属性${key}=${data[key]}`);
+                }
+            }
         }
-        this._cacheStack.length = 0;
-        this._cacheStack = null;
-        this._usingArray.length = 0;
-        this._usingArray = null;
+    }
+    _sendReport(eventName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userProperties = this._getUserProperties();
+            return Promise.all(this._senderList
+                .filter((sender) => sender.sendAble(eventName))
+                .map((sender) => {
+                const senderData = Object.assign({}, data);
+                if (!this._usesSenderUserProperties(sender)) {
+                    this._copyToData(eventName, senderData, userProperties);
+                }
+                return sender.send(eventName, senderData);
+            })).then();
+        });
     }
 }
 
+const ALI_ANALYTICS_EVENT_CACHE = "ALI_ANALYTICS_EVENT_CACHE";
 /**
- * <p><code>Handler</code> 是事件处理器类。</p>
- * <p>推荐使用 Handler.create() 方法从对象池创建，减少对象创建消耗。创建的 Handler 对象不再使用后，可以使用 Handler.recover() 将其回收到对象池，回收后不要再使用此对象，否则会导致不可预料的错误。</p>
- * <p><b>注意：</b>由于鼠标事件也用本对象池，不正确的回收及调用，可能会影响鼠标事件的执行。</p>
+ * 内部阿里云日志事件上报器
  */
-class Handler {
+class ALiAnalyticsSender extends EmptyAnalyticsSender {
     /**
-     * 根据指定的属性值，创建一个 <code>Handler</code> 类的实例。
-     * @param	caller 执行域。
-     * @param	method 处理函数。
-     * @param	args 函数参数。
-     * @param	once 是否只执行一次。
+     *
+     * @param project
+     * @param logstore
+     * @param host
+     * @param exclude
+     * @param cd
+     * @param count
      */
-    constructor(caller = null, method = null, args = null, once = false) {
-        /** 表示是否只执行一次。如果为true，回调后执行recover()进行回收，回收后会被再利用，默认为false 。*/
-        this.once = false;
-        /**@private */
-        this._id = 0;
-        this.setTo(caller, method, args, once);
+    constructor(config, exclude) {
+        super(exclude);
+        this._eventCache = [];
+        this._index = 0;
+        this._storageKey = ALI_ANALYTICS_EVENT_CACHE;
+        this._index = 0;
+        this._setConfig(config);
+        this._eventCache = this._loadStoredEvents();
+        this._tracker = window['SLS_Tracker'] && new window['SLS_Tracker']({
+            host: config.host || "cn-hangzhou.log.aliyuncs.com",
+            project: config.project,
+            logstore: config.logstore,
+            time: config.cd,
+            count: config.count, // 定义数据条数，默认是10条，number类型，选填
+        });
+        this._addListen();
+        this._startLoop();
+        this._doReport();
     }
-    /**
-     * 设置此对象的指定属性值。
-     * @param	caller 执行域(this)。
-     * @param	method 回调方法。
-     * @param	args 携带的参数。
-     * @param	once 是否只执行一次，如果为true，执行后执行recover()进行回收。
-     * @return  返回 handler 本身。
-     */
-    setTo(caller, method, args, once = false) {
-        this._id = Handler._gid++;
-        this.caller = caller;
-        this.method = method;
-        this.args = args;
-        this.once = once;
-        return this;
+    _setConfig(config) {
+        config.cd = config.cd || 2;
+        config.count = config.count || 5;
+        this._config = config;
     }
-    /**
-     * 执行处理器。
-     */
-    run() {
-        if (this.method == null)
-            return null;
-        var id = this._id;
-        var result = this.method.apply(this.caller, this.args);
-        this._id === id && this.once && this.recover();
-        return result;
-    }
-    /**
-     * 执行处理器，并携带额外数据。
-     * @param	data 附加的回调数据，可以是单数据或者Array(作为多参)。
-     */
-    runWith(data) {
-        if (this.method == null)
-            return null;
-        var id = this._id;
-        if (data == null)
-            var result = this.method.apply(this.caller, this.args);
-        else if (!this.args && !data.unshift)
-            result = this.method.call(this.caller, data);
-        else if (this.args)
-            result = this.method.apply(this.caller, this.args.concat(data));
-        else
-            result = this.method.apply(this.caller, data);
-        this._id === id && this.once && this.recover();
-        return result;
+    _loadStoredEvents() {
+        const storedValue = storage.getGValue(this._storageKey, []);
+        const events = Array.isArray(storedValue) ? storedValue : [];
+        if (events.length > 0) {
+            storage.removeGValue(this._storageKey);
+        }
+        return events;
     }
-    /**
-     * 清理对象引用。
-     */
-    clear() {
-        this.caller = null;
-        this.method = null;
-        this.args = null;
-        return this;
+    _storeEvents(events) {
+        if (!events.length) {
+            storage.removeGValue(this._storageKey);
+            return;
+        }
+        storage.setGValue(this._storageKey, events);
     }
-    reset() {
-        this.clear();
+    _startLoop() {
+        timer.loop((this._config.cd || 2) * 1000, this, this._doReport, [this._config.count]);
     }
-    destroy() {
-        this.clear();
+    _addListen() {
+        App.onHide(() => {
+            this._doReport(this._eventCache.length, true);
+        });
+        App.onShow(this._restoreEvents, this);
     }
-    /**
-     * 清理并回收到 Handler 对象池内。
-     */
-    recover() {
-        if (this._id > 0) {
-            this._id = 0;
-            Handler._pool.recover(this);
+    _restoreEvents() {
+        const eventsInLocalStore = this._loadStoredEvents();
+        if (eventsInLocalStore.length > 0) {
+            this._eventCache.unshift(...eventsInLocalStore);
+            console.log(`[ALiAnalyticsSender] 恢复本地events(length:${eventsInLocalStore.length}, total:${this._eventCache.length})`);
         }
     }
-    equal(value) {
-        return value === this;
+    _doReport(maxCount = 5, store = false) {
+        if (this._eventCache.length <= 0) {
+            return false;
+        }
+        if (!this._tracker) {
+            return false;
+        }
+        const events = this._eventCache.splice(0, Math.min(this._eventCache.length, maxCount));
+        try {
+            this._tracker.sendBatchLogsImmediate(events);
+            return true;
+        }
+        catch (e) {
+            if (!store) {
+                this._eventCache.unshift(...events);
+                console.log(`[ALiAnalyticsSender] 事件发送失败,恢复事件到队列,等待下次发送。`);
+            }
+            else {
+                this._storeEvents([...events, ...this._eventCache]);
+                this._eventCache.length = 0;
+                console.log(`[ALiAnalyticsSender] 事件发送失败,存储到缓存，等待下次切回游戏。`);
+            }
+            return false;
+        }
     }
-    /**
-     * 从对象池内创建一个Handler，默认会执行一次并立即回收，如果不需要自动回收，设置once参数为false。
-     * @param	caller 执行域(this)。
-     * @param	method 回调方法。
-     * @param	args 携带的参数。
-     * @param	once 是否只执行一次，如果为true，回调后执行recover()进行回收，默认为true。
-     * @return  返回创建的handler实例。
-     */
-    static create(caller, method, args = null, once = true) {
-        return Handler._pool.allocate().setTo(caller, method, args, once);
+    send(eventName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = data && typeof data === "object" && !Array.isArray(data)
+                ? Object.assign({}, data) : { value: data };
+            payload['_event'] = eventName;
+            let msg_data = {
+                appid: publisher.appId,
+                openid: storage.userId || publisher.login.openID || "",
+                deviceid: App.deviceId,
+                sessionid: App.sessionId,
+                level: ++this._index,
+                data: JSON.stringify(payload),
+                event: eventName,
+                timestamp: this._config.timestampCall() || Date.now()
+            };
+            this._eventCache.push(msg_data);
+        });
     }
 }
-/**@private handler对象池*/
-Handler._pool = new Pool(Handler);
-/**@private */
-Handler._gid = 1;
 
-/**
- * <code>EventDispatcher</code> 类是可调度事件的所有类的基类。
- */
-class EventDispatcher {
-    //[IF-JS]Object.defineProperty(EventDispatcher.prototype, "_events", {enumerable: false,writable:true});
-    /**
-     * 检查 EventDispatcher 对象是否为特定事件类型注册了任何侦听器。
-     * @param	type 事件的类型。
-     * @return 如果指定类型的侦听器已注册，则值为 true；否则，值为 false。
-     */
-    hasListener(type) {
-        var listener = this._events && this._events[type];
-        return !!listener;
+var DimensionType;
+(function (DimensionType) {
+    DimensionType[DimensionType["ACTIVITY"] = 0] = "ACTIVITY";
+    DimensionType[DimensionType["AD"] = 1] = "AD";
+    DimensionType[DimensionType["PAYMENT"] = 2] = "PAYMENT";
+    DimensionType[DimensionType["SOCIAL"] = 3] = "SOCIAL";
+    DimensionType[DimensionType["PLAYER_ABILITY"] = 4] = "PLAYER_ABILITY";
+    DimensionType[DimensionType["LEVEL_STATS"] = 5] = "LEVEL_STATS";
+})(DimensionType || (DimensionType = {}));
+
+class BaseDimension {
+    constructor(name) {
+        this._data = {};
+        this._initialized = false;
+        this._dirty = false;
+        this._name = name;
     }
-    /**
-     * 派发事件。
-     * @param type	事件类型。
-     * @param data	（可选）回调数据。<b>注意：</b>如果是需要传递多个参数 p1,p2,p3,...可以使用数组结构如：[p1,p2,p3,...] ；如果需要回调单个参数 p ，且 p 是一个数组，则需要使用结构如：[p]，其他的单个参数 p ，可以直接传入参数 p。
-     * @return 此事件类型是否有侦听者，如果有侦听者则值为 true，否则值为 false。
-     */
-    event(type, data = null) {
-        if (!this._events || !this._events[type])
-            return false;
-        var listeners = this._events[type];
-        if (listeners.run) {
-            if (listeners.once)
-                delete this._events[type];
-            data != null ? listeners.runWith(data) : listeners.run();
+    get name() {
+        return this._name;
+    }
+    _ensureInit() {
+        if (!this._initialized) {
+            this._loadFromStorage();
+            this._initialized = true;
         }
-        else {
-            for (var i = 0, n = listeners.length; i < n; i++) {
-                var listener = listeners[i];
-                if (listener) {
-                    (data != null) ? listener.runWith(data) : listener.run();
-                }
-                if (!listener || listener.once) {
-                    listeners.splice(i, 1);
-                    i--;
-                    n--;
-                }
+    }
+    _loadFromStorage() {
+        const key = `dim_${this._name}`;
+        const data = storage.getUValue(key, "");
+        if (data) {
+            try {
+                this._data = this._decompress(data);
+            }
+            catch (e) {
+                console.error(`加载维度${this._name}失败:`, e);
+                this._data = {};
             }
-            if (listeners.length === 0 && this._events)
-                delete this._events[type];
         }
-        return true;
-    }
-    /**
-     * 使用 EventDispatcher 对象注册指定类型的事件侦听器对象，以使侦听器能够接收事件通知。
-     * @param type		事件的类型。
-     * @param caller	事件侦听函数的执行域。
-     * @param listener	事件侦听函数。
-     * @param args		（可选）事件侦听函数的回调参数。
-     * @return 此 EventDispatcher 对象。
-     */
-    on(type, caller, listener, args = null) {
-        return this._createListener(type, caller, listener, args, false);
     }
-    /**
-     * 使用 EventDispatcher 对象注册指定类型的事件侦听器对象，以使侦听器能够接收事件通知，此侦听事件响应一次后自动移除。
-     * @param type		事件的类型。
-     * @param caller	事件侦听函数的执行域。
-     * @param listener	事件侦听函数。
-     * @param args		（可选）事件侦听函数的回调参数。
-     * @return 此 EventDispatcher 对象。
-     */
-    once(type, caller, listener, args = null) {
-        return this._createListener(type, caller, listener, args, true);
+    _saveToStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._dirty)
+                return;
+            const key = `dim_${this._name}`;
+            const compressed = this._compress(this._data);
+            storage.setUValue(key, compressed);
+            this._dirty = false;
+        });
     }
-    /**@internal */
-    _createListener(type, caller, listener, args, once, offBefore = true) {
-        //移除之前相同的监听
-        offBefore && this.off(type, caller, listener, once);
-        //使用对象池进行创建回收
-        var handler = Handler.create(caller || this, listener, args, once);
-        this._events || (this._events = {});
-        var events = this._events;
-        //默认单个，每个对象只有多个监听才用数组，节省一个数组的消耗
-        if (!events[type])
-            events[type] = handler;
-        else {
-            if (!events[type].run)
-                events[type].push(handler);
-            else
-                events[type] = [events[type], handler];
-        }
-        return this;
+    _updateValue(key, value) {
+        this._ensureInit();
+        this._data[key] = value;
+        this._dirty = true;
+        this._saveToStorage();
     }
-    /**
-     * 从 EventDispatcher 对象中删除侦听器。
+    _incrementValue(key, delta = 1) {
+        this._ensureInit();
+        this._data[key] = (this._data[key] || 0) + delta;
+        this._dirty = true;
+        this._saveToStorage();
+    }
+    _getValue(key, defaultValue = 0) {
+        var _a;
+        this._ensureInit();
+        return (_a = this._data[key]) !== null && _a !== void 0 ? _a : defaultValue;
+    }
+    getData() {
+        this._ensureInit();
+        return Object.assign({}, this._data);
+    }
+    _compress(data) {
+        return Object.entries(data)
+            .map(([k, v]) => `${k}:${v}`)
+            .join(',');
+    }
+    _decompress(str) {
+        const data = {};
+        if (!str)
+            return data;
+        str.split(',').forEach(pair => {
+            const [k, v] = pair.split(':');
+            if (k && v !== undefined) {
+                data[k] = Number(v);
+            }
+        });
+        return data;
+    }
+    clear() {
+        this._data = {};
+        this._dirty = true;
+        this._saveToStorage();
+    }
+}
+
+var AdDataKey;
+(function (AdDataKey) {
+    // 累计展示次数
+    AdDataKey["SHOW_COUNT"] = "sc";
+    // 展示天数
+    AdDataKey["SHOW_DAYS"] = "sd";
+    // 累计完成次数
+    AdDataKey["COMPLETE_COUNT"] = "cpc";
+    // 最后展示天数
+    AdDataKey["LAST_SHOW_DAY"] = "lsd";
+    // 今日展示次数
+    AdDataKey["TODAY_SHOW_COUNT"] = "tsc";
+    // 首次展示时间（相对安装时间，秒）
+    AdDataKey["FIRST_SHOW_TIME"] = "fst";
+    // 上次展示时间（相对安装时间，秒）
+    AdDataKey["LAST_SHOW_TIME"] = "lst";
+    // 平均展示间隔（秒）
+    AdDataKey["AVG_SHOW_INTERVAL"] = "asi";
+    // 今日平均展示间隔（秒）
+    AdDataKey["TODAY_AVG_SHOW_INTERVAL"] = "tasi";
+})(AdDataKey || (AdDataKey = {}));
+const AD_METRIC_ORDER_V1 = [
+    'AD.show_count',
+    'AD.show_days',
+    'AD.complete_count',
+    'AD.last_show_day',
+    'AD.today_show_count',
+    'AD.first_show_time',
+    'AD.last_show_time',
+    'AD.avg_show_interval',
+    'AD.today_avg_show_interval',
+    'AD.avg_show_per_day',
+    'AD.avg_complete_per_day',
+];
+/**
+ * 广告维度,记录广告展示次数、完成次数、展示天数、展示间隔等信息
+ */
+class AdDimension extends BaseDimension {
+    constructor() {
+        super(DimensionType[DimensionType.AD]);
+        this._todayPrevShowTime = 0; // 内存中记录今日上次展示时间（相对启动），用于计算今日间隔
+        this._checkAndResetDailyData();
+    }
+    /**
+     * 检测并重置今日数据（仅在新的一天的新启动时）
+     */
+    _checkAndResetDailyData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._ensureInit();
+            const today = App.daysInstall;
+            const lastDay = this._getValue(AdDataKey.LAST_SHOW_DAY, -1);
+            // 只有在新的一天才重置今日数据
+            if (lastDay !== -1 && lastDay !== today) {
+                this._updateValue(AdDataKey.TODAY_SHOW_COUNT, 0);
+                this._updateValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
+                this._todayPrevShowTime = 0;
+            }
+        });
+    }
+    recordShow() {
+        const showCount = this._getValue(AdDataKey.SHOW_COUNT, 0);
+        const prevShowTime = this._getValue(AdDataKey.LAST_SHOW_TIME, 0);
+        this._incrementValue(AdDataKey.SHOW_COUNT);
+        this._incrementValue(AdDataKey.TODAY_SHOW_COUNT);
+        const today = App.daysInstall;
+        const lastDay = this._getValue(AdDataKey.LAST_SHOW_DAY, -1);
+        // 更新展示天数和最后展示天数
+        if (lastDay !== today) {
+            this._incrementValue(AdDataKey.SHOW_DAYS);
+            this._updateValue(AdDataKey.LAST_SHOW_DAY, today);
+        }
+        // 记录当前展示时间（相对安装时间）
+        const currentTime = Math.floor(App.durationOfInstall / 1000);
+        const currentLaunchTime = Math.floor(App.durationOfLaunch / 1000);
+        // 计算总体平均间隔（从第二次展示开始）
+        if (showCount > 0 && prevShowTime > 0) {
+            const interval = currentTime - prevShowTime;
+            const oldAvg = this._getValue(AdDataKey.AVG_SHOW_INTERVAL, 0);
+            // 增量平均公式: 新平均 = 旧平均 + (本次值 - 旧平均) / 新的数据个数
+            const newAvg = Math.floor(oldAvg + (interval - oldAvg) / showCount);
+            this._updateValue(AdDataKey.AVG_SHOW_INTERVAL, newAvg);
+        }
+        // 计算今日平均间隔（从今日第二次展示开始）
+        const todayShowCount = this._getValue(AdDataKey.TODAY_SHOW_COUNT, 0);
+        if (todayShowCount > 1 && this._todayPrevShowTime > 0) {
+            const todayInterval = currentLaunchTime - this._todayPrevShowTime;
+            const oldTodayAvg = this._getValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
+            // 今日间隔数 = 今日展示次数 - 1
+            const newTodayAvg = Math.floor(oldTodayAvg + (todayInterval - oldTodayAvg) / (todayShowCount - 1));
+            this._updateValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, newTodayAvg);
+        }
+        // 记录首次展示时间（仅首次）
+        if (showCount === 0) {
+            this._updateValue(AdDataKey.FIRST_SHOW_TIME, currentTime);
+        }
+        // 更新时间记录
+        this._updateValue(AdDataKey.LAST_SHOW_TIME, currentTime);
+        this._todayPrevShowTime = currentLaunchTime;
+    }
+    recordComplete() {
+        this._incrementValue(AdDataKey.COMPLETE_COUNT);
+    }
+    /**
+     * 获取日均展示次数
+     */
+    get avgShowPerDay() {
+        const total = this._getValue(AdDataKey.SHOW_COUNT, 0);
+        const days = this._getValue(AdDataKey.SHOW_DAYS, 0);
+        return days > 0 ? Math.floor(total / days) : 0;
+    }
+    /**
+     * 获取日均完成次数
+     */
+    get avgCompletePerDay() {
+        const total = this._getValue(AdDataKey.COMPLETE_COUNT, 0);
+        const days = this._getValue(AdDataKey.SHOW_DAYS, 0);
+        return days > 0 ? Math.floor(total / days) : 0;
+    }
+    /**
+     * 获取平均广告展示间隔（秒）
+     * 使用增量平均算法计算相邻两次展示的平均间隔
+     */
+    get avgShowInterval() {
+        return this._getValue(AdDataKey.AVG_SHOW_INTERVAL, 0);
+    }
+    /**
+     * 获取今日平均广告展示间隔（秒）
+     * 使用增量平均算法计算今日相邻两次展示的平均间隔
+     */
+    get todayAvgShowInterval() {
+        return this._getValue(AdDataKey.TODAY_AVG_SHOW_INTERVAL, 0);
+    }
+    getMetrics(order = [
+        AdDataKey.SHOW_COUNT,
+        AdDataKey.SHOW_DAYS,
+        AdDataKey.COMPLETE_COUNT,
+        AdDataKey.LAST_SHOW_DAY,
+        AdDataKey.TODAY_SHOW_COUNT,
+        AdDataKey.FIRST_SHOW_TIME,
+        AdDataKey.LAST_SHOW_TIME,
+        AdDataKey.AVG_SHOW_INTERVAL,
+        AdDataKey.TODAY_AVG_SHOW_INTERVAL
+    ]) {
+        this._ensureInit();
+        const result = [];
+        for (const key of order) {
+            result.push(this._getValue(key, 0));
+        }
+        result.push(this.avgShowPerDay);
+        result.push(this.avgCompletePerDay);
+        return result;
+    }
+}
+
+var ADType;
+(function (ADType) {
+    ADType[ADType["BANNER"] = 0] = "BANNER";
+    ADType[ADType["INTERSTITIAL"] = 1] = "INTERSTITIAL";
+    ADType[ADType["REWARD_VIDEO"] = 2] = "REWARD_VIDEO";
+    ADType[ADType["NATIVE"] = 3] = "NATIVE";
+})(ADType || (ADType = {}));
+var ADEvent;
+(function (ADEvent) {
+    ADEvent[ADEvent["LOAD"] = 0] = "LOAD";
+    ADEvent[ADEvent["LOAD_COMPLETE"] = 1] = "LOAD_COMPLETE";
+    ADEvent[ADEvent["LOAD_FAIL"] = 2] = "LOAD_FAIL";
+    ADEvent[ADEvent["SHOW"] = 3] = "SHOW";
+    ADEvent[ADEvent["SHOW_COMPLETE"] = 4] = "SHOW_COMPLETE";
+    ADEvent[ADEvent["SHOW_FAIL"] = 5] = "SHOW_FAIL";
+    ADEvent[ADEvent["CLOSE_BY_USER"] = 6] = "CLOSE_BY_USER";
+})(ADEvent || (ADEvent = {}));
+class ADBehaviorReporter {
+    constructor(baseAble) {
+        this.baseAble = baseAble;
+        this._groupCount = {};
+    }
+    /**
+     * 重置单个模块的广告计数
+     * @param group 模块名称，默认为game
+     */
+    resetGroupCount(group = "game") {
+        this._groupCount[group] = 0;
+    }
+    /**
+     * 开始加载广告
+     * @param type 广告类型
+     * @param from 广告来源
+     * @param msg 广告失败原因
+     */
+    onStartLoad(type, from, msg) {
+        this.report(type, ADEvent.LOAD, from, msg);
+    }
+    /**
+     * 广告加载完成
+     * @param type 广告类型
+     * @param from 广告来源
+     */
+    onLoadComplete(type, from) {
+        this.report(type, ADEvent.LOAD_COMPLETE, from);
+    }
+    /**
+     * 广告加载失败
+     * @param type 广告类型
+     * @param from 广告来源
+     * @param msg 广告失败原因
+     */
+    onLoadFail(type, from, msg) {
+        this.report(type, ADEvent.LOAD_FAIL, from, msg);
+    }
+    /**
+     * 显示广告
+     * @param type 广告类型
+     * @param from 广告来源
+     */
+    onShow(type, from) {
+        this.report(type, ADEvent.SHOW, from);
+    }
+    /**
+     * 广告显示完成
+     * @param type 广告类型
+     * @param from 广告来源
+     */
+    onShowComplete(type, from) {
+        this.report(type, ADEvent.SHOW_COMPLETE, from);
+    }
+    /**
+     * 广告显示失败
+     * @param type 广告类型
+     * @param from 广告来源
+     * @param msg 广告失败原因
+     */
+    onShowFail(type, from, msg) {
+        this.report(type, ADEvent.SHOW_FAIL, from, msg);
+    }
+    /**
+     * 用户关闭广告
+     * @param type 广告类型
+     * @param from 广告来源
+     */
+    onCloseByUser(type, from) {
+        this.report(type, ADEvent.CLOSE_BY_USER, from);
+    }
+    /**
+     * 上报广告事件
+     * @param type 广告类型
+     * @param event 广告事件
+     * @param from 广告来源
+     * @param msg 广告失败原因
+     */
+    report(type, event, from, msg) {
+        from = from || {};
+        const group = from.group || "game";
+        from.group && delete from.group;
+        from._adtype = type;
+        from._adevent = event;
+        if (!this._groupCount[group]) {
+            this._groupCount[group] = 0;
+        }
+        from.count = event == ADEvent.SHOW_COMPLETE ? ++this._groupCount[group] : this._groupCount[group];
+        if (msg) {
+            from.msg = msg;
+        }
+        this.baseAble.report("ad", from);
+    }
+}
+
+/**
+ * <code>EventDispatcher</code> 类是可调度事件的所有类的基类。
+ */
+class EventDispatcher {
+    //[IF-JS]Object.defineProperty(EventDispatcher.prototype, "_events", {enumerable: false,writable:true});
+    /**
+     * 检查 EventDispatcher 对象是否为特定事件类型注册了任何侦听器。
+     * @param	type 事件的类型。
+     * @return 如果指定类型的侦听器已注册，则值为 true；否则，值为 false。
+     */
+    hasListener(type) {
+        var listener = this._events && this._events[type];
+        return !!listener;
+    }
+    /**
+     * 派发事件。
+     * @param type	事件类型。
+     * @param data	（可选）回调数据。<b>注意：</b>如果是需要传递多个参数 p1,p2,p3,...可以使用数组结构如：[p1,p2,p3,...] ；如果需要回调单个参数 p ，且 p 是一个数组，则需要使用结构如：[p]，其他的单个参数 p ，可以直接传入参数 p。
+     * @return 此事件类型是否有侦听者，如果有侦听者则值为 true，否则值为 false。
+     */
+    event(type, data = null) {
+        if (!this._events || !this._events[type])
+            return false;
+        var listeners = this._events[type];
+        if (listeners.run) {
+            if (listeners.once)
+                delete this._events[type];
+            data != null ? listeners.runWith(data) : listeners.run();
+        }
+        else {
+            for (var i = 0, n = listeners.length; i < n; i++) {
+                var listener = listeners[i];
+                if (listener) {
+                    (data != null) ? listener.runWith(data) : listener.run();
+                }
+                if (!listener || listener.once) {
+                    listeners.splice(i, 1);
+                    i--;
+                    n--;
+                }
+            }
+            if (listeners.length === 0 && this._events)
+                delete this._events[type];
+        }
+        return true;
+    }
+    /**
+     * 使用 EventDispatcher 对象注册指定类型的事件侦听器对象，以使侦听器能够接收事件通知。
+     * @param type		事件的类型。
+     * @param caller	事件侦听函数的执行域。
+     * @param listener	事件侦听函数。
+     * @param args		（可选）事件侦听函数的回调参数。
+     * @return 此 EventDispatcher 对象。
+     */
+    on(type, caller, listener, args = null) {
+        return this._createListener(type, caller, listener, args, false);
+    }
+    /**
+     * 使用 EventDispatcher 对象注册指定类型的事件侦听器对象，以使侦听器能够接收事件通知，此侦听事件响应一次后自动移除。
+     * @param type		事件的类型。
+     * @param caller	事件侦听函数的执行域。
+     * @param listener	事件侦听函数。
+     * @param args		（可选）事件侦听函数的回调参数。
+     * @return 此 EventDispatcher 对象。
+     */
+    once(type, caller, listener, args = null) {
+        return this._createListener(type, caller, listener, args, true);
+    }
+    /**@internal */
+    _createListener(type, caller, listener, args, once, offBefore = true) {
+        //移除之前相同的监听
+        offBefore && this.off(type, caller, listener, once);
+        //使用对象池进行创建回收
+        var handler = Handler.create(caller || this, listener, args, once);
+        this._events || (this._events = {});
+        var events = this._events;
+        //默认单个，每个对象只有多个监听才用数组，节省一个数组的消耗
+        if (!events[type])
+            events[type] = handler;
+        else {
+            if (!events[type].run)
+                events[type].push(handler);
+            else
+                events[type] = [events[type], handler];
+        }
+        return this;
+    }
+    /**
+     * 从 EventDispatcher 对象中删除侦听器。
      * @param type		事件的类型。
      * @param caller	事件侦听函数的执行域。
      * @param listener	事件侦听函数。
@@ -5367,983 +5704,708 @@ class Socket extends EventDispatcher {
             this._onError(e);
         };
     }
-    /**
-     * 清理Socket：关闭Socket链接，关闭事件监听，重置Socket
-     */
-    cleanSocket() {
-        this.close();
-        this._connected = false;
-        this._socket.onopen = null;
-        this._socket.onmessage = null;
-        this._socket.onclose = null;
-        this._socket.onerror = null;
-        this._socket = null;
-    }
-    /**
-     * 关闭连接。
-     */
-    close(code, reason) {
-        if (this._socket != null) {
-            let event = null;
-            try {
-                this._socket.close(code, reason);
-            }
-            catch (e) {
-                event = e;
-            }
-            return event == null;
-        }
-    }
-    /**
-     * @private
-     * 连接建立成功 。
-     */
-    _onOpen(e) {
-        this._connected = true;
-        this.event(Event$2.OPEN, e);
-    }
-    /**
-     * @private
-     * 接收到数据处理方法。
-     * @param msg 数据。
-     */
-    _onMessage(msg) {
-        if (!msg || !msg.data)
-            return;
-        var data = msg.data;
-        if (this.disableInput && data) {
-            let byte = new ByteView(data);
-            byte.endian = this.endian;
-            this.event(Event$2.MESSAGE, byte);
-            return;
-        }
-        if (this._input.length > 0 && this._input.bytesAvailable < 1) {
-            this._input.clear();
-            this._addInputPosition = 0;
-        }
-        var pre = this._input.pos;
-        !this._addInputPosition && (this._addInputPosition = 0);
-        this._input.pos = this._addInputPosition;
-        if (data) {
-            if (typeof (data) == 'string') {
-                this._input.writeUTFBytes(data);
-            }
-            else {
-                this._input.writeArrayBuffer(data);
-            }
-            this._addInputPosition = this._input.pos;
-            this._input.pos = pre;
-        }
-        this.event(Event$2.MESSAGE, data);
-    }
-    /**
-     * @private
-     * 连接被关闭处理方法。
-     */
-    _onClose(e) {
-        this._connected = false;
-        this.event(Event$2.CLOSE, e);
-    }
-    /**
-     * @private
-     * 出现异常处理方法。
-     */
-    _onError(e) {
-        this.event(Event$2.ERROR, e);
-    }
-    /**
-     * 发送数据到服务器。
-     * @param	data 需要发送的数据，可以是String或者ArrayBuffer。
-     */
-    send(data) {
-        if (this._socket && this._socket.readyState === WebSocket.CONNECTING) {
-            this._socket.send(data);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 发送缓冲区中的数据到服务器。
-     */
-    flush() {
-        if (this._output && this._output.length > 0) {
-            var evt;
-            try {
-                this._socket && this._socket.send(this._output._getBuffer().slice(0, this._output.length));
-            }
-            catch (e) {
-                evt = e;
-            }
-            this._output.endian = this.endian;
-            this._output.clear();
-            if (evt)
-                this.event(Event$2.ERROR, evt);
-        }
-    }
-    get state() { return this._socket ? this._socket.readyState : WebSocket.CLOSED; }
-    get url() { return this._socket ? this._socket.url : ""; }
-    get binaryType() { return this._socket ? this._socket.binaryType : "arraybuffer"; }
-}
-/**
- * <p>主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。</p>
- * <p> LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。</p>
- * <p> BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。</p>
- */
-Socket.LITTLE_ENDIAN = "littleEndian";
-/**
- * <p>主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。</p>
- * <p> BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。</p>
- * <p> LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。</p>
- */
-Socket.BIG_ENDIAN = "bigEndian";
-
-var SocketLogType;
-(function (SocketLogType) {
-    SocketLogType["Connected"] = "[C==S]";
-    SocketLogType["C2S"] = "[C=>S]";
-    SocketLogType["S2C"] = "[S=>C]";
-    SocketLogType["S2xC"] = "[S=xC]";
-    SocketLogType["CxS"] = "[CxS]";
-})(SocketLogType || (SocketLogType = {}));
-/**
- * Socket节点，实现断线重连、心跳等机制
- */
-class SocketNode {
-    constructor() {
-        this._socket = null;
-        this._protocolHelper = null;
-        this._networkTips = null;
-        this._reconnectTimes = 3;
-        this._loger = null;
-        this._reconnectCD = 3 * 1000;
-        this._reconnectCount = null;
-        this._heartbeatID = 0;
-        this._heartbeatCD = 5 * 1000;
-    }
-    init(socket, protocolHelper, networkTips) {
-        if (this._socket)
-            return;
-        this._socket = socket;
-        this._protocolHelper = protocolHelper;
-        this._networkTips = networkTips;
-    }
-    _addEvent() {
-        this._socket.on(Event$2.OPEN, this, this._onConnected);
-        this._socket.on(Event$2.MESSAGE, this, this._onMessage);
-        this._socket.on(Event$2.ERROR, this, this._onError);
-        this._socket.on(Event$2.CLOSE, this, this._onClosed);
-    }
-    _removeEvent() {
-        this._socket.off(Event$2.OPEN, this, this._onConnected);
-        this._socket.off(Event$2.MESSAGE, this, this._onMessage);
-        this._socket.off(Event$2.ERROR, this, this._onError);
-        this._socket.off(Event$2.CLOSE, this, this._onClosed);
-    }
-    /**
-     * 连接服务器
-     * @param url 服务器地址 wss://localhost:80
-     * @param binaryType BinaryType "arraybuffer" | "blob"
-     * @param reconnectTimes 重连次数 -1: 一直尝试重连 0: 不重连 >0: 重连尝试次数
-     * @returns
-     */
-    connect(url, binaryType = "arraybuffer", reconnectTimes = 3) {
-        this._removeEvent();
-        this._addEvent();
-        this._networkTips.onConnecting();
-        this._reconnectTimes = reconnectTimes;
-        this._socket.connectByUrl(url, binaryType);
+    /**
+     * 清理Socket：关闭Socket链接，关闭事件监听，重置Socket
+     */
+    cleanSocket() {
+        this.close();
+        this._connected = false;
+        this._socket.onopen = null;
+        this._socket.onmessage = null;
+        this._socket.onclose = null;
+        this._socket.onerror = null;
+        this._socket = null;
     }
     /**
-     * 发送数据
-     * @returns
+     * 关闭连接。
      */
-    flush() {
-        if (this._socket.connected) {
-            this._networkTips.onFlush();
+    close(code, reason) {
+        if (this._socket != null) {
+            let event = null;
             try {
-                this._socket.flush();
-                return true;
+                this._socket.close(code, reason);
             }
             catch (e) {
-                return false;
+                event = e;
             }
-        }
-        return false;
-    }
-    log(type, data) {
-        if (this._loger) {
-            this._loger(type, typeof data === 'string' ? data : `ID:${data.id} Len:${data.len} Data:${JSON.stringify(data.data)}`);
+            return event == null;
         }
     }
     /**
-     * 关闭连接
-     * @param code
-     * @param reason
+     * @private
+     * 连接建立成功 。
      */
-    close(code, reason) {
-        this._cleanupTimeout();
-        this._removeEvent();
-        this._socket.close(code, reason);
-        this.log(SocketLogType.CxS, `${this._socket.url} By Client`);
-    }
-    _onConnected(event) {
-        this.log(SocketLogType.Connected, this._socket.url);
-        this._reconnectCount = null;
-        if (this._socket.state == WebSocket.OPEN) {
-            this._networkTips.onConnectSuccess();
-        }
-        else {
-            this._onError(event);
-        }
-    }
-    _onMessage(data) {
-        this._protocolHelper.decode(this._socket.disableInput ? data : this._socket.input);
-        this._networkTips.onMessage();
-        this._socket.input.clear();
-        this._heartbeat(); //重置心跳
-    }
-    _onError(event) {
-        this._networkTips.onConnectFailed();
-        this.log(SocketLogType.CxS, `${this._socket.url}`);
-        this._retry();
-    }
-    _onClosed(event) {
-        this._networkTips.onClosed();
-        this.log(SocketLogType.CxS, `${this._socket.url} Code:${event.code} Reason:${event.reason} WasClean:${event.wasClean}`);
-        this._retry();
-    }
-    _retry() {
-        if (this._reconnectTimes != 0) {
-            if (this._reconnectCount == null) {
-                this._reconnectCount = this._reconnectTimes == -1 ? 9999 : this._reconnectTimes + 1;
-            }
-            if (--this._reconnectCount > 0) {
-                this._reconnectHandler = setTimeout(() => {
-                    this.connect(this._socket.url, this._socket.binaryType, this._reconnectTimes);
-                }, this._reconnectCD);
-            }
-        }
-    }
-    _heartbeat() {
-        this._cleanupTimeout();
-        this._keepAliveHandler = setTimeout(() => {
-            this._protocolHelper.heartbeat();
-        }, this._heartbeatCD);
-    }
-    _cleanupTimeout() {
-        clearTimeout(this._keepAliveHandler);
-        clearTimeout(this._reconnectHandler);
-    }
-    set logable(value) {
-        this._loger = value ? console.log : null;
-    }
-    get reconnectCD() {
-        return this._reconnectCD;
-    }
-    set reconnectCD(value) {
-        this._reconnectCD = value;
-    }
-    get heartbeatCD() {
-        return this._heartbeatCD;
-    }
-    set heartbeatCD(value) {
-        this._heartbeatCD = value;
-    }
-    get output() { return this._socket.output; }
-    ;
-    get input() { return this._socket.input; }
-    ;
-}
-
-class NetManager {
-    constructor() {
-        this._logable = false;
-        this._socket = null;
-        this._http = null;
-        if (NetManager.created) {
-            throw new Error("NetManager 是单例");
-        }
-        NetManager.created = true;
-    }
-    initSocket() {
-        if (this._socket)
-            return;
-        this._protocol = Injector.getInject(NetManager.PROTOCOL_HELPER_KEY);
-        this._netTips = Injector.getInject(NetManager.NETWORK_TIPS_KEY);
-        this._socket = new SocketNode();
-        let socket = new Socket();
-        socket.disableInput = true;
-        // socket.protocols = [];
-        // socket.endian = Socket.BIG_ENDIAN;
-        this._socket.init(socket, this._protocol, this._netTips);
-        this._socket.logable = this._logable;
+    _onOpen(e) {
+        this._connected = true;
+        this.event(Event$2.OPEN, e);
     }
-    initHttp() {
-        if (this._http)
+    /**
+     * @private
+     * 接收到数据处理方法。
+     * @param msg 数据。
+     */
+    _onMessage(msg) {
+        if (!msg || !msg.data)
             return;
-        this._http = new HttpNode();
-    }
-    set logable(value) {
-        this._logable = value;
-        if (this._socket) {
-            this._socket.logable = value;
-        }
-    }
-    get socket() {
-        this.initSocket();
-        return this._socket;
-    }
-    get http() {
-        this.initHttp();
-        return this._http;
-    }
-    get server() {
-        this.initSocket();
-        return this._protocol;
-    }
-}
-NetManager.PROTOCOL_HELPER_KEY = "net.protocolHelper";
-NetManager.NETWORK_TIPS_KEY = "net.networkTips";
-NetManager.created = false;
-/**
- * 网络
- */
-const net = new NetManager();
-
-const KEYTOPS_ANALYTICS_EVENT_CACHE = "KEYTOPS_ANALYTICS_EVENT_CACHE";
-const KEYTOPS_RETRY_DELAYS = [100, 500, 2000];
-const KEYTOPS_REQUEST_TIMEOUT = 10000;
-class KeytopsAnalyticsSender extends EmptyAnalyticsSender {
-    constructor(config, exclude) {
-        super(exclude);
-        this._sending = false;
-        this._flushScheduled = false;
-        this._eventCache = [];
-        this._index = 0;
-        this._index = 0;
-        this._setConfig(config);
-        this._storageKey = this._config.cacheKey || KEYTOPS_ANALYTICS_EVENT_CACHE;
-        this._eventCache = this._loadStoredEvents();
-        this._addListen();
-        this._startLoop();
-        void this._doReport();
-    }
-    _setConfig(config) {
-        config.cd = config.cd || 1;
-        config.count = config.count || 20;
-        config.maxBufferedBytes = config.maxBufferedBytes || 512 * 1024;
-        this._config = config;
-    }
-    _loadStoredEvents() {
-        const storedValue = storage.getGValue(this._storageKey, []);
-        const events = Array.isArray(storedValue) ? storedValue : [];
-        if (events.length > 0) {
-            storage.removeGValue(this._storageKey);
-        }
-        return events;
-    }
-    _storeEvents(events) {
-        if (!events.length) {
-            storage.removeGValue(this._storageKey);
+        var data = msg.data;
+        if (this.disableInput && data) {
+            let byte = new ByteView(data);
+            byte.endian = this.endian;
+            this.event(Event$2.MESSAGE, byte);
             return;
         }
-        storage.setGValue(this._storageKey, events);
-    }
-    _estimateBytes(value) {
-        try {
-            const text = JSON.stringify(value) || "";
-            return encodeURIComponent(text).replace(/%[A-F\d]{2}/g, "U").length;
+        if (this._input.length > 0 && this._input.bytesAvailable < 1) {
+            this._input.clear();
+            this._addInputPosition = 0;
         }
-        catch (error) {
-            return 0;
+        var pre = this._input.pos;
+        !this._addInputPosition && (this._addInputPosition = 0);
+        this._input.pos = this._addInputPosition;
+        if (data) {
+            if (typeof (data) == 'string') {
+                this._input.writeUTFBytes(data);
+            }
+            else {
+                this._input.writeArrayBuffer(data);
+            }
+            this._addInputPosition = this._input.pos;
+            this._input.pos = pre;
         }
+        this.event(Event$2.MESSAGE, data);
     }
-    _currentBufferedBytes() {
-        return this._estimateBytes(this._eventCache);
-    }
-    _startLoop() {
-        timer.loop((this._config.cd || 1) * 1000, this, this._doReport, [this._config.count], true);
-    }
-    _addListen() {
-        App.onHide(() => {
-            void this._doReport(this._eventCache.length, true);
-        });
-        App.onShow(this._restoreEvents, this);
+    /**
+     * @private
+     * 连接被关闭处理方法。
+     */
+    _onClose(e) {
+        this._connected = false;
+        this.event(Event$2.CLOSE, e);
     }
-    _restoreEvents() {
-        const eventsInLocalStore = this._loadStoredEvents();
-        if (eventsInLocalStore.length > 0) {
-            this._eventCache.unshift(...eventsInLocalStore);
-            console.log(`[KeytopsAnalyticsSender] 恢复本地events(length:${eventsInLocalStore.length}, total:${this._eventCache.length})`);
-            this._scheduleFlush(0);
+    /**
+     * @private
+     * 出现异常处理方法。
+     */
+    _onError(e) {
+        this.event(Event$2.ERROR, e);
+    }
+    /**
+     * 发送数据到服务器。
+     * @param	data 需要发送的数据，可以是String或者ArrayBuffer。
+     */
+    send(data) {
+        if (this._socket && this._socket.readyState === WebSocket.CONNECTING) {
+            this._socket.send(data);
+            return true;
         }
+        return false;
     }
-    _scheduleFlush(delay = 0) {
-        if (this._flushScheduled) {
-            return;
+    /**
+     * 发送缓冲区中的数据到服务器。
+     */
+    flush() {
+        if (this._output && this._output.length > 0) {
+            var evt;
+            try {
+                this._socket && this._socket.send(this._output._getBuffer().slice(0, this._output.length));
+            }
+            catch (e) {
+                evt = e;
+            }
+            this._output.endian = this.endian;
+            this._output.clear();
+            if (evt)
+                this.event(Event$2.ERROR, evt);
         }
-        this._flushScheduled = true;
-        timer.once(delay, this, () => {
-            this._flushScheduled = false;
-            void this._doReport();
-        }, null, false);
     }
-    _buildRequestBody(payload) {
-        const body = JSON.stringify(payload);
-        return {
-            data: body,
-            headers: ["Content-Type", "application/json"],
-        };
+    get state() { return this._socket ? this._socket.readyState : WebSocket.CLOSED; }
+    get url() { return this._socket ? this._socket.url : ""; }
+    get binaryType() { return this._socket ? this._socket.binaryType : "arraybuffer"; }
+}
+/**
+ * <p>主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。</p>
+ * <p> LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。</p>
+ * <p> BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。</p>
+ */
+Socket.LITTLE_ENDIAN = "littleEndian";
+/**
+ * <p>主机字节序，是 CPU 存放数据的两种不同顺序，包括小端字节序和大端字节序。</p>
+ * <p> BIG_ENDIAN ：大端字节序，地址低位存储值的高位，地址高位存储值的低位。有时也称之为网络字节序。</p>
+ * <p> LITTLE_ENDIAN ：小端字节序，地址低位存储值的低位，地址高位存储值的高位。</p>
+ */
+Socket.BIG_ENDIAN = "bigEndian";
+
+var SocketLogType;
+(function (SocketLogType) {
+    SocketLogType["Connected"] = "[C==S]";
+    SocketLogType["C2S"] = "[C=>S]";
+    SocketLogType["S2C"] = "[S=>C]";
+    SocketLogType["S2xC"] = "[S=xC]";
+    SocketLogType["CxS"] = "[CxS]";
+})(SocketLogType || (SocketLogType = {}));
+/**
+ * Socket节点，实现断线重连、心跳等机制
+ */
+class SocketNode {
+    constructor() {
+        this._socket = null;
+        this._protocolHelper = null;
+        this._networkTips = null;
+        this._reconnectTimes = 3;
+        this._loger = null;
+        this._reconnectCD = 3 * 1000;
+        this._reconnectCount = null;
+        this._heartbeatID = 0;
+        this._heartbeatCD = 5 * 1000;
     }
-    buildRequestId() {
-        return `relay-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+    init(socket, protocolHelper, networkTips) {
+        if (this._socket)
+            return;
+        this._socket = socket;
+        this._protocolHelper = protocolHelper;
+        this._networkTips = networkTips;
     }
-    _sendBatch(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._config.url) {
-                throw new Error("Keytops analytics relay url is empty");
-            }
-            const payload = {
-                requestId: this.buildRequestId(),
-                appid: publisher.appId,
-                sentAt: this._config.timestampCall ? (this._config.timestampCall() || Date.now()) : Date.now(),
-                events,
-            };
-            const request = this._buildRequestBody(payload);
-            const response = yield net.http.sendsync(this._config.url, {
-                method: "post",
-                responseType: "json",
-                data: request.data,
-                headers: request.headers,
-                timeout: KEYTOPS_REQUEST_TIMEOUT,
-            });
-            const code = response && response.code;
-            if (!(code === 0 || code === "0" || code === 200 || code === "200")) {
-                throw new Error(response && response.message ? response.message : "relay request failed");
-            }
-        });
+    _addEvent() {
+        this._socket.on(Event$2.OPEN, this, this._onConnected);
+        this._socket.on(Event$2.MESSAGE, this, this._onMessage);
+        this._socket.on(Event$2.ERROR, this, this._onError);
+        this._socket.on(Event$2.CLOSE, this, this._onClosed);
     }
-    _sendBatchWithRetry(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let lastError = null;
-            for (let i = 0; i <= KEYTOPS_RETRY_DELAYS.length; i++) {
-                try {
-                    yield this._sendBatch(events);
-                    return;
-                }
-                catch (error) {
-                    lastError = error;
-                    if (i >= KEYTOPS_RETRY_DELAYS.length) {
-                        break;
-                    }
-                    yield new Promise((resolve) => timer.once(KEYTOPS_RETRY_DELAYS[i], this, resolve, null, false));
-                }
-            }
-            throw lastError || new Error("relay request failed");
-        });
+    _removeEvent() {
+        this._socket.off(Event$2.OPEN, this, this._onConnected);
+        this._socket.off(Event$2.MESSAGE, this, this._onMessage);
+        this._socket.off(Event$2.ERROR, this, this._onError);
+        this._socket.off(Event$2.CLOSE, this, this._onClosed);
     }
-    _doReport(maxCount = this._config.count || 20, store = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._sending || this._eventCache.length <= 0) {
-                return false;
-            }
-            this._sending = true;
-            const events = this._eventCache.splice(0, Math.min(this._eventCache.length, maxCount));
+    /**
+     * 连接服务器
+     * @param url 服务器地址 wss://localhost:80
+     * @param binaryType BinaryType "arraybuffer" | "blob"
+     * @param reconnectTimes 重连次数 -1: 一直尝试重连 0: 不重连 >0: 重连尝试次数
+     * @returns
+     */
+    connect(url, binaryType = "arraybuffer", reconnectTimes = 3) {
+        this._removeEvent();
+        this._addEvent();
+        this._networkTips.onConnecting();
+        this._reconnectTimes = reconnectTimes;
+        this._socket.connectByUrl(url, binaryType);
+    }
+    /**
+     * 发送数据
+     * @returns
+     */
+    flush() {
+        if (this._socket.connected) {
+            this._networkTips.onFlush();
             try {
-                yield this._sendBatchWithRetry(events);
+                this._socket.flush();
                 return true;
             }
             catch (e) {
-                if (!store) {
-                    this._eventCache.unshift(...events);
-                    console.log(`[KeytopsAnalyticsSender] 事件发送失败,恢复事件到队列,等待下次发送。`);
-                }
-                else {
-                    this._storeEvents([...events, ...this._eventCache]);
-                    this._eventCache.length = 0;
-                    console.log(`[KeytopsAnalyticsSender] 事件发送失败,存储到缓存，等待下次切回游戏。`);
-                }
                 return false;
             }
-            finally {
-                this._sending = false;
-                if (!store && this._eventCache.length > 0) {
-                    const countLimit = this._config.count || 20;
-                    const byteLimit = this._config.maxBufferedBytes || 512 * 1024;
-                    if (this._eventCache.length >= countLimit || this._currentBufferedBytes() >= byteLimit) {
-                        this._scheduleFlush(0);
-                    }
-                }
-            }
-        });
+        }
+        return false;
     }
-    send(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const payload = data && typeof data === "object" && !Array.isArray(data)
-                ? Object.assign({}, data) : { value: data };
-            let msg_data = {
-                appid: publisher.appId,
-                openid: String(storage.userId || publisher.login.openID || ""),
-                deviceid: App.deviceId,
-                sessionid: App.sessionId,
-                level: ++this._index,
-                data: payload,
-                event: eventName,
-                timestamp: this._config.timestampCall() || Date.now()
-            };
-            this._eventCache.push(msg_data);
-            const countLimit = this._config.count || 20;
-            const byteLimit = this._config.maxBufferedBytes || 512 * 1024;
-            if (this._eventCache.length >= countLimit || this._currentBufferedBytes() >= byteLimit) {
-                this._scheduleFlush(0);
+    log(type, data) {
+        if (this._loger) {
+            this._loger(type, typeof data === 'string' ? data : `ID:${data.id} Len:${data.len} Data:${JSON.stringify(data.data)}`);
+        }
+    }
+    /**
+     * 关闭连接
+     * @param code
+     * @param reason
+     */
+    close(code, reason) {
+        this._cleanupTimeout();
+        this._removeEvent();
+        this._socket.close(code, reason);
+        this.log(SocketLogType.CxS, `${this._socket.url} By Client`);
+    }
+    _onConnected(event) {
+        this.log(SocketLogType.Connected, this._socket.url);
+        this._reconnectCount = null;
+        if (this._socket.state == WebSocket.OPEN) {
+            this._networkTips.onConnectSuccess();
+        }
+        else {
+            this._onError(event);
+        }
+    }
+    _onMessage(data) {
+        this._protocolHelper.decode(this._socket.disableInput ? data : this._socket.input);
+        this._networkTips.onMessage();
+        this._socket.input.clear();
+        this._heartbeat(); //重置心跳
+    }
+    _onError(event) {
+        this._networkTips.onConnectFailed();
+        this.log(SocketLogType.CxS, `${this._socket.url}`);
+        this._retry();
+    }
+    _onClosed(event) {
+        this._networkTips.onClosed();
+        this.log(SocketLogType.CxS, `${this._socket.url} Code:${event.code} Reason:${event.reason} WasClean:${event.wasClean}`);
+        this._retry();
+    }
+    _retry() {
+        if (this._reconnectTimes != 0) {
+            if (this._reconnectCount == null) {
+                this._reconnectCount = this._reconnectTimes == -1 ? 9999 : this._reconnectTimes + 1;
             }
-        });
+            if (--this._reconnectCount > 0) {
+                this._reconnectHandler = setTimeout(() => {
+                    this.connect(this._socket.url, this._socket.binaryType, this._reconnectTimes);
+                }, this._reconnectCD);
+            }
+        }
+    }
+    _heartbeat() {
+        this._cleanupTimeout();
+        this._keepAliveHandler = setTimeout(() => {
+            this._protocolHelper.heartbeat();
+        }, this._heartbeatCD);
+    }
+    _cleanupTimeout() {
+        clearTimeout(this._keepAliveHandler);
+        clearTimeout(this._reconnectHandler);
+    }
+    set logable(value) {
+        this._loger = value ? console.log : null;
+    }
+    get reconnectCD() {
+        return this._reconnectCD;
+    }
+    set reconnectCD(value) {
+        this._reconnectCD = value;
+    }
+    get heartbeatCD() {
+        return this._heartbeatCD;
+    }
+    set heartbeatCD(value) {
+        this._heartbeatCD = value;
     }
+    get output() { return this._socket.output; }
+    ;
+    get input() { return this._socket.input; }
+    ;
 }
 
-class AnalyticsManager {
+class NetManager {
     constructor() {
-        this._base = null;
-        this._level = null;
-        this._ad = null;
-        this._session = null;
-        this._launch = null;
-        this._social = null;
-        this._assignmentSender = null;
+        this._logable = false;
+        this._socket = null;
+        this._http = null;
+        if (NetManager.created) {
+            throw new Error("NetManager 是单例");
+        }
+        NetManager.created = true;
     }
-    hasRelayUrl(config) {
-        return !!String(config && config.url || "").trim();
+    initSocket() {
+        if (this._socket)
+            return;
+        this._protocol = Injector.getInject(NetManager.PROTOCOL_HELPER_KEY);
+        this._netTips = Injector.getInject(NetManager.NETWORK_TIPS_KEY);
+        this._socket = new SocketNode();
+        let socket = new Socket();
+        socket.disableInput = true;
+        // socket.protocols = [];
+        // socket.endian = Socket.BIG_ENDIAN;
+        this._socket.init(socket, this._protocol, this._netTips);
+        this._socket.logable = this._logable;
     }
-    hasAliDirectConfig(config) {
-        return !!String(config && config.project || "").trim() && !!String(config && config.logstore || "").trim();
+    initHttp() {
+        if (this._http)
+            return;
+        this._http = new HttpNode();
     }
-    createBehaviorSenders() {
-        const analyticsConfig = remoteConfigService.config(SystemOnlineConfig).getAnalyticsConfig();
-        if (this.hasRelayUrl(analyticsConfig)) {
-            return [new KeytopsAnalyticsSender(analyticsConfig)];
-        }
-        if (this.hasAliDirectConfig(analyticsConfig)) {
-            return [new ALiAnalyticsSender(analyticsConfig)];
+    set logable(value) {
+        this._logable = value;
+        if (this._socket) {
+            this._socket.logable = value;
         }
-        return [];
     }
-    /**
-     * 基础统计能力
-     */
-    get base() {
-        if (!this._base) {
-            this._base = new AnalyticsAble();
-        }
-        return this._base;
+    get socket() {
+        this.initSocket();
+        return this._socket;
     }
-    /**
-     * 关卡统计能力，用于关卡分析
-     */
-    get level() {
-        if (!this.base.inited) {
-            throw new Error("请先通过enable初始化基础统计能力");
-        }
-        if (!this._level) {
-            this._level = new LevelAnalyticsAble(this.base);
-        }
-        return this._level;
+    get http() {
+        this.initHttp();
+        return this._http;
     }
-    /**
-     * 广告统计能力，用于广告分析
-     */
-    get ad() {
-        if (!this.base.inited) {
-            throw new Error("请先通过enable初始化基础统计能力");
-        }
-        if (!this._ad) {
-            this._ad = new ADAnalyticsAble(this.base);
-        }
-        return this._ad;
+    get server() {
+        this.initSocket();
+        return this._protocol;
     }
-    /**
-     * 会话统计能力，用于会话分析
-     */
-    get session() {
-        if (!this.base.inited) {
-            throw new Error("请先通过enable初始化基础统计能力");
-        }
-        if (!this._session) {
-            this._session = new SessionAnalyticsAble(this.base);
-        }
-        return this._session;
+}
+NetManager.PROTOCOL_HELPER_KEY = "net.protocolHelper";
+NetManager.NETWORK_TIPS_KEY = "net.networkTips";
+NetManager.created = false;
+/**
+ * 网络
+ */
+const net = new NetManager();
+
+const KEYTOPS_ANALYTICS_EVENT_CACHE = "KEYTOPS_ANALYTICS_EVENT_CACHE";
+const KEYTOPS_RETRY_DELAYS = [100, 500, 2000];
+const KEYTOPS_REQUEST_TIMEOUT = 10000;
+class KeytopsAnalyticsSender extends EmptyAnalyticsSender {
+    constructor(config, exclude) {
+        super(exclude);
+        this._sending = false;
+        this._flushScheduled = false;
+        this._eventCache = [];
+        this._index = 0;
+        this._index = 0;
+        this._setConfig(config);
+        this._storageKey = this._config.cacheKey || KEYTOPS_ANALYTICS_EVENT_CACHE;
+        this._eventCache = this._loadStoredEvents();
+        this._addListen();
+        this._startLoop();
+        void this._doReport();
     }
-    /**
-     * 启动统计能力,用于启动性能分析
-     */
-    get launch() {
-        if (!this.base.inited) {
-            throw new Error("请先通过enable初始化基础统计能力");
+    _setConfig(config) {
+        config.cd = config.cd || 1;
+        config.count = config.count || 20;
+        config.maxBufferedBytes = config.maxBufferedBytes || 512 * 1024;
+        this._config = config;
+    }
+    _loadStoredEvents() {
+        const storedValue = storage.getGValue(this._storageKey, []);
+        const events = Array.isArray(storedValue) ? storedValue : [];
+        if (events.length > 0) {
+            storage.removeGValue(this._storageKey);
         }
-        if (!this._launch) {
-            this._launch = new LaunchAnalyticsAble(this.base);
+        return events;
+    }
+    _storeEvents(events) {
+        if (!events.length) {
+            storage.removeGValue(this._storageKey);
+            return;
         }
-        return this._launch;
+        storage.setGValue(this._storageKey, events);
     }
-    /**
-     * 社交统计能力
-     */
-    get social() {
-        if (!this.base.inited) {
-            throw new Error("请先通过enable初始化基础统计能力");
+    _estimateBytes(value) {
+        try {
+            const text = JSON.stringify(value) || "";
+            return encodeURIComponent(text).replace(/%[A-F\d]{2}/g, "U").length;
         }
-        if (!this._social) {
-            this._social = new SocialAnalyticsAble(this.base);
+        catch (error) {
+            return 0;
         }
-        return this._social;
     }
-    /**
-     * 启用统计（基础统计能力）
-     * @param debugMode 调试模式，是否打印日志信息，默认为false
-     * @param senders 上报器列表，允许多个 默认为ALiAnalyticsSender
-     * @returns
-     */
-    enable(debugMode = false, senders) {
-        if (this.base.inited) {
-            return;
-        }
-        senders = senders || this.createBehaviorSenders();
-        this.base.init(senders, debugMode);
-        this.launch.report("enabled");
+    _currentBufferedBytes() {
+        return this._estimateBytes(this._eventCache);
     }
-    get version() {
-        return "v1";
+    _startLoop() {
+        timer.loop((this._config.cd || 1) * 1000, this, this._doReport, [this._config.count], true);
     }
-    /**
-     * 获取所有维度的数据
-     * @returns 所有维度的数据
-     */
-    getMetrics() {
-        const result = {};
-        result[DimensionType[DimensionType.ACTIVITY]] = this.session.getMetrics();
-        result[DimensionType[DimensionType.AD]] = this.ad.getMetrics();
-        result[DimensionType[DimensionType.SOCIAL]] = this.social.getMetrics();
-        return result;
+    _addListen() {
+        App.onHide(() => {
+            void this._doReport(this._eventCache.length, true);
+        });
+        App.onShow(this._restoreEvents, this);
     }
-    get assignmentSender() {
-        if (!this._assignmentSender) {
-            const analyticsConfig = remoteConfigService.config(SystemOnlineConfig).getAssignmentConfig();
-            this._assignmentSender = this.hasRelayUrl(analyticsConfig)
-                ? new KeytopsAnalyticsSender(analyticsConfig, analyticsConfig.exclude || ["view"])
-                : new EmptyAnalyticsSender();
+    _restoreEvents() {
+        const eventsInLocalStore = this._loadStoredEvents();
+        if (eventsInLocalStore.length > 0) {
+            this._eventCache.unshift(...eventsInLocalStore);
+            console.log(`[KeytopsAnalyticsSender] 恢复本地events(length:${eventsInLocalStore.length}, total:${this._eventCache.length})`);
+            this._scheduleFlush(0);
         }
-        return this._assignmentSender;
     }
-    reportAssignments(resolveMeta, levelid) {
-        if (!resolveMeta) {
+    _scheduleFlush(delay = 0) {
+        if (this._flushScheduled) {
             return;
         }
-        const method = resolveMeta.method;
-        if (!method) {
-            throw new Error("method is required");
-        }
-        const eventName = `${method}_assignment`;
-        (resolveMeta.matchedUnits || []).forEach((unit) => {
+        this._flushScheduled = true;
+        timer.once(delay, this, () => {
+            this._flushScheduled = false;
+            void this._doReport();
+        }, null, false);
+    }
+    _buildRequestBody(payload) {
+        const body = JSON.stringify(payload);
+        return {
+            data: body,
+            headers: ["Content-Type", "application/json"],
+        };
+    }
+    buildRequestId() {
+        return `relay-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+    }
+    _sendBatch(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._config.url) {
+                throw new Error("Keytops analytics relay url is empty");
+            }
             const payload = {
-                method: method,
-                resolve_key: resolveMeta.resolveKey,
-                config_name: unit.configName,
-                fingerprint: unit.fingerprint,
+                requestId: this.buildRequestId(),
+                appid: publisher.appId,
+                sentAt: this._config.timestampCall ? (this._config.timestampCall() || Date.now()) : Date.now(),
+                events,
             };
-            if (unit.publishId) {
-                payload.publish_id = unit.publishId;
+            const request = this._buildRequestBody(payload);
+            const response = yield net.http.sendsync(this._config.url, {
+                method: "post",
+                responseType: "json",
+                data: request.data,
+                headers: request.headers,
+                timeout: KEYTOPS_REQUEST_TIMEOUT,
+            });
+            const code = response && response.code;
+            if (!(code === 0 || code === "0" || code === 200 || code === "200")) {
+                throw new Error(response && response.message ? response.message : "relay request failed");
             }
-            if (unit.variantId) {
-                payload.variant_id = unit.variantId;
+        });
+    }
+    _sendBatchWithRetry(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError = null;
+            for (let i = 0; i <= KEYTOPS_RETRY_DELAYS.length; i++) {
+                try {
+                    yield this._sendBatch(events);
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (i >= KEYTOPS_RETRY_DELAYS.length) {
+                        break;
+                    }
+                    yield new Promise((resolve) => timer.once(KEYTOPS_RETRY_DELAYS[i], this, resolve, null, false));
+                }
             }
-            if (unit.variantFingerprint) {
-                payload.variant_fingerprint = unit.variantFingerprint;
+            throw lastError || new Error("relay request failed");
+        });
+    }
+    _doReport(maxCount = this._config.count || 20, store = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sending || this._eventCache.length <= 0) {
+                return false;
             }
-            if (levelid !== undefined) {
-                payload.level_id = levelid;
+            this._sending = true;
+            const events = this._eventCache.splice(0, Math.min(this._eventCache.length, maxCount));
+            try {
+                yield this._sendBatchWithRetry(events);
+                return true;
+            }
+            catch (e) {
+                if (!store) {
+                    this._eventCache.unshift(...events);
+                    console.log(`[KeytopsAnalyticsSender] 事件发送失败,恢复事件到队列,等待下次发送。`);
+                }
+                else {
+                    this._storeEvents([...events, ...this._eventCache]);
+                    this._eventCache.length = 0;
+                    console.log(`[KeytopsAnalyticsSender] 事件发送失败,存储到缓存，等待下次切回游戏。`);
+                }
+                return false;
+            }
+            finally {
+                this._sending = false;
+                if (!store && this._eventCache.length > 0) {
+                    const countLimit = this._config.count || 20;
+                    const byteLimit = this._config.maxBufferedBytes || 512 * 1024;
+                    if (this._eventCache.length >= countLimit || this._currentBufferedBytes() >= byteLimit) {
+                        this._scheduleFlush(0);
+                    }
+                }
             }
-            this.assignmentSender.send(eventName, payload);
         });
     }
-}
-/**
- * 埋点统计能力
- */
-const analytics = new AnalyticsManager();
-
-/**
- * 通用计时器实现。
- * 使用 setInterval 驱动 Timer 的内部更新循环。
- */
-class TimerImpl {
-    constructor() {
-        this._intervalMap = new WeakMap();
-    }
-    enable(timer) {
-        if (this._intervalMap.has(timer)) {
-            return;
-        }
-        const intervalId = setInterval(() => {
-            timer["_update"]();
-        }, 100);
-        this._intervalMap.set(timer, intervalId);
-    }
-}
-
-class MathUtils {
-    /**
-     * 随机
-     * @param min
-     * @param max
-     */
-    static random(min, max) {
-        this.seed = (this.seed * 9301 + 49297) % 233280;
-        let c = this.seed / (233280.0);
-        return min + c * (max - min);
-    }
-    /**
-     * 随机整数值
-     * @param min
-     * @param max
-     */
-    static randomInt(min, max) {
-        return Math.floor(this.random(min, max + 0.999));
-    }
-    /**
-     * 随机唯一稳定值
-     * @param min
-     * @param max
-     * @param clear  是否清除唯一记录
-     */
-    static randomOnlyInt(min, max, clear) {
-        if (clear) {
-            this.onlyMap.clear();
-        }
-        let value = this.randomInt(min, max);
-        let tryCount = (max - min) * 2;
-        let tryIndex = 0;
-        while (this.onlyMap.has(value)) {
-            value = this.randomInt(min, max);
-            if (tryIndex > tryCount) {
-                console.error("所有唯一值已取完");
-                return 0;
+    send(eventName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = data && typeof data === "object" && !Array.isArray(data)
+                ? Object.assign({}, data) : { value: data };
+            let msg_data = {
+                appid: publisher.appId,
+                openid: String(storage.userId || publisher.login.openID || ""),
+                deviceid: App.deviceId,
+                sessionid: App.sessionId,
+                level: ++this._index,
+                data: payload,
+                event: eventName,
+                timestamp: this._config.timestampCall() || Date.now()
+            };
+            this._eventCache.push(msg_data);
+            const countLimit = this._config.count || 20;
+            const byteLimit = this._config.maxBufferedBytes || 512 * 1024;
+            if (this._eventCache.length >= countLimit || this._currentBufferedBytes() >= byteLimit) {
+                this._scheduleFlush(0);
             }
-            tryIndex++;
-        }
-        this.onlyMap.set(value, true);
-        return value;
-    }
-    /**
-     * 获取两点间的角度
-     * @param p1 点1
-     * @param p2 点2
-     */
-    static getAngle(p1, p2) {
-        return Math.atan((p2.y - p1.y) / (p2.x - p1.x));
-    }
-    /**
-     * 获取两点间的距离
-     * @param p1 点1
-     * @param p2 点2
-     */
-    static getDistance(p1, p2) {
-        return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
-    }
-    /**
-     * 将角度转为弧度
-     * @param angle 角度
-     */
-    static angleToRadian(angle) {
-        return angle * Math.PI / 180;
-    }
-    /**
-     * 求旋转后的点坐标
-     * @param angle         角度
-     * @param point         旋转前的坐标点
-     * @param result
-     */
-    static getRotationPoint(angle, pointOrDir, result) {
-        if (result == null) {
-            result = { x: 0, y: 0 };
-        }
-        //角度转弧度
-        angle = angle * (Math.PI / 180);
-        result.x = Math.cos(angle) * pointOrDir.x - Math.sin(angle) * pointOrDir.y;
-        result.y = Math.cos(angle) * pointOrDir.y + Math.sin(angle) * pointOrDir.x;
-        return result;
+        });
     }
 }
-/**
- * 随机种子
- */
-MathUtils.seed = 10;
-/**
- * 唯一记录
- */
-MathUtils.onlyMap = new Map();
 
-class StringUtils {
-    static random(length, chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
-        var result = '';
-        for (var i = length; i > 0; --i) {
-            result += chars[Math.floor(Math.random() * chars.length)];
+class AnalyticsManager {
+    constructor() {
+        this._base = null;
+        this._level = null;
+        this._ad = null;
+        this._session = null;
+        this._launch = null;
+        this._social = null;
+        this._assignmentSender = null;
+    }
+    hasRelayUrl(config) {
+        return !!String(config && config.url || "").trim();
+    }
+    hasAliDirectConfig(config) {
+        return !!String(config && config.project || "").trim() && !!String(config && config.logstore || "").trim();
+    }
+    createBehaviorSenders() {
+        const analyticsConfig = remoteConfigService.config(SystemOnlineConfig).getAnalyticsConfig();
+        if (this.hasRelayUrl(analyticsConfig)) {
+            return [new KeytopsAnalyticsSender(analyticsConfig)];
         }
-        return result;
+        if (this.hasAliDirectConfig(analyticsConfig)) {
+            return [new ALiAnalyticsSender(analyticsConfig)];
+        }
+        return [];
     }
     /**
-     * 判断是否是远程资源
-     * @param url
-     * @returns
+     * 基础统计能力
      */
-    static isRemote(url) {
-        if (url.indexOf("http://") == 0 || url.indexOf("https://") == 0) {
-            return true;
+    get base() {
+        if (!this._base) {
+            this._base = new AnalyticsAble();
         }
-        return false;
+        return this._base;
     }
     /**
-     * 是否为空
-     * @param str
+     * 关卡统计能力，用于关卡分析
      */
-    static isEmpty(str) {
-        if (str == null || str == undefined || str.length == 0) {
-            return true;
+    get level() {
+        if (!this.base.inited) {
+            throw new Error("请先通过enable初始化基础统计能力");
         }
-        return false;
+        if (!this._level) {
+            this._level = new LevelAnalyticsAble(this.base);
+        }
+        return this._level;
     }
     /**
-    * 替换全部字符串
-    * @param string src 源串
-    * @param string from_ch 被替换的字符
-    * @param string to_ch 替换的字符
-    *
-    * @return string 结果字符串
-    */
-    static replaceAll(src, from_ch, to_ch) {
-        let regExp = new RegExp(from_ch, "g");
-        return src.replace(regExp, to_ch);
+     * 广告统计能力，用于广告分析
+     */
+    get ad() {
+        if (!this.base.inited) {
+            throw new Error("请先通过enable初始化基础统计能力");
+        }
+        if (!this._ad) {
+            this._ad = new ADAnalyticsAble(this.base);
+        }
+        return this._ad;
     }
     /**
-     * 参数替换
-     *  @param  str
-     *  @param  rest
-     *
-     *  @example
-     *
-     *  var str:string = "here is some info '{0}' and {1}";
-     *  trace(StringUtil.substitute(str, 15.4, true));
-     *
-     *  // this will output the following string:
-     *  // "here is some info '15.4' and true"
+     * 会话统计能力，用于会话分析
      */
-    static format(str, ...rest) {
-        if (str == null)
-            return '';
-        // Replace all of the parameters in the msg string.
-        var len = rest.length;
-        var args;
-        if (len == 1 && rest[0] instanceof Array) {
-            args = rest[0];
-            len = args.length;
-        }
-        else {
-            args = rest;
+    get session() {
+        if (!this.base.inited) {
+            throw new Error("请先通过enable初始化基础统计能力");
         }
-        for (var i = 0; i < len; i++) {
-            str = str.replace(new RegExp("\\{" + i + "\\}", "g"), args[i]);
+        if (!this._session) {
+            this._session = new SessionAnalyticsAble(this.base);
         }
-        return str;
+        return this._session;
     }
     /**
-     *
-     * 格式化数字
-     * @param amount 目标数字
-     * @param format 支持{1:"", 100:"百", 1000:"千", 10000:"万", 100000:"十万", 1000000:"百万", 10000000:"千万", 100000000:"亿", 1000000000000:"兆"}等
-     * @returns
+     * 启动统计能力,用于启动性能分析
      */
-    static formatNumber(amount, format) {
-        if (!format || amount == 0) {
-            return `${amount}`;
+    get launch() {
+        if (!this.base.inited) {
+            throw new Error("请先通过enable初始化基础统计能力");
         }
-        let formatKey = [];
-        for (const key in format) {
-            if (format.hasOwnProperty(key)) {
-                formatKey.push(Number(key));
-            }
+        if (!this._launch) {
+            this._launch = new LaunchAnalyticsAble(this.base);
         }
-        if (!formatKey || formatKey.length == 0) {
-            return `${amount}`;
+        return this._launch;
+    }
+    /**
+     * 社交统计能力
+     */
+    get social() {
+        if (!this.base.inited) {
+            throw new Error("请先通过enable初始化基础统计能力");
         }
-        formatKey.sort((a, b) => b - a);
-        let result = [];
-        let total = amount;
-        for (let i = 0; i < formatKey.length; i++) {
-            const key = formatKey[i];
-            let count = Math.floor(Math.abs(total / key)) * (total / Math.abs(total));
-            if (count == 0) {
-                continue;
-            }
-            total = total % key;
-            result.push(`${count}${format[key]}`);
+        if (!this._social) {
+            this._social = new SocialAnalyticsAble(this.base);
         }
-        return result.length ? result.join("") : `${amount}`;
+        return this._social;
     }
     /**
-     * 带自动补全的秒数格式。
-     * @param second 秒数
-     * @param format 格式化文本
-     * @param pad 填充文本，默认为“0”
-     * @example
-     * formatSecond(86400, "ddd天hh小时mm分ss秒")=>"001天00小时00分00秒"
-     * formatSecond(86400, "dd天hh小时mm分ss秒")=>"01天00小时00分00秒"
-     * formatSecond(86400, "hh小时mm分ss秒")=>"24小时00分00秒"
-     * formatSecond(86400, "mm分ss秒")=>"1440分00秒"
+     * 启用统计（基础统计能力）
+     * @param debugMode 调试模式，是否打印日志信息，默认为false
+     * @param senders 上报器列表，允许多个 默认为ALiAnalyticsSender
      * @returns
      */
-    static formatSecond(second, format, pad = "0") {
-        const formatArr = [
-            { unit: 86400, regExp: /D{2,}/i },
-            { unit: 3600, regExp: /H{1,2}/i },
-            { unit: 60, regExp: /m{1,2}/i },
-            { unit: 1, regExp: /s{1,2}/i },
-        ];
-        for (let i = 0; i < formatArr.length; i++) {
-            const element = formatArr[i];
-            let match = element.regExp.exec(format);
-            if (match) {
-                format = format.replace(element.regExp, Math.floor(second / element.unit).toFixed(0).padStart(match[0].length, pad));
-                second = second % element.unit;
-            }
+    enable(debugMode = false, senders) {
+        if (this.base.inited) {
+            return;
         }
-        return format;
+        senders = senders || this.createBehaviorSenders();
+        this.base.init(senders, debugMode);
+        this.launch.report("enabled");
+    }
+    get version() {
+        return "v1";
     }
     /**
-     * 带自动补全的时间戳格式化
-     * @param milliseconds
-     * @param format
-     * @param pad 填充文本，默认为“0”
-     * @returns
+     * 获取所有维度的数据
+     * @returns 所有维度的数据
      */
-    static formatTimestamp(milliseconds, format, pad = "0") {
-        let date = new Date(milliseconds);
-        date.getHours();
-        const formatArr = [
-            { r: /Y{4}/, to: date.getFullYear() },
-            { r: /M{1,2}/, to: date.getMonth() + 1 },
-            { r: /D{1,2}/, to: date.getDate() },
-            { r: /H{1,2}/, to: date.getHours() },
-            { r: /m{1,2}/, to: date.getMinutes() },
-            { r: /s{1,2}/, to: date.getSeconds() },
-        ];
-        for (let i = 0; i < formatArr.length; i++) {
-            const element = formatArr[i];
-            let match = element.r.exec(format);
-            if (match) {
-                format = format.replace(element.r, element.to.toString().padStart(match[0].length, "0"));
-            }
+    getMetrics() {
+        const result = {};
+        result[DimensionType[DimensionType.ACTIVITY]] = this.session.getMetrics();
+        result[DimensionType[DimensionType.AD]] = this.ad.getMetrics();
+        result[DimensionType[DimensionType.SOCIAL]] = this.social.getMetrics();
+        return result;
+    }
+    get assignmentSender() {
+        if (!this._assignmentSender) {
+            const analyticsConfig = remoteConfigService.config(SystemOnlineConfig).getAssignmentConfig();
+            this._assignmentSender = this.hasRelayUrl(analyticsConfig)
+                ? new KeytopsAnalyticsSender(analyticsConfig, analyticsConfig.exclude || ["view"])
+                : new EmptyAnalyticsSender();
         }
-        return format;
+        return this._assignmentSender;
+    }
+    reportAssignments(resolveMeta, levelid) {
+        if (!resolveMeta) {
+            return;
+        }
+        const method = resolveMeta.method;
+        if (!method) {
+            throw new Error("method is required");
+        }
+        const eventName = `${method}_assignment`;
+        (resolveMeta.matchedUnits || []).forEach((unit) => {
+            const payload = {
+                method: method,
+                resolve_key: resolveMeta.resolveKey,
+                config_name: unit.configName,
+                fingerprint: unit.fingerprint,
+            };
+            if (unit.publishId) {
+                payload.publish_id = unit.publishId;
+            }
+            if (unit.variantId) {
+                payload.variant_id = unit.variantId;
+            }
+            if (unit.variantFingerprint) {
+                payload.variant_fingerprint = unit.variantFingerprint;
+            }
+            if (levelid !== undefined) {
+                payload.level_id = levelid;
+            }
+            this.assignmentSender.send(eventName, payload);
+        });
     }
 }
+/**
+ * 埋点统计能力
+ */
+const analytics = new AnalyticsManager();
 
 class KKTServer {
     requestConfig(context) {
@@ -6462,7 +6524,6 @@ class Application {
             this.impl.launch();
             this._resetLaunchTimes();
             timer.enable();
-            analytics.enable(debug);
             let isFirstLaunch = this.isFirstLaunch;
             console.log(`App Launch Done. isFirstLaunch:${isFirstLaunch}`);
         });