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

package/src/ads-manager/RewardedInterstitialAdsManager.ts

@@ -0,0 +1,410 @@
+import {
+  AdStatus,
+  type RewardedInterstitialAdConfig,
+  type RewardedInterstitialAdInstance,
+} from '../types/ads-types';
+import { googleMobileAdsManager } from './GoogleMobileAdsManager';
+import { CustomEventEmitter } from '../event/custom-event';
+
+export class RewardedInterstitialAdsManager extends CustomEventEmitter {
+  private state: Map<string, RewardedInterstitialAdInstance> = new Map();
+  private configs: Map<string, RewardedInterstitialAdConfig> = 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: RewardedInterstitialAdConfig): Promise<void> {
+    const fullConfig: RewardedInterstitialAdConfig = {
+      ...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: RewardedInterstitialAdInstance = {
+        adKey,
+        adId,
+        status: AdStatus.IDLE,
+        data: null,
+        error: null,
+        loadTime: null,
+        displayTime: null,
+        retryCount: 0,
+        type: 'rewarded_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: RewardedInterstitialAdConfig): Promise<void> {
+    return this.preloadAd(config);
+  }
+
+  async displayAd(
+    adKey: string
+  ): Promise<{ ad: RewardedInterstitialAdInstance | null; reward: any }> {
+    const ad = this.state.get(adKey);
+
+    if (!ad) {
+      console.warn(`Rewarded interstitial ad with key "${adKey}" not found`);
+      return { ad: null, reward: null };
+    }
+
+    if (ad.status === AdStatus.LOADED) {
+      try {
+        const reward = await this.showRewardedInterstitialAd(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 interstitial 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 interstitial ad with key "${adKey}" in status: ${ad.status}`
+    );
+    return { ad: null, reward: null };
+  }
+
+  getAd(adKey: string): RewardedInterstitialAdInstance | 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 rewardedInterstitialAd = await this.loadRewardedInterstitialAd(
+        adIdToLoad,
+        config.timeout!
+      );
+
+      ad.status = AdStatus.LOADED;
+      ad.rewardedInterstitialAd = rewardedInterstitialAd;
+      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 loadRewardedInterstitialAd(
+    adId: string,
+    timeout: number
+  ): Promise<any> {
+    try {
+      const googleMobileAdsModule = await import(
+        'react-native-google-mobile-ads'
+      );
+      const {
+        RewardedInterstitialAd,
+        TestIds,
+        AdEventType,
+        RewardedAdEventType,
+      } = googleMobileAdsModule;
+
+      const finalAdId = adId === 'test' ? TestIds.REWARDED_INTERSTITIAL : adId;
+
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(
+            new Error(
+              `Timeout loading rewarded interstitial ad after ${timeout}ms`
+            )
+          );
+        }, timeout);
+
+        // Tạo rewarded interstitial ad instance
+        const rewardedInterstitialAd =
+          RewardedInterstitialAd.createForAdRequest(finalAdId);
+
+        // Thêm event listeners
+        const unsubscribeLoaded = rewardedInterstitialAd.addAdEventListener(
+          RewardedAdEventType.LOADED,
+          () => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            resolve(rewardedInterstitialAd);
+          }
+        );
+
+        const unsubscribeError = rewardedInterstitialAd.addAdEventListener(
+          AdEventType.ERROR,
+          (error: any) => {
+            clearTimeout(timeoutId);
+            unsubscribeLoaded();
+            unsubscribeError();
+            reject(
+              new Error(
+                `Failed to load rewarded interstitial ad: ${error.message || error}`
+              )
+            );
+          }
+        );
+
+        // Bắt đầu load quảng cáo
+        rewardedInterstitialAd.load();
+      });
+    } catch (error) {
+      console.warn('Failed to load rewarded interstitial ad:', error);
+      throw error;
+    }
+  }
+
+  private async showRewardedInterstitialAd(
+    ad: RewardedInterstitialAdInstance
+  ): Promise<any> {
+    if (!ad.rewardedInterstitialAd) {
+      throw new Error('Rewarded interstitial 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.rewardedInterstitialAd.addAdEventListener(
+          RewardedAdEventType.EARNED_REWARD,
+          (reward: any) => {
+            earnedReward = reward;
+            // Emit sự kiện earnedReward
+            this.emit('adEarnedReward', { ad, reward });
+          }
+        );
+
+      const unsubscribeClosed = ad.rewardedInterstitialAd.addAdEventListener(
+        AdEventType.CLOSED,
+        () => {
+          unsubscribeEarnedReward();
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+
+          // Emit sự kiện adClosed
+          this.emit('adClosed', ad);
+          resolve(earnedReward);
+        }
+      );
+
+      const unsubscribeError = ad.rewardedInterstitialAd.addAdEventListener(
+        AdEventType.ERROR,
+        (error: any) => {
+          unsubscribeEarnedReward();
+          unsubscribeClosed();
+          unsubscribeError();
+          unsubscribeOpened();
+          unsubscribeClicked();
+          reject(
+            new Error(
+              `Failed to show rewarded interstitial ad: ${error.message || error}`
+            )
+          );
+        }
+      );
+
+      const unsubscribeOpened = ad.rewardedInterstitialAd.addAdEventListener(
+        AdEventType.OPENED,
+        () => {
+          // Emit sự kiện adOpened
+          this.emit('adOpened', ad);
+        }
+      );
+
+      const unsubscribeClicked = ad.rewardedInterstitialAd.addAdEventListener(
+        AdEventType.CLICKED,
+        () => {
+          // Emit sự kiện adClicked
+          this.emit('adClicked', ad);
+        }
+      );
+
+      // Hiển thị quảng cáo
+      ad.rewardedInterstitialAd.show();
+    });
+  }
+
+  private async waitForAdLoad(adKey: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(
+          new Error(
+            `Timeout waiting for rewarded interstitial ad "${adKey}" to load`
+          )
+        );
+      }, 10000);
+
+      const checkAd = () => {
+        const ad = this.state.get(adKey);
+        if (!ad) {
+          clearTimeout(timeout);
+          reject(new Error(`Rewarded 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 rewardedInterstitialAdsManager =
+  new RewardedInterstitialAdsManager();

package/src/components/BannerAdComponent.tsx

@@ -0,0 +1,205 @@
+import React, { useEffect, useState, useRef } from 'react';
+import { View, StyleSheet, ActivityIndicator, Text } from 'react-native';
+import { BannerAd, type RequestOptions } from 'react-native-google-mobile-ads';
+
+interface BannerAdComponentProps {
+  adId: string;
+  adHighpriorityId?: string;
+  style?: any;
+  size?:
+    | 'BANNER'
+    | 'LARGE_BANNER'
+    | 'MEDIUM_RECTANGLE'
+    | 'FULL_BANNER'
+    | 'LEADERBOARD'
+    | 'ANCHORED_ADAPTIVE_BANNER';
+  onAdLoaded?: () => void;
+  onAdFailedToLoad?: (error: Error) => void;
+  onAdOpened?: () => void;
+  onAdClosed?: () => void;
+  onAdClicked?: () => void;
+  onAdImpression?: () => void;
+  showLoading?: boolean;
+  loadingText?: string;
+  errorText?: string;
+  showError?: boolean;
+  requestOptions?: RequestOptions;
+}
+
+export const BannerAdComponent: React.FC<BannerAdComponentProps> = ({
+  adId,
+  adHighpriorityId,
+  style,
+  size = 'BANNER',
+  onAdLoaded,
+  onAdFailedToLoad,
+  onAdOpened,
+  onAdClosed,
+  onAdClicked,
+  onAdImpression,
+  showLoading = true,
+  loadingText = 'Đang tải quảng cáo...',
+  errorText = 'Không thể tải quảng cáo',
+  showError = true,
+  requestOptions,
+}) => {
+  const [isLoaded, setIsLoaded] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [shouldRender, setShouldRender] = useState(false);
+  const bannerRef = useRef<any>(null);
+
+  const [currentAdId, setCurrentAdId] = useState<string>(
+    adHighpriorityId || adId
+  );
+  const [hasTriedHighPriority, setHasTriedHighPriority] =
+    useState<boolean>(false);
+
+  useEffect(() => {
+    setShouldRender(true);
+    if (adHighpriorityId) {
+      setCurrentAdId(adHighpriorityId);
+      setHasTriedHighPriority(false);
+    }
+  }, [adHighpriorityId]);
+
+  const handleAdLoaded = () => {
+    setIsLoaded(true);
+    setError(null);
+    console.log('PreloadedBannerAd loaded:', currentAdId);
+    onAdLoaded?.();
+  };
+
+  const handleAdFailedToLoad = (error: Error) => {
+    console.error(
+      'PreloadedBannerAd failed:',
+      error.message,
+      'AdId:',
+      currentAdId
+    );
+
+    // Nếu đang load high priority và chưa thử fallback, thử lại với adId thường
+    if (
+      adHighpriorityId &&
+      currentAdId === adHighpriorityId &&
+      !hasTriedHighPriority
+    ) {
+      console.log('Fallback to normal adId:', adId);
+      setHasTriedHighPriority(true);
+      setCurrentAdId(adId);
+      setIsLoaded(false);
+      setError(null);
+      return; // Không gọi onAdFailedToLoad vì sẽ thử lại
+    }
+
+    // Nếu đã thử cả 2 hoặc không có high priority, hiển thị error
+    setError(error.message);
+    onAdFailedToLoad?.(error);
+  };
+
+  const handleAdOpened = () => {
+    console.log('PreloadedBannerAd opened');
+    onAdOpened?.();
+  };
+
+  const handleAdClosed = () => {
+    console.log('PreloadedBannerAd closed');
+    onAdClosed?.();
+  };
+
+  const handleAdClicked = () => {
+    console.log('PreloadedBannerAd clicked');
+    onAdClicked?.();
+  };
+
+  const handleAdImpression = () => {
+    console.log('PreloadedBannerAd impression');
+    onAdImpression?.();
+  };
+
+  if (!shouldRender) {
+    return null;
+  }
+
+  return (
+    <View style={[styles.container, style]}>
+      {/* Hiển thị loading chỉ khi chưa load được và chưa có lỗi */}
+      {!isLoaded && !error && showLoading && (
+        <View style={styles.loadingContainer}>
+          <ActivityIndicator size="small" color="#007AFF" />
+          <Text style={styles.loadingText}>{loadingText}</Text>
+        </View>
+      )}
+
+      {/* Hiển thị error nếu có */}
+      {error && showError && (
+        <View style={styles.errorContainer}>
+          <Text style={styles.errorText}>{errorText}</Text>
+        </View>
+      )}
+
+      {/* Banner component - luôn render để load ngay */}
+      <BannerAd
+        key={currentAdId} // Key quan trọng để force re-render khi adId thay đổi
+        ref={bannerRef}
+        unitId={currentAdId}
+        size={size}
+        onAdLoaded={handleAdLoaded}
+        onAdFailedToLoad={handleAdFailedToLoad}
+        onAdOpened={handleAdOpened}
+        onAdClosed={handleAdClosed}
+        onAdClicked={handleAdClicked}
+        onAdImpression={handleAdImpression}
+        requestOptions={requestOptions}
+      />
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    minHeight: 50,
+    backgroundColor: 'transparent',
+  },
+  loadingContainer: {
+    width: '80%',
+    position: 'absolute',
+    alignItems: 'center',
+    justifyContent: 'center',
+    zIndex: 1,
+    backgroundColor: 'rgba(255, 255, 255, 0.9)',
+    borderRadius: 8,
+    padding: 12,
+  },
+  loadingText: {
+    marginTop: 8,
+    fontSize: 12,
+    color: '#666',
+    textAlign: 'center',
+  },
+  errorContainer: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: 10,
+    backgroundColor: '#ffe6e6',
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: '#ffcccb',
+  },
+  errorText: {
+    fontSize: 12,
+    color: '#ff3b30',
+    textAlign: 'center',
+  },
+  banner: {
+    width: '100%',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  hiddenBanner: {
+    opacity: 0,
+    height: 0,
+    overflow: 'hidden',
+  },
+});