drgame-cc 1.0.14 → 1.0.16

package/drscript/ad/AdManager.ts

@@ -0,0 +1,174 @@
+import TvUiConfigManager from "../config/TvUiConfigManager";
+import { TvUiAdChannelConfig, TvUiAdSlotConfig } from "../config/TvUiConfig";
+import IAdProvider, { AdRuntimeData, AdShowOptions, AdShowResult } from "./IAdProvider";
+import AggregateAdProvider from "./AggregateAdProvider";
+import SelfAdProvider from "./SelfAdProvider";
+import MockAdProvider from "./MockAdProvider";
+
+export default class AdManager {
+    private static providers: { [type: string]: IAdProvider } = {};
+
+    public static init() {
+        this.providers = {};
+        this.registerProvider(new AggregateAdProvider());
+        this.registerProvider(new SelfAdProvider());
+        this.registerProvider(new MockAdProvider());
+    }
+
+    public static registerProvider(provider: IAdProvider) {
+        if (!provider || !provider.type) return;
+        this.providers[provider.type] = provider;
+    }
+
+    public static showSlot(slotId: string, options: AdShowOptions = {}): Promise<boolean> {
+        let slotConfig = this.getSlotConfig(slotId);
+        if (!slotConfig || slotConfig.enabled === false) {
+            if (options.onFail) options.onFail({ message: "ad slot disabled", slotId: slotId });
+            return Promise.resolve(false);
+        }
+
+        let channels = this.getSortedChannels(slotConfig);
+        return this.showByChannels(slotId, slotConfig, options, channels, 0, null).then((result: AdShowResult) => {
+            if (result && (result.status == "success" || result.status == "loaded")) return true;
+            if (result && result.status == "closed") return false;
+            if (options.onFail) {
+                options.onFail((result && result.error) || { message: "all ad channels failed", slotId: slotId });
+            }
+            return false;
+        });
+    }
+
+    public static hideSlot(slotId: string) {
+        let slotConfig = this.getSlotConfig(slotId);
+        let channels = slotConfig ? this.getSortedChannels(slotConfig) : [];
+        if (channels.length > 0) {
+            for (let i = 0; i < channels.length; i++) {
+                let channel = channels[i];
+                let provider = channel && this.providers[channel.type];
+                if (provider) provider.hide(slotId, channel);
+            }
+            return;
+        }
+        for (let type in this.providers) {
+            if (this.providers.hasOwnProperty(type)) this.providers[type].hide(slotId);
+        }
+    }
+
+    public static refreshSlot(slotId: string, options: AdShowOptions = {}) {
+        this.hideSlot(slotId);
+        return this.showSlot(slotId, options);
+    }
+
+    public static showReward(options: AdShowOptions): Promise<boolean> {
+        options = this.mergeOptions(options, { mode: "reward" });
+        return this.showSlot((options && options.slotId) || "reward", options);
+    }
+
+    public static showPopup(options: AdShowOptions): Promise<boolean> {
+        options = this.mergeOptions(options, { mode: "popup" });
+        return this.showSlot((options && options.slotId) || (options && options.trigger_scene) || "popup", options);
+    }
+
+    public static hidePopup(scene?: string) {
+        this.hideSlot(scene || "popup");
+    }
+
+    private static getSlotConfig(slotId: string): TvUiAdSlotConfig {
+        let config = TvUiConfigManager.getConfig();
+        let ads = config.ads || {};
+        return ads[slotId] || ads["popup"] || null;
+    }
+
+    private static showByChannels(
+        slotId: string,
+        slotConfig: TvUiAdSlotConfig,
+        options: AdShowOptions,
+        channels: TvUiAdChannelConfig[],
+        index: number,
+        lastError: any
+    ): Promise<AdShowResult> {
+        if (index >= channels.length) {
+            return Promise.resolve({ status: "failed", error: lastError || { message: "ad channels empty", slotId: slotId } });
+        }
+
+        let channel = channels[index];
+        if (!channel || channel.enabled === false) {
+            return this.showByChannels(slotId, slotConfig, options, channels, index + 1, lastError);
+        }
+
+        let provider = this.providers[channel.type];
+        if (!provider) {
+            return this.showByChannels(slotId, slotConfig, options, channels, index + 1, { message: "ad provider missing", channel: channel.type });
+        }
+        if (!provider.isAvailable()) {
+            return this.showByChannels(slotId, slotConfig, options, channels, index + 1, { message: "ad provider unavailable", channel: channel.type });
+        }
+
+        let data: AdRuntimeData = {
+            slotId: slotId,
+            slotConfig: slotConfig,
+            channel: channel,
+            options: options
+        };
+        return provider.load(data).then((runtimeData: AdRuntimeData) => {
+            return provider.show(runtimeData);
+        }).then((result: AdShowResult) => {
+            if (!result || result.status == "failed") {
+                if (options && options.mode == "reward") return result || <AdShowResult>{ status: "failed", error: lastError };
+                return this.showByChannels(slotId, slotConfig, options, channels, index + 1, result && (result.error || result.data));
+            }
+            return result;
+        }).catch((error: any) => {
+            if (options && options.mode == "reward") return <AdShowResult>{ status: "failed", error: error };
+            return this.showByChannels(slotId, slotConfig, options, channels, index + 1, error);
+        });
+    }
+
+    private static getSortedChannels(slotConfig: TvUiAdSlotConfig): TvUiAdChannelConfig[] {
+        let channels: TvUiAdChannelConfig[] = [];
+        let configured = (slotConfig && slotConfig.channels) || [];
+        for (let i = 0; i < configured.length; i++) {
+            if (configured[i]) channels.push(configured[i]);
+        }
+        if (slotConfig && slotConfig.fallback) {
+            channels.push(this.normalizeFallback(slotConfig.fallback));
+        }
+        if (!this.hasChannelType(channels, "mock")) {
+            channels.push({ type: "mock", priority: 100 });
+        }
+        channels.sort((a: TvUiAdChannelConfig, b: TvUiAdChannelConfig) => {
+            return this.getPriority(a) - this.getPriority(b);
+        });
+        return channels;
+    }
+
+    private static normalizeFallback(fallback: TvUiAdChannelConfig): TvUiAdChannelConfig {
+        if (fallback.type) return fallback;
+        let result: any = this.mergeOptions(<any>fallback, {});
+        result.type = (fallback.imagePath || fallback.imageUrl) ? "self" : "mock";
+        if (result.priority === undefined) result.priority = 90;
+        return result;
+    }
+
+    private static hasChannelType(channels: TvUiAdChannelConfig[], type: string): boolean {
+        for (let i = 0; i < channels.length; i++) {
+            if (channels[i] && channels[i].type == type) return true;
+        }
+        return false;
+    }
+
+    private static getPriority(channel: TvUiAdChannelConfig): number {
+        if (!channel || channel.priority === undefined) return 999;
+        return channel.priority;
+    }
+
+    private static mergeOptions(base: AdShowOptions, extra: AdShowOptions): AdShowOptions {
+        let result: any = {};
+        let key: string;
+        base = base || {};
+        extra = extra || {};
+        for (key in base) result[key] = (<any>base)[key];
+        for (key in extra) result[key] = (<any>extra)[key];
+        return result;
+    }
+}

package/drscript/ad/AdManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "6b1da664-0e06-4afe-bee8-14720c303a68",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/ad/AdSlot.ts

@@ -0,0 +1,44 @@
+import AdManager from "./AdManager";
+
+const { ccclass, property } = cc._decorator;
+
+@ccclass
+export default class AdSlot extends cc.Component {
+    @property
+    slotId: string = "popup";
+
+    @property
+    showOnLoad: boolean = false;
+
+    onEnable() {
+        if (this.showOnLoad) this.show();
+    }
+
+    onDisable() {
+        this.hide();
+    }
+
+    public show() {
+        AdManager.showSlot(this.slotId, { container: this.node });
+    }
+
+    public hide() {
+        AdManager.hideSlot(this.slotId);
+    }
+
+    public refresh() {
+        AdManager.refreshSlot(this.slotId, { container: this.node });
+    }
+
+    public static show(slotId: string) {
+        return AdManager.showSlot(slotId);
+    }
+
+    public static hide(slotId: string) {
+        AdManager.hideSlot(slotId);
+    }
+
+    public static refresh(slotId: string) {
+        return AdManager.refreshSlot(slotId);
+    }
+}

package/drscript/ad/AdSlot.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "4db774ef-5abf-4415-a468-dc2ef8fea47b",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/ad/AggregateAdProvider.ts

@@ -0,0 +1,148 @@
+import TvUiConfigManager from "../config/TvUiConfigManager";
+import NativeBridge from "../core/NativeBridge";
+import { TvUiAdChannelConfig } from "../config/TvUiConfig";
+import IAdProvider, { AdRuntimeData, AdShowResult } from "./IAdProvider";
+import { AdSdk, AdPlatform, AdType, AdErrorCode } from "../ad-sdk/ad-sdk";
+
+export default class AggregateAdProvider implements IAdProvider {
+    public type: string = "aggregate";
+
+    private static initialized: boolean = false;
+    private static initTask: Promise<void> | null = null;
+    private static gameReadyNotified: boolean = false;
+    private static GAME_VERSION: string = "1.0.0";
+
+    public isAvailable(): boolean {
+        return NativeBridge.hasBridge();
+    }
+
+    public load(data: AdRuntimeData): Promise<AdRuntimeData> {
+        return this.ensureSdk().then(() => data);
+    }
+
+    public show(data: AdRuntimeData): Promise<AdShowResult> {
+        return null;
+        // let options = data.options || {};
+        // let mode = options.mode || data.slotConfig.mode || "popup";
+        // if (mode == "reward") {
+        //     return this.showReward(data);
+        // }
+        // return this.showPopup(data);
+    }
+
+    public hide(slotId: string, channel?: TvUiAdChannelConfig): void {
+        // if (!AggregateAdProvider.initialized || !this.isAvailable()) return;
+        // let runtime = TvUiConfigManager.getConfig();
+        // try {
+        //     AdSdk.hidePopupAd({
+        //         cpId: runtime.cpId || "ppl",
+        //         trigger_scene: slotId || "",
+        //         placementId: (channel && channel.placementId) || ""
+        //     });
+        // } catch (error) {
+        //     console.warn("[AggregateAdProvider] hide popup failed", error);
+        // }
+    }
+
+    private showReward(data: AdRuntimeData): Promise<AdShowResult> {
+        let options = data.options || {};
+        let channel = data.channel || <any>{};
+        let runtime = TvUiConfigManager.getConfig();
+        return AdSdk.requestAd({
+            adType: AdType.RewardVideo,
+            cpId: options.cpId || runtime.cpId || "ppl",
+            rewardType: options.reward_type || channel.reward_type || "reward",
+            triggerScene: options.trigger_scene || data.slotId,
+            extra: options.extra || {}
+        }).then((result: any) => {
+            if (!result || result.isCompleted !== true) {
+                if (options.onClose) options.onClose(result);
+                return <AdShowResult>{ status: "closed", data: result };
+            }
+            if (options.onSuccess) options.onSuccess(result);
+            return <AdShowResult>{ status: "success", data: result };
+        }).catch((error: any) => {
+            if (this.isUserAbandoned(error)) {
+                if (options.onClose) options.onClose(error);
+                return <AdShowResult>{ status: "closed", data: error };
+            }
+            return <AdShowResult>{ status: "failed", error: error };
+        });
+    }
+
+    // private showPopup(data: AdRuntimeData): Promise<AdShowResult> {
+    //     let options = data.options || {};
+    //     let channel = data.channel || <any>{};
+    //     let runtime = TvUiConfigManager.getConfig();
+    //     return AdSdk.requestPopupAd({
+    //         adType: AdType.Interstitial,
+    //         cpId: options.cpId || runtime.cpId || "ppl",
+    //         reward_type: options.reward_type || channel.reward_type || "popup",
+    //         trigger_scene: options.trigger_scene || data.slotId,
+    //         placementId: channel.placementId || "",
+    //         extra: options.extra || {}
+    //     }).then((result: any) => {
+    //         if (result && result.isClosed) {
+    //             if (options.onClose) options.onClose(result);
+    //             return <AdShowResult>{ status: "closed", data: result };
+    //         }
+    //         if (options.onLoad) options.onLoad(result);
+    //         return <AdShowResult>{ status: "loaded", data: result };
+    //     }).catch((error: any) => {
+    //         return <AdShowResult>{ status: "failed", error: error };
+    //     });
+    // }
+
+    private ensureSdk(): Promise<void> {
+        if (AggregateAdProvider.initialized) return Promise.resolve();
+        if (AggregateAdProvider.initTask) return AggregateAdProvider.initTask;
+
+        let runtime = TvUiConfigManager.getConfig();
+        let adSdkConfig = runtime.adSdk || {};
+        let platform = this.getPlatform(adSdkConfig.platform || "xiaomi");
+        let adapterConfig: any = {};
+        let customConfig = adSdkConfig.adapterConfig || {};
+        let key: string;
+        adapterConfig.cpId = runtime.cpId || "ppl";
+        for (key in customConfig) adapterConfig[key] = customConfig[key];
+
+        let adapters: any = {};
+        adapters[platform] = adapterConfig;
+
+        AggregateAdProvider.initTask = AdSdk.init({
+            platform: platform,
+            adapters: adapters
+        }).then(() => {
+            AggregateAdProvider.initialized = true;
+            this.notifyGameReady(runtime.version || AggregateAdProvider.GAME_VERSION);
+        }).catch((error: any) => {
+            AggregateAdProvider.initTask = null;
+            throw error;
+        });
+        return AggregateAdProvider.initTask;
+    }
+
+    private notifyGameReady(version: string) {
+        if (AggregateAdProvider.gameReadyNotified) return;
+        AggregateAdProvider.gameReadyNotified = true;
+        try {
+            AdSdk.onGameReady(version || AggregateAdProvider.GAME_VERSION);
+        } catch (error) {
+            console.warn("[AggregateAdProvider] onGameReady failed", error);
+        }
+    }
+
+    private getPlatform(platform: string): any {
+        if (platform == "xiaomi" || !platform) return AdPlatform.Xiaomi;
+        return platform;
+    }
+
+    private isUserAbandoned(error: any): boolean {
+        if (!error) return false;
+        return error.code == AdErrorCode.UserAbandoned
+            || error.code == 1006
+            || error.isCompleted === false
+            || error.is_completed === false
+            || error.message == "Ad closed by user before completion";
+    }
+}

package/drscript/ad/AggregateAdProvider.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "6bbf6f7e-4fe1-43e9-9de9-b3e5762628db",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/ad/IAdProvider.ts

@@ -0,0 +1,39 @@
+import { TvUiAdChannelConfig, TvUiAdSlotConfig } from "../config/TvUiConfig";
+
+export interface AdShowOptions {
+    slotId?: string;
+    mode?: string;
+    cpId?: string;
+    trigger_scene?: string;
+    reward_type?: string;
+    extra?: any;
+    container?: cc.Node;
+    onLoad?: (data?: any) => void;
+    onSuccess?: (data?: any) => void;
+    onClose?: (data?: any) => void;
+    onFail?: (data?: any) => void;
+}
+
+export interface AdRuntimeData {
+    slotId: string;
+    slotConfig: TvUiAdSlotConfig;
+    channel: TvUiAdChannelConfig;
+    options: AdShowOptions;
+}
+
+export type AdShowResultStatus = "success" | "loaded" | "closed" | "failed";
+
+export interface AdShowResult {
+    status: AdShowResultStatus;
+    data?: any;
+    error?: any;
+    action?: string;
+}
+
+export default interface IAdProvider {
+    type: string;
+    isAvailable(): boolean;
+    load(data: AdRuntimeData): Promise<AdRuntimeData>;
+    show(data: AdRuntimeData): Promise<AdShowResult>;
+    hide(slotId: string, channel?: TvUiAdChannelConfig): void;
+}

package/drscript/ad/IAdProvider.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "fa1cfbaf-e828-42f9-b1d5-2b5664f0b48a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/ad/MockAdProvider.ts

@@ -0,0 +1,36 @@
+import IAdProvider, { AdRuntimeData, AdShowResult } from "./IAdProvider";
+
+export default class MockAdProvider implements IAdProvider {
+    public type: string = "mock";
+
+    public isAvailable(): boolean {
+        return true;
+    }
+
+    public load(data: AdRuntimeData): Promise<AdRuntimeData> {
+        return Promise.resolve(data);
+    }
+
+    public show(data: AdRuntimeData): Promise<AdShowResult> {
+        let options = data.options || {};
+        let mode = options.mode || data.slotConfig.mode || "popup";
+        console.log("[MockAdProvider] show", data.slotId, mode);
+        return new Promise<AdShowResult>((resolve) => {
+            setTimeout(() => {
+                let result = { mock: true, slotId: data.slotId };
+                if (mode == "reward") {
+                    let rewardResult = { isCompleted: true, mock: true, slotId: data.slotId };
+                    if (options.onSuccess) options.onSuccess(rewardResult);
+                    resolve({ status: "success", data: rewardResult });
+                } else {
+                    if (options.onLoad) options.onLoad(result);
+                    resolve({ status: "loaded", data: result });
+                }
+            }, 0);
+        });
+    }
+
+    public hide(slotId: string): void {
+        console.log("[MockAdProvider] hide", slotId);
+    }
+}

package/drscript/ad/MockAdProvider.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "79d1fbec-5a22-41a9-93c5-905ebe95881b",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/ad/SelfAdProvider.ts

@@ -0,0 +1,41 @@
+import IAdProvider, { AdRuntimeData, AdShowResult } from "./IAdProvider";
+
+export default class SelfAdProvider implements IAdProvider {
+    public type: string = "self";
+
+    public isAvailable(): boolean {
+        return true;
+    }
+
+    public load(data: AdRuntimeData): Promise<AdRuntimeData> {
+        return Promise.resolve(data);
+    }
+
+    public show(data: AdRuntimeData): Promise<AdShowResult> {
+        let channel = data.channel || <any>{};
+        let options = data.options || {};
+        let path = channel.imagePath || (data.slotConfig.fallback && data.slotConfig.fallback.imagePath);
+        if (!path || !options.container) {
+            if (options.onLoad) options.onLoad({ self: true, slotId: data.slotId });
+            return Promise.resolve({ status: "loaded", data: { self: true, slotId: data.slotId } });
+        }
+        let node = options.container;
+        let sprite = node.getComponent(cc.Sprite) || node.addComponent(cc.Sprite);
+        sprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+        return new Promise<AdShowResult>((resolve) => {
+            cc.loader.loadRes(path, cc.SpriteFrame, (error: Error, frame: cc.SpriteFrame) => {
+                if (error || !frame) {
+                    resolve({ status: "failed", error: error || { message: "self ad frame missing" } });
+                    return;
+                }
+                sprite.spriteFrame = frame;
+                node.active = true;
+                if (options.onLoad) options.onLoad({ self: true, slotId: data.slotId });
+                resolve({ status: "loaded", data: { self: true, slotId: data.slotId } });
+            });
+        });
+    }
+
+    public hide(_slotId: string): void {
+    }
+}

package/drscript/ad/SelfAdProvider.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3411bed4-146e-4244-8804-aa5ee24f5df0",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}