@chiyou/minigame-framework 1.0.0 → 1.0.2

package/assets/Scripts/Framework/Manager/NodePoolMgr.ts

@@ -0,0 +1,385 @@
+import { _decorator, Node, NodePool, Vec3 } from 'cc';
+import { BaseMgr } from './BaseMgr';
+import { LogUtils } from '../Utils/LogUtils';
+import { UIMgr } from './UIMgr';
+
+/**
+ * 节点池配置接口
+ */
+export interface IPoolConfig {
+    prefabUiName?: string;     // 节点池预制体名称
+    initCount?: number;       // 初始节点数量
+    enableDebug?: boolean;    // 启用调试
+}
+
+/**
+ * 节点池统计信息
+ */
+export interface IPoolStatistics {
+    createdCount: number;           // 创建次数(节点池大小)
+    reusedCount: number;            // 复用次数
+    nowActiveCount: number;         // 当前活跃节点数
+    maxActiveCount: number;         // 历史最大活跃节点数
+    lastAccessTime: number;         // 最后访问时间
+}
+
+export class PoolInfo {
+    poolConfig: IPoolConfig;
+    pool: NodePool;
+    usingNodeSet: Set<Node> = new Set<Node>();
+    statistics: IPoolStatistics;
+
+    constructor(poolConfig: Required<IPoolConfig>) {
+        this.poolConfig = poolConfig;
+        this.pool = new NodePool();
+        this.usingNodeSet = new Set<Node>();
+        this.statistics = {
+            createdCount: 0,
+            reusedCount: 0,
+            nowActiveCount: 0,
+            maxActiveCount: 0,
+            lastAccessTime: Date.now(),
+        };
+    }
+}
+
+export class NodePoolMgr extends BaseMgr {
+
+    public static Instance: NodePoolMgr = null;
+    static TAG: string = "NodePoolMgr";
+
+    private _poolInfoMap: Map<string, PoolInfo> = new Map<string, PoolInfo>();
+
+    private _defaultPoolConfig: Required<IPoolConfig> = {
+        prefabUiName: "",
+        initCount: 10,
+        enableDebug: false,
+    };
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (NodePoolMgr.Instance === null) {
+            NodePoolMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this._poolInfoMap = new Map<string, PoolInfo>();
+
+        LogUtils.Instance.log(NodePoolMgr.TAG, "init() finished.");
+    }
+
+    public initPools(pools: Array<{poolName: string, config: IPoolConfig}>): void {
+         LogUtils.Instance.log(NodePoolMgr.TAG, `initPools()`);
+
+        if (pools === null || pools.length === 0) {
+            return;
+        }
+
+        pools.forEach(pool => {
+            this.initPool(pool.poolName, pool.config);
+        });
+    }
+
+    public initPool(poolName: string, config: IPoolConfig): boolean {
+        LogUtils.Instance.log(NodePoolMgr.TAG, `initPool() ${poolName}`);
+
+        if (this._poolInfoMap.has(poolName)) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} already exist.`);
+            return false;
+        }
+
+        if (!config || config.prefabUiName === "") {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} config is invalid.`);
+            return false;
+        }
+
+        let poolConfig: Required<IPoolConfig> = {
+             ...this._defaultPoolConfig,
+             ...config
+        };
+
+        let poolInfo: PoolInfo = new PoolInfo(poolConfig);
+        this._poolInfoMap.set(poolName, poolInfo);
+
+        for (let index: number = 0; index < poolConfig.initCount; index++) {
+            this._createNode(poolName);
+        }
+
+        LogUtils.Instance.log(NodePoolMgr.TAG, `initPool() ${poolName} sucess.`);
+
+        return true;
+    }
+
+    // 销毁所有节点池
+    public destoryPools(): void {
+        LogUtils.Instance.log(NodePoolMgr.TAG, `destoryPools()`);
+
+        this.clearAllPools(true);
+    }
+
+    // 清空所有节点池
+    public clearAllPools(destoryNodes: boolean = true): void {
+        LogUtils.Instance.log(NodePoolMgr.TAG, `clearPools()`);
+
+        this._poolInfoMap.forEach((poolInfo: PoolInfo, poolName: string) => {
+             this.clearPool(poolName, destoryNodes);
+        });
+    }
+
+    public clearPool(poolName: string, destroyNodes: boolean = true): void {
+        LogUtils.Instance.log(NodePoolMgr.TAG, `clearPool() ${poolName}`);
+
+        if (!this._poolInfoMap.has(poolName)) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} not exist.`);
+            return;
+        }
+
+        this.recyclePool(poolName);
+        
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (poolInfo.pool !== null && poolInfo.pool.size() > 0) {
+            if (destroyNodes) {
+                while (poolInfo.pool.size() > 0) {
+                    let node: Node = poolInfo.pool.get() as Node;
+                    this._destoryNode(poolName, node);
+                }
+
+                poolInfo.pool.clear();
+
+                poolInfo.statistics = {
+                    createdCount: 0,
+                    reusedCount: 0,
+                    nowActiveCount: 0,
+                    maxActiveCount: 0,
+                    lastAccessTime: Date.now(),
+                }
+            }
+        }
+
+        this._poolInfoMap.set(poolName, poolInfo);
+
+        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
+            this._printPoolState(poolName);
+        }
+    }
+
+    public recyclePool(poolName: string): void {
+        LogUtils.Instance.log(NodePoolMgr.TAG, `recyclePool() ${poolName}`);
+
+        if (!this._poolInfoMap.has(poolName)) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `${poolName} not exist.`);
+            return;
+        }
+
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (poolInfo.usingNodeSet !== null && poolInfo.usingNodeSet.size > 0) {
+            poolInfo.usingNodeSet.forEach((node: Node) => {
+                this._recycleNode(poolName, node, true);
+            });
+            poolInfo.usingNodeSet.clear();
+        }
+
+        this._poolInfoMap.set(poolName, poolInfo);
+    }
+
+    public getNodes(
+        poolName: string,
+        count: number,
+        parent?: Node,
+        callback?: (node: Node, index: number) => void
+    ): Node[] {
+        let nodes: Node[] = [];
+
+        for (let index: number = 0; index < count; index++) {
+            let node: Node = this.getNode(poolName, parent, (n: Node) => {
+                if (callback) {
+                    callback(n, index);
+                }
+            });
+
+            if (node) {
+                nodes.push(node);
+            }
+        }
+
+        return nodes;
+    }
+
+    public getNode(
+        poolName: string,
+        parent?: Node,
+        callback?: (node: Node) => void
+    ): Node {
+        if (!this._poolInfoMap.has(poolName)) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `getNode() ${poolName} not exist.`);
+            return null;
+        }
+
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (poolInfo.pool === null) {
+            poolInfo.pool = new NodePool();
+        }
+        if (poolInfo.pool.size() === 0) {
+            this._createNode(poolName);
+        }
+
+        let node: Node = poolInfo.pool.get() as Node;
+        poolInfo.usingNodeSet.add(node);
+
+        if (parent) {
+            parent.addChild(node);
+        }
+    
+        node.active = true;
+
+        poolInfo.statistics.reusedCount++;
+        poolInfo.statistics.nowActiveCount++;
+        if (poolInfo.statistics.nowActiveCount > poolInfo.statistics.maxActiveCount) {
+            poolInfo.statistics.maxActiveCount = poolInfo.statistics.nowActiveCount;
+        }
+        poolInfo.statistics.lastAccessTime = Date.now();
+
+        this._poolInfoMap.set(poolName, poolInfo);
+
+        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
+            this._printPoolState(poolName);
+        }
+
+        if (callback) {
+            callback(node);
+        }
+        
+        return node;
+    }
+
+    public putNodes(poolName: string, nodes: Node[], resetNode: boolean = true): void {
+        if (!nodes || nodes.length === 0) {
+            return;
+        }
+        
+        nodes.forEach(node => {
+            this.putNode(poolName, node, resetNode);
+        });
+    }
+
+    public putNode(poolName: string, node: Node, immediate: boolean = true, resetNode: boolean = true): void {
+        if (!node || !node.isValid) {
+            return;
+        }
+
+        if (!this._poolInfoMap.has(poolName)) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `putNode() ${poolName} not exist.`);
+
+            this._destoryNode(poolName, node);
+            return;
+        }
+
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (poolInfo.usingNodeSet.has(node)) {
+            poolInfo.usingNodeSet.delete(node);
+        }
+
+        if (immediate) {
+            this._recycleNode(poolName, node, resetNode);
+        } else {
+            this.scheduleOnce(() => {
+                this._recycleNode(poolName, node, resetNode);
+            });
+        }
+    }
+
+    private _createNode(poolName: string) {
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (!poolInfo) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `_createNode() ${poolName} not exist.`);
+            return null;
+        }
+
+        let node: Node = UIMgr.Instance.create_ui(poolInfo.poolConfig.prefabUiName);
+        if (!node) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `_createNode() ${poolName} create node failed.`);
+            return null;
+        }
+        node.active = false;
+
+        poolInfo.pool.put(node);
+        poolInfo.statistics.createdCount++;
+        this._poolInfoMap.set(poolName, poolInfo);
+
+        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
+            this._printPoolState(poolName);
+        }
+    }
+
+    private _destoryNode(poolName: string, node: Node): void {
+        if (!node || !node.isValid) {
+            return;
+        }
+
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+
+        UIMgr.Instance.destroy_ui(poolName, node);
+
+        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
+            this._printPoolState(poolName);
+        }
+    }
+
+    private _recycleNode(poolName: string, node: Node, resetNode: boolean = true): void {
+        if (!node || !node.isValid) {
+            return;
+        }
+
+        if (node.parent) {
+            node.removeFromParent();
+        }
+
+        if (resetNode) {
+            this._resetNode(node);
+        }
+
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        
+        poolInfo.pool.put(node);
+
+        node.active = false;
+        poolInfo.statistics.nowActiveCount--;
+        poolInfo.statistics.lastAccessTime = Date.now();
+
+        this._poolInfoMap.set(poolName, poolInfo);
+
+        if (poolInfo.poolConfig && poolInfo.poolConfig.enableDebug) {
+            this._printPoolState(poolName);
+        }
+    }
+
+    private _resetNode(node: Node): void {
+        if (!node || !node.isValid) {
+            return;
+        }
+
+        node.position = Vec3.ZERO;
+        node.eulerAngles = Vec3.ZERO;
+        node.scale = Vec3.ONE;
+    }
+
+    private _printPoolState(poolName: string): void {
+        let poolInfo: PoolInfo = this._poolInfoMap.get(poolName);
+        if (!poolInfo) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `_printPoolState() ${poolName} not exist.`);
+            return;
+        }
+
+        if (!poolInfo.statistics) {
+            LogUtils.Instance.log(NodePoolMgr.TAG, `_printPoolState() ${poolName} statistics is null.`);
+            return;
+        }
+
+        LogUtils.Instance.log(NodePoolMgr.TAG, `节点池 ${poolName} 已创建数：${poolInfo.statistics.createdCount} ，复用数：${poolInfo.statistics.reusedCount}，当前活跃数：${poolInfo.statistics.nowActiveCount}，最大活跃数：${poolInfo.statistics.maxActiveCount}`);
+    }
+}

package/assets/Scripts/Framework/Manager/NodePoolMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "910f0631-d7f0-4f7f-86e4-761c9da17c83",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Manager/PrivacyMgr.ts

@@ -0,0 +1,189 @@
+import { LogUtils } from '../Utils/LogUtils';
+import { AuthorizeResult, GetSettingResult, KindReminder, KindReminderType, PrivacyDefinition, PrivacyInfo, PrivacyPlatformInfo, PrivacyType, QueryPrivacyResult } from '../Definition/PrivacyDefinition';
+import { UIMgr } from './UIMgr';
+import { ToastDuration } from '../Definition/UIDefinition';
+import { PlatformID } from '../Definition/SystemDefinition';
+import { BaseMgr } from './BaseMgr';
+import { FrameworkBase } from '../Definition/FrameworkBase';
+
+export class PrivacyMgr extends BaseMgr {
+    public static Instance: PrivacyMgr = null;
+    static TAG: string = "PrivacyMgr";
+
+    private kindReminder: KindReminder = null;
+    private kindReminderAgreeVersion: string = "";
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (PrivacyMgr.Instance === null) {
+            PrivacyMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(kindReminder: KindReminder): void {
+        this.kindReminder = kindReminder;
+
+        let aggreeVersion = localStorage.getItem(FrameworkBase.LocalStorage.Key_PrivacyManager_KindReminder_AgreeVersion);
+        let aggreeVersionOld = localStorage.getItem(FrameworkBase.LocalStorage.Key_KindReminder_AgreeVersion);
+        
+        if (aggreeVersion !== null && aggreeVersion !== "") {
+            this.kindReminderAgreeVersion = aggreeVersion;
+        } else if (aggreeVersionOld !== null && aggreeVersionOld !== "") {
+            this.kindReminderAgreeVersion = aggreeVersionOld;
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_PrivacyManager_KindReminder_AgreeVersion, this.kindReminderAgreeVersion);
+            localStorage.removeItem(FrameworkBase.LocalStorage.Key_KindReminder_AgreeVersion);
+        } else {
+            this.kindReminderAgreeVersion = "";
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_PrivacyManager_KindReminder_AgreeVersion, this.kindReminderAgreeVersion);
+        }
+
+        LogUtils.Instance.log(PrivacyMgr.TAG, "init() finished.");
+    }
+
+    public shouldShowKindReminderOnLaunch(): boolean {
+        let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+        if (!this.kindReminder.shouldShowPlatform.has(currentPlatformID)) {
+            return false;
+        }
+
+        if (this.kindReminder.latestVersion !== this.kindReminderAgreeVersion) {
+            return true;
+        }
+        return false;
+    }
+
+    public shouldShowKindReminder(): boolean {
+        let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+        if (!this.kindReminder.shouldShowPlatform.has(currentPlatformID)) {
+            return false;
+        }
+        return true;
+    }
+
+    public getKindReminderContent(type: KindReminderType): string {
+        let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+
+        let content: string[][] = [];
+        if (type === KindReminderType.Type_UserAgreement) {
+            content = this.kindReminder.userAgreement.mainContent;
+
+            if (this.kindReminder.userAgreement.supplementaryContent !== null &&
+                this.kindReminder.userAgreement.supplementaryContent.has(currentPlatformID)) {
+                content = content.concat(this.kindReminder.userAgreement.supplementaryContent.get(currentPlatformID));
+            }
+        } else if (type === KindReminderType.Type_PrivacyPolicy) {
+            content = this.kindReminder.privacyPolicy.mainContent;
+
+            if (this.kindReminder.privacyPolicy.supplementaryContent !== null &&
+                this.kindReminder.privacyPolicy.supplementaryContent.has(currentPlatformID)) {
+                content = content.concat(this.kindReminder.privacyPolicy.supplementaryContent.get(currentPlatformID));
+            }
+        }
+        
+        let resultStr: string = "";
+        for (let i: number = 1; i <= content.length; i++) {
+            let paragraph: string[] = content[i - 1];
+            for (let j: number = 1; j <= paragraph.length; j++) {
+                resultStr += paragraph[j - 1] + "\n";
+            }
+            resultStr += "\n";
+        }
+
+        return resultStr;
+    }
+
+    public setKindReminderAgreed(): void {
+        this.kindReminderAgreeVersion = this.kindReminder.latestVersion;
+        localStorage.setItem(FrameworkBase.LocalStorage.Key_PrivacyManager_KindReminder_AgreeVersion, this.kindReminderAgreeVersion);
+    }
+
+    public queryPrivacyAvailable(featureName: string, privacyType: PrivacyType, callback: Function): void {
+        LogUtils.Instance.log(PrivacyMgr.TAG, "checkPrivacyAvailable");
+        LogUtils.Instance.log("", "featureName=" + featureName + ",privacyType=" + PrivacyType[privacyType]);
+        if (callback === null) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Invalid]);
+            callback(QueryPrivacyResult.Result_Invalid);
+            return;
+        }
+
+        let privacyInfo: PrivacyInfo = PrivacyDefinition.PrivacyConfig.get(privacyType);
+        if (privacyInfo === null) {
+            LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Invalid]);
+            callback(QueryPrivacyResult.Result_Invalid);
+            return;
+        }
+
+        this.getPlatformAdapter().requirePrivacyAuthorize((result) => {
+            if (!result) {
+                UIMgr.Instance.showToast("未同意隐私协议，无法使用" + featureName);
+                LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_PrivacyReject]);
+                callback(QueryPrivacyResult.Result_PrivacyReject);
+                return;
+            }
+
+            let privacyPlatformInfo: PrivacyPlatformInfo = privacyInfo.privacyPlatformMap.get(this.getCurrentPlatformID());
+            let scopeDescription: string = privacyPlatformInfo.scopeDescription;
+            if (privacyPlatformInfo === null || privacyPlatformInfo.scopeDisable) {
+                UIMgr.Instance.showToast("不支持[" + scopeDescription + "]，无法使用" + featureName);
+                LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_ScopeDisable]);
+                callback(QueryPrivacyResult.Result_ScopeDisable);
+                return;
+            }
+
+            if (!privacyPlatformInfo.needAuthorize) {
+                LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Agree]);
+                callback(QueryPrivacyResult.Result_Agree);
+                return;
+            }
+
+            let scopeName: string = privacyPlatformInfo.scopeName;
+            this.getPlatformAdapter().getSetting(scopeName, (result: GetSettingResult) => {
+                if (result === GetSettingResult.Result_SettingNotAvailable) {
+                    UIMgr.Instance.showToast("App版本过低，无法使用" + featureName, ToastDuration.Duration_Long);
+                    LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Invalid]);
+                    callback(QueryPrivacyResult.Result_Invalid);
+                    return;
+                } else if (result === GetSettingResult.Result_Rejected) {
+                    UIMgr.Instance.showToast("右上角...设置，开启[" + scopeDescription + "]权限，即可使用" + featureName, ToastDuration.Duration_Long);
+                    LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_AuthorizeReject]);
+                    callback(QueryPrivacyResult.Result_AuthorizeReject);
+                    return;
+                } else if (result === GetSettingResult.Result_NotExist_AuthorizeAvailable) {                    
+                    this.getPlatformAdapter().authorize(scopeName, (result3) => {
+                        if (result3 === AuthorizeResult.Result_AuthorizeNotAvailable) {
+                            UIMgr.Instance.showToast("App版本过低，无法使用" + featureName, ToastDuration.Duration_Long);
+                            LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Invalid]);
+                            callback(QueryPrivacyResult.Result_Invalid);
+                            return;
+                        } else if (result3 === AuthorizeResult.Result_Rejected) {
+                            UIMgr.Instance.showToast("右上角...设置，开启[" + scopeDescription + "]权限，即可使用" + featureName, ToastDuration.Duration_Long);
+                            LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_AuthorizeReject]);
+                            callback(QueryPrivacyResult.Result_AuthorizeReject);
+                            return;
+                        } else if (result3 === AuthorizeResult.Result_Authorized) {
+                            LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Agree]);
+                            callback(QueryPrivacyResult.Result_Agree);
+                            return;
+                        }
+                    });
+                } else if (result === GetSettingResult.Result_Authorized) {
+                    LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Agree]);
+                    callback(QueryPrivacyResult.Result_Agree);
+                    return;
+                } else if (result === GetSettingResult.Result_NotExist_AuthorizeNotAvailable) {
+                    LogUtils.Instance.log("", QueryPrivacyResult[QueryPrivacyResult.Result_Continue]);
+                    callback(QueryPrivacyResult.Result_Continue);
+                    return;
+                }
+            });
+        });
+    }
+}

package/assets/Scripts/Framework/Manager/PrivacyMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "11bb5bfb-f5f9-4c91-abdd-017026b81446",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}