@chiyou/minigame-framework 1.0.0 → 1.0.2

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

@@ -0,0 +1,812 @@
+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, BannerAd_Info, CustomAd_Info, BannerAd_PlatformInfo, CustomAd_PlatformInfo, InterstitialAd_Scene, RewardedVideoAd_Scene, AdPlatformSettingInfo, AdPlatformUnitInfo, AdDefinition } from '../Definition/AdDefinition';
+import { PlatformID } from '../Definition/SystemDefinition';
+import { UserMgr } from './UserMgr';
+import { BaseMgr } from './BaseMgr';
+import { AbsAdAdapter } from '../Adapter/AdAdapter/AbsAdAdapter';
+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 {
+    public static Instance: AdMgr = null;
+    static TAG: string = "AudioMgr";
+
+    private static adPlatformUnitMap: Map<PlatformID, AdPlatformUnitInfo> = null;
+    private static adPlatformSettingMap: Map<PlatformID, AdPlatformSettingInfo> = null;
+
+    private static launchTime: number = 0;
+
+    private static interstitialAd_nowIntervalCount: number = 0;
+
+    private static interstitialAds: Map<InterstitialAd_Scene, AdCallback> = new Map<InterstitialAd_Scene, AdCallback>();
+    private static nowInterstitialAdScene: InterstitialAd_Scene = "InterstitialAd_Scene.Scene_Invalid";
+    private static interstitialAdCallback: Function = null;
+    private static lastInterstitialAdTimestamp: number = 0;
+
+    private static rewardedVideoAds: Map<RewardedVideoAd_Scene, AdCallback> = new Map<RewardedVideoAd_Scene, AdCallback>();
+    private static nowRewardedVideoAdScene: RewardedVideoAd_Scene = "";
+    private static rewardedVideoAdCallback: Function = null;
+
+    private static nowRunningBannerAd: string = "";
+    private static nowRunningCustomAd: string = "";
+    private static isPermanentAdShowing: boolean = false;
+
+    private static adRecord: Ad_Record = new Ad_Record();
+
+    private static contentTop: number = 0;
+    private static contentBottom: number = 0;
+
+    onLoad(): void {
+        if (AdMgr.Instance === null) {
+            AdMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+    
+    public init(contentHeight: number,
+        adPlatformUnitMap: Map<PlatformID, AdPlatformUnitInfo>,
+        adPlatformSettingMap: Map<PlatformID, AdPlatformSettingInfo>): number {
+        let currentPlatformID: PlatformID = 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: AbsAdAdapter = 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<InterstitialAd_Scene, AdCallback>();
+
+        AdMgr.interstitialAdCallback = function (res: InterstitialAd_Callback_Status) {
+            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: InterstitialAd_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: 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<RewardedVideoAd_Scene, AdCallback>();
+
+        AdMgr.rewardedVideoAdCallback = function (res: RewardedVideoAd_Callback_Status) {
+            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: RewardedVideoAd_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: 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);
+    }
+
+    public createAds(): void {
+        this.createInterstitialAd();
+        this.createRewardedVideoAd();
+        this.createPortalAd();
+        this.createAllPermanentAd();
+    }
+
+    public isPermanentAdShowing(): boolean {
+        return AdMgr.isPermanentAdShowing;
+    }
+
+    public adSwithOn(): boolean {
+        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;
+    }
+
+    public supportAdType(adType: AdType): boolean {
+        if (!this.adSwithOn()) {
+            return false;
+        }
+
+        let adPlatformUnitInfo: 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;
+        }
+    }
+
+    public createBannerAd(): void {
+        AdMgr.nowRunningBannerAd = "";
+
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let bannerAd_Info: BannerAd_Info = AdDefinition.AdInfoConfig.BannerAd_Info;
+        if (bannerAd_Info === null || !bannerAd_Info.shouldShow) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).bannerAd;
+        let result: boolean = this.getAdAdapter().createBannerAd(adUnitId);
+        if (result) {
+            AdMgr.nowRunningBannerAd = adUnitId;
+        }
+    }
+
+    public destroyBannerAd(): void {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).bannerAd;
+        this.getAdAdapter().destroyBannerAd(adUnitId);
+        AdMgr.nowRunningBannerAd = "";
+    }
+
+    public showBannerAd(): void {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        if (AdMgr.nowRunningBannerAd !== "") {
+            this.getAdAdapter().showBannerAd(AdMgr.nowRunningBannerAd);
+        }
+    }
+
+    public hideBannerAd(): void {
+        if (!this.supportAdType(AdType.Type_Banner)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        if (AdMgr.nowRunningBannerAd !== "") {
+            this.getAdAdapter().hideBannerAd(AdMgr.nowRunningBannerAd);
+        }
+    }
+
+    public createInterstitialAd(): void {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().createInterstitialAd();
+    }
+
+    public showInterstitialAd(scene: InterstitialAd_Scene, callback: Function, target: any): void {
+        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: number = 0;
+        let interstitialAdIntervalBase: number = 60000;
+        if (AdMgr.adPlatformSettingMap.has(this.getCurrentPlatformID())) {
+            let adPlatformSettingInfo: 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: number = interstitialAdIntervalBase * AdMgr.interstitialAd_nowIntervalCount;
+
+        let now: number = 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();
+    }
+
+    public destroyInterstitialAd(): void {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return;   
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().destroyInterstitialAd();
+    }
+
+    public isIntersititialAdShowing(): boolean {
+        if (!this.supportAdType(AdType.Type_Interstitial)) {
+            return false;   
+        }
+
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isIntersititialAdShowing();
+    }
+
+    public createRewardedVideoAd(): void {
+        if (!this.supportAdType(AdType.Type_RewardedVideo)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().createRewardedVideoAd();
+    }
+
+    public showRewardedVideoAd(scene: RewardedVideoAd_Scene, callback: Function, target: any): void {
+        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: RewardedVideoAd_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: 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();
+        }
+    }
+
+    public destroyRewardedVideoAd(): void {
+        if (!this.supportAdType(AdType.Type_RewardedVideo)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+        this.getAdAdapter().destroyRewardedVideoAd();
+    }
+
+    public isRewardedVideoAdShowing(): boolean {
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isRewardedVideoAdShowing();
+    }
+
+    public isRewardedVideoAdLoaded(): boolean {
+        if (this.getAdAdapter() === null) {
+            return false;
+        }
+        return this.getAdAdapter().isRewardedVideoAdLoaded();
+    }
+
+    public createCustomAd(): void {
+        AdMgr.nowRunningCustomAd = "";
+
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let customAd_Info: CustomAd_Info = AdDefinition.AdInfoConfig.CustomAd_Info;
+        if (customAd_Info === null || !customAd_Info.shouldShow) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).customAd;
+        let result: boolean = this.getAdAdapter().createCustomAd(adUnitId);
+        if (result) {
+            AdMgr.nowRunningCustomAd = adUnitId;
+        }
+    }
+
+    public destroyCustomAd(): void {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).customAd;
+        this.getAdAdapter().destroyCustomAd(adUnitId);
+        AdMgr.nowRunningCustomAd = "";
+    }
+
+    public showCustomAd(): void {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        if (AdMgr.nowRunningCustomAd !== "") {
+            this.getAdAdapter().showCustomAd(AdMgr.nowRunningCustomAd);
+        }
+    }
+
+    public hideCustomAd(): void {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        if (AdMgr.nowRunningCustomAd !== "") {
+            this.getAdAdapter().hideCustomAd(AdMgr.nowRunningCustomAd);
+        }
+    }
+
+    public createPortalAd(): void {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().createPortalAd(adUnitId);
+    }
+
+    public destoryPortalAd(): void {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().destroyPortalAd(adUnitId);
+    }
+
+    public showPortalAd(): void {
+        if (!this.supportAdType(AdType.Type_Portal)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().showPortalAd(adUnitId);        
+    }
+
+    public hidePortalAd(): void {
+        if (!this.supportAdType(AdType.Type_Custom)) {
+            return;
+        }
+
+        if (this.getAdAdapter() === null) {
+            return;
+        }
+
+        let adUnitId: string = AdMgr.adPlatformUnitMap.get(this.getCurrentPlatformID()).portalAd;
+        this.getAdAdapter().hidePortalAd(adUnitId);
+    }
+
+    private createAllPermanentAd(): void {
+        this.createBannerAd();
+        this.createCustomAd();
+    }
+
+    public showAllPermanentAd(): void {
+        let delay: number = 0;
+
+        let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+        if (AdMgr.adPlatformSettingMap.has(currentPlatformID)) {
+            let launchNoAdInterval: number = AdMgr.adPlatformSettingMap.get(currentPlatformID).launchNoAdInterval_permanentAd;
+            let now: number = 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);
+        }
+    }
+
+    public hideAllPermanentAd(): void {
+        LogUtils.Instance.log(AdMgr.TAG, "hideAllPermanentAd");
+        AdMgr.isPermanentAdShowing = false;
+        this.hideBannerAd();
+        this.hideCustomAd();
+    }
+
+    public getAdRecord(): Ad_Record {
+        return AdMgr.adRecord;
+    }
+
+    public clearAdRecord(): void {
+        AdMgr.adRecord.intersitialAdRecord.clear();
+        AdMgr.adRecord.rewardedVideoAdRecord.clear();
+    }
+
+    // [0] bannerAd_shouldShow
+    // [1] customAd_shouldShow
+    // [2] yOffset
+    private adjustSuitableUIConfig(contentHeight: number): number {
+        LogUtils.Instance.log(AdMgr.TAG, "adjustSuitableUIConfig() contentHeight=" + contentHeight);
+
+        LogUtils.Instance.log(AdMgr.TAG, "screen");
+        LogUtils.Instance.log("", screen);
+        let screenSize: math.Size = 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: math.Size = view.getDesignResolutionSize();
+        LogUtils.Instance.log(AdMgr.TAG, "designSize=" + designSize + ", screenSize=" + screenSize);
+
+        let screenDisplayWidth: number = designSize.width;
+        let screenDisplayHeight: number = designSize.width * screenSize.y / screenSize.x;
+        LogUtils.Instance.log("", "screenDisplayWidth=" + screenDisplayWidth + ", screenDisplayHeight=" + screenDisplayHeight);
+
+        let bannerAdHeight: number = 0;
+        let bannerAdYMargin: number = 0;
+        let bannerAdDisplayHeight: number = 0;
+        let bannerAdYMarginDisplayHeight: number = 0;
+
+        let currentPlatformID: PlatformID = this.getCurrentPlatformID();
+        if (AdDefinition.BannerAdStyleConfig.has(currentPlatformID)) {
+            let bannerAd_PlatformInfo: 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: number = 0;
+        let customAdYMargin: number = 0;
+        let customAdDisplayHeight: number = 0;
+        let customAdYMarginDisplayHeight: number = 0;
+        if (AdDefinition.CustomAdStyleConfig.has(currentPlatformID)) {
+            let customAd_PlatformInfo: 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: number = bannerAdDisplayHeight + bannerAdYMarginDisplayHeight + 30;
+        let height_2: number = bannerAdDisplayHeight + bannerAdYMarginDisplayHeight + customAdDisplayHeight + customAdYMarginDisplayHeight + 50;
+        LogUtils.Instance.log("", "height_1=" + height_1);
+        LogUtils.Instance.log("", "height_2=" + height_2);
+
+        let solution: number = 0;
+        if (height_2 <= screenDisplayHeight - contentHeight) {
+            solution = 2;
+        } else if (height_1 <= screenDisplayHeight - contentHeight) {
+            solution = 1;
+        }
+        LogUtils.Instance.log("", "solution=" + solution);
+
+        let yOffset: number = 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;
+    }
+}