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

package/src/stores/rewarded-ads-store.ts

@@ -0,0 +1,290 @@
+import { create } from 'zustand';
+import { subscribeWithSelector } from 'zustand/middleware';
+import { rewardedAdsManager } from '../ads-manager/RewardedAdsManager';
+import {
+  AdStatus,
+  type RewardedAdInstance,
+  type RewardedAdConfig,
+} from '../types/ads-types';
+
+interface RewardedAdStore {
+  // State
+  ads: Map<string, RewardedAdInstance>;
+  loadingKeys: Set<string>;
+  errors: Map<string, string>;
+
+  // Actions - CẬP NHẬT SIGNATURES
+  preloadAd: (config: RewardedAdConfig) => Promise<void>;
+  loadAd: (config: RewardedAdConfig) => Promise<void>;
+  displayAd: (
+    adKey: string
+  ) => Promise<{ ad: RewardedAdInstance | null; reward: any }>;
+  removeAd: (adKey: string) => void;
+  refreshAd: (adKey: string) => Promise<void>;
+  clearAllAds: () => void;
+
+  // Getters
+  getAd: (adKey: string) => RewardedAdInstance | null;
+  isLoading: (adKey: string) => boolean;
+  getError: (adKey: string) => string | null;
+  getAllAds: () => RewardedAdInstance[];
+  getLoadedAds: () => RewardedAdInstance[];
+  getErrorAds: () => RewardedAdInstance[];
+  isUsingHighPriority: (adKey: string) => boolean; // THÊM MỚI
+  hasTriedHighPriority: (adKey: string) => boolean; // THÊM MỚI
+
+  // Internal actions
+  _updateAd: (ad: RewardedAdInstance) => void;
+  _removeAd: (adKey: string) => void;
+  _setLoading: (adKey: string, loading: boolean) => void;
+  _setError: (adKey: string, error: string | null) => void;
+  _clearError: (adKey: string) => void;
+}
+
+export const useRewardedAdStore = create<RewardedAdStore>()(
+  subscribeWithSelector((set, get) => ({
+    // Initial state
+    ads: new Map(),
+    loadingKeys: new Set(),
+    errors: new Map(),
+
+    // Public actions - CẬP NHẬT IMPLEMENTATIONS
+    preloadAd: async (config) => {
+      const { adKey } = config;
+      try {
+        get()._setLoading(adKey, true);
+        get()._clearError(adKey);
+
+        await rewardedAdsManager.preloadAd(config);
+
+        const ad = rewardedAdsManager.getAd(adKey);
+        if (ad) {
+          get()._updateAd(ad);
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        get()._setError(adKey, errorMessage);
+        console.error(`Failed to preload rewarded ad ${adKey}:`, errorMessage);
+      } finally {
+        get()._setLoading(adKey, false);
+      }
+    },
+
+    loadAd: async (config) => {
+      return get().preloadAd(config);
+    },
+
+    displayAd: async (adKey) => {
+      try {
+        get()._clearError(adKey);
+
+        const result = await rewardedAdsManager.displayAd(adKey);
+        if (result.ad) {
+          get()._updateAd(result.ad);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        get()._setError(adKey, errorMessage);
+        console.error(`Failed to display rewarded ad ${adKey}:`, errorMessage);
+        return { ad: null, reward: null };
+      }
+    },
+
+    removeAd: (adKey) => {
+      rewardedAdsManager.removeAd(adKey);
+      get()._removeAd(adKey);
+    },
+
+    refreshAd: async (adKey) => {
+      try {
+        get()._setLoading(adKey, true);
+        get()._clearError(adKey);
+
+        await rewardedAdsManager.refreshAd(adKey);
+
+        const ad = rewardedAdsManager.getAd(adKey);
+        if (ad) {
+          get()._updateAd(ad);
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        get()._setError(adKey, errorMessage);
+        console.error(`Failed to refresh rewarded ad ${adKey}:`, errorMessage);
+      } finally {
+        get()._setLoading(adKey, false);
+      }
+    },
+
+    clearAllAds: () => {
+      rewardedAdsManager.clearAllAds();
+      set({
+        ads: new Map(),
+        loadingKeys: new Set(),
+        errors: new Map(),
+      });
+    },
+
+    // Getters
+    getAd: (adKey) => {
+      return get().ads.get(adKey) || null;
+    },
+
+    isLoading: (adKey) => {
+      return get().loadingKeys.has(adKey);
+    },
+
+    getError: (adKey) => {
+      return get().errors.get(adKey) || null;
+    },
+
+    getAllAds: () => {
+      return Array.from(get().ads.values());
+    },
+
+    getLoadedAds: () => {
+      return Array.from(get().ads.values()).filter(
+        (ad) => ad.status === AdStatus.LOADED
+      );
+    },
+
+    getErrorAds: () => {
+      return Array.from(get().ads.values()).filter(
+        (ad) => ad.status === AdStatus.ERROR
+      );
+    },
+
+    // THÊM MỚI
+    isUsingHighPriority: (adKey) => {
+      const ad = get().ads.get(adKey);
+      return ad?.isUsingHighPriority ?? false;
+    },
+
+    hasTriedHighPriority: (adKey) => {
+      const ad = get().ads.get(adKey);
+      return ad?.hasTriedHighPriority ?? false;
+    },
+
+    // Internal actions
+    _updateAd: (ad) => {
+      set((state) => ({
+        ads: new Map(state.ads.set(ad.adKey, ad)),
+      }));
+    },
+
+    _removeAd: (adKey) => {
+      set((state) => {
+        const newAds = new Map(state.ads);
+        const newLoadingKeys = new Set(state.loadingKeys);
+        const newErrors = new Map(state.errors);
+
+        newAds.delete(adKey);
+        newLoadingKeys.delete(adKey);
+        newErrors.delete(adKey);
+
+        return {
+          ads: newAds,
+          loadingKeys: newLoadingKeys,
+          errors: newErrors,
+        };
+      });
+    },
+
+    _setLoading: (adKey, loading) => {
+      set((state) => {
+        const newLoadingKeys = new Set(state.loadingKeys);
+        if (loading) {
+          newLoadingKeys.add(adKey);
+        } else {
+          newLoadingKeys.delete(adKey);
+        }
+        return { loadingKeys: newLoadingKeys };
+      });
+    },
+
+    _setError: (adKey, error) => {
+      set((state) => {
+        const newErrors = new Map(state.errors);
+        if (error) {
+          newErrors.set(adKey, error);
+        } else {
+          newErrors.delete(adKey);
+        }
+        return { errors: newErrors };
+      });
+    },
+
+    _clearError: (adKey) => {
+      set((state) => {
+        const newErrors = new Map(state.errors);
+        newErrors.delete(adKey);
+        return { errors: newErrors };
+      });
+    },
+  }))
+);
+
+// Setup native manager listeners để sync với Zustand store
+let isListenerSetup = false;
+
+const setupRewardedListeners = () => {
+  if (isListenerSetup) return;
+
+  rewardedAdsManager.on('adLoading', (ad: { adKey: string }) => {
+    useRewardedAdStore.getState()._setLoading(ad.adKey, true);
+  });
+
+  rewardedAdsManager.on('adLoaded', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+    useRewardedAdStore.getState()._setLoading(ad.adKey, false);
+    useRewardedAdStore.getState()._clearError(ad.adKey);
+  });
+
+  rewardedAdsManager.on('adDisplayed', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+  });
+
+  rewardedAdsManager.on('adOpened', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+  });
+
+  rewardedAdsManager.on('adClicked', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+  });
+
+  rewardedAdsManager.on('adClosed', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+  });
+
+  rewardedAdsManager.on(
+    'adEarnedReward',
+    ({ ad, _reward }: { ad: RewardedAdInstance; _reward: any }) => {
+      console.log(_reward);
+      useRewardedAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedAdsManager.on('adError', (ad: RewardedAdInstance) => {
+    useRewardedAdStore.getState()._updateAd(ad);
+    useRewardedAdStore.getState()._setLoading(ad.adKey, false);
+    useRewardedAdStore
+      .getState()
+      ._setError(ad.adKey, ad.error || 'Unknown error');
+  });
+
+  rewardedAdsManager.on('adRemoved', (adKey: string) => {
+    useRewardedAdStore.getState()._removeAd(adKey);
+  });
+
+  rewardedAdsManager.on('allAdsCleared', () => {
+    useRewardedAdStore.getState().clearAllAds();
+  });
+
+  isListenerSetup = true;
+};
+
+// Initialize listeners
+setupRewardedListeners();

package/src/stores/rewarded-interstitial-ads-store.ts

@@ -0,0 +1,318 @@
+import { create } from 'zustand';
+import { subscribeWithSelector } from 'zustand/middleware';
+import { rewardedInterstitialAdsManager } from '../ads-manager/RewardedInterstitialAdsManager';
+import {
+  AdStatus,
+  type RewardedInterstitialAdInstance,
+  type RewardedInterstitialAdConfig,
+} from '../types/ads-types';
+
+interface RewardedInterstitialAdStore {
+  // State
+  ads: Map<string, RewardedInterstitialAdInstance>;
+  loadingKeys: Set<string>;
+  errors: Map<string, string>;
+
+  // Actions - CẬP NHẬT SIGNATURES
+  preloadAd: (config: RewardedInterstitialAdConfig) => Promise<void>;
+  loadAd: (config: RewardedInterstitialAdConfig) => Promise<void>;
+  displayAd: (
+    adKey: string
+  ) => Promise<{ ad: RewardedInterstitialAdInstance | null; reward: any }>;
+  removeAd: (adKey: string) => void;
+  refreshAd: (adKey: string) => Promise<void>;
+  clearAllAds: () => void;
+
+  // Getters
+  getAd: (adKey: string) => RewardedInterstitialAdInstance | null;
+  isLoading: (adKey: string) => boolean;
+  getError: (adKey: string) => string | null;
+  getAllAds: () => RewardedInterstitialAdInstance[];
+  getLoadedAds: () => RewardedInterstitialAdInstance[];
+  getErrorAds: () => RewardedInterstitialAdInstance[];
+  isUsingHighPriority: (adKey: string) => boolean; // THÊM MỚI
+  hasTriedHighPriority: (adKey: string) => boolean; // THÊM MỚI
+
+  // Internal actions
+  _updateAd: (ad: RewardedInterstitialAdInstance) => void;
+  _removeAd: (adKey: string) => void;
+  _setLoading: (adKey: string, loading: boolean) => void;
+  _setError: (adKey: string, error: string | null) => void;
+  _clearError: (adKey: string) => void;
+}
+
+export const useRewardedInterstitialAdStore =
+  create<RewardedInterstitialAdStore>()(
+    subscribeWithSelector((set, get) => ({
+      // Initial state
+      ads: new Map(),
+      loadingKeys: new Set(),
+      errors: new Map(),
+
+      // Public actions - CẬP NHẬT IMPLEMENTATIONS
+      preloadAd: async (config) => {
+        const { adKey } = config;
+        try {
+          get()._setLoading(adKey, true);
+          get()._clearError(adKey);
+
+          await rewardedInterstitialAdsManager.preloadAd(config);
+
+          const ad = rewardedInterstitialAdsManager.getAd(adKey);
+          if (ad) {
+            get()._updateAd(ad);
+          }
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          get()._setError(adKey, errorMessage);
+          console.error(
+            `Failed to preload rewarded interstitial ad ${adKey}:`,
+            errorMessage
+          );
+        } finally {
+          get()._setLoading(adKey, false);
+        }
+      },
+
+      loadAd: async (config) => {
+        return get().preloadAd(config);
+      },
+
+      displayAd: async (adKey) => {
+        try {
+          get()._clearError(adKey);
+
+          const result = await rewardedInterstitialAdsManager.displayAd(adKey);
+          if (result.ad) {
+            get()._updateAd(result.ad);
+          }
+          return result;
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          get()._setError(adKey, errorMessage);
+          console.error(
+            `Failed to display rewarded interstitial ad ${adKey}:`,
+            errorMessage
+          );
+          return { ad: null, reward: null };
+        }
+      },
+
+      removeAd: (adKey) => {
+        rewardedInterstitialAdsManager.removeAd(adKey);
+        get()._removeAd(adKey);
+      },
+
+      refreshAd: async (adKey) => {
+        try {
+          get()._setLoading(adKey, true);
+          get()._clearError(adKey);
+
+          await rewardedInterstitialAdsManager.refreshAd(adKey);
+
+          const ad = rewardedInterstitialAdsManager.getAd(adKey);
+          if (ad) {
+            get()._updateAd(ad);
+          }
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          get()._setError(adKey, errorMessage);
+          console.error(
+            `Failed to refresh rewarded interstitial ad ${adKey}:`,
+            errorMessage
+          );
+        } finally {
+          get()._setLoading(adKey, false);
+        }
+      },
+
+      clearAllAds: () => {
+        rewardedInterstitialAdsManager.clearAllAds();
+        set({
+          ads: new Map(),
+          loadingKeys: new Set(),
+          errors: new Map(),
+        });
+      },
+
+      // Getters
+      getAd: (adKey) => {
+        return get().ads.get(adKey) || null;
+      },
+
+      isLoading: (adKey) => {
+        return get().loadingKeys.has(adKey);
+      },
+
+      getError: (adKey) => {
+        return get().errors.get(adKey) || null;
+      },
+
+      getAllAds: () => {
+        return Array.from(get().ads.values());
+      },
+
+      getLoadedAds: () => {
+        return Array.from(get().ads.values()).filter(
+          (ad) => ad.status === AdStatus.LOADED
+        );
+      },
+
+      getErrorAds: () => {
+        return Array.from(get().ads.values()).filter(
+          (ad) => ad.status === AdStatus.ERROR
+        );
+      },
+
+      // THÊM MỚI
+      isUsingHighPriority: (adKey) => {
+        const ad = get().ads.get(adKey);
+        return ad?.isUsingHighPriority ?? false;
+      },
+
+      hasTriedHighPriority: (adKey) => {
+        const ad = get().ads.get(adKey);
+        return ad?.hasTriedHighPriority ?? false;
+      },
+
+      // Internal actions
+      _updateAd: (ad) => {
+        set((state) => ({
+          ads: new Map(state.ads.set(ad.adKey, ad)),
+        }));
+      },
+
+      _removeAd: (adKey) => {
+        set((state) => {
+          const newAds = new Map(state.ads);
+          const newLoadingKeys = new Set(state.loadingKeys);
+          const newErrors = new Map(state.errors);
+
+          newAds.delete(adKey);
+          newLoadingKeys.delete(adKey);
+          newErrors.delete(adKey);
+
+          return {
+            ads: newAds,
+            loadingKeys: newLoadingKeys,
+            errors: newErrors,
+          };
+        });
+      },
+
+      _setLoading: (adKey, loading) => {
+        set((state) => {
+          const newLoadingKeys = new Set(state.loadingKeys);
+          if (loading) {
+            newLoadingKeys.add(adKey);
+          } else {
+            newLoadingKeys.delete(adKey);
+          }
+          return { loadingKeys: newLoadingKeys };
+        });
+      },
+
+      _setError: (adKey, error) => {
+        set((state) => {
+          const newErrors = new Map(state.errors);
+          if (error) {
+            newErrors.set(adKey, error);
+          } else {
+            newErrors.delete(adKey);
+          }
+          return { errors: newErrors };
+        });
+      },
+
+      _clearError: (adKey) => {
+        set((state) => {
+          const newErrors = new Map(state.errors);
+          newErrors.delete(adKey);
+          return { errors: newErrors };
+        });
+      },
+    }))
+  );
+
+// Setup native manager listeners để sync với Zustand store
+let isListenerSetup = false;
+
+const setupRewardedInterstitialListeners = () => {
+  if (isListenerSetup) return;
+
+  rewardedInterstitialAdsManager.on('adLoading', (ad: { adKey: string }) => {
+    useRewardedInterstitialAdStore.getState()._setLoading(ad.adKey, true);
+  });
+
+  rewardedInterstitialAdsManager.on(
+    'adLoaded',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+      useRewardedInterstitialAdStore.getState()._setLoading(ad.adKey, false);
+      useRewardedInterstitialAdStore.getState()._clearError(ad.adKey);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adDisplayed',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adOpened',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adClicked',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adClosed',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adEarnedReward',
+    ({ ad, _reward }: { ad: RewardedInterstitialAdInstance; _reward: any }) => {
+      console.log(_reward);
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+    }
+  );
+
+  rewardedInterstitialAdsManager.on(
+    'adError',
+    (ad: RewardedInterstitialAdInstance) => {
+      useRewardedInterstitialAdStore.getState()._updateAd(ad);
+      useRewardedInterstitialAdStore.getState()._setLoading(ad.adKey, false);
+      useRewardedInterstitialAdStore
+        .getState()
+        ._setError(ad.adKey, ad.error || 'Unknown error');
+    }
+  );
+
+  rewardedInterstitialAdsManager.on('adRemoved', (adKey: string) => {
+    useRewardedInterstitialAdStore.getState()._removeAd(adKey);
+  });
+
+  rewardedInterstitialAdsManager.on('allAdsCleared', () => {
+    useRewardedInterstitialAdStore.getState().clearAllAds();
+  });
+
+  isListenerSetup = true;
+};
+
+// Initialize listeners
+setupRewardedInterstitialListeners();