@chiyou/minigame-framework 1.0.2 → 1.0.3

package/dist/Framework/Manager/PrivacyMgr.js

@@ -1,176 +0,0 @@
-import { LogUtils } from '../Utils/LogUtils';
-import { AuthorizeResult, GetSettingResult, KindReminderType, PrivacyDefinition, PrivacyType, QueryPrivacyResult } from '../Definition/PrivacyDefinition';
-import { UIMgr } from './UIMgr';
-import { ToastDuration } from '../Definition/UIDefinition';
-import { BaseMgr } from './BaseMgr';
-import { FrameworkBase } from '../Definition/FrameworkBase';
-export class PrivacyMgr extends BaseMgr {
-    constructor() {
-        super(...arguments);
-        this.kindReminder = null;
-        this.kindReminderAgreeVersion = "";
-    }
-    onLoad() {
-        super.onLoad();
-        if (PrivacyMgr.Instance === null) {
-            PrivacyMgr.Instance = this;
-        }
-        else {
-            this.destroy();
-            return;
-        }
-    }
-    init(kindReminder) {
-        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.");
-    }
-    shouldShowKindReminderOnLaunch() {
-        let currentPlatformID = this.getCurrentPlatformID();
-        if (!this.kindReminder.shouldShowPlatform.has(currentPlatformID)) {
-            return false;
-        }
-        if (this.kindReminder.latestVersion !== this.kindReminderAgreeVersion) {
-            return true;
-        }
-        return false;
-    }
-    shouldShowKindReminder() {
-        let currentPlatformID = this.getCurrentPlatformID();
-        if (!this.kindReminder.shouldShowPlatform.has(currentPlatformID)) {
-            return false;
-        }
-        return true;
-    }
-    getKindReminderContent(type) {
-        let currentPlatformID = this.getCurrentPlatformID();
-        let content = [];
-        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 = "";
-        for (let i = 1; i <= content.length; i++) {
-            let paragraph = content[i - 1];
-            for (let j = 1; j <= paragraph.length; j++) {
-                resultStr += paragraph[j - 1] + "\n";
-            }
-            resultStr += "\n";
-        }
-        return resultStr;
-    }
-    setKindReminderAgreed() {
-        this.kindReminderAgreeVersion = this.kindReminder.latestVersion;
-        localStorage.setItem(FrameworkBase.LocalStorage.Key_PrivacyManager_KindReminder_AgreeVersion, this.kindReminderAgreeVersion);
-    }
-    queryPrivacyAvailable(featureName, privacyType, callback) {
-        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 = 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 = privacyInfo.privacyPlatformMap.get(this.getCurrentPlatformID());
-            let scopeDescription = 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 = privacyPlatformInfo.scopeName;
-            this.getPlatformAdapter().getSetting(scopeName, (result) => {
-                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;
-                }
-            });
-        });
-    }
-}
-PrivacyMgr.Instance = null;
-PrivacyMgr.TAG = "PrivacyMgr";

package/dist/Framework/Manager/ResMgr.d.ts

@@ -1,49 +0,0 @@
-import { Asset } from 'cc';
-import { BaseMgr } from './BaseMgr';
-export type ResBatch = string;
-export interface ResBundleConfig {
-    assetType: typeof Asset;
-    resBatchUrlsMap: Map<ResBatch, string[]>;
-}
-export declare class ResBundleInfo {
-    assetType: typeof Asset;
-    isBundleLoaded: boolean;
-    constructor(assetType: typeof Asset);
-}
-export declare class ResLoadInfo {
-    totalResCount: number;
-    loadedResCount: number;
-    constructor();
-}
-export declare class ResBatchInfo {
-    isBatchLoaded: boolean;
-    bundleLoadInfo: Map<string, ResLoadInfo>;
-    constructor();
-}
-export declare class ResMgr extends BaseMgr {
-    static Instance: ResMgr;
-    static TAG: string;
-    private resBundleConfig;
-    private resBatchSet;
-    private resBundleInfoMap;
-    private resBatchInfoMap;
-    private abBundsMap;
-    private loadInProgressFunc;
-    private loadEndFunc;
-    private totalResCount;
-    private nowLoadedResCount;
-    onLoad(): void;
-    init(resBundleConfig: Map<string, ResBundleConfig>): void;
-    private _printInfo;
-    private _initResBundleInfo;
-    private _initResBatchInfo;
-    preloadResBatch(resBatchList: ResBatch[], loadInProgressFunc: (loadedResCount: number, totalResCount: number) => void, loadEndFunc: () => void): void;
-    private _preloadAssetsBundle;
-    private _preloadAssetInAssetBundle;
-    private _preloadAsset;
-    getAsset<T extends Asset>(bundleName: string, url: string, assetType?: typeof Asset): T | null;
-    getBundleResCount(bundleName: string, path: string, assetType: typeof Asset): number;
-    loadRes(bundleName: string, url: string, assetType: typeof Asset, callback: Function): void;
-    private _loadRes;
-    loadRemoteImage(imageUrl: string, fileSuffix: string, callback: Function): void;
-}

package/dist/Framework/Manager/ResMgr.js

@@ -1,337 +0,0 @@
-import { assetManager } from 'cc';
-import { LogUtils } from '../Utils/LogUtils';
-import { BaseMgr } from './BaseMgr';
-export class ResBundleInfo {
-    constructor(assetType) {
-        this.assetType = assetType;
-        this.isBundleLoaded = false;
-    }
-}
-export class ResLoadInfo {
-    constructor() {
-        this.totalResCount = 0;
-        this.loadedResCount = 0;
-    }
-}
-export class ResBatchInfo {
-    constructor() {
-        this.bundleLoadInfo = null;
-        this.isBatchLoaded = false;
-        this.bundleLoadInfo = new Map();
-    }
-}
-export class ResMgr extends BaseMgr {
-    constructor() {
-        super(...arguments);
-        this.resBundleConfig = new Map();
-        this.resBatchSet = new Set();
-        this.resBundleInfoMap = new Map();
-        this.resBatchInfoMap = new Map();
-        this.abBundsMap = new Map();
-        this.totalResCount = 0;
-        this.nowLoadedResCount = 0;
-    }
-    onLoad() {
-        super.onLoad();
-        if (ResMgr.Instance === null) {
-            ResMgr.Instance = this;
-        }
-        else {
-            this.destroy();
-            return;
-        }
-    }
-    init(resBundleConfig) {
-        this.resBundleConfig = resBundleConfig;
-        this._initResBundleInfo();
-        this._initResBatchInfo();
-        // this._printInfo();
-        LogUtils.Instance.log(ResMgr.TAG, "init() finished.");
-    }
-    _printInfo() {
-        LogUtils.Instance.log("", "resBundleInfoMap", this.resBundleInfoMap);
-        LogUtils.Instance.log("", "resBatchInfoMap", this.resBatchInfoMap);
-    }
-    _initResBundleInfo() {
-        this.resBundleInfoMap.clear();
-        this.resBundleConfig.forEach((resBundleConfig, bundleName) => {
-            let assetType = resBundleConfig.assetType;
-            let resBundleInfo = new ResBundleInfo(assetType);
-            this.resBundleInfoMap.set(bundleName, resBundleInfo);
-        });
-    }
-    _initResBatchInfo() {
-        this.resBatchSet.clear();
-        this.resBundleConfig.forEach((resBundleConfig, bundleName) => {
-            let resBatchUrlsMap = resBundleConfig.resBatchUrlsMap;
-            resBatchUrlsMap.forEach((resUrls, resBatch) => {
-                if (!this.resBatchSet.has(resBatch)) {
-                    this.resBatchSet.add(resBatch);
-                }
-            });
-        });
-        this.resBatchInfoMap.clear();
-        this.resBatchSet.forEach((resBatch) => {
-            let resBatchInfo = new ResBatchInfo();
-            let totalResCount = 0;
-            this.resBundleConfig.forEach((resBundleConfig, bundleName) => {
-                let resBatchUrlsMap = resBundleConfig.resBatchUrlsMap;
-                if (resBatchUrlsMap.has(resBatch) && resBatchUrlsMap.get(resBatch) !== null) {
-                    let resUrls = resBatchUrlsMap.get(resBatch);
-                    totalResCount += resUrls.length;
-                    let bundleLoadInfo = new ResLoadInfo();
-                    bundleLoadInfo.totalResCount = resUrls.length;
-                    resBatchInfo.bundleLoadInfo.set(bundleName, bundleLoadInfo);
-                }
-            });
-            this.resBatchInfoMap.set(resBatch, resBatchInfo);
-        });
-    }
-    preloadResBatch(resBatchList, loadInProgressFunc, loadEndFunc) {
-        if (loadInProgressFunc === null || loadEndFunc === null) {
-            return;
-        }
-        this.loadInProgressFunc = loadInProgressFunc;
-        this.loadEndFunc = loadEndFunc;
-        LogUtils.Instance.log(ResMgr.TAG, "preloadResBatch resBatchList = " + resBatchList);
-        let resBatchListToLoad = [];
-        for (let index = 0; index < resBatchList.length; index++) {
-            let resBatch = resBatchList[index];
-            let resBatchInfo = this.resBatchInfoMap.get(resBatch);
-            if (resBatchInfo === null) {
-                LogUtils.Instance.log(ResMgr.TAG, "preloadResBatch [fail] resBatchInfo is null.");
-                return;
-            }
-            if (!resBatchInfo.isBatchLoaded) {
-                resBatchListToLoad.push(resBatch);
-            }
-        }
-        if (resBatchListToLoad.length === 0) {
-            LogUtils.Instance.log(ResMgr.TAG, "preloadResBatch [success] all resBatch already loaded.");
-            this.loadEndFunc();
-            return;
-        }
-        let totalBundleCount = this.resBundleInfoMap.size;
-        let loadedBundleCount = 0;
-        let keys = this.resBundleInfoMap.keys();
-        let resultKey = keys.next();
-        while (resultKey.done === false) {
-            let resBundleInfo = this.resBundleInfoMap.get(resultKey.value);
-            if (resBundleInfo === null) {
-                LogUtils.Instance.log(ResMgr.TAG, "preloadResBatch [fail] resBundleInfo is null.");
-                return;
-            }
-            if (!resBundleInfo.isBundleLoaded) {
-                this._preloadAssetsBundle(resultKey.value, (isSuccess) => {
-                    if (isSuccess) {
-                        loadedBundleCount++;
-                    }
-                    if (loadedBundleCount === totalBundleCount) {
-                        this._preloadAssetInAssetBundle(resBatchListToLoad);
-                    }
-                });
-            }
-            else {
-                loadedBundleCount++;
-                if (loadedBundleCount === totalBundleCount) {
-                    this._preloadAssetInAssetBundle(resBatchListToLoad);
-                }
-            }
-            resultKey = keys.next();
-        }
-    }
-    _preloadAssetsBundle(bundleName, endFunc) {
-        if (endFunc === null) {
-            return;
-        }
-        let resBundleInfo = this.resBundleInfoMap.get(bundleName);
-        if (resBundleInfo === null) {
-            LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetsBundle() : bundleName = " + bundleName + " [fail] resBundleInfo is null.");
-            endFunc(false);
-            return;
-        }
-        if (resBundleInfo.isBundleLoaded) {
-            if (this.abBundsMap.has(bundleName)) {
-                LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetsBundle() : bundleName = " + bundleName + " [success] bundle already loaded.");
-                endFunc(true);
-                return;
-            }
-            else {
-                resBundleInfo.isBundleLoaded = false;
-                this.resBundleInfoMap.set(bundleName, resBundleInfo);
-            }
-        }
-        else {
-            if (this.abBundsMap.has(bundleName)) {
-                this.abBundsMap.delete(bundleName);
-            }
-        }
-        assetManager.loadBundle(bundleName, (err, bundle) => {
-            if (err !== null) {
-                LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetsBundle() : bundleName = " + bundleName + " [fail] load bundle failed." + err);
-                endFunc(false);
-                return;
-            }
-            LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetsBundle() : bundleName = " + bundleName + " [success] load bundle succeed.");
-            this.abBundsMap.set(bundleName, bundle);
-            resBundleInfo.isBundleLoaded = true;
-            this.resBundleInfoMap.set(bundleName, resBundleInfo);
-            endFunc(true);
-        });
-    }
-    _preloadAssetInAssetBundle(resBatchListToLoad) {
-        LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetInAssetBundle() resBatchListToLoad = " + resBatchListToLoad);
-        this.totalResCount = 0;
-        for (let index = 0; index < resBatchListToLoad.length; index++) {
-            let resBatch = resBatchListToLoad[index];
-            let resBatchInfo = this.resBatchInfoMap.get(resBatch);
-            if (resBatchInfo === null) {
-                LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetInAssetBundle() [fail] resBatchInfo is null.");
-                return;
-            }
-            if (resBatchInfo.isBatchLoaded) {
-                continue;
-            }
-            resBatchInfo.bundleLoadInfo.forEach((bundleLoadInfo, bundleName) => {
-                this.totalResCount += bundleLoadInfo.totalResCount;
-            });
-        }
-        LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetInAssetBundle() totalResCount = " + this.totalResCount);
-        this.nowLoadedResCount = 0;
-        for (let index = 0; index < resBatchListToLoad.length; index++) {
-            let resBatch = resBatchListToLoad[index];
-            this.resBundleConfig.forEach((resBundleConfig, bundleName) => {
-                if (resBundleConfig.resBatchUrlsMap.has(resBatch) &&
-                    resBundleConfig.resBatchUrlsMap.get(resBatch) !== null) {
-                    let resBatchInfo = this.resBatchInfoMap.get(resBatch);
-                    let resUrlList = resBundleConfig.resBatchUrlsMap.get(resBatch);
-                    for (let index = 0; index < resUrlList.length; index++) {
-                        let resUrl = resUrlList[index];
-                        if (!this.abBundsMap.has(bundleName) || this.abBundsMap.get(bundleName) === null) {
-                            continue;
-                        }
-                        let adBundle = this.abBundsMap.get(bundleName);
-                        let bundleLoadInfo = resBatchInfo.bundleLoadInfo.get(bundleName);
-                        this._preloadAsset(adBundle, resUrl, resBundleConfig.assetType, (isSuccess, error) => {
-                            if (isSuccess) {
-                                LogUtils.Instance.log(ResMgr.TAG, "_preloadAsset() bundleName = " + bundleName + ", resUrl = " + resUrl + " [success]");
-                                this.nowLoadedResCount++;
-                                bundleLoadInfo.loadedResCount++;
-                                resBatchInfo.bundleLoadInfo.set(bundleName, bundleLoadInfo);
-                            }
-                            else {
-                                LogUtils.Instance.log(ResMgr.TAG, "_preloadAsset() bundleName = " + bundleName + ", resUrl = " + resUrl + ", [fail] " + error);
-                            }
-                            if (this.loadInProgressFunc) {
-                                this.loadInProgressFunc(this.nowLoadedResCount, this.totalResCount);
-                            }
-                            if (this.nowLoadedResCount === this.totalResCount) {
-                                for (let index = 0; index < resBatchListToLoad.length; index++) {
-                                    let _resBatch = resBatchListToLoad[index];
-                                    let _resBatchInfo = this.resBatchInfoMap.get(_resBatch);
-                                    _resBatchInfo.isBatchLoaded = true;
-                                }
-                                this.resBatchInfoMap.set(resBatch, resBatchInfo);
-                                // this._printInfo();
-                                if (this.loadEndFunc) {
-                                    this.loadEndFunc();
-                                }
-                            }
-                        });
-                    }
-                }
-            });
-        }
-    }
-    _preloadAsset(abBundle, resUrl, assetType, endFunc) {
-        if (endFunc === null) {
-            return;
-        }
-        abBundle.load(resUrl, assetType, (error, asset) => {
-            if (error) {
-                endFunc(false, error);
-            }
-            else {
-                endFunc(true);
-            }
-        });
-    }
-    getAsset(bundleName, url, assetType) {
-        let bundle = assetManager.getBundle(bundleName);
-        if (bundle === null) {
-            LogUtils.Instance.log(ResMgr.TAG, "getAsset() error: " + bundleName + " AssetsBundle not loaded");
-            return null;
-        }
-        if (!assetType) {
-            return bundle.get(url);
-        }
-        return bundle.get(url, assetType);
-    }
-    getBundleResCount(bundleName, path, assetType) {
-        let abBundle = this.abBundsMap.get(bundleName);
-        if (abBundle === null) {
-            return 0;
-        }
-        const infos = [];
-        abBundle.getDirWithPath(path, assetType, infos);
-        return infos.length;
-    }
-    loadRes(bundleName, url, assetType, callback) {
-        if (!callback) {
-            return;
-        }
-        if (this.abBundsMap.has(bundleName)) {
-            this._loadRes(bundleName, url, assetType, callback);
-            return;
-        }
-        assetManager.loadBundle(bundleName, (err, bundle) => {
-            if (err !== null) {
-                LogUtils.Instance.log(ResMgr.TAG, "loadAssetsBundle() error:" + bundleName);
-                if (this.abBundsMap.has(bundleName)) {
-                    this.abBundsMap.delete(bundleName);
-                }
-                callback(false);
-                return;
-            }
-            else {
-                LogUtils.Instance.log(ResMgr.TAG, "loadAssetsBundle() success:" + bundleName);
-                this.abBundsMap.set(bundleName, bundle);
-                this._loadRes(bundleName, url, assetType, callback);
-            }
-        });
-    }
-    _loadRes(bundleName, url, assetType, callback) {
-        let abBundle = this.abBundsMap.get(bundleName);
-        if (abBundle === null) {
-            callback(false);
-            return;
-        }
-        abBundle.load(url, assetType, (error, asset) => {
-            if (error) {
-                LogUtils.Instance.log(ResMgr.TAG, "loadRes() " + url + " error: " + error);
-                callback(false);
-            }
-            else {
-                LogUtils.Instance.log(ResMgr.TAG, "loadRes() " + url + " sucess");
-                callback(true);
-            }
-        });
-    }
-    /*
-        imageUrl: "https://xxxx"
-        fileSuffix: ".png"
-    */
-    loadRemoteImage(imageUrl, fileSuffix, callback) {
-        assetManager.loadRemote(imageUrl, { ext: fileSuffix }, (err, data) => {
-            if (err) {
-                LogUtils.Instance.log(ResMgr.TAG, err);
-                callback(err, null);
-            }
-            else {
-                callback(null, data);
-            }
-        });
-    }
-}
-ResMgr.Instance = null;
-ResMgr.TAG = "ResMgr";

package/dist/Framework/Manager/SocialMgr.d.ts

@@ -1,23 +0,0 @@
-import { ShareInfo } from "../Definition/SocialDefinition";
-import { BaseMgr } from "./BaseMgr";
-export declare class SocialMgr extends BaseMgr {
-    static Instance: SocialMgr;
-    static TAG: string;
-    private shareInfo;
-    onLoad(): void;
-    init(shareInfo: ShareInfo): void;
-    supportPassiveShare(): boolean;
-    supportActiveShare(): boolean;
-    configPassiveShare(title?: string, desc?: string, imageUrl?: string, templateId?: string, query?: string): void;
-    activeShareToFriend(callback?: Function, title?: string, desc?: string, imageUrl?: string, templateId?: string, query?: string): void;
-    supportRankList(): boolean;
-    setRankData(args: any[]): void;
-    showRankList(args: any[]): void;
-    openPortalGame(): void;
-    supportGameClub(): boolean;
-    openGameClub(): void;
-    supportRecommendToFriend(): boolean;
-    openRecommendToFriend(): void;
-    supportRecommendToGameClub(): boolean;
-    openRecommendToGameClub(): void;
-}