setupad-prebid-react-native 0.1.3

package/src/VeonPrebidModule.ts

@@ -0,0 +1,159 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+import type { PrebidConfig } from './types';
+
+const LINKING_ERROR =
+  `The package 'setupad-prebid-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+// Native Module
+const VeonPrebidReactNativeModule = NativeModules.VeonPrebidReactNativeModule
+  ? NativeModules.VeonPrebidReactNativeModule
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+// Event Emitter for SDK events
+const eventEmitter = new NativeEventEmitter(VeonPrebidReactNativeModule);
+
+/**
+ * Veon Prebid SDK Module
+ * Handles SDK initialization and global SDK operations
+ */
+class VeonPrebidSDK {
+  private static instance: VeonPrebidSDK;
+  private isInitialized: boolean = false;
+  private initializationPromise: Promise<string> | null = null;
+
+  private constructor() {}
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): VeonPrebidSDK {
+    if (!VeonPrebidSDK.instance) {
+      VeonPrebidSDK.instance = new VeonPrebidSDK();
+    }
+    return VeonPrebidSDK.instance;
+  }
+
+  /**
+   * Initialize Prebid Mobile SDK
+   *
+   * @param config - Prebid configuration
+   * @returns Promise that resolves when SDK is initialized
+   *
+   * @example
+   * ```typescript
+   * await VeonPrebidSDK.getInstance().initialize({
+   *   prebidHost: 'https://prebid.veonadx.com/openrtb2/auction',
+   *   configHost: 'https://config.veonadx.com',
+   *   accountId: 'YOUR_ACCOUNT_ID',
+   *   timeoutMillis: 3000,
+   *   pbsDebug: __DEV__,
+   * });
+   * ```
+   */
+  public async initialize(config: PrebidConfig): Promise<string> {
+    // Return existing initialization if in progress
+    if (this.initializationPromise !== null) {
+      return this.initializationPromise;
+    }
+
+    // Return immediately if already initialized
+    if (this.isInitialized) {
+      return Promise.resolve('already initialized');
+    }
+
+    const {
+      prebidHost,
+      configHost,
+      accountId,
+      timeoutMillis = 3000,
+      pbsDebug = false,
+    } = config;
+
+    console.log('Initializing Veon Prebid SDK...', {
+      prebidHost,
+      configHost,
+      accountId,
+      timeoutMillis,
+      pbsDebug,
+    });
+
+    const promise = VeonPrebidReactNativeModule.initializeSDK(
+      prebidHost,
+      configHost,
+      accountId,
+      timeoutMillis,
+      pbsDebug
+    )
+      .then((result: string) => {
+        console.log('Veon Prebid SDK initialized successfully:', result);
+        this.isInitialized = true;
+        this.initializationPromise = null;
+        return result;
+      })
+      .catch((error: any) => {
+        console.error('Failed to initialize Veon Prebid SDK:', error);
+        this.initializationPromise = null;
+        throw error;
+      });
+
+    this.initializationPromise = promise;
+    return promise;
+  }
+
+  /**
+   * Get Prebid SDK version
+   *
+   * @returns Promise that resolves with SDK version string
+   */
+  public async getSDKVersion(): Promise<string> {
+    try {
+      return await VeonPrebidReactNativeModule.getSDKVersion();
+    } catch (error) {
+      console.error('Failed to get SDK version:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if SDK is initialized
+   */
+  public isSDKInitialized(): boolean {
+    return this.isInitialized;
+  }
+
+  /**
+   * Add listener for SDK initialization events
+   *
+   * @param event - Event name ('prebidSdkInitialized' or 'prebidSdkInitializeFailed')
+   * @param listener - Callback function
+   * @returns Subscription object with remove() method
+   */
+  public addListener(
+    event: 'prebidSdkInitialized' | 'prebidSdkInitializeFailed',
+    listener: (data: any) => void
+  ) {
+    return eventEmitter.addListener(event, listener);
+  }
+
+  /**
+   * Remove all listeners for specific event
+   *
+   * @param event - Event name
+   */
+  public removeAllListeners(
+    event: 'prebidSdkInitialized' | 'prebidSdkInitializeFailed'
+  ) {
+    eventEmitter.removeAllListeners(event);
+  }
+}
+
+export default VeonPrebidSDK;

package/src/VeonPrebidReactNativeViewNativeComponent.ts

@@ -0,0 +1,50 @@
+import type { ViewProps } from 'react-native';
+import type {
+  Int32,
+  DirectEventHandler,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+/**
+ * Event payload for ad events
+ */
+export interface AdEventPayload {
+  adId?: string;
+  sdk?: string;
+  message?: string;
+}
+
+/**
+ * Native Props for VeonPrebidReactNativeView
+ */
+export interface NativeProps extends ViewProps {
+  /** Ad type: banner, interstitial, or rewardVideo */
+  adType?: string;
+
+  /** Prebid config ID */
+  configId?: string;
+
+  /** Google Ad Manager ad unit ID */
+  adUnitId?: string;
+
+  /** Ad width (required for banners) */
+  width?: Int32;
+
+  /** Ad height (required for banners) */
+  height?: Int32;
+
+  /** Refresh interval in seconds (30-120, for banners only) */
+  refreshInterval?: Int32;
+
+  // Event handlers
+  onAdLoaded?: DirectEventHandler<AdEventPayload>;
+  onAdDisplayed?: DirectEventHandler<AdEventPayload>;
+  onAdFailed?: DirectEventHandler<AdEventPayload>;
+  onAdClicked?: DirectEventHandler<AdEventPayload>;
+  onAdClosed?: DirectEventHandler<AdEventPayload>;
+}
+
+/**
+ * Native component for Veon Prebid ads
+ */
+export default codegenNativeComponent<NativeProps>('VeonPrebidReactNativeView');

package/src/VeonPrebidView.tsx

@@ -0,0 +1,13 @@
+import React from 'react';
+import VeonPrebidReactNativeViewNative from './VeonPrebidReactNativeViewNativeComponent';
+import type { VeonPrebidViewProps } from './types';
+
+export const VeonPrebidView = React.forwardRef<any, VeonPrebidViewProps>(
+  (props, ref) => {
+    return <VeonPrebidReactNativeViewNative ref={ref} {...props} />;
+  }
+);
+
+VeonPrebidView.displayName = 'VeonPrebidView';
+
+export default VeonPrebidView;

package/src/index.tsx

@@ -0,0 +1,12 @@
+export { VeonPrebidView } from './VeonPrebidView';
+export { VeonPrebidCommands } from './Commands';
+export { default as VeonPrebidAd } from './VeonPrebidAd';
+export { default as VeonPrebidSDK } from './VeonPrebidModule';
+export { AdType } from './types';
+export type {
+  VeonPrebidViewProps,
+  AdEventData,
+  AdController,
+  VeonPrebidAdProps,
+  PrebidConfig
+} from './types';

package/src/types.ts

@@ -0,0 +1,64 @@
+export const AdType = {
+  BANNER: 'banner' as const,
+  INTERSTITIAL: 'interstitial' as const,
+  REWARD_VIDEO: 'rewardvideo' as const,
+};
+
+export type AdType = typeof AdType[keyof typeof AdType];
+
+export interface VeonPrebidViewProps {
+  adType: AdType;
+  configId: string;
+  adUnitId: string;
+  width?: number;
+  height?: number;
+  refreshInterval?: number;
+  style?: any;
+  onAdLoaded?: (event: { nativeEvent: { adId?: string; sdk?: string; message?: string } }) => void;
+  onAdDisplayed?: (event: { nativeEvent: { adId?: string; sdk?: string; message?: string } }) => void;
+  onAdFailed?: (event: { nativeEvent: { adId?: string; sdk?: string; message?: string } }) => void;
+  onAdClicked?: (event: { nativeEvent: { adId?: string; sdk?: string; message?: string } }) => void;
+  onAdClosed?: (event: { nativeEvent: { adId?: string; sdk?: string; message?: string } }) => void;
+}
+
+export interface AdEventData {
+  configId?: string;
+  adUnitId?: string;
+  sdkType?: string;
+  error?: string;
+}
+
+export interface AdController {
+  loadBanner: () => void;
+  showBanner: () => void;
+  hideBanner: () => void;
+  loadInterstitial: () => void;
+  showInterstitial: () => void;
+  hideInterstitial: () => void;
+  pauseAuction: () => void;
+  resumeAuction: () => void;
+  destroyAuction: () => void;
+}
+
+export interface VeonPrebidAdProps {
+  adType: AdType;
+  configId: string;
+  adUnitId: string;
+  width?: number;
+  height?: number;
+  refreshInterval?: number;
+  style?: any;
+  onAdLoaded?: (data: AdEventData) => void;
+  onAdDisplayed?: (data: AdEventData) => void;
+  onAdFailed?: (data: AdEventData) => void;
+  onAdClicked?: (data: AdEventData) => void;
+  onAdClosed?: (data: AdEventData) => void;
+}
+
+export interface PrebidConfig {
+  prebidHost: string;
+  configHost: string;
+  accountId: string;
+  timeoutMillis?: number;
+  pbsDebug?: boolean;
+}

package/src/useVeonPrebidAd.ts

@@ -0,0 +1,156 @@
+import { useRef, useCallback, useEffect } from 'react';
+import type { AdController, VeonPrebidAdProps } from './types';
+
+/**
+ * Hook for managing Veon Prebid ads programmatically
+ *
+ * @param config - Ad configuration
+ * @param eventListener - Optional event listener
+ * @returns AdController reference and helper functions
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { adRef, loadBanner, showBanner } = useVeonPrebidAd(
+ *     {
+ *       adType: AdType.BANNER,
+ *       configId: 'YOUR_CONFIG_ID',
+ *       adUnitId: 'YOUR_AD_UNIT_ID',
+ *       width: 300,
+ *       height: 250,
+ *     },
+ *     {
+ *       onAdLoaded: (data) => console.log('Ad loaded', data),
+ *       onAdFailed: (error) => console.error('Ad failed', error),
+ *     }
+ *   );
+ *
+ *   useEffect(() => {
+ *     loadBanner();
+ *   }, []);
+ *
+ *   return (
+ *     <VeonPrebidAd
+ *       ref={adRef}
+ *       {...config}
+ *       {...eventListener}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export function useVeonPrebidAd(
+  config: Pick<VeonPrebidAdProps, 'adType' | 'configId' | 'adUnitId' | 'width' | 'height' | 'refreshInterval'>
+) {
+  const adRef = useRef<AdController>(null);
+
+  /**
+   * Load banner ad
+   */
+  const loadBanner = useCallback(() => {
+    if (config.adType !== 'banner') {
+      console.warn('loadBanner called but ad type is not banner');
+      return;
+    }
+    adRef.current?.loadBanner();
+  }, [config.adType]);
+
+  /**
+   * Show banner ad
+   */
+  const showBanner = useCallback(() => {
+    if (config.adType !== 'banner') {
+      console.warn('showBanner called but ad type is not banner');
+      return;
+    }
+    adRef.current?.showBanner();
+  }, [config.adType]);
+
+  /**
+   * Hide banner ad
+   */
+  const hideBanner = useCallback(() => {
+    if (config.adType !== 'banner') {
+      console.warn('hideBanner called but ad type is not banner');
+      return;
+    }
+    adRef.current?.hideBanner();
+  }, [config.adType]);
+
+  /**
+   * Load interstitial ad
+   */
+  const loadInterstitial = useCallback(() => {
+    if (config.adType !== 'interstitial') {
+      console.warn('loadInterstitial called but ad type is not interstitial');
+      return;
+    }
+    adRef.current?.loadInterstitial();
+  }, [config.adType]);
+
+  /**
+   * Show interstitial ad
+   */
+  const showInterstitial = useCallback(() => {
+    if (config.adType !== 'interstitial') {
+      console.warn('showInterstitial called but ad type is not interstitial');
+      return;
+    }
+    adRef.current?.showInterstitial();
+  }, [config.adType]);
+
+  /**
+   * Hide interstitial ad
+   */
+  const hideInterstitial = useCallback(() => {
+    if (config.adType !== 'interstitial') {
+      console.warn('hideInterstitial called but ad type is not interstitial');
+      return;
+    }
+    adRef.current?.hideInterstitial();
+  }, [config.adType]);
+
+  /**
+   * Pause ad auction (for banners)
+   */
+  const pauseAuction = useCallback(() => {
+    adRef.current?.pauseAuction();
+  }, []);
+
+  /**
+   * Resume ad auction (for banners)
+   */
+  const resumeAuction = useCallback(() => {
+    adRef.current?.resumeAuction();
+  }, []);
+
+  /**
+   * Destroy ad and free resources
+   */
+  const destroyAuction = useCallback(() => {
+    adRef.current?.destroyAuction();
+  }, []);
+
+  /**
+   * Cleanup on unmount
+   */
+  useEffect(() => {
+    return () => {
+      // Optional: destroy ad on unmount
+      // adRef.current?.destroyAuction();
+    };
+  }, []);
+
+  return {
+    adRef,
+    loadBanner,
+    showBanner,
+    hideBanner,
+    loadInterstitial,
+    showInterstitial,
+    hideInterstitial,
+    pauseAuction,
+    resumeAuction,
+    destroyAuction,
+  };
+}