@chiyou/minigame-framework 1.0.0 → 1.0.2

package/assets/Scripts/Framework/Adapter/AdAdapter/AdAdapterOppo.ts

@@ -0,0 +1,946 @@
+import { BannerAd_Info, BannerAd_PlatformInfo, InterstitialAd_Callback_Status, RewardedVideoAd_Callback_Status, CustomAd_Info, CustomAd_PlatformInfo, PortalAd_PlatformInfo, AdDefinition } from "../../Definition/AdDefinition";
+import { PlatformID } from "../../Definition/SystemDefinition";
+import { LogUtils } from "../../Utils/LogUtils";
+import { AbsAdAdapter, BannerAdPosition, CustomAdPosition, InterstitialAdStatus, RewardedVideoAdStatus } from "./AbsAdAdapter";
+
+class OppoBannerAd {
+    unitId: string;
+    ad: any;
+    errorListener: Function;
+    loadListener: Function;
+    resizeListener: Function;
+    isRecreating: boolean;
+    isFirstLoad: boolean;
+
+    constructor(adUnitId: string, ad: any, isFirstLoad: boolean) {
+        this.unitId = adUnitId;
+        this.ad = ad;
+        this.errorListener = null;
+        this.loadListener = null;
+        this.resizeListener = null;
+        this.isFirstLoad = isFirstLoad;
+    }
+
+    public destroy(): void {
+        if (this.ad !== null) {
+            if (this.errorListener !== null) {
+                this.ad.offError(this.errorListener);
+                this.errorListener = null;
+            }
+            if (this.loadListener !== null) {
+                this.ad.offLoad(this.loadListener);
+                this.loadListener = null;
+            }
+            if (this.resizeListener !== null) {
+                this.ad.offResize(this.resizeListener);
+                this.resizeListener = null;
+            }
+
+            this.ad.destroy();
+            this.ad = null;
+        }
+        this.isRecreating = false;
+    }
+}
+
+class OppoInterstitialAd {
+    unitId: string;
+    ad: any;
+    status: InterstitialAdStatus;
+    callback: Function;
+    errorListener: Function;
+    loadListener: Function;
+    closeListener: Function;
+    isShowImmediately: boolean;
+
+    constructor(adUnitId: string, callback: Function) {
+        this.unitId = adUnitId;
+        this.ad = null;
+        this.status = InterstitialAdStatus.Status_Init;
+        this.callback = callback;
+        this.errorListener = null;
+        this.loadListener = null;
+        this.closeListener = null;
+        this.isShowImmediately = false;
+    }
+
+    public destroy(): void {
+        if (this.ad !== null) {
+            if (this.errorListener !== null) {
+                this.ad.offError(this.errorListener);
+                this.errorListener = null;
+            }
+            if (this.loadListener !== null) {
+                this.ad.offLoad(this.loadListener);
+                this.loadListener = null;
+            }
+            if (this.closeListener !== null) {
+                this.ad.offClose(this.closeListener);
+                this.closeListener = null;
+            }
+
+            this.ad.destroy();
+            this.ad = null;
+        }
+        this.isShowImmediately = false;
+        this.status = InterstitialAdStatus.Status_Destroyed;
+    }
+}
+
+class OppoRewardedVideoAd {
+    unitId: string;
+    ad: any;
+    status: RewardedVideoAdStatus;
+    callback: Function;
+    errorListener: Function;
+    loadListener: Function;
+    closeListener: Function;
+    isShowImmediately: boolean;
+
+    constructor(adUnitId: string, callback: Function) {
+        this.unitId = adUnitId;
+        this.ad = null;
+        this.status = RewardedVideoAdStatus.Status_Init;
+        this.callback = callback;
+        this.errorListener = null;
+        this.loadListener = null;
+        this.closeListener = null;
+        this.isShowImmediately = false;
+    }
+
+    public destroy(): void {
+        if (this.ad !== null) {
+            if (this.errorListener !== null) {
+                this.ad.offError(this.errorListener);
+                this.errorListener = null;
+            }
+            if (this.loadListener !== null) {
+                this.ad.offLoad(this.loadListener);
+                this.loadListener = null;
+            }
+            if (this.closeListener !== null) {
+                this.ad.offClose(this.closeListener);
+                this.closeListener = null;
+            }
+
+            this.ad.destroy();
+            this.ad = null;
+        }
+        this.isShowImmediately = false;
+        this.status = RewardedVideoAdStatus.Status_Destroyed;
+    }
+}
+
+class OppoCustomAd {
+    unitId: string;
+    ad: any;
+    errorListener: Function;
+    loadListener: Function;
+    isRecreating: boolean;
+    isFirstLoad: boolean;
+
+    constructor(adUnitId: string, ad: any, isFirstLoad: boolean) {
+        this.unitId = adUnitId;
+        this.ad = ad;
+        this.errorListener = null;
+        this.loadListener = null;
+        this.isFirstLoad = isFirstLoad;
+    }
+
+    public destroy(): void {
+        if (this.ad !== null) {
+            if (this.errorListener !== null) {
+                this.ad.offError(this.errorListener);
+                this.errorListener = null;
+            }
+            if (this.loadListener !== null) {
+                this.ad.offLoad(this.loadListener);
+                this.loadListener = null;
+            }
+
+            this.ad.destroy();
+            this.ad = null;
+        }
+        this.isRecreating = false;
+    }
+}
+
+class OppoPortalAd {
+    unitId: string;
+    ad: any;
+    errorListener: Function;
+    loadListener: Function;
+    showListener: Function;
+    closeListener: Function;
+    isLoaded: boolean;
+    isShowing: boolean;
+    isRecreating: boolean;
+
+    constructor(adUnitId: string, ad: any) {
+        this.unitId = adUnitId;
+        this.ad = ad;
+        this.errorListener = null;
+        this.loadListener = null;
+        this.showListener = null;
+        this.closeListener = null;
+        this.isLoaded = false;
+        this.isShowing = false;
+        this.isRecreating = false;
+    }
+
+    public destroy(): void {
+        if (this.ad !== null) {
+            if (this.errorListener !== null) {
+                this.ad.offError(this.errorListener);
+                this.errorListener = null;
+            }
+            if (this.loadListener !== null) {
+                this.ad.offLoad(this.loadListener);
+                this.loadListener = null;
+            }
+            if (this.showListener !== null) {
+                this.ad.offShow(this.showListener);
+                this.showListener = null;
+            }
+            if (this.closeListener !== null) {
+                this.ad.offClose(this.closeListener);
+                this.closeListener = null;
+            }
+
+            this.ad.destroy();
+            this.ad = null;
+        }
+        this.isLoaded = false;
+        this.isShowing = false;
+        this.isRecreating = false;
+    }
+}
+
+export class AdAdapterOppo extends AbsAdAdapter {
+    static TAG: string = "AdAdapterOppo";
+
+    private oppoInterstitialAd: OppoInterstitialAd = null;
+    private oppoRewardedVideoAd: OppoRewardedVideoAd = null;
+    private oppoBannerAds: OppoBannerAd[] = [];
+    private oppoCustomAds: OppoCustomAd[] = [];
+    private oppoPortalAds: OppoPortalAd[] = [];
+
+    public init(interstitialAdUnitId: string, interstitialAdCallback: Function, rewardedVideoAdUnitId: string, rewardedVideoAdCallback: Function): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "init()");
+
+        this.oppoInterstitialAd = new OppoInterstitialAd(interstitialAdUnitId, interstitialAdCallback);
+        this.oppoRewardedVideoAd = new OppoRewardedVideoAd(rewardedVideoAdUnitId, rewardedVideoAdCallback);
+
+        this.oppoBannerAds = [];
+        this.oppoCustomAds = [];
+        this.oppoPortalAds = [];
+    }
+
+    public createBannerAd(adUnitId: string): boolean {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createBannerAd()");
+
+        let isFirstLoad: boolean = true;
+        for (let i = 0; i < this.oppoBannerAds.length; i++) {
+            if (this.oppoBannerAds[i].unitId === adUnitId) {
+                isFirstLoad = this.oppoBannerAds[i].isFirstLoad;
+                break;
+            }
+        }
+
+        this.destroyBannerAd(adUnitId);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createBannerAd() adUnitId=" + adUnitId);
+
+        let bannerAdInfo: BannerAd_Info = AdDefinition.AdInfoConfig.BannerAd_Info;
+        if (bannerAdInfo === null || !bannerAdInfo.shouldShow) {
+            return false;
+        }
+
+        let bannerAdPlatformInfo: BannerAd_PlatformInfo = AdDefinition.BannerAdStyleConfig.get(PlatformID.ID_QuickGame_Oppo);
+        if (bannerAdPlatformInfo === null) {
+            return false;
+        }
+
+        let bannerAdPosition: BannerAdPosition = this.calcBannerAdPosition(bannerAdInfo, bannerAdPlatformInfo);
+        let bannerAdParam: any = {
+            adUnitId: adUnitId,
+            style: {
+                width: bannerAdPosition.realWidth,
+                height: bannerAdPosition.realHeight,
+                left: bannerAdPosition.left,
+                top: bannerAdPosition.top,
+            },
+        };
+        if (bannerAdPlatformInfo.canAutoRefresh) {
+            bannerAdParam.adIntervals = bannerAdPlatformInfo.refreshInterval;
+        }
+
+        let bannerAd: any = window["qg"].createBannerAd(bannerAdParam);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "qg.createBannerAd() " + (bannerAd !== null ? "success" : "fail"));
+        LogUtils.Instance.log("", bannerAd);
+        if (!bannerAd) {
+            return false;
+        } 
+
+        let oppoBannerAd: OppoBannerAd = new OppoBannerAd(adUnitId, bannerAd, isFirstLoad);
+        this.oppoBannerAds.push(oppoBannerAd);
+
+        oppoBannerAd.errorListener = (err) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.onError()");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+
+            if (!oppoBannerAd.isRecreating) {
+                oppoBannerAd.isRecreating = true;
+
+                this.scheduleOnce(() => {
+                    oppoBannerAd.isRecreating = false;
+                    this.createBannerAd(adUnitId);
+                }, 15);
+            }
+        };
+        oppoBannerAd.ad.onError(oppoBannerAd.errorListener);
+
+        oppoBannerAd.resizeListener = (res) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.onResize()");
+            if (res) {
+                LogUtils.Instance.log("", res);
+            }
+
+            if (oppoBannerAd.isFirstLoad) {
+                oppoBannerAd.isFirstLoad = false;
+                oppoBannerAd.ad.hide();
+            }
+        };
+        oppoBannerAd.ad.onResize(oppoBannerAd.resizeListener);
+
+        oppoBannerAd.loadListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.onLoad()");
+        };
+        oppoBannerAd.ad.onLoad(oppoBannerAd.loadListener);
+
+        if (!bannerAdPlatformInfo.canAutoRefresh) {
+            if (!oppoBannerAd.isRecreating) {
+                oppoBannerAd.isRecreating = true;
+
+                this.scheduleOnce(() => {
+                    oppoBannerAd.isRecreating = false;
+                    this.createBannerAd(adUnitId);
+                }, bannerAdPlatformInfo.refreshInterval);
+            }
+        }
+
+        if (this.adMgr.isPermanentAdShowing()) {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.show()");
+            oppoBannerAd.ad.show()
+                .then(() => {
+                    LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.show() success");
+                }).catch((err) => {
+                    LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoBannerAd.ad.show() fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                });
+        }
+
+        return true;
+    }
+
+    public destroyBannerAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "destroyBannerAd(): adUnitId=" + adUnitId);
+
+        let index = -1;
+        for (let i = 0; i < this.oppoBannerAds.length; i++) {
+            if (this.oppoBannerAds[i].unitId === adUnitId) {
+                index = i;
+                break;
+            }
+        }
+
+        if (index >= 0) {
+            this.oppoBannerAds[index].destroy();
+            this.oppoBannerAds.splice(index, 1);
+        }
+    }
+
+    public showBannerAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "showBannerAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoBannerAds.length; i++) {
+            if (this.oppoBannerAds[i].unitId === adUnitId) {
+                this.oppoBannerAds[i].ad.show();
+                break;
+            }
+        }
+    }
+
+    public hideBannerAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "hideBannerAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoBannerAds.length; i++) {
+            if (this.oppoBannerAds[i].unitId === adUnitId) {
+                this.oppoBannerAds[i].ad.hide();
+                break;
+            }
+        }
+    }
+
+    public createInterstitialAd(): void {
+        this.destroyInterstitialAd();
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createInterstitialAd() adUnitId=" + this.oppoInterstitialAd.unitId);
+
+        let interstitialAd: any = window["qg"].createInterstitialAd({
+            adUnitId: this.oppoInterstitialAd.unitId
+        });
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "qg.createInterstitialAd() " + (interstitialAd !== null ? "success" : "fail"));
+        LogUtils.Instance.log("", interstitialAd);
+        if (!interstitialAd) {
+            this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Error;
+            this.oppoInterstitialAd.callback(InterstitialAd_Callback_Status.Status_Error);
+            return;
+        }
+
+        this.oppoInterstitialAd.ad = interstitialAd;
+        this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Init;
+
+        this.oppoInterstitialAd.errorListener = (err) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.onError()");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+
+            if (this.oppoInterstitialAd.status !== InterstitialAdStatus.Status_Watching) {
+                this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Error;
+                this.oppoInterstitialAd.callback(InterstitialAd_Callback_Status.Status_Error);
+            }
+        };
+        this.oppoInterstitialAd.ad.onError(this.oppoInterstitialAd.errorListener);
+
+        this.oppoInterstitialAd.loadListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.onLoad()");
+
+            this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Loaded;
+
+            if (this.oppoInterstitialAd.isShowImmediately) {
+                this.oppoInterstitialAd.isShowImmediately = false;
+                this._showInterstitialAd();
+            }
+        };
+        this.oppoInterstitialAd.ad.onLoad(this.oppoInterstitialAd.loadListener);
+
+        this.oppoInterstitialAd.closeListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.onClose()");
+
+            this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Watched;
+            this.oppoInterstitialAd.callback(InterstitialAd_Callback_Status.Status_Close);
+
+            this.scheduleOnce(() => {
+                if (this.oppoInterstitialAd.status !== InterstitialAdStatus.Status_Loaded) {
+                    this._loadInterstitialAd(false);
+                }
+            }, 2);
+        };
+        this.oppoInterstitialAd.ad.onClose(this.oppoInterstitialAd.closeListener);
+
+        this.scheduleOnce(() => {
+            if (this.oppoInterstitialAd.status !== InterstitialAdStatus.Status_Loaded) {
+                this._loadInterstitialAd(false);
+            }
+        }, 2);
+    }
+
+    public showInterstitialAd(): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "showInterstitialAd()");
+
+        if (this.oppoInterstitialAd.ad === null) {
+            return;
+        }
+
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.status=" + InterstitialAdStatus[this.oppoInterstitialAd.status]);
+        switch(this.oppoInterstitialAd.status) {
+            case InterstitialAdStatus.Status_Destroyed:
+            case InterstitialAdStatus.Status_Watching:
+            case InterstitialAdStatus.Status_StartToWatch:
+                break;
+            case InterstitialAdStatus.Status_Loaded:
+                this._showInterstitialAd();
+                break;
+            case InterstitialAdStatus.Status_Watched:
+            case InterstitialAdStatus.Status_Init:
+            case InterstitialAdStatus.Status_Error:
+                this._loadInterstitialAd(true);
+                break;
+            default:
+                break;
+        }
+    }
+
+    public destroyInterstitialAd(): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "destroyInterstitialAd()");
+        this.oppoInterstitialAd.destroy();
+    }
+
+    public isIntersititialAdShowing(): boolean {
+        if (this.oppoInterstitialAd.ad === null) {
+            return false;
+        }
+        if (this.oppoInterstitialAd.status === InterstitialAdStatus.Status_Watching) {
+            return true;
+        }
+        return false;
+    }
+
+    protected _loadInterstitialAd(isShowImmediately: boolean): void {
+        this.oppoInterstitialAd.isShowImmediately = isShowImmediately;
+
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.load()");
+        this.oppoInterstitialAd.ad.load()
+            .then(() => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.load() success");
+            }).catch((err) => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.load() error");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+            });
+    }
+
+    protected _showInterstitialAd(): void {
+        if (this.oppoInterstitialAd.status !== InterstitialAdStatus.Status_Loaded) {
+            return;
+        }
+
+        this.oppoInterstitialAd.status = InterstitialAdStatus.Status_StartToWatch;
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.show()");
+        this.oppoInterstitialAd.ad.show()
+            .then(() => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.show() success");
+
+                if (this.oppoInterstitialAd.status === InterstitialAdStatus.Status_StartToWatch) {
+                    this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Watching;
+                    this.oppoInterstitialAd.callback(InterstitialAd_Callback_Status.Status_Watching);
+                }
+            }).catch((err) => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoInterstitialAd.ad.show() error");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+
+                if (this.oppoInterstitialAd.status === InterstitialAdStatus.Status_StartToWatch) {
+                    this.oppoInterstitialAd.status = InterstitialAdStatus.Status_Loaded;
+                }
+            });
+    }
+
+    public createRewardedVideoAd(): void {
+        this.destroyRewardedVideoAd();
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createRewardedVideoAd() adUnitId=" + this.oppoRewardedVideoAd.unitId);
+
+        let rewardedVideoAd: any = window["qg"].createRewardedVideoAd({
+            adUnitId: this.oppoRewardedVideoAd.unitId
+        });
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "qg.createRewardedVideoAd() " + (rewardedVideoAd !== null ? "success" : "fail"));
+        LogUtils.Instance.log("", rewardedVideoAd);
+        if (!rewardedVideoAd) {
+            this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Error;
+            this.oppoRewardedVideoAd.callback(RewardedVideoAd_Callback_Status.Status_Error);
+            return;
+        }
+
+        this.oppoRewardedVideoAd.ad = rewardedVideoAd;
+        this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Init;
+
+        this.oppoRewardedVideoAd.errorListener = (err) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.onError()");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+
+            if (this.oppoRewardedVideoAd.status !== RewardedVideoAdStatus.Status_Watching) {
+                this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Error;
+                this.oppoRewardedVideoAd.callback(RewardedVideoAd_Callback_Status.Status_Error);
+            }
+        };
+        this.oppoRewardedVideoAd.ad.onError(this.oppoRewardedVideoAd.errorListener);
+
+        this.oppoRewardedVideoAd.loadListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.onLoad()");
+
+            this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Loaded;
+
+            if (this.oppoRewardedVideoAd.isShowImmediately) {
+                this.oppoRewardedVideoAd.isShowImmediately = false;
+                this._showRewardedVideoAd();
+            }
+        };
+        this.oppoRewardedVideoAd.ad.onLoad(this.oppoRewardedVideoAd.loadListener);
+
+        this.oppoRewardedVideoAd.closeListener = (res) => {
+            let isEnded: boolean = (res !== null) ? res.isEnded : false;
+
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.onClose()");            
+            LogUtils.Instance.log("", "isEnded=" + isEnded);
+
+            this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Watched;
+            if (isEnded) {
+                this.oppoRewardedVideoAd.callback(RewardedVideoAd_Callback_Status.Status_Complete);
+            } else {
+                this.oppoRewardedVideoAd.callback(RewardedVideoAd_Callback_Status.Status_Giveup);
+            }
+
+            this.scheduleOnce(() => {
+                if (this.oppoRewardedVideoAd.status !== RewardedVideoAdStatus.Status_Loaded) {
+                    this._loadRewardedVideoAd(false);
+                }
+            }, 2);
+        };
+        this.oppoRewardedVideoAd.ad.onClose(this.oppoRewardedVideoAd.closeListener);
+
+        this.scheduleOnce(() => {
+            if (this.oppoRewardedVideoAd.status !== RewardedVideoAdStatus.Status_Loaded) {
+                this._loadRewardedVideoAd(false);
+            }
+        }, 2);
+    }
+
+    public showRewardedVideoAd(): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "showRewardedVideoAd()");
+
+        if (this.oppoRewardedVideoAd.ad === null) {
+            return;
+        }
+        
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.status=" + RewardedVideoAdStatus[this.oppoRewardedVideoAd.status]);
+        switch(this.oppoRewardedVideoAd.status) {
+            case RewardedVideoAdStatus.Status_Destroyed:
+            case RewardedVideoAdStatus.Status_StartToWatch:
+            case RewardedVideoAdStatus.Status_Watching:
+                break;
+            case RewardedVideoAdStatus.Status_Loaded:
+                this._showRewardedVideoAd();
+                break;
+            case RewardedVideoAdStatus.Status_Watched:
+            case RewardedVideoAdStatus.Status_Init:
+            case RewardedVideoAdStatus.Status_Error:
+                this._loadRewardedVideoAd(true);
+                break;
+            default:
+                break;
+        }
+    }
+
+    public destroyRewardedVideoAd(): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "destroyRewardedVideoAd()");
+        this.oppoRewardedVideoAd.destroy();
+    }
+
+    public isRewardedVideoAdLoaded(): boolean {
+        if (this.oppoRewardedVideoAd.ad === null) {
+            return false;
+        }
+        if (this.oppoRewardedVideoAd.status === RewardedVideoAdStatus.Status_Loaded) {
+            return true;
+        }
+        return false;
+    }
+
+    public isRewardedVideoAdShowing(): boolean {
+        if (this.oppoRewardedVideoAd.ad === null) {
+            return false;
+        }
+        if (this.oppoRewardedVideoAd.status === RewardedVideoAdStatus.Status_Watching) {
+            return true;
+        }
+        return false;
+    }
+
+    protected _loadRewardedVideoAd(isShowImmediately: boolean): void {
+        this.oppoRewardedVideoAd.isShowImmediately = isShowImmediately;
+
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.load()");
+        this.oppoRewardedVideoAd.ad.load()
+            .then(() => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.load() success");
+            }).catch((err) => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.load() error");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+            });
+    }
+
+    protected _showRewardedVideoAd(): void {
+        if (this.oppoRewardedVideoAd.status !== RewardedVideoAdStatus.Status_Loaded) {
+            return;
+        }
+
+        this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_StartToWatch;
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.show()");
+        this.oppoRewardedVideoAd.ad.show()
+            .then(() => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.show() success");
+
+                if (this.oppoRewardedVideoAd.status === RewardedVideoAdStatus.Status_StartToWatch) {
+                    this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Watching;
+                    this.oppoRewardedVideoAd.callback(RewardedVideoAd_Callback_Status.Status_Watching);
+                }
+            }).catch((err) => {
+                LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoRewardedVideoAd.ad.show() error");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+
+                if (this.oppoRewardedVideoAd.status === RewardedVideoAdStatus.Status_StartToWatch) {
+                    this.oppoRewardedVideoAd.status = RewardedVideoAdStatus.Status_Loaded;
+                }
+            });
+    }
+
+    public createCustomAd(adUnitId: string): boolean {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createCustomAd()");
+
+        let isFirstLoad: boolean = true;
+        for (let i = 0; i < this.oppoCustomAds.length; i++) {
+            if (this.oppoCustomAds[i].unitId === adUnitId) {
+                isFirstLoad = this.oppoCustomAds[i].isFirstLoad;
+                break;
+            }
+        }
+
+        this.destroyCustomAd(adUnitId);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createCustomAd() adUnitId=" + adUnitId);
+
+        let customAdInfo: CustomAd_Info = AdDefinition.AdInfoConfig.CustomAd_Info;
+        if (customAdInfo === null || !customAdInfo.shouldShow) {
+            return false;
+        }
+
+        let customAdPlatformInfo: CustomAd_PlatformInfo = AdDefinition.CustomAdStyleConfig.get(PlatformID.ID_QuickGame_Oppo);
+        if (customAdPlatformInfo === null) {
+            return false;
+        }
+
+        let customAdPosition: CustomAdPosition = this.calcCustomAdPosition(customAdInfo, customAdPlatformInfo);
+        let customAdParam: any = {
+            adUnitId: adUnitId,
+            style: {
+                left: customAdPosition.left,
+                top: customAdPosition.top,
+                orientation: "horizontal",
+            },
+        };
+        if (customAdPlatformInfo.canAutoRefresh) {
+            customAdParam.adIntervals = customAdPlatformInfo.refreshInterval;
+        }
+
+        let customAd: any = window["qg"].createGameBannerAd(customAdParam);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "qg.createGameBannerAd() " + (customAd !== null ? "success" : "fail"));
+        LogUtils.Instance.log("", customAd);
+        if (!customAd) {
+            return false;
+        }
+
+        let oppoCustomAd: OppoCustomAd = new OppoCustomAd(adUnitId, customAd, isFirstLoad);
+        this.oppoCustomAds.push(oppoCustomAd);
+
+        oppoCustomAd.errorListener = (err) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoCustomAd.ad.onError()");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+
+            if (!oppoCustomAd.isRecreating) {
+                oppoCustomAd.isRecreating = true;
+
+                this.scheduleOnce(() => {
+                    oppoCustomAd.isRecreating = false;
+                    this.createCustomAd(adUnitId);
+                }, 15);
+            }
+        };
+        oppoCustomAd.ad.onError(oppoCustomAd.errorListener);
+
+        oppoCustomAd.loadListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoCustomAd.ad.onLoad()");
+
+            if (oppoCustomAd.isFirstLoad) {
+                oppoCustomAd.isFirstLoad = false;
+            }
+        };
+        oppoCustomAd.ad.onLoad(oppoCustomAd.loadListener);
+
+        if (!customAdPlatformInfo.canAutoRefresh) {
+            if (!oppoCustomAd.isRecreating) {
+                oppoCustomAd.isRecreating = true;
+
+                this.scheduleOnce(() => {
+                    oppoCustomAd.isRecreating = false;
+                    this.createCustomAd(adUnitId);
+                }, customAdPlatformInfo.refreshInterval);
+            }
+        }
+
+        if (this.adMgr.isPermanentAdShowing()) {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoCustomAd.ad.show()");
+            oppoCustomAd.ad.show()
+                .then(() => {
+                    LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoCustomAd.ad.show() success");
+                }).catch((err) => {
+                    LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoCustomAd.ad.show() fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                });
+        }
+
+        return true;
+    }
+
+    public destroyCustomAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "destroyCustomAd(): adUnitId=" + adUnitId);
+
+        let index = -1;
+        for (let i = 0; i < this.oppoCustomAds.length; i++) {
+            if (this.oppoCustomAds[i].unitId === adUnitId) {
+                index = i;
+                break;
+            }
+        }
+
+        if (index >= 0) {
+            this.oppoCustomAds[index].destroy();
+            this.oppoCustomAds.splice(index, 1);
+        }
+    }
+
+    public showCustomAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "showCustomAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoCustomAds.length; i++) {
+            if (this.oppoCustomAds[i].unitId === adUnitId) {
+                this.oppoCustomAds[i].ad.show();
+                break;
+            }
+        }
+    }
+
+    public hideCustomAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "hideCustomAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoCustomAds.length; i++) {
+            if (this.oppoCustomAds[i].unitId === adUnitId) {
+                this.oppoCustomAds[i].ad.hide();
+                break;
+            }
+        }
+    }
+
+    public createPortalAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createPortalAd()");
+
+        this.destroyPortalAd(adUnitId);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "createPortalAd() adUnitId=" + adUnitId);
+
+        let portalAdPlatformInfo: PortalAd_PlatformInfo = AdDefinition.PortalAdStyleConfig.get(PlatformID.ID_QuickGame_Oppo);
+        if (portalAdPlatformInfo === null) {
+            return;
+        }
+
+        let portalAdParam: any = {
+            adUnitId: adUnitId,
+        }
+        let portalAd: any = window["qg"].createGamePortalAd(portalAdParam);
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "qg.createGamePortalAd() " + (portalAd !== null ? "success" : "fail"));
+        LogUtils.Instance.log("", portalAd);
+        if (!portalAd) {
+            return;
+        }
+
+        let oppoPortalAd: OppoPortalAd = new OppoPortalAd(adUnitId, portalAd);
+        this.oppoPortalAds.push(oppoPortalAd);
+
+        oppoPortalAd.errorListener = (err) => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoPortalAd.ad.onError()");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+
+            if (!oppoPortalAd.isRecreating) {
+                oppoPortalAd.isRecreating = true;
+
+                this.scheduleOnce(() => {
+                    oppoPortalAd.isRecreating = false;
+                    this.createPortalAd(adUnitId);
+                }, 15);
+            }
+        };
+        oppoPortalAd.ad.onError(oppoPortalAd.errorListener);
+
+        oppoPortalAd.loadListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoPortalAd.ad.onLoad()");
+
+            oppoPortalAd.isLoaded = true;
+        };
+        oppoPortalAd.ad.onLoad(oppoPortalAd.loadListener);
+
+        oppoPortalAd.showListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoPortalAd.ad.onShow()");
+            oppoPortalAd.isShowing = true;
+        };
+        oppoPortalAd.ad.onShow(oppoPortalAd.showListener);
+
+        oppoPortalAd.closeListener = () => {
+            LogUtils.Instance.log(AdAdapterOppo.TAG, "oppoPortalAd.ad.onClose()");
+
+            oppoPortalAd.ad.load();
+        };
+        oppoPortalAd.ad.onClose(oppoPortalAd.closeListener);
+    }
+
+    public destroyPortalAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "destroyPortalAd(): adUnitId=" + adUnitId);
+
+        let index: number = -1;
+        for (let i = 0; i < this.oppoPortalAds.length; i++) {
+            if (this.oppoPortalAds[i].unitId === adUnitId) {
+                index = i;
+                break;
+            }
+        }
+
+        if (index >= 0) {
+            this.oppoPortalAds[index].destroy();
+            this.oppoPortalAds.splice(index, 1);
+        }
+    }
+
+    public showPortalAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "showPortalAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoPortalAds.length; i++) {
+            if (this.oppoPortalAds[i].unitId === adUnitId) {
+                let portalAd = this.oppoPortalAds[i];
+                if (portalAd.isLoaded) {
+                    portalAd.isLoaded = false;
+                    portalAd.ad.show();
+                }
+                break;
+            }
+        }
+    }
+
+    public hidePortalAd(adUnitId: string): void {
+        LogUtils.Instance.log(AdAdapterOppo.TAG, "hidePortalAd(): adUnitId=" + adUnitId);
+
+        for (let i = 0; i < this.oppoPortalAds.length; i++) {
+            if (this.oppoPortalAds[i].unitId === adUnitId) {
+                let portalAd = this.oppoPortalAds[i];
+                if (portalAd.isShowing) {
+                    portalAd.isShowing = false;
+                    portalAd.ad.hide();
+                }
+                break;
+            }
+        }
+    }
+}