@chiyou/minigame-framework 1.0.0

package/dist/Framework/Manager/PrivacyMgr.js

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,337 @@
+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

@@ -0,0 +1,23 @@
+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;
+}