@chiyou/minigame-framework 1.0.0 → 1.0.2

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

@@ -0,0 +1,420 @@
+import { Asset, assetManager, AssetManager, ImageAsset } from 'cc';
+import { LogUtils } from '../Utils/LogUtils';
+import { BaseMgr } from './BaseMgr';
+
+export type ResBatch = string;
+
+export interface ResBundleConfig {
+    assetType: typeof Asset;
+    resBatchUrlsMap: Map<ResBatch, string[]>;
+}
+
+export class ResBundleInfo {
+    assetType: typeof Asset;
+    isBundleLoaded: boolean;
+
+    constructor(assetType: typeof Asset) {
+        this.assetType = assetType;
+        this.isBundleLoaded = false;
+    }
+}
+
+export class ResLoadInfo {
+    totalResCount: number;
+    loadedResCount: number;
+
+    constructor() {
+        this.totalResCount = 0;
+        this.loadedResCount = 0;
+    }
+}
+
+export class ResBatchInfo {
+    isBatchLoaded: boolean;
+    bundleLoadInfo: Map<string, ResLoadInfo> = null; 
+
+    constructor() {
+        this.isBatchLoaded = false;
+        this.bundleLoadInfo = new Map<string, ResLoadInfo>();
+    }
+}
+
+export class ResMgr extends BaseMgr {
+    
+    public static Instance: ResMgr = null;
+    static TAG: string = "ResMgr";
+
+    private resBundleConfig: Map<string, ResBundleConfig> = new Map<string, ResBundleConfig>();
+    private resBatchSet: Set<ResBatch> = new Set<ResBatch>();
+
+    private resBundleInfoMap: Map<string, ResBundleInfo> = new Map<string, ResBundleInfo>();
+    private resBatchInfoMap: Map<ResBatch, ResBatchInfo> = new Map<ResBatch, ResBatchInfo>();
+
+    private abBundsMap: Map<string, AssetManager.Bundle> = new Map<string, AssetManager.Bundle>();
+
+    private loadInProgressFunc: (loadedResCount: number, totalResCount: number) => void;
+    private loadEndFunc: () => void;
+
+    private totalResCount: number = 0;
+    private nowLoadedResCount: number = 0;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (ResMgr.Instance === null) {
+            ResMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(resBundleConfig: Map<string, ResBundleConfig>): void {
+        this.resBundleConfig = resBundleConfig;
+
+        this._initResBundleInfo();
+        this._initResBatchInfo();
+
+        // this._printInfo();
+
+        LogUtils.Instance.log(ResMgr.TAG, "init() finished.");
+    }
+
+    private _printInfo(): void {
+        LogUtils.Instance.log("", "resBundleInfoMap", this.resBundleInfoMap);
+        LogUtils.Instance.log("", "resBatchInfoMap", this.resBatchInfoMap);
+    }
+
+    private _initResBundleInfo(): void {
+        this.resBundleInfoMap.clear();
+        this.resBundleConfig.forEach((resBundleConfig: ResBundleConfig, bundleName: string) => {
+            let assetType: typeof Asset = resBundleConfig.assetType;
+            let resBundleInfo: ResBundleInfo = new ResBundleInfo(assetType);
+            this.resBundleInfoMap.set(bundleName, resBundleInfo);
+        });
+    }
+
+    private _initResBatchInfo(): void {
+        this.resBatchSet.clear();
+        this.resBundleConfig.forEach((resBundleConfig: ResBundleConfig, bundleName: string) => {
+            let resBatchUrlsMap: Map<ResBatch, string[]> = resBundleConfig.resBatchUrlsMap;
+            resBatchUrlsMap.forEach((resUrls: string[], resBatch: ResBatch) => {
+                if (!this.resBatchSet.has(resBatch)) {
+                    this.resBatchSet.add(resBatch);
+                }
+            });
+        });
+
+        this.resBatchInfoMap.clear();
+        this.resBatchSet.forEach((resBatch: ResBatch) => {
+            let resBatchInfo = new ResBatchInfo();
+
+            let totalResCount: number = 0;
+
+            this.resBundleConfig.forEach((resBundleConfig: ResBundleConfig, bundleName: string) => {
+                let resBatchUrlsMap: Map<ResBatch, string[]> = resBundleConfig.resBatchUrlsMap;
+                if (resBatchUrlsMap.has(resBatch) && resBatchUrlsMap.get(resBatch) !== null) {
+                    let resUrls: string[] = resBatchUrlsMap.get(resBatch);
+
+                    totalResCount += resUrls.length;
+
+                    let bundleLoadInfo: ResLoadInfo = new ResLoadInfo();
+                    bundleLoadInfo.totalResCount = resUrls.length;
+                    resBatchInfo.bundleLoadInfo.set(bundleName, bundleLoadInfo); 
+                }
+            });
+
+            this.resBatchInfoMap.set(resBatch, resBatchInfo);
+        });
+    }
+
+    public preloadResBatch(resBatchList: ResBatch[],
+        loadInProgressFunc: (loadedResCount: number, totalResCount: number) => void,
+        loadEndFunc: () => void): void {
+        if (loadInProgressFunc === null || loadEndFunc === null) {
+            return;
+        }
+
+        this.loadInProgressFunc = loadInProgressFunc;
+        this.loadEndFunc = loadEndFunc;
+
+        LogUtils.Instance.log(ResMgr.TAG, "preloadResBatch resBatchList = " + resBatchList);
+
+        let resBatchListToLoad: ResBatch[] = [];
+        for (let index: number = 0; index < resBatchList.length; index++) {
+            let resBatch: ResBatch = resBatchList[index];
+
+            let resBatchInfo: 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: number = this.resBundleInfoMap.size;
+        let loadedBundleCount: number = 0;
+
+        let keys: IterableIterator<string> = this.resBundleInfoMap.keys();
+        let resultKey: IteratorResult<string> = keys.next();
+        while (resultKey.done === false) {
+            let resBundleInfo: 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: boolean) => {
+                    if (isSuccess) {
+                        loadedBundleCount++;
+                    }
+
+                    if (loadedBundleCount === totalBundleCount) {
+                        this._preloadAssetInAssetBundle(resBatchListToLoad);
+                    }
+                });
+            } else {
+                loadedBundleCount++;
+
+                if (loadedBundleCount === totalBundleCount) {
+                    this._preloadAssetInAssetBundle(resBatchListToLoad);
+                }
+            }
+            resultKey = keys.next();
+        }
+    }
+
+    private _preloadAssetsBundle(bundleName: string, endFunc: (isSuccess: boolean) => void): void {
+        if (endFunc === null) {
+            return;
+        }
+
+        let resBundleInfo: 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: Error, bundle: AssetManager.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);
+        });
+    }
+
+    private _preloadAssetInAssetBundle(resBatchListToLoad: ResBatch[]): void {
+        LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetInAssetBundle() resBatchListToLoad = " + resBatchListToLoad);
+
+        this.totalResCount = 0;
+        for (let index: number = 0; index < resBatchListToLoad.length; index++) {
+            let resBatch: ResBatch = resBatchListToLoad[index];
+
+            let resBatchInfo: 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: ResLoadInfo, bundleName: string) => {
+                this.totalResCount += bundleLoadInfo.totalResCount;
+            });
+        }
+        LogUtils.Instance.log(ResMgr.TAG, "_preloadAssetInAssetBundle() totalResCount = " + this.totalResCount);
+
+        this.nowLoadedResCount = 0;
+        for (let index: number = 0; index < resBatchListToLoad.length; index++) {
+            let resBatch: ResBatch = resBatchListToLoad[index];
+
+            this.resBundleConfig.forEach((resBundleConfig: ResBundleConfig, bundleName: string) => {
+                if (resBundleConfig.resBatchUrlsMap.has(resBatch) &&
+                    resBundleConfig.resBatchUrlsMap.get(resBatch) !== null) {
+
+                    let resBatchInfo: ResBatchInfo = this.resBatchInfoMap.get(resBatch);
+
+                    let resUrlList: string[] = resBundleConfig.resBatchUrlsMap.get(resBatch);
+                    for (let index: number = 0; index < resUrlList.length; index++) {
+                        let resUrl: string = resUrlList[index];
+
+                        if (!this.abBundsMap.has(bundleName) || this.abBundsMap.get(bundleName) === null) {
+                            continue;
+                        }
+                        let adBundle: AssetManager.Bundle = this.abBundsMap.get(bundleName);
+                        let bundleLoadInfo: ResLoadInfo = resBatchInfo.bundleLoadInfo.get(bundleName);
+
+                        this._preloadAsset(adBundle, resUrl, resBundleConfig.assetType, (isSuccess: boolean, error?: 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: number = 0; index < resBatchListToLoad.length; index++) {
+                                    let _resBatch: ResBatch = resBatchListToLoad[index];
+                                    let _resBatchInfo: ResBatchInfo = this.resBatchInfoMap.get(_resBatch);
+                                    _resBatchInfo.isBatchLoaded = true;
+                                }
+                                this.resBatchInfoMap.set(resBatch, resBatchInfo);
+
+                                // this._printInfo();
+
+                                if (this.loadEndFunc) {
+                                    this.loadEndFunc();
+                                }
+                            }
+                        });
+                    }
+                }
+            });
+        }
+    }
+
+    private _preloadAsset(abBundle: AssetManager.Bundle, resUrl: string, assetType: typeof Asset, endFunc: (isSuccess: boolean, error?: Error) => void): void {
+        if (endFunc === null) {
+            return;
+        }
+
+        abBundle.load(resUrl, assetType, (error: Error | null, asset: Asset) => {
+            if (error) {
+                endFunc(false, error);
+            } else {
+                endFunc(true);
+            }
+        });
+    }
+
+    public getAsset<T extends Asset>(bundleName: string, url: string, assetType?: typeof Asset): T | null {
+        let bundle: AssetManager.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) as T;
+    }
+
+    public getBundleResCount(bundleName: string, path: string, assetType: typeof Asset): number {
+        let abBundle: AssetManager.Bundle = this.abBundsMap.get(bundleName);
+        if (abBundle === null) {
+            return 0;
+        }
+    
+        const infos = [];
+        
+        abBundle.getDirWithPath(path, assetType, infos);
+    
+        return infos.length;
+    }
+
+    public loadRes(bundleName: string, url: string, assetType: typeof Asset, callback: Function): void {
+        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);
+            }
+        });
+    }
+
+    private _loadRes(bundleName: string, url: string, assetType: typeof Asset, callback: Function): void {
+        let abBundle: AssetManager.Bundle = this.abBundsMap.get(bundleName);
+        if (abBundle === null) {
+            callback(false);
+            return;
+        }
+
+        abBundle.load(url, assetType, (error: Error | null, asset: 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"
+    */
+    public loadRemoteImage(imageUrl: string, fileSuffix: string, callback: Function): void {
+        assetManager.loadRemote<ImageAsset>(imageUrl, {ext: fileSuffix}, (err: Error, data: ImageAsset) => {
+            if (err) {
+                LogUtils.Instance.log(ResMgr.TAG, err);
+                callback(err, null);
+            } else {
+                callback(null, data);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "e561ed75-43ae-433c-a050-91b01848acbb",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,250 @@
+import { ShareInfo, ShareTemplateInfo } from "../Definition/SocialDefinition";
+import { PlatformID } from "../Definition/SystemDefinition";
+import { LogUtils } from "../Utils/LogUtils";
+import { BaseMgr } from "./BaseMgr";
+
+export class SocialMgr extends BaseMgr {
+    public static Instance: SocialMgr = null;
+    static TAG: string = "SocialMgr";
+
+    private shareInfo: ShareInfo = null;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (SocialMgr.Instance === null) {
+            SocialMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }   
+    }
+
+    public init(shareInfo: ShareInfo): void {
+        this.shareInfo = shareInfo;
+
+        LogUtils.Instance.log(SocialMgr.TAG, "init() finished.");
+    }
+
+    public supportPassiveShare(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+            case PlatformID.ID_MiniGame_KuaiShou:
+            case PlatformID.ID_MiniGame_ZhiFuBao:
+            case PlatformID.ID_MiniGame_TapTap:
+            case PlatformID.ID_MiniGame_Bilibili:
+            case PlatformID.ID_MiniGame_JingDong:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public supportActiveShare(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+            case PlatformID.ID_MiniGame_KuaiShou:
+            case PlatformID.ID_MiniGame_TapTap:
+            case PlatformID.ID_MiniGame_Bilibili:
+            case PlatformID.ID_MiniGame_JingDong:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public configPassiveShare(title?: string, desc?: string, imageUrl?: string, templateId?: string, query?: string): void {
+        if (!desc || desc.length === 0) {
+            desc = this.shareInfo.defaultInfo.desc;
+        }
+        if (!title || title.length === 0) {
+            title = this.shareInfo.defaultInfo.title;
+        }
+        if (this.getCurrentPlatformID() === PlatformID.ID_MiniGame_WeiXin) {
+            title = desc;
+        }
+
+        if (!templateId || templateId.length === 0) {
+            let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+            if (this.shareInfo.templateInfoMap.has(currentPlatformID)) {
+                let templateInfo: ShareTemplateInfo = this.shareInfo.templateInfoMap.get(currentPlatformID);
+                if (templateInfo.templateId !== "") {
+                    templateId = templateInfo.templateId;
+
+                    if (this.getCurrentPlatformID() === PlatformID.ID_MiniGame_DouYin) {
+                        title = "";
+                        desc = "";
+                    }
+                }
+                if (templateInfo.imageUrl !== "") {
+                    imageUrl = templateInfo.imageUrl;
+                }
+            }
+        }
+
+        if (!imageUrl || imageUrl.length === 0) {
+            imageUrl = this.shareInfo.defaultInfo.imageUrl;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().configPassiveShare(title, desc, imageUrl, templateId, query);
+    }
+
+    public activeShareToFriend(callback?: Function, title?: string, desc?: string, imageUrl?: string, templateId?: string, query?: string): void {
+        if (!desc || desc.length === 0) {
+            desc = this.shareInfo.defaultInfo.desc;
+        }
+        if (!title || title.length === 0) {
+            title = this.shareInfo.defaultInfo.title;
+        }
+        if (this.getCurrentPlatformID() === PlatformID.ID_MiniGame_WeiXin) {
+            title = desc;
+        }
+
+        if (!templateId || templateId.length === 0) {
+            let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+            if (this.shareInfo.templateInfoMap.has(currentPlatformID)) {
+                let templateInfo: ShareTemplateInfo = this.shareInfo.templateInfoMap.get(currentPlatformID);
+                if (templateInfo.templateId !== "") {
+                    templateId = templateInfo.templateId;
+                }
+                if (templateInfo.imageUrl !== "") {
+                    imageUrl = templateInfo.imageUrl;
+                }
+            }
+        }
+
+        if (!imageUrl || imageUrl.length === 0) {
+            imageUrl = this.shareInfo.defaultInfo.imageUrl;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().activeShareToFriend(callback, title, desc, imageUrl, templateId, query);
+    }
+
+    public supportRankList(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+            case PlatformID.ID_MiniGame_TapTap:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public setRankData(args: any[]): void {
+        if (!this.supportRankList()) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().setRankData(args);
+    }
+
+    public showRankList(args: any[]): void {
+        if (!this.supportRankList()) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().showRankList(args);
+    }
+
+    public openPortalGame(): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().openPortalGame();
+    }
+
+    public supportGameClub(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public openGameClub(): void {
+        if (!this.supportGameClub()) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().openGameClub();
+    }
+
+    public supportRecommendToFriend(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+            case PlatformID.ID_MiniGame_KuaiShou:
+            case PlatformID.ID_MiniGame_TapTap:
+            case PlatformID.ID_MiniGame_Bilibili:
+            case PlatformID.ID_MiniGame_JingDong:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public openRecommendToFriend(): void {
+        if (!this.supportRecommendToFriend()) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+            case PlatformID.ID_MiniGame_DouYin:
+                this.getPlatformAdapter().openRecommendToFriend();
+                break;
+            case PlatformID.ID_MiniGame_KuaiShou:
+            case PlatformID.ID_MiniGame_Bilibili:
+            case PlatformID.ID_MiniGame_TapTap:
+            case PlatformID.ID_MiniGame_JingDong:
+                this.activeShareToFriend();
+                break;
+            default:
+                break;
+        }
+    }
+
+    public supportRecommendToGameClub(): boolean {
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public openRecommendToGameClub(): void {
+        if (!this.supportRecommendToGameClub()) {
+            return;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+        this.getPlatformAdapter().openRecommendToGameClub();
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "d891fb7e-29f5-4460-9fe4-f98ab00fd037",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}