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

package/src/ads-manager/GoogleMobileAdsManager.ts

@@ -0,0 +1,68 @@
+import { MobileAds } from 'react-native-google-mobile-ads';
+
+export class GoogleMobileAdsManager {
+  private static instance: GoogleMobileAdsManager;
+  private isInitialized = false;
+  private initPromise: Promise<void> | null = null;
+
+  private constructor() {}
+
+  static getInstance(): GoogleMobileAdsManager {
+    if (!GoogleMobileAdsManager.instance) {
+      GoogleMobileAdsManager.instance = new GoogleMobileAdsManager();
+    }
+    return GoogleMobileAdsManager.instance;
+  }
+
+  /**
+   * Khởi tạo Google Mobile Ads SDK
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    this.initPromise = this.initializeInternal();
+    return this.initPromise;
+  }
+
+  private async initializeInternal(): Promise<void> {
+    try {
+      await MobileAds().initialize();
+      this.isInitialized = true;
+      console.log('Google Mobile Ads SDK initialized successfully');
+    } catch (error) {
+      console.error('Failed to initialize Google Mobile Ads SDK:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Kiểm tra xem SDK đã được khởi tạo chưa
+   */
+  isSDKInitialized(): boolean {
+    return this.isInitialized;
+  }
+
+  /**
+   * Lấy trạng thái khởi tạo
+   */
+  getInitializationStatus(): Promise<boolean> {
+    if (this.isInitialized) {
+      return Promise.resolve(true);
+    }
+
+    if (this.initPromise) {
+      return this.initPromise.then(() => true).catch(() => false);
+    }
+
+    return Promise.resolve(false);
+  }
+}
+
+// Singleton instance
+export const googleMobileAdsManager = GoogleMobileAdsManager.getInstance();

package/src/ads-manager/InterstitialAdsManager.ts

@@ -0,0 +1,371 @@
+import {
+  AdStatus,
+  type InterstitialAdConfig,
+  type InterstitialAdInstance,
+} from '../types/ads-types';
+import { googleMobileAdsManager } from './GoogleMobileAdsManager';
+import { CustomEventEmitter } from '../event/custom-event';
+
+export class InterstitialAdsManager extends CustomEventEmitter {
+  private state: Map<string, InterstitialAdInstance> = new Map();
+  private configs: Map<string, InterstitialAdConfig> = 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: InterstitialAdConfig): Promise<void> {
+    const fullConfig: InterstitialAdConfig = {
+      ...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: InterstitialAdInstance = {
+        adKey,
+        adId,
+        status: AdStatus.IDLE,
+        data: null,
+        error: null,
+        loadTime: null,
+        displayTime: null,
+        retryCount: 0,
+        type: 'interstitial',
+        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: InterstitialAdConfig): Promise<void> {
+    return this.preloadAd(config);
+  }
+
+  async displayAd(adKey: string): Promise<InterstitialAdInstance | null> {
+    const ad = this.state.get(adKey);
+
+    if (!ad) {
+      console.warn(`Interstitial ad with key "${adKey}" not found`);
+      return null;
+    }
+
+    if (ad.status === AdStatus.LOADED) {
+      try {
+        await this.showInterstitialAd(ad);
+
+        ad.status = AdStatus.DISPLAYED;
+        ad.displayTime = Date.now();
+        this.emit('adDisplayed', ad);
+
+        return ad;
+      } catch (error) {
+        ad.status = AdStatus.ERROR;
+        ad.error = error instanceof Error ? error.message : String(error);
+        this.emit('adError', ad);
+        return 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 interstitial ad with key "${adKey}" in status: ${ad.status}`
+    );
+    return null;
+  }
+
+  getAd(adKey: string): InterstitialAdInstance | 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 interstitialAd = await this.loadInterstitialAd(
+        adIdToLoad,
+        config.timeout!
+      );
+
+      ad.status = AdStatus.LOADED;
+      ad.interstitialAd = interstitialAd;
+      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 loadInterstitialAd(
+    adId: string,
+    timeout: number
+  ): Promise<any> {
+    try {
+      const googleMobileAdsModule = await import(
+        'react-native-google-mobile-ads'
+      );
+      const { InterstitialAd, TestIds, AdEventType } = googleMobileAdsModule;
+
+      const finalAdId = adId === 'test' ? TestIds.INTERSTITIAL : adId;
+
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(
+            new Error(`Timeout loading interstitial ad after ${timeout}ms`)
+          );
+        }, timeout);
+
+        // Tạo interstitial ad instance
+        const interstitialAd = InterstitialAd.createForAdRequest(finalAdId);
+
+        // Thêm event listeners
+        const unsubscribeLoaded = interstitialAd.addAdEventListener(
+          AdEventType.LOADED,
+          () => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            resolve(interstitialAd);
+          }
+        );
+
+        const unsubscribeError = interstitialAd.addAdEventListener(
+          AdEventType.ERROR,
+          (error: any) => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            reject(
+              new Error(
+                `Failed to load interstitial ad: ${error.message || error}`
+              )
+            );
+          }
+        );
+
+        // Bắt đầu load quảng cáo
+        interstitialAd.load();
+      });
+    } catch (error) {
+      console.warn('Failed to load interstitial ad:', error);
+      throw error;
+    }
+  }
+
+  private async showInterstitialAd(ad: InterstitialAdInstance): Promise<void> {
+    if (!ad.interstitialAd) {
+      throw new Error('Interstitial ad not loaded');
+    }
+
+    console.log('Show interstitial ad:', ad.adKey);
+
+    return new Promise((resolve, reject) => {
+      const googleMobileAdsModule = require('react-native-google-mobile-ads');
+      const { AdEventType } = googleMobileAdsModule;
+
+      // Thêm event listeners cho việc hiển thị
+      const unsubscribeClosed = ad.interstitialAd.addAdEventListener(
+        AdEventType.CLOSED,
+        () => {
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+
+          // Emit sự kiện adClosed
+          this.emit('adClosed', ad);
+          resolve();
+        }
+      );
+
+      const unsubscribeError = ad.interstitialAd.addAdEventListener(
+        AdEventType.ERROR,
+        (error: any) => {
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+          reject(
+            new Error(
+              `Failed to show interstitial ad: ${error.message || error}`
+            )
+          );
+        }
+      );
+
+      const unsubscribeOpened = ad.interstitialAd.addAdEventListener(
+        AdEventType.OPENED,
+        () => {
+          // Emit sự kiện adOpened
+          this.emit('adOpened', ad);
+        }
+      );
+
+      const unsubscribeClicked = ad.interstitialAd.addAdEventListener(
+        AdEventType.CLICKED,
+        () => {
+          // Emit sự kiện adClicked
+          this.emit('adClicked', ad);
+        }
+      );
+
+      // Hiển thị quảng cáo
+      ad.interstitialAd.show();
+    });
+  }
+
+  private async waitForAdLoad(adKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(
+          new Error(`Timeout waiting for interstitial ad "${adKey}" to load`)
+        );
+      }, 10000);
+
+      const checkAd = () => {
+        const ad = this.state.get(adKey);
+        if (!ad) {
+          clearTimeout(timeout);
+          reject(new Error(`Interstitial 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 interstitialAdsManager = new InterstitialAdsManager();