@thealteroffice/react-native-adgeist 0.0.20 → 0.0.22

package/src/{components → providers}/AdgeistProvider.tsx

@@ -1,8 +1,3 @@
-/**
- * @module AdgeistProvider
- * @description Context provider for Adgeist ad-serving configuration and initialization
- */
-
 import React, {
   createContext,
   useContext,
@@ -10,64 +5,25 @@ import React, {
   useState,
   useCallback,
 } from 'react';
-import Adgeist from '../NativeAdgeist';
-import { ConsentModal } from './ConsentModal';
-
-/**
- * Interface for Adgeist context
- */
-interface AdgeistContextType {
-  publisherId: string;
-  apiKey: string;
-  domain: string;
-  isTestEnvironment: boolean;
-  isInitialized: boolean;
-  initializationError?: Error;
-  setAdgeistConsentModal: (value: boolean) => void;
-}
-
-/**
- * Props for AdgeistProvider
- */
-interface AdgeistProviderProps {
-  children: React.ReactNode;
-  /** Custom API origin for Adgeist SDK */
-  customAdgeistApiOrigin?: string;
-  /** Publisher identifier */
-  publisherId: string;
-  /** API key for authentication */
-  apiKey: string;
-  /** Domain for ad serving */
-  domain: string;
-  /** Enable test environment mode */
-  isTestEnvironment?: boolean;
-  /** Callback for initialization errors */
-  onInitializationError?: (error: Error) => void;
-  /** Callback for successful initialization */
-  onInitializationSuccess?: () => void;
-}
+import Adgeist from '../specs/NativeAdgeist';
+import { ConsentModal } from '../components/deprecated/ConsentModal';
+import type {
+  AdgeistContextType,
+  AdgeistProviderProps,
+} from '../types/Provider';
 
 const AdgeistContext = createContext<AdgeistContextType>({
-  publisherId: '',
-  apiKey: '',
-  domain: '',
-  isTestEnvironment: true,
+  isTestEnvironment: false,
   isInitialized: false,
   setAdgeistConsentModal: () => {},
 });
 
-/**
- * AdgeistProvider component for managing ad-serving configuration
- * @param props - Component properties
- * @returns JSX.Element
- */
 export const AdgeistProvider: React.FC<AdgeistProviderProps> = ({
   children,
-  publisherId = '',
-  apiKey = '',
-  domain = '',
-  customAdgeistApiOrigin = 'bg-services-qa-api.adgeist.ai',
-  isTestEnvironment = true,
+  customBidRequestBackendDomain = 'https://beta.v2.bg-services.adgeist.ai',
+  customPackageOrBundleID = '',
+  customAdgeistAppID = '',
+  isTestEnvironment = false,
   onInitializationError,
   onInitializationSuccess,
 }) => {
@@ -86,7 +42,14 @@ export const AdgeistProvider: React.FC<AdgeistProviderProps> = ({
     setIsInitialized(false);
 
     try {
-      await Adgeist.initializeSdk(customAdgeistApiOrigin);
+      await Adgeist.destroySdk();
+
+      await Adgeist.initializeSdk(
+        customBidRequestBackendDomain,
+        customPackageOrBundleID,
+        customAdgeistAppID
+      );
+
       setIsInitialized(true);
       onInitializationSuccess?.();
     } catch (error: unknown) {
@@ -96,7 +59,13 @@ export const AdgeistProvider: React.FC<AdgeistProviderProps> = ({
       setIsInitialized(false);
       onInitializationError?.(err);
     }
-  }, [customAdgeistApiOrigin, onInitializationError, onInitializationSuccess]);
+  }, [
+    customBidRequestBackendDomain,
+    onInitializationError,
+    onInitializationSuccess,
+    customPackageOrBundleID,
+    customAdgeistAppID,
+  ]);
 
   useEffect(() => {
     initializeAdgeist();
@@ -105,9 +74,6 @@ export const AdgeistProvider: React.FC<AdgeistProviderProps> = ({
   return (
     <AdgeistContext.Provider
       value={{
-        publisherId,
-        apiKey,
-        domain,
         isTestEnvironment,
         isInitialized,
         initializationError,

package/src/specs/HTML5AdNativeComponent.ts

@@ -0,0 +1,46 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+  DirectEventHandler,
+  Double,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import * as React from 'react';
+
+export interface AdSize {
+  width?: Double;
+  height?: Double;
+}
+
+export interface AdFailedToLoadEvent {
+  error: string;
+}
+
+export interface NativeProps extends ViewProps {
+  adUnitID: string;
+  adIsResponsive?: boolean;
+  adSize?: AdSize;
+  adType: string;
+
+  onAdLoaded?: DirectEventHandler<null>;
+  onAdFailedToLoad?: DirectEventHandler<AdFailedToLoadEvent>;
+  onAdOpened?: DirectEventHandler<null>;
+  onAdClosed?: DirectEventHandler<null>;
+  onAdClicked?: DirectEventHandler<null>;
+}
+
+interface NativeCommands {
+  loadAd: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>,
+    isTestMode: boolean
+  ) => void;
+  destroy: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['loadAd', 'destroy'],
+});
+
+export default codegenNativeComponent<NativeProps>(
+  'HTML5AdNativeComponent'
+) as HostComponent<NativeProps>;

package/src/{NativeAdgeist.ts → specs/NativeAdgeist.ts}

@@ -13,13 +13,17 @@ export interface Event {
   eventProperties: Object;
 }
 export interface Spec extends TurboModule {
-  initializeSdk(customDomain: string): Promise<boolean>;
+  initializeSdk(
+    customBidRequestBackendDomain: string,
+    customPackageOrBundleID: string,
+    customAdgeistAppID: string
+  ): Promise<boolean>;
+
+  destroySdk(): Promise<boolean>;
 
   fetchCreative(
-    apiKey: string,
-    origin: string,
     adSpaceId: string,
-    publisherId: string,
+    buyType: string,
     isTestEnvironment: boolean
   ): Promise<Object>;
 
@@ -34,9 +38,9 @@ export interface Spec extends TurboModule {
   trackImpression(
     campaignId: string,
     adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
     bidId: string,
+    bidMeta: string,
+    buyType: string,
     isTestEnvironment: boolean,
     renderTime: number
   ): Promise<string>;
@@ -44,9 +48,9 @@ export interface Spec extends TurboModule {
   trackView(
     campaignId: string,
     adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
     bidId: string,
+    bidMeta: string,
+    buyType: string,
     isTestEnvironment: boolean,
     viewTime: number,
     visibilityRatio: number,
@@ -57,42 +61,39 @@ export interface Spec extends TurboModule {
   trackTotalView(
     campaignId: string,
     adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
     bidId: string,
+    bidMeta: string,
+    buyType: string,
     isTestEnvironment: boolean,
-    totalViewTime: number,
-    visibilityRatio: number
+    totalViewTime: number
   ): Promise<string>;
 
   trackClick(
     campaignId: string,
     adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
     bidId: string,
+    bidMeta: string,
+    buyType: string,
     isTestEnvironment: boolean
   ): Promise<string>;
 
   trackVideoPlayback(
     campaignId: string,
     adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
     bidId: string,
+    bidMeta: string,
+    buyType: string,
     isTestEnvironment: boolean,
     totalPlaybackTime: number
   ): Promise<string>;
 
-  trackVideoQuartile(
-    campaignId: string,
-    adSpaceId: string,
-    publisherId: string,
-    apiKey: string,
-    bidId: string,
-    isTestEnvironment: boolean,
-    quartile: string
-  ): Promise<string>;
+  // trackVideoQuartile(
+  //   campaignId: string,
+  //   adSpaceId: string,
+  //   bidId: string,
+  //   isTestEnvironment: boolean,
+  //   quartile: string
+  // ): Promise<string>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('Adgeist');

package/src/types/AdSize.ts

@@ -0,0 +1,4 @@
+export interface AdSize {
+  width?: number;
+  height?: number;
+}

package/src/types/CPMAdResponse.ts

@@ -0,0 +1,26 @@
+export interface CPMADRESPONSE {
+  id: string;
+  bidId: string;
+  cur: string;
+  seatBid: SeatBid[];
+}
+
+interface SeatBid {
+  bidId: string;
+  bid: Bid[];
+}
+
+interface Bid {
+  id: string;
+  impId: string;
+  price: number;
+  ext: BidExtension;
+}
+
+interface BidExtension {
+  creativeUrl: string;
+  ctaUrl: string;
+  creativeTitle: string;
+  creativeDescription: string;
+  creativeBrandName?: string;
+}

package/src/types/FixedAdResponse.ts

@@ -0,0 +1,51 @@
+export interface FIXEDADRESPONSE {
+  metaData: string;
+  id: string;
+  generatedAt: string;
+  signature: string;
+  campaignId: string;
+  advertiser: Advertiser;
+  type: 'FIXED' | string;
+  loadType: 'QUICK' | string;
+  displayOptions: DisplayOptions;
+  campaignValidity: {
+    startTime: string;
+    endTime: string;
+  };
+  creatives: Creative[];
+  frontendCacheDurationSeconds: number;
+  impressionRequirements: {
+    impressionType: ('VIEW' | 'CLICK')[];
+    minViewDurationSeconds: number;
+  };
+}
+
+interface Advertiser {
+  id: string;
+  name: string;
+  logoUrl: string;
+}
+
+interface DisplayOptions {
+  isResponsive: boolean;
+  dimensions: {
+    width: number;
+    height: number;
+  };
+  styleOptions: {
+    fontFamily: string;
+    fontColor: string;
+  };
+  allowedFormats: string[];
+}
+
+interface Creative {
+  ctaUrl: string;
+  title: string;
+  description: string;
+  type: 'image' | string;
+  fileName: string;
+  fileSize: number;
+  fileUrl: string;
+  thumbnailUrl: string;
+}

package/src/types/HTML5AdNativeComponentProps.ts

@@ -0,0 +1,28 @@
+import type { NativeSyntheticEvent } from 'react-native';
+import type { AdSize } from './AdSize';
+
+export interface HTML5AdNativeComponentProps {
+  adUnitID: string;
+  adIsResponsive?: boolean;
+  adSize?: AdSize;
+  adType: string;
+
+  onAdLoaded?: () => void;
+  onAdFailedToLoad?: (event: NativeSyntheticEvent<AdFailedToLoadEvent>) => void;
+  onAdOpened?: () => void;
+  onAdClosed?: () => void;
+  onAdClicked?: () => void;
+}
+
+export interface AdFailedToLoadEvent {
+  error: string;
+}
+
+export interface HTML5AdRequest {
+  isTestMode?: boolean;
+}
+
+export interface HTML5AdViewRef {
+  loadAd: (adRequest?: HTML5AdRequest) => void;
+  destroy: () => void;
+}

package/src/types/Provider.ts

@@ -0,0 +1,16 @@
+export interface AdgeistContextType {
+  isTestEnvironment: boolean;
+  isInitialized: boolean;
+  initializationError?: Error;
+  setAdgeistConsentModal: (value: boolean) => void;
+}
+
+export interface AdgeistProviderProps {
+  children: React.ReactNode;
+  customBidRequestBackendDomain?: string;
+  customPackageOrBundleID?: string;
+  customAdgeistAppID?: string;
+  isTestEnvironment?: boolean;
+  onInitializationError?: (error: Error) => void;
+  onInitializationSuccess?: () => void;
+}

package/android/src/main/AndroidManifestNew.xml

@@ -1,2 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>

package/android/src/main/java/com/adgeist/implementation/AdgeistModuleImpl.kt

@@ -1,252 +0,0 @@
-package com.adgeist.implementation
-
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-import com.adgeistkit.AdgeistCore
-import com.adgeistkit.FetchCreative
-import com.adgeistkit.CreativeAnalytics
-import com.adgeistkit.CreativeDataModel
-import com.adgeistkit.BidResponseData
-import com.adgeistkit.SeatBid
-import com.adgeistkit.Bid
-import com.adgeistkit.BidExtension
-import com.adgeistkit.UserDetails
-import com.adgeistkit.Event
-import com.facebook.react.bridge.ReadableMap
-
-class AdgeistModuleImpl internal constructor(private val context: ReactApplicationContext) {
-
-  private var adgeistInstance: AdgeistCore? = null
-  private var getAd: FetchCreative? = null
-  private var postCreativeAnalytic: CreativeAnalytics? = null
-
-  fun initializeSdk(customDomain: String?, promise: Promise) {
-    try {
-      adgeistInstance = AdgeistCore.initialize(context.applicationContext, customDomain)
-      getAd = adgeistInstance?.getCreative()
-      postCreativeAnalytic = adgeistInstance?.postCreativeAnalytics()
-      promise.resolve("SDK initialized with domain: ${customDomain ?: "default"}")
-    } catch (e: Exception) {
-      promise.reject("INIT_FAILED", "SDK initialization failed", e)
-    }
-  }
-
-  fun fetchCreative(apiKey: String, origin: String, adSpaceId: String, publisherId: String, isTestEnvironment: Boolean, promise: Promise) {
-    getAd?.fetchCreative(apiKey, origin, adSpaceId, publisherId, isTestEnvironment) { adData ->
-      if (adData != null) {
-        promise.resolve(adData.toWritableMap())
-      } else {
-        promise.reject("NO_AD", "Ad data not available")
-      }
-    } ?: promise.reject("NOT_INITIALIZED", "SDK not initialized")
-  }
-
-
-  fun setUserDetails(userDetailsMap: ReadableMap) {
-    val userDetails = UserDetails(
-        userId = userDetailsMap.getStringSafe("userId"),
-        userName = userDetailsMap.getStringSafe("userName"),
-        email = userDetailsMap.getStringSafe("email"),
-        phone = userDetailsMap.getStringSafe("phone")
-    )
-    adgeistInstance?.setUserDetails(userDetails)
-  }
-
-  fun logEvent(eventMap: ReadableMap) {
-    val eventType = eventMap.getStringSafe("eventType")
-
-    if (eventType.isNullOrEmpty()) {
-        throw IllegalArgumentException("Event must have a non-empty eventType")
-    }
-
-    val props = if (eventMap.hasKey("eventProperties")) eventMap.getMap("eventProperties") else null
-    val eventProps = props?.toHashMap() ?: emptyMap<String, Any>()
-
-    val event = Event(
-        eventType = eventType,
-        eventProperties = eventProps
-    )
-    adgeistInstance?.logEvent(event)
-  }
-
-  fun getConsentStatus(promise: Promise) {
-    try {
-        val consent = adgeistInstance?.getConsentStatus() ?: false
-        promise.resolve(consent)
-    } catch (e: Exception) {
-        promise.reject("CONSENT_ERROR", "Failed to get consent status", e)
-    }
-}
-
-  fun updateConsentStatus(consent: Boolean) {
-    adgeistInstance?.updateConsentStatus(consent)
-  }
-  
-  fun trackImpression(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    renderTime: Float,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackImpression(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment, renderTime
-    )
-    promise.resolve("Impression event sent")
-  }
-
-  fun trackView(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    viewTime: Float,
-    visibilityRatio: Float,
-    scrollDepth: Float,
-    timeToVisible: Float,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackView(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment,
-      viewTime, visibilityRatio, scrollDepth, timeToVisible
-    )
-    promise.resolve("View event sent")
-  }
-
-  fun trackTotalView(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    totalViewTime: Float,
-    visibilityRatio: Float,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackTotalView(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment,
-      totalViewTime, visibilityRatio
-    )
-    promise.resolve("Total view event sent")
-  }
-
-  fun trackClick(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackClick(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment
-    )
-    promise.resolve("Click event sent")
-  }
-
-  fun trackVideoPlayback(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    totalPlaybackTime: Float,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackVideoPlayback(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment, totalPlaybackTime
-    )
-    promise.resolve("Video playback event sent")
-  }
-
-  fun trackVideoQuartile(
-    campaignId: String,
-    adSpaceId: String,
-    publisherId: String,
-    apiKey: String,
-    bidId: String,
-    isTestEnvironment: Boolean,
-    quartile: String,
-    promise: Promise
-  ) {
-    postCreativeAnalytic?.trackVideoQuartile(
-      campaignId, adSpaceId, publisherId, apiKey, bidId, isTestEnvironment, quartile
-    )
-    promise.resolve("Video quartile event sent")
-  }
-
-  companion object {
-    const val NAME = "Adgeist"
-  }
-}
-
-fun ReadableMap.getStringSafe(key: String): String? =
-    if (this.hasKey(key) && !this.isNull(key)) this.getString(key) else null
-
-
-// Extension function to convert CreativeDataModel to WritableMap
-fun CreativeDataModel.toWritableMap(): WritableMap {
-    val map = Arguments.createMap()
-    
-    map.putBoolean("success", this.success)
-    map.putString("message", this.message)
-    
-    // Handle null data - store in local variable for smart casting
-    val dataValue = this.data
-    if (dataValue != null) {
-        val dataMap = Arguments.createMap()
-        dataMap.putString("id", dataValue.id)
-        dataMap.putString("bidId", dataValue.bidId)
-        dataMap.putString("cur", dataValue.cur)
-        
-        // Handle null seatBid list - store in local variable
-        val seatBidArray = Arguments.createArray()
-        val seatBidList = dataValue.seatBid
-        if (seatBidList != null) {
-            for (seatBid in seatBidList) {
-                val seatBidMap = Arguments.createMap()
-                seatBidMap.putString("bidId", seatBid.bidId)
-                
-                // Handle null bid list - store in local variable
-                val bidArray = Arguments.createArray()
-                val bidList = seatBid.bid
-                if (bidList != null) {
-                    for (bid in bidList) {
-                        val bidMap = Arguments.createMap()
-                        bidMap.putString("id", bid.id)
-                        bidMap.putString("impId", bid.impId)
-                        bidMap.putDouble("price", bid.price)
-                        
-                        // Handle extension
-                        val extMap = Arguments.createMap()
-                        extMap.putString("creativeUrl", bid.ext.creativeUrl)
-                        extMap.putString("ctaUrl", bid.ext.ctaUrl)
-                        extMap.putString("creativeTitle", bid.ext.creativeTitle)
-                        extMap.putString("creativeDescription", bid.ext.creativeDescription)
-                        
-                        bidMap.putMap("ext", extMap)
-                        bidArray.pushMap(bidMap)
-                    }
-                }
-                seatBidMap.putArray("bid", bidArray)
-                seatBidArray.pushMap(seatBidMap)
-            }
-        }
-        dataMap.putArray("seatBid", seatBidArray)
-        map.putMap("data", dataMap)
-    } else {
-        map.putNull("data")
-    }
-    
-    return map
-}