@vynix-org/react-native-ads-sdk 0.1.1

package/src/ads-manager/RewardedAdsManager.ts

@@ -0,0 +1,383 @@
+import {
+  AdStatus,
+  type RewardedAdConfig,
+  type RewardedAdInstance,
+} from '../types/ads-types';
+import { googleMobileAdsManager } from './GoogleMobileAdsManager';
+import { CustomEventEmitter } from '../event/custom-event';
+
+export class RewardedAdsManager extends CustomEventEmitter {
+  private state: Map<string, RewardedAdInstance> = new Map();
+  private configs: Map<string, RewardedAdConfig> = new Map();
+  private loadPromises: Map<string, Promise<void>> = new Map();
+
+  constructor() {
+    super();
+    this.initializeGoogleMobileAds();
+  }
+
+  private async initializeGoogleMobileAds(): Promise<void> {
+    try {
+      await googleMobileAdsManager.initialize();
+    } catch (error) {
+      console.warn('Failed to initialize Google Mobile Ads SDK:', error);
+    }
+  }
+
+  // Thay đổi signature: chỉ nhận config
+  async preloadAd(config: RewardedAdConfig): Promise<void> {
+    const fullConfig: RewardedAdConfig = {
+      ...config,
+      timeout: config.timeout ?? 10000,
+      maxRetries: config.maxRetries ?? 3,
+      showOnAppStateChange: config.showOnAppStateChange ?? false,
+    };
+
+    const { adKey, adId } = fullConfig;
+    this.configs.set(adKey, fullConfig);
+
+    if (!this.state.has(adKey)) {
+      const adInstance: RewardedAdInstance = {
+        adKey,
+        adId,
+        status: AdStatus.IDLE,
+        data: null,
+        error: null,
+        loadTime: null,
+        displayTime: null,
+        retryCount: 0,
+        type: 'rewarded',
+        config: fullConfig,
+        isUsingHighPriority: false,
+        hasTriedHighPriority: false,
+      };
+      this.state.set(adKey, adInstance);
+    }
+
+    if (this.loadPromises.has(adKey)) {
+      return this.loadPromises.get(adKey)!;
+    }
+
+    const loadPromise = this.loadAdInternal(adKey);
+    this.loadPromises.set(adKey, loadPromise);
+
+    try {
+      await loadPromise;
+    } finally {
+      this.loadPromises.delete(adKey);
+    }
+  }
+
+  // Thay đổi signature: chỉ nhận config
+  async loadAd(config: RewardedAdConfig): Promise<void> {
+    return this.preloadAd(config);
+  }
+
+  async displayAd(
+    adKey: string
+  ): Promise<{ ad: RewardedAdInstance | null; reward: any }> {
+    const ad = this.state.get(adKey);
+
+    if (!ad) {
+      console.warn(`Rewarded ad with key "${adKey}" not found`);
+      return { ad: null, reward: null };
+    }
+
+    if (ad.status === AdStatus.LOADED) {
+      try {
+        const reward = await this.showRewardedAd(ad);
+
+        ad.status = AdStatus.DISPLAYED;
+        ad.displayTime = Date.now();
+        ad.reward = reward;
+        this.emit('adDisplayed', ad);
+
+        // Tự động preload lại quảng cáo mới
+        // const config = this.configs.get(adKey);
+        // if (config) {
+        //   this.preloadAd(adKey, config.adId, config).catch((error) => {
+        //     console.warn(
+        //       `Failed to preload new rewarded ad for key "${adKey}":`,
+        //       error
+        //     );
+        //   });
+        // }
+
+        return { ad, reward };
+      } catch (error) {
+        ad.status = AdStatus.ERROR;
+        ad.error = error instanceof Error ? error.message : String(error);
+        this.emit('adError', ad);
+        return { ad: null, reward: null };
+      }
+    }
+
+    if (ad.status === AdStatus.LOADING) {
+      await this.waitForAdLoad(adKey);
+      return this.displayAd(adKey);
+    }
+
+    if (ad.status === AdStatus.ERROR) {
+      await this.refreshAd(adKey);
+      return this.displayAd(adKey);
+    }
+
+    console.warn(
+      `Cannot display rewarded ad with key "${adKey}" in status: ${ad.status}`
+    );
+    return { ad: null, reward: null };
+  }
+
+  getAd(adKey: string): RewardedAdInstance | null {
+    return this.state.get(adKey) || null;
+  }
+
+  removeAd(adKey: string): void {
+    this.state.delete(adKey);
+    this.configs.delete(adKey);
+    this.loadPromises.delete(adKey);
+    this.emit('adRemoved', adKey);
+  }
+
+  async refreshAd(adKey: string): Promise<void> {
+    const config = this.configs.get(adKey);
+    if (!config) {
+      throw new Error(`Config for key "${adKey}" not found`);
+    }
+
+    console.log('Refresh ad:', adKey);
+
+    const ad = this.state.get(adKey);
+    if (ad) {
+      ad.status = AdStatus.IDLE;
+      ad.error = null;
+      ad.retryCount = 0;
+    }
+
+    return this.preloadAd(config); // Truyền config thay vì adKey, adId, config
+  }
+
+  clearAllAds(): void {
+    const keys = Array.from(this.state.keys());
+    keys.forEach((adKey) => this.removeAd(adKey));
+    this.emit('allAdsCleared');
+  }
+
+  private async loadAdInternal(adKey: string): Promise<void> {
+    const ad = this.state.get(adKey);
+    const config = this.configs.get(adKey);
+
+    if (!ad || !config) {
+      throw new Error(`Ad or config for key "${adKey}" not found`);
+    }
+
+    // Xác định adId sẽ được sử dụng
+    let adIdToLoad = config.adId;
+
+    // Nếu có adHighpriorityId và chưa thử load high priority
+    if (config.adHighpriorityId && !ad.hasTriedHighPriority) {
+      adIdToLoad = config.adHighpriorityId;
+      ad.isUsingHighPriority = true;
+    } else {
+      ad.isUsingHighPriority = false;
+    }
+
+    // Kiểm tra retry limit
+    if (ad.retryCount >= config.maxRetries!) {
+      // Nếu đang dùng high priority và đã hết retry, fallback về adId bình thường
+      if (ad.isUsingHighPriority) {
+        console.log(
+          `High priority ad failed after ${config.maxRetries} retries, falling back to normal ad`
+        );
+        ad.hasTriedHighPriority = true;
+        ad.retryCount = 0;
+        ad.isUsingHighPriority = false;
+        return this.loadAdInternal(adKey);
+      } else {
+        ad.status = AdStatus.ERROR;
+        ad.error = `Max retries (${config.maxRetries}) exceeded`;
+        this.emit('adError', ad);
+        return;
+      }
+    }
+
+    ad.status = AdStatus.LOADING;
+    ad.retryCount++;
+    this.emit('adLoading', ad);
+
+    try {
+      await googleMobileAdsManager.initialize();
+
+      const rewardedAd = await this.loadRewardedAd(adIdToLoad, config.timeout!);
+
+      ad.status = AdStatus.LOADED;
+      ad.rewardedAd = rewardedAd;
+      ad.error = null;
+      ad.loadTime = Date.now();
+      ad.retryCount = 0;
+
+      if (ad.isUsingHighPriority) {
+        ad.hasTriedHighPriority = true;
+      }
+
+      this.emit('adLoaded', ad);
+    } catch (error) {
+      ad.status = AdStatus.ERROR;
+      ad.error = error instanceof Error ? error.message : String(error);
+      this.emit('adError', ad);
+      throw error;
+    }
+  }
+
+  private async loadRewardedAd(adId: string, timeout: number): Promise<any> {
+    try {
+      const googleMobileAdsModule = await import(
+        'react-native-google-mobile-ads'
+      );
+      const { RewardedAd, TestIds, RewardedAdEventType, AdEventType } =
+        googleMobileAdsModule;
+
+      const finalAdId = adId === 'test' ? TestIds.REWARDED : adId;
+
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error(`Timeout loading rewarded ad after ${timeout}ms`));
+        }, timeout);
+
+        // Tạo rewarded ad instance
+        const rewardedAd = RewardedAd.createForAdRequest(finalAdId);
+
+        // Thêm event listeners
+        const unsubscribeLoaded = rewardedAd.addAdEventListener(
+          RewardedAdEventType.LOADED,
+          () => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            resolve(rewardedAd);
+          }
+        );
+
+        const unsubscribeError = rewardedAd.addAdEventListener(
+          AdEventType.ERROR,
+          (error: any) => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            reject(
+              new Error(`Failed to load rewarded ad: ${error.message || error}`)
+            );
+          }
+        );
+
+        // Bắt đầu load quảng cáo
+        rewardedAd.load();
+      });
+    } catch (error) {
+      console.warn('Failed to load rewarded ad:', error);
+      throw error;
+    }
+  }
+
+  private async showRewardedAd(ad: RewardedAdInstance): Promise<any> {
+    if (!ad.rewardedAd) {
+      throw new Error('Rewarded ad not loaded');
+    }
+
+    return new Promise((resolve, reject) => {
+      const googleMobileAdsModule = require('react-native-google-mobile-ads');
+      const { AdEventType, RewardedAdEventType } = googleMobileAdsModule;
+
+      let earnedReward: any = null;
+
+      // Thêm event listeners cho việc hiển thị
+      const unsubscribeEarnedReward = ad.rewardedAd.addAdEventListener(
+        RewardedAdEventType.EARNED_REWARD,
+        (reward: any) => {
+          earnedReward = reward;
+          // Emit sự kiện earnedReward
+          this.emit('adEarnedReward', { ad, reward });
+        }
+      );
+
+      const unsubscribeClosed = ad.rewardedAd.addAdEventListener(
+        AdEventType.CLOSED,
+        () => {
+          unsubscribeEarnedReward();
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+
+          // Emit sự kiện adClosed
+          this.emit('adClosed', ad);
+          resolve(earnedReward);
+        }
+      );
+
+      const unsubscribeError = ad.rewardedAd.addAdEventListener(
+        AdEventType.ERROR,
+        (error: any) => {
+          unsubscribeEarnedReward();
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+          reject(
+            new Error(`Failed to show rewarded ad: ${error.message || error}`)
+          );
+        }
+      );
+
+      const unsubscribeOpened = ad.rewardedAd.addAdEventListener(
+        AdEventType.OPENED,
+        () => {
+          // Emit sự kiện adOpened
+          this.emit('adOpened', ad);
+        }
+      );
+
+      const unsubscribeClicked = ad.rewardedAd.addAdEventListener(
+        AdEventType.CLICKED,
+        () => {
+          // Emit sự kiện adClicked
+          this.emit('adClicked', ad);
+        }
+      );
+
+      // Hiển thị quảng cáo
+      ad.rewardedAd.show();
+    });
+  }
+
+  private async waitForAdLoad(adKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout waiting for rewarded ad "${adKey}" to load`));
+      }, 10000);
+
+      const checkAd = () => {
+        const ad = this.state.get(adKey);
+        if (!ad) {
+          clearTimeout(timeout);
+          reject(new Error(`Rewarded ad "${adKey}" not found`));
+          return;
+        }
+
+        if (ad.status === AdStatus.LOADED) {
+          clearTimeout(timeout);
+          resolve();
+        } else if (ad.status === AdStatus.ERROR) {
+          clearTimeout(timeout);
+          reject(new Error(ad.error || 'Unknown error'));
+        } else {
+          setTimeout(checkAd, 100);
+        }
+      };
+
+      checkAd();
+    });
+  }
+}
+
+export const rewardedAdsManager = new RewardedAdsManager();