@bigcrunch/react-native-ads 0.1.0

package/src/BigCrunchInterstitial.ts

@@ -0,0 +1,266 @@
+/**
+ * BigCrunchInterstitial - API for interstitial ads
+ */
+
+import { NativeBigCrunchAds, BigCrunchAdsEventEmitter, NativeEventNames } from './NativeBigCrunchAds';
+import type {
+  InterstitialAd,
+  AdRequestOptions,
+  AdEvent,
+  AdEventListener,
+  EventSubscription,
+  AdError,
+  AdRevenue,
+} from './types';
+
+/**
+ * Static API for BigCrunch interstitial ads
+ *
+ * @example
+ * ```typescript
+ * // Load an interstitial
+ * await BigCrunchInterstitial.load({ placementId: 'interstitial-level-complete' });
+ *
+ * // Show when ready
+ * if (await BigCrunchInterstitial.isLoaded('interstitial-level-complete')) {
+ *   await BigCrunchInterstitial.show('interstitial-level-complete');
+ * }
+ * ```
+ */
+export class BigCrunchInterstitial {
+  private static instances = new Map<string, InterstitialAdInstance>();
+
+  /**
+   * Load an interstitial ad
+   *
+   * @param options - Ad request options including placementId
+   */
+  static async load(options: AdRequestOptions): Promise<void> {
+    const { placementId } = options;
+
+    // Create or get existing instance
+    let instance = this.instances.get(placementId);
+    if (!instance) {
+      instance = new InterstitialAdInstance(placementId);
+      this.instances.set(placementId, instance);
+    }
+
+    return instance.load(options);
+  }
+
+  /**
+   * Show a loaded interstitial ad
+   *
+   * @param placementId - The placement ID of the ad to show
+   */
+  static async show(placementId: string): Promise<void> {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      throw new Error(`No interstitial loaded for placement: ${placementId}`);
+    }
+    return instance.show();
+  }
+
+  /**
+   * Check if an interstitial is loaded and ready to show
+   *
+   * @param placementId - The placement ID to check
+   */
+  static async isLoaded(placementId: string): Promise<boolean> {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      return false;
+    }
+    return instance.isLoaded();
+  }
+
+  /**
+   * Destroy an interstitial instance
+   *
+   * @param placementId - The placement ID of the ad to destroy
+   */
+  static destroy(placementId: string): void {
+    const instance = this.instances.get(placementId);
+    if (instance) {
+      instance.destroy();
+      this.instances.delete(placementId);
+    }
+  }
+
+  /**
+   * Destroy all interstitial instances
+   */
+  static destroyAll(): void {
+    this.instances.forEach(instance => instance.destroy());
+    this.instances.clear();
+  }
+
+  /**
+   * Create an interstitial ad instance
+   * Alternative to static methods for more control
+   *
+   * @param placementId - The placement ID for this ad
+   */
+  static createAd(placementId: string): InterstitialAd {
+    let instance = this.instances.get(placementId);
+    if (!instance) {
+      instance = new InterstitialAdInstance(placementId);
+      this.instances.set(placementId, instance);
+    }
+    return instance;
+  }
+
+  /**
+   * Add event listener for a specific placement
+   *
+   * @param placementId - The placement ID to listen to
+   * @param eventType - The event type to listen for
+   * @param listener - The callback function
+   */
+  static addEventListener<T extends AdEvent>(
+    placementId: string,
+    eventType: T['type'],
+    listener: AdEventListener<T>
+  ): EventSubscription {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      const newInstance = new InterstitialAdInstance(placementId);
+      this.instances.set(placementId, newInstance);
+      return newInstance.addEventListener(eventType, listener);
+    }
+    return instance.addEventListener(eventType, listener);
+  }
+}
+
+/**
+ * Internal interstitial ad instance
+ */
+class InterstitialAdInstance implements InterstitialAd {
+  private placementId: string;
+  private subscriptions: EventSubscription[] = [];
+  private listeners = new Map<string, Set<AdEventListener<AdEvent>>>();
+
+  constructor(placementId: string) {
+    this.placementId = placementId;
+    this.setupEventListeners();
+  }
+
+  async load(options: AdRequestOptions): Promise<void> {
+    return NativeBigCrunchAds.loadInterstitial(options);
+  }
+
+  async show(): Promise<void> {
+    return NativeBigCrunchAds.showInterstitial(this.placementId);
+  }
+
+  async isLoaded(): Promise<boolean> {
+    return NativeBigCrunchAds.isInterstitialLoaded(this.placementId);
+  }
+
+  destroy(): void {
+    this.removeAllListeners();
+    NativeBigCrunchAds.destroyInterstitial(this.placementId).catch(console.error);
+  }
+
+  addEventListener<T extends AdEvent>(
+    eventType: T['type'],
+    listener: AdEventListener<T>
+  ): EventSubscription {
+    // Add to local listeners
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, new Set());
+    }
+    // Cast listener to base type for storage - runtime behavior is the same
+    const typedListener = listener as AdEventListener<AdEvent>;
+    this.listeners.get(eventType)!.add(typedListener);
+
+    // Return subscription
+    return {
+      remove: () => {
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+          listeners.delete(typedListener);
+        }
+      },
+    };
+  }
+
+  removeAllListeners(): void {
+    this.subscriptions.forEach(sub => sub.remove());
+    this.subscriptions = [];
+    this.listeners.clear();
+  }
+
+  private setupEventListeners(): void {
+    const eventMap = {
+      adLoaded: NativeEventNames.INTERSTITIAL_AD_LOADED,
+      adFailedToLoad: NativeEventNames.INTERSTITIAL_AD_FAILED_TO_LOAD,
+      adImpression: NativeEventNames.INTERSTITIAL_AD_IMPRESSION,
+      adClicked: NativeEventNames.INTERSTITIAL_AD_CLICKED,
+      adOpened: NativeEventNames.INTERSTITIAL_AD_OPENED,
+      adClosed: NativeEventNames.INTERSTITIAL_AD_CLOSED,
+      adRevenue: NativeEventNames.INTERSTITIAL_AD_REVENUE,
+    };
+
+    Object.entries(eventMap).forEach(([eventType, nativeEvent]) => {
+      const subscription = BigCrunchAdsEventEmitter.addListener(nativeEvent, (event: any) => {
+        // Check if event is for this placement
+        if (event.placementId === this.placementId) {
+          // Transform event data if needed
+          let transformedEvent: AdEvent;
+
+          switch (eventType) {
+            case 'adFailedToLoad':
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'interstitial',
+                timestamp: Date.now(),
+                error: {
+                  code: event.errorCode || 'UNKNOWN',
+                  message: event.errorMessage || 'Ad failed to load',
+                  underlyingError: event.underlyingError,
+                } as AdError,
+              };
+              break;
+
+            case 'adRevenue':
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'interstitial',
+                timestamp: Date.now(),
+                revenue: {
+                  valueMicros: event.valueMicros,
+                  currencyCode: event.currencyCode,
+                  adUnitId: event.adUnitId,
+                  precision: event.precision,
+                } as AdRevenue,
+              };
+              break;
+
+            default:
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'interstitial',
+                timestamp: Date.now(),
+                ...event,
+              };
+          }
+
+          // Notify local listeners
+          const listeners = this.listeners.get(eventType);
+          if (listeners) {
+            listeners.forEach(listener => listener(transformedEvent));
+          }
+        }
+      });
+
+      this.subscriptions.push(subscription);
+    });
+  }
+}
+
+// Export as default
+export default BigCrunchInterstitial;

package/src/BigCrunchRewarded.ts

@@ -0,0 +1,307 @@
+/**
+ * BigCrunchRewarded - API for rewarded ads
+ */
+
+import { NativeBigCrunchAds, BigCrunchAdsEventEmitter, NativeEventNames } from './NativeBigCrunchAds';
+import type {
+  RewardedAd,
+  AdRequestOptions,
+  AdEvent,
+  AdEventListener,
+  EventSubscription,
+  AdError,
+  AdRevenue,
+  RewardedAdEarnedEvent,
+} from './types';
+
+/**
+ * Static API for BigCrunch rewarded ads
+ *
+ * @example
+ * ```typescript
+ * // Load a rewarded ad
+ * await BigCrunchRewarded.load({ placementId: 'rewarded-extra-life' });
+ *
+ * // Set up reward listener
+ * BigCrunchRewarded.addEventListener(
+ *   'rewarded-extra-life',
+ *   'rewardEarned',
+ *   (event) => {
+ *     console.log(`User earned ${event.rewardAmount} ${event.rewardType}`);
+ *   }
+ * );
+ *
+ * // Show when ready
+ * if (await BigCrunchRewarded.isLoaded('rewarded-extra-life')) {
+ *   await BigCrunchRewarded.show('rewarded-extra-life');
+ * }
+ * ```
+ */
+export class BigCrunchRewarded {
+  private static instances = new Map<string, RewardedAdInstance>();
+
+  /**
+   * Load a rewarded ad
+   *
+   * @param options - Ad request options including placementId
+   */
+  static async load(options: AdRequestOptions): Promise<void> {
+    const { placementId } = options;
+
+    // Create or get existing instance
+    let instance = this.instances.get(placementId);
+    if (!instance) {
+      instance = new RewardedAdInstance(placementId);
+      this.instances.set(placementId, instance);
+    }
+
+    return instance.load(options);
+  }
+
+  /**
+   * Show a loaded rewarded ad
+   *
+   * @param placementId - The placement ID of the ad to show
+   */
+  static async show(placementId: string): Promise<void> {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      throw new Error(`No rewarded ad loaded for placement: ${placementId}`);
+    }
+    return instance.show();
+  }
+
+  /**
+   * Check if a rewarded ad is loaded and ready to show
+   *
+   * @param placementId - The placement ID to check
+   */
+  static async isLoaded(placementId: string): Promise<boolean> {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      return false;
+    }
+    return instance.isLoaded();
+  }
+
+  /**
+   * Destroy a rewarded ad instance
+   *
+   * @param placementId - The placement ID of the ad to destroy
+   */
+  static destroy(placementId: string): void {
+    const instance = this.instances.get(placementId);
+    if (instance) {
+      instance.destroy();
+      this.instances.delete(placementId);
+    }
+  }
+
+  /**
+   * Destroy all rewarded ad instances
+   */
+  static destroyAll(): void {
+    this.instances.forEach(instance => instance.destroy());
+    this.instances.clear();
+  }
+
+  /**
+   * Create a rewarded ad instance
+   * Alternative to static methods for more control
+   *
+   * @param placementId - The placement ID for this ad
+   */
+  static createAd(placementId: string): RewardedAd {
+    let instance = this.instances.get(placementId);
+    if (!instance) {
+      instance = new RewardedAdInstance(placementId);
+      this.instances.set(placementId, instance);
+    }
+    return instance;
+  }
+
+  /**
+   * Add event listener for a specific placement
+   *
+   * @param placementId - The placement ID to listen to
+   * @param eventType - The event type to listen for
+   * @param listener - The callback function
+   */
+  static addEventListener<T extends AdEvent>(
+    placementId: string,
+    eventType: T['type'],
+    listener: AdEventListener<T>
+  ): EventSubscription {
+    const instance = this.instances.get(placementId);
+    if (!instance) {
+      const newInstance = new RewardedAdInstance(placementId);
+      this.instances.set(placementId, newInstance);
+      return newInstance.addEventListener(eventType, listener);
+    }
+    return instance.addEventListener(eventType, listener);
+  }
+
+  /**
+   * Convenience method to listen for reward earned events
+   *
+   * @param placementId - The placement ID to listen to
+   * @param listener - Callback when user earns reward
+   */
+  static onRewardEarned(
+    placementId: string,
+    listener: (reward: { rewardType: string; rewardAmount: number }) => void
+  ): EventSubscription {
+    return this.addEventListener(placementId, 'rewardEarned' as any, (event: any) => {
+      const rewardEvent = event as RewardedAdEarnedEvent;
+      listener({
+        rewardType: rewardEvent.rewardType,
+        rewardAmount: rewardEvent.rewardAmount,
+      });
+    });
+  }
+}
+
+/**
+ * Internal rewarded ad instance
+ */
+class RewardedAdInstance implements RewardedAd {
+  private placementId: string;
+  private subscriptions: EventSubscription[] = [];
+  private listeners = new Map<string, Set<AdEventListener<AdEvent>>>();
+
+  constructor(placementId: string) {
+    this.placementId = placementId;
+    this.setupEventListeners();
+  }
+
+  async load(options: AdRequestOptions): Promise<void> {
+    return NativeBigCrunchAds.loadRewarded(options);
+  }
+
+  async show(): Promise<void> {
+    return NativeBigCrunchAds.showRewarded(this.placementId);
+  }
+
+  async isLoaded(): Promise<boolean> {
+    return NativeBigCrunchAds.isRewardedLoaded(this.placementId);
+  }
+
+  destroy(): void {
+    this.removeAllListeners();
+    NativeBigCrunchAds.destroyRewarded(this.placementId).catch(console.error);
+  }
+
+  addEventListener<T extends AdEvent>(
+    eventType: T['type'],
+    listener: AdEventListener<T>
+  ): EventSubscription {
+    // Add to local listeners
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, new Set());
+    }
+    // Cast listener to base type for storage - runtime behavior is the same
+    const typedListener = listener as AdEventListener<AdEvent>;
+    this.listeners.get(eventType)!.add(typedListener);
+
+    // Return subscription
+    return {
+      remove: () => {
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+          listeners.delete(typedListener);
+        }
+      },
+    };
+  }
+
+  removeAllListeners(): void {
+    this.subscriptions.forEach(sub => sub.remove());
+    this.subscriptions = [];
+    this.listeners.clear();
+  }
+
+  private setupEventListeners(): void {
+    const eventMap = {
+      adLoaded: NativeEventNames.REWARDED_AD_LOADED,
+      adFailedToLoad: NativeEventNames.REWARDED_AD_FAILED_TO_LOAD,
+      adImpression: NativeEventNames.REWARDED_AD_IMPRESSION,
+      adClicked: NativeEventNames.REWARDED_AD_CLICKED,
+      adOpened: NativeEventNames.REWARDED_AD_OPENED,
+      adClosed: NativeEventNames.REWARDED_AD_CLOSED,
+      adRevenue: NativeEventNames.REWARDED_AD_REVENUE,
+      rewardEarned: NativeEventNames.REWARDED_AD_EARNED,
+    };
+
+    Object.entries(eventMap).forEach(([eventType, nativeEvent]) => {
+      const subscription = BigCrunchAdsEventEmitter.addListener(nativeEvent, (event: any) => {
+        // Check if event is for this placement
+        if (event.placementId === this.placementId) {
+          // Transform event data if needed
+          let transformedEvent: AdEvent;
+
+          switch (eventType) {
+            case 'adFailedToLoad':
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'rewarded',
+                timestamp: Date.now(),
+                error: {
+                  code: event.errorCode || 'UNKNOWN',
+                  message: event.errorMessage || 'Ad failed to load',
+                  underlyingError: event.underlyingError,
+                } as AdError,
+              };
+              break;
+
+            case 'adRevenue':
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'rewarded',
+                timestamp: Date.now(),
+                revenue: {
+                  valueMicros: event.valueMicros,
+                  currencyCode: event.currencyCode,
+                  adUnitId: event.adUnitId,
+                  precision: event.precision,
+                } as AdRevenue,
+              };
+              break;
+
+            case 'rewardEarned':
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'rewarded',
+                timestamp: Date.now(),
+                rewardType: event.rewardType || 'default',
+                rewardAmount: event.rewardAmount || 1,
+              } as RewardedAdEarnedEvent;
+              break;
+
+            default:
+              transformedEvent = {
+                type: eventType as any,
+                placementId: this.placementId,
+                format: 'rewarded',
+                timestamp: Date.now(),
+                ...event,
+              };
+          }
+
+          // Notify local listeners
+          const listeners = this.listeners.get(eventType);
+          if (listeners) {
+            listeners.forEach(listener => listener(transformedEvent));
+          }
+        }
+      });
+
+      this.subscriptions.push(subscription);
+    });
+  }
+}
+
+// Export as default
+export default BigCrunchRewarded;

package/src/NativeBigCrunchAds.ts

@@ -0,0 +1,120 @@
+/**
+ * Native module interface for BigCrunch Ads
+ * This is the bridge to the native Android/iOS implementation
+ */
+
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+import type { InitializationOptions, AdRequestOptions, SessionInfo, DeviceContext, AppConfig } from './types';
+
+// Type definition for the native module
+export interface NativeBigCrunchAdsModule {
+  // Initialization
+  initialize(options: InitializationOptions): Promise<void>;
+  isInitialized(): Promise<boolean>;
+
+  // Configuration
+  getAppConfig(): Promise<AppConfig | null>;
+  refreshConfig(): Promise<void>;
+
+  // Screen tracking
+  trackScreenView(screenName: string): Promise<void>;
+
+  // Interstitial ads
+  loadInterstitial(options: AdRequestOptions): Promise<void>;
+  showInterstitial(placementId: string): Promise<void>;
+  isInterstitialLoaded(placementId: string): Promise<boolean>;
+  destroyInterstitial(placementId: string): Promise<void>;
+
+  // Rewarded ads
+  loadRewarded(options: AdRequestOptions): Promise<void>;
+  showRewarded(placementId: string): Promise<void>;
+  isRewardedLoaded(placementId: string): Promise<boolean>;
+  destroyRewarded(placementId: string): Promise<void>;
+
+  // Session management
+  getSessionInfo(): Promise<SessionInfo>;
+  startNewSession(): Promise<void>;
+
+  // Device context
+  getDeviceContext(): Promise<DeviceContext>;
+
+  // Privacy
+  setGdprConsent(consent: string): Promise<void>;
+  setCcpaString(ccpaString: string): Promise<void>;
+  setCoppaCompliant(isCompliant: boolean): Promise<void>;
+
+  // Debug
+  setDebugMode(enabled: boolean): Promise<void>;
+  addTestDevice(deviceId: string): Promise<void>;
+  removeTestDevice(deviceId: string): Promise<void>;
+  getTestDevices(): Promise<string[]>;
+
+  // UTM Attribution
+  setUTMParameters(params: {
+    source?: string;
+    medium?: string;
+    campaign?: string;
+    term?: string;
+    content?: string;
+  }): Promise<void>;
+  clearUTMParameters(): Promise<void>;
+}
+
+// Get the native module
+const { BigCrunchAdsModule } = NativeModules;
+
+if (!BigCrunchAdsModule) {
+  const errorMessage = Platform.select({
+    ios: 'BigCrunchAdsModule native module is not available on iOS. Make sure you have run `pod install` and rebuilt the app.',
+    android: 'BigCrunchAdsModule native module is not available on Android. Make sure you have rebuilt the app.',
+    default: 'BigCrunchAdsModule native module is not available. Make sure the library is properly linked.',
+  });
+
+  throw new Error(errorMessage);
+}
+
+// Export the native module with proper typing
+export const NativeBigCrunchAds = BigCrunchAdsModule as NativeBigCrunchAdsModule;
+
+// Export the event emitter for the native module
+export const BigCrunchAdsEventEmitter = new NativeEventEmitter(BigCrunchAdsModule);
+
+// Event names used by the native module
+export const NativeEventNames = {
+  // Banner events
+  BANNER_AD_LOADED: 'BigCrunchBannerAdLoaded',
+  BANNER_AD_FAILED_TO_LOAD: 'BigCrunchBannerAdFailedToLoad',
+  BANNER_AD_IMPRESSION: 'BigCrunchBannerAdImpression',
+  BANNER_AD_CLICKED: 'BigCrunchBannerAdClicked',
+  BANNER_AD_OPENED: 'BigCrunchBannerAdOpened',
+  BANNER_AD_CLOSED: 'BigCrunchBannerAdClosed',
+  BANNER_AD_REVENUE: 'BigCrunchBannerAdRevenue',
+  BANNER_AD_VIEWABLE: 'BigCrunchBannerAdViewable',
+
+  // Interstitial events
+  INTERSTITIAL_AD_LOADED: 'BigCrunchInterstitialAdLoaded',
+  INTERSTITIAL_AD_FAILED_TO_LOAD: 'BigCrunchInterstitialAdFailedToLoad',
+  INTERSTITIAL_AD_IMPRESSION: 'BigCrunchInterstitialAdImpression',
+  INTERSTITIAL_AD_CLICKED: 'BigCrunchInterstitialAdClicked',
+  INTERSTITIAL_AD_OPENED: 'BigCrunchInterstitialAdOpened',
+  INTERSTITIAL_AD_CLOSED: 'BigCrunchInterstitialAdClosed',
+  INTERSTITIAL_AD_REVENUE: 'BigCrunchInterstitialAdRevenue',
+
+  // Rewarded events
+  REWARDED_AD_LOADED: 'BigCrunchRewardedAdLoaded',
+  REWARDED_AD_FAILED_TO_LOAD: 'BigCrunchRewardedAdFailedToLoad',
+  REWARDED_AD_IMPRESSION: 'BigCrunchRewardedAdImpression',
+  REWARDED_AD_CLICKED: 'BigCrunchRewardedAdClicked',
+  REWARDED_AD_OPENED: 'BigCrunchRewardedAdOpened',
+  REWARDED_AD_CLOSED: 'BigCrunchRewardedAdClosed',
+  REWARDED_AD_REVENUE: 'BigCrunchRewardedAdRevenue',
+  REWARDED_AD_EARNED: 'BigCrunchRewardedAdEarned',
+
+  // Configuration events
+  CONFIG_UPDATED: 'BigCrunchConfigUpdated',
+  CONFIG_FAILED: 'BigCrunchConfigFailed',
+
+  // Session events
+  SESSION_STARTED: 'BigCrunchSessionStarted',
+  SESSION_ENDED: 'BigCrunchSessionEnded',
+} as const;