@chiyou/minigame-framework 1.0.0

package/dist/Framework/Manager/AdMgr.js

@@ -0,0 +1,684 @@
+import { math, randomRangeInt, view } from 'cc';
+import { LogUtils } from '../Utils/LogUtils';
+import { AudioMgr } from './AudioMgr';
+import { AdCallback, Ad_Record, InterstitialAd_Callback_Status, InterstitialAd_Record, RewardedVideoAd_Callback_Status, RewardedVideoAd_Record, AdSwitchType, AdType, AdDefinition } from '../Definition/AdDefinition';
+import { PlatformID } from '../Definition/SystemDefinition';
+import { UserMgr } from './UserMgr';
+import { BaseMgr } from './BaseMgr';
+import { AdAdapterWeiXin } from '../Adapter/AdAdapter/AdAdapterWeiXin';
+import { AdAdapterBilibili } from '../Adapter/AdAdapter/AdAdapterBilibili';
+import { AdAdapterDouYin } from '../Adapter/AdAdapter/AdAdapterDouYin';
+import { AdAdapterHonor } from '../Adapter/AdAdapter/AdAdapterHonor';
+import { AdAdapterHuaWei } from '../Adapter/AdAdapter/AdAdapterHuaWei';
+import { AdAdapterJingDong } from '../Adapter/AdAdapter/AdAdapterJingDong';
+import { AdAdapterKuaiShou } from '../Adapter/AdAdapter/AdAdapterKuaiShou';
+import { AdAdapterOppo } from '../Adapter/AdAdapter/AdAdapterOppo';
+import { AdAdapterTapTap } from '../Adapter/AdAdapter/AdAdapterTapTap';
+import { AdAdapterVivo } from '../Adapter/AdAdapter/AdAdapterVivo';
+import { AdAdapterXiaoMi } from '../Adapter/AdAdapter/AdAdapterXiaoMi';
+import { AdAdapterZhiFuBao } from '../Adapter/AdAdapter/AdAdapterZhiFuBao';
+export class AdMgr extends BaseMgr {
+    onLoad() {
+        if (AdMgr.Instance === null) {
+            AdMgr.Instance = this;
+        }
+        else {
+            this.destroy();
+            return;
+        }
+    }
+    init(contentHeight, adPlatformUnitMap, adPlatformSettingMap) {
+        let currentPlatformID = this.getCurrentPlatformID();
+        if (adPlatformUnitMap === null ||
+            adPlatformUnitMap.get(currentPlatformID) === null) {
+            return 0;
+        }
+        if (adPlatformSettingMap === null ||
+            adPlatformSettingMap.get(currentPlatformID) === null) {
+            return 0;
+        }
+        if (this.getPlatformAdapter() === null) {
+            return 0;
+        }
+        AdMgr.adPlatformUnitMap = adPlatformUnitMap;
+        AdMgr.adPlatformSettingMap = adPlatformSettingMap;
+        let adAdapterImpl = null;
+        switch (BaseMgr.Instance.getCurrentPlatformID()) {
+            case PlatformID.ID_MiniGame_WeiXin:
+                adAdapterImpl = this.node.addComponent(AdAdapterWeiXin);
+                break;
+            case PlatformID.ID_MiniGame_DouYin:
+                adAdapterImpl = this.node.addComponent(AdAdapterDouYin);
+                break;
+            case PlatformID.ID_MiniGame_KuaiShou:
+                adAdapterImpl = this.node.addComponent(AdAdapterKuaiShou);
+                break;
+            case PlatformID.ID_MiniGame_ZhiFuBao:
+                adAdapterImpl = this.node.addComponent(AdAdapterZhiFuBao);
+                break;
+            case PlatformID.ID_MiniGame_Bilibili:
+                adAdapterImpl = this.node.addComponent(AdAdapterBilibili);
+                break;
+            case PlatformID.ID_MiniGame_TapTap:
+                adAdapterImpl = this.node.addComponent(AdAdapterTapTap);
+                break;
+            case PlatformID.ID_MiniGame_JingDong:
+                adAdapterImpl = this.node.addComponent(AdAdapterJingDong);
+                break;
+            case PlatformID.ID_QuickGame_XiaoMi:
+                adAdapterImpl = this.node.addComponent(AdAdapterXiaoMi);
+                break;
+            case PlatformID.ID_QuickGame_Oppo:
+                adAdapterImpl = this.node.addComponent(AdAdapterOppo);
+                break;
+            case PlatformID.ID_QuickGame_Honor:
+                adAdapterImpl = this.node.addComponent(AdAdapterHonor);
+                break;
+            case PlatformID.ID_QuickGame_Vivo:
+                adAdapterImpl = this.node.addComponent(AdAdapterVivo);
+                break;
+            case PlatformID.ID_QuickGame_HuaWei:
+                adAdapterImpl = this.node.addComponent(AdAdapterHuaWei);
+                break;
+            default:
+                break;
+        }
+        if (adAdapterImpl !== null) {
+            BaseMgr.Instance.setAdAdapter(adAdapterImpl);
+        }
+        AdMgr.launchTime = new Date().getTime();
+        AdMgr.lastInterstitialAdTimestamp = 0;
+        AdMgr.interstitialAd_nowIntervalCount = 1;
+        if (this.getAdAdapter() === null) {
+            return 0;
+        }
+        if (!this.adSwithOn()) {
+            return 0;
+        }
+        this.clearAdRecord();
+        AdMgr.nowRunningBannerAd = "";
+        AdMgr.nowRunningCustomAd = "";
+        AdMgr.isPermanentAdShowing = false;
+        AdMgr.nowInterstitialAdScene = "InterstitialAd_Scene.Scene_Invalid";
+        AdMgr.adRecord.intersitialAdRecord.set(AdMgr.nowInterstitialAdScene, new InterstitialAd_Record());
+        AdMgr.interstitialAds = new Map();
+        AdMgr.interstitialAdCallback = function (res) {
+            LogUtils.Instance.log(AdMgr.TAG, "interstitialAdCallback");
+            LogUtils.Instance.log("", "scene=" + AdMgr.nowInterstitialAdScene + ",res=" + InterstitialAd_Callback_Status[res]);
+            if (res === InterstitialAd_Callback_Status.Status_Watching) {
+                AdMgr.Instance.hideAllPermanentAd();
+            }
+            else if (res === InterstitialAd_Callback_Status.Status_Close ||
+                res === InterstitialAd_Callback_Status.Status_Error) {
+                AdMgr.Instance.showAllPermanentAd();
+            }
+            if (res === InterstitialAd_Callback_Status.Status_Close) {
+                AdMgr.lastInterstitialAdTimestamp = new Date().getTime();
+                AdMgr.interstitialAd_nowIntervalCount = 1;
+            }
+            if (AdMgr.adRecord.intersitialAdRecord !== null &&
+                AdMgr.adRecord.intersitialAdRecord.has(AdMgr.nowInterstitialAdScene) &&
+                AdMgr.adRecord.intersitialAdRecord.get(AdMgr.nowInterstitialAdScene) !== null) {
+                let record = AdMgr.adRecord.intersitialAdRecord.get(AdMgr.nowInterstitialAdScene);
+                if (res === InterstitialAd_Callback_Status.Status_Watching) {
+                    record.viewCount++;
+                }
+                else if (res === InterstitialAd_Callback_Status.Status_Error) {
+                    record.errorCount++;
+                }
+                else if (res === InterstitialAd_Callback_Status.Status_Close) {
+                    record.completeCount++;
+                }
+                AdMgr.adRecord.intersitialAdRecord.set(AdMgr.nowInterstitialAdScene, record);
+            }
+            if (AdMgr.interstitialAds !== null &&
+                AdMgr.interstitialAds.has(AdMgr.nowInterstitialAdScene) &&
+                AdMgr.interstitialAds.get(AdMgr.nowInterstitialAdScene) !== null) {
+                let adCallback = AdMgr.interstitialAds.get(AdMgr.nowInterstitialAdScene);
+                if (adCallback.callback && adCallback.target) {
+                    adCallback.callback.apply(adCallback.target, [res]);
+                }
+            }
+            if (res !== InterstitialAd_Callback_Status.Status_Watching) {
+                AdMgr.nowInterstitialAdScene = "InterstitialAd_Scene.Scene_Invalid";
+            }
+        };
+        AdMgr.nowRewardedVideoAdScene = "RewardedVideoAd_Scene.Scene_Invalid";
+        AdMgr.adRecord.rewardedVideoAdRecord.set(AdMgr.nowRewardedVideoAdScene, new RewardedVideoAd_Record());
+        AdMgr.rewardedVideoAds = new Map();
+        AdMgr.rewardedVideoAdCallback = function (res) {
+            LogUtils.Instance.log(AdMgr.TAG, "rewardedVideoAdCallback");
+            LogUtils.Instance.log("", "scene=" + AdMgr.nowRewardedVideoAdScene + ",res=" + RewardedVideoAd_Callback_Status[res]);
+            if (res === RewardedVideoAd_Callback_Status.Status_Watching) {
+                AudioMgr.Instance.pauseMusic();
+                AdMgr.Instance.hideAllPermanentAd();
+            }
+            else if (res === RewardedVideoAd_Callback_Status.Status_Complete ||
+                res === RewardedVideoAd_Callback_Status.Status_Giveup ||
+                res === RewardedVideoAd_Callback_Status.Status_Error) {
+                AudioMgr.Instance.resumeMusic();
+                AdMgr.Instance.showAllPermanentAd();
+            }
+            if (res === RewardedVideoAd_Callback_Status.Status_Complete) {
+                AdMgr.interstitialAd_nowIntervalCount++;
+            }
+            if (AdMgr.adRecord.rewardedVideoAdRecord !== null &&
+                AdMgr.adRecord.rewardedVideoAdRecord.has(AdMgr.nowRewardedVideoAdScene) &&
+                AdMgr.adRecord.rewardedVideoAdRecord.get(AdMgr.nowRewardedVideoAdScene) !== null) {
+                let record = AdMgr.adRecord.rewardedVideoAdRecord.get(AdMgr.nowRewardedVideoAdScene);
+                if (res === RewardedVideoAd_Callback_Status.Status_Watching) {
+                    record.viewCount++;
+                }
+                else if (res === RewardedVideoAd_Callback_Status.Status_Complete) {
+                    record.completeCount++;
+                }
+                else if (res === RewardedVideoAd_Callback_Status.Status_Giveup) {
+                    record.giveupCount++;
+                }
+                else if (res === RewardedVideoAd_Callback_Status.Status_Error) {
+                    record.errorCount++;
+                }
+                AdMgr.adRecord.rewardedVideoAdRecord.set(AdMgr.nowRewardedVideoAdScene, record);
+            }
+            if (AdMgr.rewardedVideoAds !== null &&
+                AdMgr.rewardedVideoAds.has(AdMgr.nowRewardedVideoAdScene) &&
+                AdMgr.rewardedVideoAds.get(AdMgr.nowRewardedVideoAdScene) !== null) {
+                let adCallback = AdMgr.rewardedVideoAds.get(AdMgr.nowRewardedVideoAdScene);
+                if (adCallback.callback && adCallback.target) {
+                    adCallback.callback.apply(adCallback.target, [res]);
+                }
+            }
+            if (res !== RewardedVideoAd_Callback_Status.Status_Watching) {
+                AdMgr.nowRewardedVideoAdScene = "RewardedVideoAd_Scene.Scene_Invalid";
+            }
+        };
+        this.getAdAdapter().onInit(this.getPlatformAdapter().getScreenInfo(), this, AdMgr.adPlatformUnitMap.get(currentPlatformID).intersitialAd, AdMgr.interstitialAdCallback, AdMgr.adPlatformUnitMap.get(currentPlatformID).rewardedVideoAd, AdMgr.rewardedVideoAdCallback);
+        LogUtils.Instance.log(AdMgr.TAG, "init() finished.");
+        return this.adjustSuitableUIConfig(contentHeight);
+    }
+    createAds() {
+        this.createInterstitialAd();
+        this.createRewardedVideoAd();
+        this.createPortalAd();
+        this.createAllPermanentAd();
+    }
+    isPermanentAdShowing() {
+        return AdMgr.isPermanentAdShowing;
+    }
+    adSwithOn() {
+        let currentPlatformID = this.getCurrentPlatformID();
+        if (!AdMgr.adPlatformUnitMap.has(currentPlatformID) ||
+            AdMgr.adPlatformUnitMap.get(currentPlatformID) === null ||
+            AdMgr.adPlatformUnitMap.get(currentPlatformID).switchType === AdSwitchType.Off) {
+            return false;
+        }
+        return true;
+    }
+    supportAdType(adType) {
+        if (!this.adSwithOn()) {
+            return false;
+        }
+        let adPlatformUnitInfo = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID());
+        if (adPlatformUnitInfo === null) {
+            return false;
+        }
+        switch (adType) {
+            case AdType.Type_Banner:
+                let bannerAd = adPlatformUnitInfo.bannerAd;
+                if (bannerAd !== null && bannerAd.length > 0) {
+                    return true;
+                }
+                return false;
+            case AdType.Type_Custom:
+                let customAd = adPlatformUnitInfo.customAd;
+                if (customAd !== null && customAd.length > 0) {
+                    return true;
+                }
+                return false;
+            case AdType.Type_Interstitial:
+                let intersitialAd = adPlatformUnitInfo.intersitialAd;
+                if (intersitialAd !== null && intersitialAd.length > 0) {
+                    return true;
+                }
+                return false;
+            case AdType.Type_RewardedVideo:
+                let rewardedVideoAd = adPlatformUnitInfo.rewardedVideoAd;
+                if (rewardedVideoAd !== null && rewardedVideoAd.length > 0) {
+                    return true;
+                }
+                return false;
+            case AdType.Type_Portal:
+                let portalAd = adPlatformUnitInfo.portalAd;
+                if (portalAd !== null && portalAd.length > 0) {
+                    return true;
+                }
+            default:
+                return false;
+        }
+    }
+    createBannerAd() {
+        AdMgr.nowRunningBannerAd = "";
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let bannerAd_Info = AdDefinition.AdInfoConfig.BannerAd_Info;
+        if (bannerAd_Info === null || !bannerAd_Info.shouldShow) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).bannerAd;
+        let result = this.getAdAdapter().createBannerAd(adUnitId);
+        if (result) {
+            AdMgr.nowRunningBannerAd = adUnitId;
+        }
+    }
+    destroyBannerAd() {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).bannerAd;
+        this.getAdAdapter().destroyBannerAd(adUnitId);
+        AdMgr.nowRunningBannerAd = "";
+    }
+    showBannerAd() {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        if (AdMgr.nowRunningBannerAd !== "") {
+            this.getAdAdapter().showBannerAd(AdMgr.nowRunningBannerAd);
+        }
+    }
+    hideBannerAd() {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        if (AdMgr.nowRunningBannerAd !== "") {
+            this.getAdAdapter().hideBannerAd(AdMgr.nowRunningBannerAd);
+        }
+    }
+    createInterstitialAd() {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().createInterstitialAd();
+    }
+    showInterstitialAd(scene, callback, target) {
+        if (AdMgr.Instance.isIntersititialAdShowing()) {
+            return;
+        }
+        if (scene === "" || scene === "InterstitialAd_Scene.Scene_Invalid") {
+            return;
+        }
+        AdMgr.nowInterstitialAdScene = scene;
+        if (!AdMgr.adRecord.intersitialAdRecord.has(AdMgr.nowInterstitialAdScene) ||
+            AdMgr.adRecord.intersitialAdRecord.get(AdMgr.nowInterstitialAdScene) === null) {
+            AdMgr.adRecord.intersitialAdRecord.set(AdMgr.nowInterstitialAdScene, new InterstitialAd_Record());
+        }
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            AdMgr.interstitialAdCallback(InterstitialAd_Callback_Status.Status_NotSupport);
+            return;
+        }
+        let launchNoAdInterval = 0;
+        let interstitialAdIntervalBase = 60000;
+        if (AdMgr.adPlatformSettingMap.has(this.getCurrentPlatformID())) {
+            let adPlatformSettingInfo = AdMgr.adPlatformSettingMap.get(this.getCurrentPlatformID());
+            launchNoAdInterval = adPlatformSettingInfo.launchNoAdInterval_interstitialAd;
+            interstitialAdIntervalBase = adPlatformSettingInfo.registerUser_interstitialAd_IntervalBase;
+            if (UserMgr.Instance.isNewUser()) {
+                interstitialAdIntervalBase = adPlatformSettingInfo.registerUser_interstitialAd_IntervalBase;
+            }
+        }
+        let interstitialAdInterval = interstitialAdIntervalBase * AdMgr.interstitialAd_nowIntervalCount;
+        let now = new Date().getTime();
+        if (now - AdMgr.launchTime < launchNoAdInterval) {
+            AdMgr.interstitialAdCallback(InterstitialAd_Callback_Status.Status_InsufficientInterval);
+            return;
+        }
+        if (now - AdMgr.lastInterstitialAdTimestamp < interstitialAdInterval) {
+            AdMgr.interstitialAdCallback(InterstitialAd_Callback_Status.Status_InsufficientInterval);
+            return;
+        }
+        if (!AdMgr.interstitialAds.has(scene) ||
+            (AdMgr.interstitialAds.get(scene).callback !== callback && AdMgr.interstitialAds.get(scene).target !== target)) {
+            AdMgr.interstitialAds.set(scene, new AdCallback(callback, target));
+        }
+        this.getAdAdapter().showInterstitialAd();
+    }
+    destroyInterstitialAd() {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().destroyInterstitialAd();
+    }
+    isIntersititialAdShowing() {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return false;
+        }
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isIntersititialAdShowing();
+    }
+    createRewardedVideoAd() {
+        if (!this.supportAdType(AdType.Type_RewardedVideo)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().createRewardedVideoAd();
+    }
+    showRewardedVideoAd(scene, callback, target) {
+        if (AdMgr.Instance.isRewardedVideoAdShowing()) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        if (scene === "" || scene === "RewardedVideoAd_Scene.Scene_Invalid") {
+            return;
+        }
+        AdMgr.nowRewardedVideoAdScene = scene;
+        if (!this.supportAdType(AdType.Type_RewardedVideo)) {
+            AdMgr.rewardedVideoAdCallback(RewardedVideoAd_Callback_Status.Status_NotSupport);
+            return;
+        }
+        if (!AdMgr.adRecord.rewardedVideoAdRecord.has(AdMgr.nowRewardedVideoAdScene) ||
+            AdMgr.adRecord.rewardedVideoAdRecord.get(AdMgr.nowRewardedVideoAdScene) === null) {
+            AdMgr.adRecord.rewardedVideoAdRecord.set(AdMgr.nowRewardedVideoAdScene, new RewardedVideoAd_Record());
+        }
+        let record = AdMgr.adRecord.rewardedVideoAdRecord.get(AdMgr.nowRewardedVideoAdScene);
+        record.clickCount++;
+        AdMgr.adRecord.rewardedVideoAdRecord.set(AdMgr.nowRewardedVideoAdScene, record);
+        if (!AdMgr.rewardedVideoAds.has(scene) ||
+            (AdMgr.rewardedVideoAds.get(scene).callback !== callback && AdMgr.rewardedVideoAds.get(scene).target !== target)) {
+            AdMgr.rewardedVideoAds.set(scene, new AdCallback(callback, target));
+        }
+        let adPlatformUnitInfo = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID());
+        if (adPlatformUnitInfo.switchType === AdSwitchType.On_Debug) {
+            let ranNumber = randomRangeInt(0, 100);
+            if (ranNumber <= 33) {
+                AdMgr.rewardedVideoAdCallback(RewardedVideoAd_Callback_Status.Status_Error);
+            }
+            else if (33 < ranNumber && ranNumber <= 66) {
+                AdMgr.rewardedVideoAdCallback(RewardedVideoAd_Callback_Status.Status_Giveup);
+            }
+            else {
+                AdMgr.rewardedVideoAdCallback(RewardedVideoAd_Callback_Status.Status_Complete);
+            }
+        }
+        else {
+            this.getAdAdapter().showRewardedVideoAd();
+        }
+    }
+    destroyRewardedVideoAd() {
+        if (!this.supportAdType(AdType.Type_RewardedVideo)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().destroyRewardedVideoAd();
+    }
+    isRewardedVideoAdShowing() {
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isRewardedVideoAdShowing();
+    }
+    isRewardedVideoAdLoaded() {
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isRewardedVideoAdLoaded();
+    }
+    createCustomAd() {
+        AdMgr.nowRunningCustomAd = "";
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let customAd_Info = AdDefinition.AdInfoConfig.CustomAd_Info;
+        if (customAd_Info === null || !customAd_Info.shouldShow) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).customAd;
+        let result = this.getAdAdapter().createCustomAd(adUnitId);
+        if (result) {
+            AdMgr.nowRunningCustomAd = adUnitId;
+        }
+    }
+    destroyCustomAd() {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).customAd;
+        this.getAdAdapter().destroyCustomAd(adUnitId);
+        AdMgr.nowRunningCustomAd = "";
+    }
+    showCustomAd() {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        if (AdMgr.nowRunningCustomAd !== "") {
+            this.getAdAdapter().showCustomAd(AdMgr.nowRunningCustomAd);
+        }
+    }
+    hideCustomAd() {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        if (AdMgr.nowRunningCustomAd !== "") {
+            this.getAdAdapter().hideCustomAd(AdMgr.nowRunningCustomAd);
+        }
+    }
+    createPortalAd() {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().createPortalAd(adUnitId);
+    }
+    destoryPortalAd() {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().destroyPortalAd(adUnitId);
+    }
+    showPortalAd() {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().showPortalAd(adUnitId);
+    }
+    hidePortalAd() {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        let adUnitId = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().hidePortalAd(adUnitId);
+    }
+    createAllPermanentAd() {
+        this.createBannerAd();
+        this.createCustomAd();
+    }
+    showAllPermanentAd() {
+        let delay = 0;
+        let currentPlatformID = this.getCurrentPlatformID();
+        if (AdMgr.adPlatformSettingMap.has(currentPlatformID)) {
+            let launchNoAdInterval = AdMgr.adPlatformSettingMap.get(currentPlatformID).launchNoAdInterval_permanentAd;
+            let now = new Date().getTime();
+            if (now - AdMgr.launchTime < launchNoAdInterval) {
+                delay = Math.floor((launchNoAdInterval - (now - AdMgr.launchTime)) / 1000);
+            }
+        }
+        if (!AdMgr.isPermanentAdShowing) {
+            LogUtils.Instance.log(AdMgr.TAG, "showAllPermanentAd, delay=" + delay);
+            this.scheduleOnce(() => {
+                AdMgr.isPermanentAdShowing = true;
+                this.showBannerAd();
+                this.showCustomAd();
+            }, delay);
+        }
+    }
+    hideAllPermanentAd() {
+        LogUtils.Instance.log(AdMgr.TAG, "hideAllPermanentAd");
+        AdMgr.isPermanentAdShowing = false;
+        this.hideBannerAd();
+        this.hideCustomAd();
+    }
+    getAdRecord() {
+        return AdMgr.adRecord;
+    }
+    clearAdRecord() {
+        AdMgr.adRecord.intersitialAdRecord.clear();
+        AdMgr.adRecord.rewardedVideoAdRecord.clear();
+    }
+    // [0] bannerAd_shouldShow
+    // [1] customAd_shouldShow
+    // [2] yOffset
+    adjustSuitableUIConfig(contentHeight) {
+        LogUtils.Instance.log(AdMgr.TAG, "adjustSuitableUIConfig() contentHeight=" + contentHeight);
+        LogUtils.Instance.log(AdMgr.TAG, "screen");
+        LogUtils.Instance.log("", screen);
+        let screenSize = new math.Size(0, 0);
+        if (screen["width"] && screen["height"]) {
+            screenSize.width = screen.width;
+            screenSize.height = screen.height;
+        }
+        else if (screen["availWidth"] && screen["availHeight"]) {
+            screenSize.width = screen.availWidth;
+            screenSize.height = screen.availHeight;
+        }
+        let designSize = view.getDesignResolutionSize();
+        LogUtils.Instance.log(AdMgr.TAG, "designSize=" + designSize + ", screenSize=" + screenSize);
+        let screenDisplayWidth = designSize.width;
+        let screenDisplayHeight = designSize.width * screenSize.y / screenSize.x;
+        LogUtils.Instance.log("", "screenDisplayWidth=" + screenDisplayWidth + ", screenDisplayHeight=" + screenDisplayHeight);
+        let bannerAdHeight = 0;
+        let bannerAdYMargin = 0;
+        let bannerAdDisplayHeight = 0;
+        let bannerAdYMarginDisplayHeight = 0;
+        let currentPlatformID = this.getCurrentPlatformID();
+        if (AdDefinition.BannerAdStyleConfig.has(currentPlatformID)) {
+            let bannerAd_PlatformInfo = AdDefinition.BannerAdStyleConfig.get(currentPlatformID);
+            bannerAdHeight = bannerAd_PlatformInfo.height;
+            bannerAdYMargin = bannerAd_PlatformInfo.yMargin;
+            if (bannerAd_PlatformInfo.scaleRatio > 0) {
+                bannerAdHeight *= bannerAd_PlatformInfo.scaleRatio;
+            }
+        }
+        bannerAdDisplayHeight = bannerAdHeight * designSize.height / screenSize.y;
+        bannerAdYMarginDisplayHeight = bannerAdYMargin * designSize.height / screenSize.y;
+        LogUtils.Instance.log("", "bannerAdDisplayHeight=" + bannerAdDisplayHeight);
+        let customAdHeight = 0;
+        let customAdYMargin = 0;
+        let customAdDisplayHeight = 0;
+        let customAdYMarginDisplayHeight = 0;
+        if (AdDefinition.CustomAdStyleConfig.has(currentPlatformID)) {
+            let customAd_PlatformInfo = AdDefinition.CustomAdStyleConfig.get(currentPlatformID);
+            customAdHeight = customAd_PlatformInfo.height;
+            customAdYMargin = customAd_PlatformInfo.yMargin;
+            if (customAd_PlatformInfo.scaleRatio > 0) {
+                customAdHeight *= customAd_PlatformInfo.scaleRatio;
+            }
+        }
+        customAdDisplayHeight = customAdHeight * designSize.height / screenSize.y;
+        customAdYMarginDisplayHeight = customAdYMargin * designSize.height / screenSize.y;
+        LogUtils.Instance.log("", "customAdDisplayHeight=" + customAdDisplayHeight);
+        let height_1 = bannerAdDisplayHeight + bannerAdYMarginDisplayHeight + 30;
+        let height_2 = bannerAdDisplayHeight + bannerAdYMarginDisplayHeight + customAdDisplayHeight + customAdYMarginDisplayHeight + 50;
+        LogUtils.Instance.log("", "height_1=" + height_1);
+        LogUtils.Instance.log("", "height_2=" + height_2);
+        let solution = 0;
+        if (height_2 <= screenDisplayHeight - contentHeight) {
+            solution = 2;
+        }
+        else if (height_1 <= screenDisplayHeight - contentHeight) {
+            solution = 1;
+        }
+        LogUtils.Instance.log("", "solution=" + solution);
+        let yOffset = 0;
+        if (solution === 0) {
+            AdDefinition.AdInfoConfig.BannerAd_Info.shouldShow = false;
+            AdDefinition.AdInfoConfig.CustomAd_Info.shouldShow = false;
+            yOffset = 0;
+        }
+        else if (solution === 1) {
+            AdDefinition.AdInfoConfig.BannerAd_Info.shouldShow = true;
+            AdDefinition.AdInfoConfig.CustomAd_Info.shouldShow = false;
+            yOffset = bannerAdDisplayHeight / 2;
+        }
+        else if (solution === 2) {
+            AdDefinition.AdInfoConfig.BannerAd_Info.shouldShow = true;
+            AdDefinition.AdInfoConfig.CustomAd_Info.shouldShow = true;
+            yOffset = (bannerAdDisplayHeight - customAdDisplayHeight) / 2;
+        }
+        LogUtils.Instance.log("", "yOffset=" + yOffset);
+        AdMgr.contentTop = designSize.y - (designSize.y - contentHeight) / 2 + yOffset;
+        AdMgr.contentBottom = (designSize.y - contentHeight) / 2 + yOffset;
+        LogUtils.Instance.log(AdMgr.TAG, "contentTop=" + AdMgr.contentTop + ",contentBottom=" + AdMgr.contentBottom);
+        return yOffset;
+    }
+}
+AdMgr.Instance = null;
+AdMgr.TAG = "AudioMgr";
+AdMgr.adPlatformUnitMap = null;
+AdMgr.adPlatformSettingMap = null;
+AdMgr.launchTime = 0;
+AdMgr.interstitialAd_nowIntervalCount = 0;
+AdMgr.interstitialAds = new Map();
+AdMgr.nowInterstitialAdScene = "InterstitialAd_Scene.Scene_Invalid";
+AdMgr.interstitialAdCallback = null;
+AdMgr.lastInterstitialAdTimestamp = 0;
+AdMgr.rewardedVideoAds = new Map();
+AdMgr.nowRewardedVideoAdScene = "";
+AdMgr.rewardedVideoAdCallback = null;
+AdMgr.nowRunningBannerAd = "";
+AdMgr.nowRunningCustomAd = "";
+AdMgr.isPermanentAdShowing = false;
+AdMgr.adRecord = new Ad_Record();
+AdMgr.contentTop = 0;
+AdMgr.contentBottom = 0;