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

package/src/ads-manager/NativeAdsManager.ts

@@ -0,0 +1,445 @@
+import {
+  AdStatus,
+  type AdConfig,
+  type AdData,
+  type AdInstance,
+  type AdManagerState,
+} from '../types/ads-types';
+import { googleMobileAdsManager } from './GoogleMobileAdsManager';
+import { CustomEventEmitter } from '../event/custom-event';
+
+export class NativeAdsManager extends CustomEventEmitter {
+  private state: AdManagerState = {
+    ads: new Map(),
+    loadingKeys: new Set(),
+    displayedKeys: new Set(),
+  };
+
+  private configs: Map<string, AdConfig> = new Map();
+  private loadPromises: Map<string, Promise<void>> = new Map();
+
+  constructor() {
+    super();
+    // Tự động khởi tạo Google Mobile Ads SDK
+    this.initializeGoogleMobileAds();
+  }
+
+  /**
+   * Khởi tạo Google Mobile Ads SDK
+   */
+  private async initializeGoogleMobileAds(): Promise<void> {
+    try {
+      await googleMobileAdsManager.initialize();
+    } catch (error) {
+      console.warn('Failed to initialize Google Mobile Ads SDK:', error);
+    }
+  }
+
+  /**
+   * Preload một native ad với config
+   */
+  async preloadAd(config: AdConfig): Promise<void> {
+    const fullConfig: AdConfig = {
+      ...config,
+      timeout: config.timeout ?? 10000,
+      maxRetries: config.maxRetries ?? 3,
+    };
+
+    const { adKey, adId } = fullConfig;
+    this.configs.set(adKey, fullConfig);
+
+    // Tạo ad instance nếu chưa tồn tại
+    if (!this.state.ads.has(adKey)) {
+      const adInstance: AdInstance = {
+        adKey,
+        adId,
+        status: AdStatus.IDLE,
+        data: null,
+        error: null,
+        loadTime: null,
+        displayTime: null,
+        retryCount: 0,
+        isUsingHighPriority: false,
+        hasTriedHighPriority: false,
+      };
+      this.state.ads.set(adKey, adInstance);
+    }
+
+    // Nếu đang load rồi thì return promise hiện tại
+    if (this.loadPromises.has(adKey)) {
+      return this.loadPromises.get(adKey)!;
+    }
+
+    // Bắt đầu load
+    const loadPromise = this.loadAdInternal(adKey);
+    this.loadPromises.set(adKey, loadPromise);
+
+    try {
+      await loadPromise;
+    } finally {
+      this.loadPromises.delete(adKey);
+    }
+  }
+
+  /**
+   * Load ad ngay lập tức (alias của preloadAd)
+   */
+  async loadAd(config: AdConfig): Promise<void> {
+    return this.preloadAd(config);
+  }
+
+  /**
+   * Hiển thị ad đã được load
+   */
+  async displayAd(adKey: string): Promise<AdInstance | null> {
+    const ad = this.state.ads.get(adKey);
+
+    if (!ad) {
+      console.warn(`Ad with key "${adKey}" not found`);
+      return null;
+    }
+
+    if (ad.status === AdStatus.LOADED) {
+      ad.status = AdStatus.DISPLAYED;
+      ad.displayTime = Date.now();
+      this.state.displayedKeys.add(adKey);
+
+      this.emit('adDisplayed', ad);
+
+      // const config = this.configs.get(adKey);
+      // if (config) {
+      //   // Preload ad mới trong background (không await để không block)
+      //   this.preloadAd(adKey, config.adId, config).catch((error) => {
+      //     console.warn(`Failed to preload new ad for key "${adKey}":`, error);
+      //   });
+      // }
+
+      return ad;
+    }
+
+    if (ad.status === AdStatus.LOADING) {
+      // Đợi load xong
+      await this.waitForAdLoad(adKey);
+      return this.displayAd(adKey);
+    }
+
+    if (ad.status === AdStatus.ERROR) {
+      // Thử load lại
+      await this.refreshAd(adKey);
+      return this.displayAd(adKey);
+    }
+
+    console.warn(
+      `Cannot display ad with key "${adKey}" in status: ${ad.status}`
+    );
+    return null;
+  }
+
+  /**
+   * Lấy ad instance
+   */
+  getAd(adKey: string): AdInstance | null {
+    return this.state.ads.get(adKey) || null;
+  }
+
+  /**
+   * Xóa ad
+   */
+  removeAd(adKey: string): void {
+    const ad = this.state.ads.get(adKey);
+    if (ad?.data?.unsubscribeListeners) {
+      ad.data.unsubscribeListeners();
+    }
+
+    this.state.ads.delete(adKey);
+    this.state.loadingKeys.delete(adKey);
+    this.state.displayedKeys.delete(adKey);
+    this.configs.delete(adKey);
+    this.loadPromises.delete(adKey);
+    this.emit('adRemoved', adKey);
+  }
+
+  /**
+   * Refresh ad (load lại)
+   */
+  async refreshAd(adKey: string): Promise<void> {
+    const config = this.configs.get(adKey);
+    if (!config) {
+      throw new Error(`Config for key "${adKey}" not found`);
+    }
+
+    // Reset status
+    const ad = this.state.ads.get(adKey);
+    if (ad) {
+      ad.status = AdStatus.IDLE;
+      ad.error = null;
+      ad.retryCount = 0;
+    }
+
+    return this.preloadAd(config);
+  }
+
+  /**
+   * Clear tất cả ads
+   */
+  clearAllAds(): void {
+    const keys = Array.from(this.state.ads.keys());
+    keys.forEach((adKey) => this.removeAd(adKey));
+    this.emit('allAdsCleared');
+  }
+
+  /**
+   * Lấy state hiện tại
+   */
+  getState(): AdManagerState {
+    return {
+      ads: new Map(this.state.ads),
+      loadingKeys: new Set(this.state.loadingKeys),
+      displayedKeys: new Set(this.state.displayedKeys),
+    };
+  }
+
+  /**
+   * Internal method để load ad
+   */
+  private async loadAdInternal(adKey: string): Promise<void> {
+    const ad = this.state.ads.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; // Reset retry count cho adId bình thường
+        ad.isUsingHighPriority = false;
+        // Không return, tiếp tục load với adId bình thường ở lần recursive call
+        return this.loadAdInternal(adKey);
+      } else {
+        // Nếu đã dùng adId bình thường mà vẫn lỗi
+        ad.status = AdStatus.ERROR;
+        ad.error = `Max retries (${config.maxRetries}) exceeded`;
+        this.emit('adError', ad);
+        return;
+      }
+    }
+
+    ad.status = AdStatus.LOADING;
+    ad.retryCount++;
+    this.state.loadingKeys.add(adKey);
+
+    this.emit('adLoading', ad);
+
+    try {
+      // Gọi native method để load ad
+      const adData = await this.loadNativeAd(adIdToLoad, config.timeout!);
+
+      ad.status = AdStatus.LOADED;
+      ad.data = adData;
+      ad.error = null;
+      ad.loadTime = Date.now();
+      ad.retryCount = 0;
+
+      // Nếu load high priority thành công, đánh dấu đã thử
+      if (ad.isUsingHighPriority) {
+        ad.hasTriedHighPriority = true;
+      }
+
+      this.state.loadingKeys.delete(adKey);
+      this.emit('adLoaded', ad);
+    } catch (error) {
+      ad.status = AdStatus.ERROR;
+      ad.error = error instanceof Error ? error.message : String(error);
+      this.state.loadingKeys.delete(adKey);
+      this.emit('adError', ad);
+      throw error;
+    }
+  }
+
+  /**
+   * Đợi ad load xong
+   */
+  private async waitForAdLoad(adKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout waiting for ad "${adKey}" to load`));
+      }, 10000);
+
+      const checkAd = () => {
+        const ad = this.state.ads.get(adKey);
+        if (!ad) {
+          clearTimeout(timeout);
+          reject(new Error(`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();
+    });
+  }
+
+  private googleMobileAdsModule: any = null;
+
+  /**
+   * Load native ad sử dụng react-native-google-mobile-ads
+   */
+  private async loadNativeAd(adId: string, timeout: number): Promise<AdData> {
+    try {
+      // Đảm bảo Google Mobile Ads SDK đã được khởi tạo
+      await googleMobileAdsManager.initialize();
+
+      // Cache import để tránh import nhiều lần
+      if (!this.googleMobileAdsModule) {
+        this.googleMobileAdsModule = await import(
+          'react-native-google-mobile-ads'
+        );
+      }
+
+      const {
+        NativeAd,
+        TestIds,
+        NativeAdChoicesPlacement,
+        NativeAdEventType,
+        NativeMediaAspectRatio,
+      } = this.googleMobileAdsModule;
+
+      // Sử dụng test ID nếu adId là test
+      const finalAdId = adId === 'test' ? TestIds.NATIVE : adId;
+
+      // Tạo promise với timeout
+      const loadPromise = new Promise<AdData>((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error(`Timeout loading ad after ${timeout}ms`));
+        }, timeout);
+
+        // Tạo native ad request
+        NativeAd.createForAdRequest(finalAdId, {
+          aspectRatio: NativeMediaAspectRatio.LANDSCAPE,
+          adChoicesPlacement: NativeAdChoicesPlacement.TOP_RIGHT,
+          startVideoMuted: false,
+        })
+          .then((nativeAd: InstanceType<typeof NativeAd>) => {
+            clearTimeout(timeoutId);
+
+            console.log('nativeAd', 'loadNativeAd');
+
+            // Thêm event listeners cho native ad
+            const unsubscribeClicked = nativeAd.addAdEventListener(
+              NativeAdEventType.CLICKED,
+              () => {
+                console.log('Native ad clicked');
+                this.emit('adClicked', { adId, nativeAd });
+              }
+            );
+
+            const unsubscribeImpression = nativeAd.addAdEventListener(
+              NativeAdEventType.IMPRESSION,
+              () => {
+                console.log('Native ad impression recorded');
+                this.emit('adImpression', { adId, nativeAd });
+              }
+            );
+            // const unsubscribeOpened = nativeAd.addAdEventListener(
+            //   AdEventType.OPENED,
+            //   () => {
+            //     console.log('Native ad opened');
+            //     this.emit('adOpened', { adId, nativeAd });
+            //   }
+            // );
+
+            // const unsubscribeClosed = nativeAd.addAdEventListener(
+            //   AdEventType.CLOSED,
+            //   () => {
+            //     console.log('Native ad closed');
+            //     this.emit('adClosed', { adId, nativeAd });
+            //   }
+            // );
+
+            // Chuyển đổi native ad data thành AdData format
+            const adData: AdData = {
+              id: adId,
+              title: nativeAd.headline || '',
+              description: nativeAd.body || '',
+              imageUrl: nativeAd.images?.[0]?.url || nativeAd.icon?.url || '',
+              callToAction: nativeAd.callToAction || 'Learn More',
+              advertiser: nativeAd.advertiser || '',
+              rating: nativeAd.starRating || undefined,
+              price: nativeAd.price || undefined,
+              store: nativeAd.store || undefined,
+              // Thêm các field khác từ native ad
+              nativeAd: nativeAd, // Lưu reference đến native ad object
+              iconUrl: nativeAd.icon?.url,
+              images:
+                nativeAd.images?.map((img: { url: any }) => img.url) || [],
+              // Lưu unsubscribe functions để cleanup sau này
+              unsubscribeListeners: () => {
+                unsubscribeClicked();
+                unsubscribeImpression();
+              },
+            };
+
+            resolve(adData);
+          })
+          .catch((error: { message: any }) => {
+            clearTimeout(timeoutId);
+            reject(new Error(`Failed to load native ad: ${error.message}`));
+          });
+      });
+
+      return await loadPromise;
+    } catch (error) {
+      // Fallback về mock data nếu có lỗi import hoặc load
+      console.warn('Failed to load native ad, using mock data:', error);
+
+      return new Promise((resolve) => {
+        setTimeout(
+          () => {
+            resolve({
+              id: adId,
+              title: 'Sample Ad Title',
+              description: 'This is a sample ad description',
+              imageUrl: 'https://via.placeholder.com/300x200',
+              callToAction: 'Learn More',
+              advertiser: 'Sample Advertiser',
+              rating: 4.5,
+              price: '$9.99',
+              store: 'App Store',
+            });
+          },
+          1000 + Math.random() * 2000
+        );
+      });
+    }
+  }
+}
+
+// Singleton instance
+export const nativeAdsManager = new NativeAdsManager();