@thealteroffice/react-native-adgeist 0.0.19 → 0.0.22

package/android/generated/jni/react/renderer/components/RNAdgeistSpec/RNAdgeistSpecJSI.h

@@ -20,18 +20,18 @@ protected:
   NativeAdgeistCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
-  virtual jsi::Value initializeSdk(jsi::Runtime &rt, jsi::String customDomain) = 0;
-  virtual jsi::Value fetchCreative(jsi::Runtime &rt, jsi::String apiKey, jsi::String origin, jsi::String adSpaceId, jsi::String publisherId, bool isTestEnvironment) = 0;
+  virtual jsi::Value initializeSdk(jsi::Runtime &rt, jsi::String customBidRequestBackendDomain, jsi::String customPackageOrBundleID, jsi::String customAdgeistAppID) = 0;
+  virtual jsi::Value destroySdk(jsi::Runtime &rt) = 0;
+  virtual jsi::Value fetchCreative(jsi::Runtime &rt, jsi::String adSpaceId, jsi::String buyType, bool isTestEnvironment) = 0;
   virtual void setUserDetails(jsi::Runtime &rt, jsi::Object user) = 0;
   virtual void logEvent(jsi::Runtime &rt, jsi::Object event) = 0;
   virtual jsi::Value getConsentStatus(jsi::Runtime &rt) = 0;
   virtual void updateConsentStatus(jsi::Runtime &rt, bool consent) = 0;
-  virtual jsi::Value trackImpression(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double renderTime) = 0;
-  virtual jsi::Value trackView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double viewTime, double visibilityRatio, double scrollDepth, double timeToVisible) = 0;
-  virtual jsi::Value trackTotalView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double totalViewTime, double visibilityRatio) = 0;
-  virtual jsi::Value trackClick(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment) = 0;
-  virtual jsi::Value trackVideoPlayback(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double totalPlaybackTime) = 0;
-  virtual jsi::Value trackVideoQuartile(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, jsi::String quartile) = 0;
+  virtual jsi::Value trackImpression(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double renderTime) = 0;
+  virtual jsi::Value trackView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double viewTime, double visibilityRatio, double scrollDepth, double timeToVisible) = 0;
+  virtual jsi::Value trackTotalView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double totalViewTime) = 0;
+  virtual jsi::Value trackClick(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment) = 0;
+  virtual jsi::Value trackVideoPlayback(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double totalPlaybackTime) = 0;
 
 };
 
@@ -62,21 +62,29 @@ private:
 
     }
 
-    jsi::Value initializeSdk(jsi::Runtime &rt, jsi::String customDomain) override {
+    jsi::Value initializeSdk(jsi::Runtime &rt, jsi::String customBidRequestBackendDomain, jsi::String customPackageOrBundleID, jsi::String customAdgeistAppID) override {
       static_assert(
-          bridging::getParameterCount(&T::initializeSdk) == 2,
-          "Expected initializeSdk(...) to have 2 parameters");
+          bridging::getParameterCount(&T::initializeSdk) == 4,
+          "Expected initializeSdk(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::initializeSdk, jsInvoker_, instance_, std::move(customDomain));
+          rt, &T::initializeSdk, jsInvoker_, instance_, std::move(customBidRequestBackendDomain), std::move(customPackageOrBundleID), std::move(customAdgeistAppID));
     }
-    jsi::Value fetchCreative(jsi::Runtime &rt, jsi::String apiKey, jsi::String origin, jsi::String adSpaceId, jsi::String publisherId, bool isTestEnvironment) override {
+    jsi::Value destroySdk(jsi::Runtime &rt) override {
       static_assert(
-          bridging::getParameterCount(&T::fetchCreative) == 6,
-          "Expected fetchCreative(...) to have 6 parameters");
+          bridging::getParameterCount(&T::destroySdk) == 1,
+          "Expected destroySdk(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::fetchCreative, jsInvoker_, instance_, std::move(apiKey), std::move(origin), std::move(adSpaceId), std::move(publisherId), std::move(isTestEnvironment));
+          rt, &T::destroySdk, jsInvoker_, instance_);
+    }
+    jsi::Value fetchCreative(jsi::Runtime &rt, jsi::String adSpaceId, jsi::String buyType, bool isTestEnvironment) override {
+      static_assert(
+          bridging::getParameterCount(&T::fetchCreative) == 4,
+          "Expected fetchCreative(...) to have 4 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::fetchCreative, jsInvoker_, instance_, std::move(adSpaceId), std::move(buyType), std::move(isTestEnvironment));
     }
     void setUserDetails(jsi::Runtime &rt, jsi::Object user) override {
       static_assert(
@@ -110,53 +118,45 @@ private:
       return bridging::callFromJs<void>(
           rt, &T::updateConsentStatus, jsInvoker_, instance_, std::move(consent));
     }
-    jsi::Value trackImpression(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double renderTime) override {
+    jsi::Value trackImpression(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double renderTime) override {
       static_assert(
           bridging::getParameterCount(&T::trackImpression) == 8,
           "Expected trackImpression(...) to have 8 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackImpression, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment), std::move(renderTime));
+          rt, &T::trackImpression, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(bidId), std::move(bidMeta), std::move(buyType), std::move(isTestEnvironment), std::move(renderTime));
     }
-    jsi::Value trackView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double viewTime, double visibilityRatio, double scrollDepth, double timeToVisible) override {
+    jsi::Value trackView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double viewTime, double visibilityRatio, double scrollDepth, double timeToVisible) override {
       static_assert(
           bridging::getParameterCount(&T::trackView) == 11,
           "Expected trackView(...) to have 11 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackView, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment), std::move(viewTime), std::move(visibilityRatio), std::move(scrollDepth), std::move(timeToVisible));
+          rt, &T::trackView, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(bidId), std::move(bidMeta), std::move(buyType), std::move(isTestEnvironment), std::move(viewTime), std::move(visibilityRatio), std::move(scrollDepth), std::move(timeToVisible));
     }
-    jsi::Value trackTotalView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double totalViewTime, double visibilityRatio) override {
+    jsi::Value trackTotalView(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double totalViewTime) override {
       static_assert(
-          bridging::getParameterCount(&T::trackTotalView) == 9,
-          "Expected trackTotalView(...) to have 9 parameters");
+          bridging::getParameterCount(&T::trackTotalView) == 8,
+          "Expected trackTotalView(...) to have 8 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackTotalView, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment), std::move(totalViewTime), std::move(visibilityRatio));
+          rt, &T::trackTotalView, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(bidId), std::move(bidMeta), std::move(buyType), std::move(isTestEnvironment), std::move(totalViewTime));
     }
-    jsi::Value trackClick(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment) override {
+    jsi::Value trackClick(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment) override {
       static_assert(
           bridging::getParameterCount(&T::trackClick) == 7,
           "Expected trackClick(...) to have 7 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackClick, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment));
+          rt, &T::trackClick, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(bidId), std::move(bidMeta), std::move(buyType), std::move(isTestEnvironment));
     }
-    jsi::Value trackVideoPlayback(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, double totalPlaybackTime) override {
+    jsi::Value trackVideoPlayback(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String bidId, jsi::String bidMeta, jsi::String buyType, bool isTestEnvironment, double totalPlaybackTime) override {
       static_assert(
           bridging::getParameterCount(&T::trackVideoPlayback) == 8,
           "Expected trackVideoPlayback(...) to have 8 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackVideoPlayback, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment), std::move(totalPlaybackTime));
-    }
-    jsi::Value trackVideoQuartile(jsi::Runtime &rt, jsi::String campaignId, jsi::String adSpaceId, jsi::String publisherId, jsi::String apiKey, jsi::String bidId, bool isTestEnvironment, jsi::String quartile) override {
-      static_assert(
-          bridging::getParameterCount(&T::trackVideoQuartile) == 8,
-          "Expected trackVideoQuartile(...) to have 8 parameters");
-
-      return bridging::callFromJs<jsi::Value>(
-          rt, &T::trackVideoQuartile, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(publisherId), std::move(apiKey), std::move(bidId), std::move(isTestEnvironment), std::move(quartile));
+          rt, &T::trackVideoPlayback, jsInvoker_, instance_, std::move(campaignId), std::move(adSpaceId), std::move(bidId), std::move(bidMeta), std::move(buyType), std::move(isTestEnvironment), std::move(totalPlaybackTime));
     }
 
   private:

package/android/generated/jni/react/renderer/components/RNAdgeistSpec/ShadowNodes.cpp

@@ -0,0 +1,17 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+#include "ShadowNodes.h"
+
+namespace facebook::react {
+
+extern const char HTML5AdNativeComponentComponentName[] = "HTML5AdNativeComponent";
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNAdgeistSpec/ShadowNodes.h

@@ -0,0 +1,32 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+#include "EventEmitters.h"
+#include "Props.h"
+#include "States.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char HTML5AdNativeComponentComponentName[];
+
+/*
+ * `ShadowNode` for <HTML5AdNativeComponent> component.
+ */
+using HTML5AdNativeComponentShadowNode = ConcreteViewShadowNode<
+    HTML5AdNativeComponentComponentName,
+    HTML5AdNativeComponentProps,
+    HTML5AdNativeComponentEventEmitter,
+    HTML5AdNativeComponentState>;
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNAdgeistSpec/States.cpp

@@ -0,0 +1,16 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateCpp.js
+ */
+#include "States.h"
+
+namespace facebook::react {
+
+
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNAdgeistSpec/States.h

@@ -0,0 +1,29 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+class HTML5AdNativeComponentState {
+public:
+  HTML5AdNativeComponentState() = default;
+
+#ifdef ANDROID
+  HTML5AdNativeComponentState(HTML5AdNativeComponentState const &previousState, folly::dynamic data){};
+  folly::dynamic getDynamic() const {
+    return {};
+  };
+#endif
+};
+
+} // namespace facebook::react

package/android/src/main/java/com/adgeist/AdgeistPackage.kt

@@ -1,21 +1,22 @@
 package com.adgeist
 
 import androidx.annotation.Nullable
+import com.adgeist.components.HTML5AdViewManager
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
-import com.adgeist.implementation.AdgeistModuleImpl
+import com.adgeist.modules.AdgeistImpl
 import java.util.HashMap
 
 class AdgeistPackage : TurboReactPackage() {
 
   @Nullable
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == AdgeistModuleImpl.NAME) {
-      AdgeistModule(reactContext)
+    return if (name == AdgeistImpl.NAME) {
+      Adgeist(reactContext)
     } else {
       null
     }
@@ -24,9 +25,9 @@ class AdgeistPackage : TurboReactPackage() {
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
     return ReactModuleInfoProvider {
       val moduleInfos = HashMap<String, ReactModuleInfo>()
-      moduleInfos[AdgeistModuleImpl.NAME] = ReactModuleInfo(
-        AdgeistModuleImpl.NAME,
-        AdgeistModuleImpl.NAME,
+      moduleInfos[AdgeistImpl.NAME] = ReactModuleInfo(
+        AdgeistImpl.NAME,
+        AdgeistImpl.NAME,
         false, // canOverrideExistingModule
         false, // needsEagerInit
         false, // isCxxModule
@@ -37,6 +38,6 @@ class AdgeistPackage : TurboReactPackage() {
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList() // Add your ViewManagers here if any
+    return listOf(HTML5AdViewManager())
   }
 }

package/android/src/main/java/com/adgeist/components/HTML5AdViewManagerImpl.kt

@@ -0,0 +1,125 @@
+package com.adgeist.components
+
+import android.util.Log
+import android.view.View
+import androidx.annotation.RequiresPermission
+import com.adgeistkit.ads.AdListener
+import com.adgeistkit.ads.AdSize
+import com.adgeistkit.ads.AdView
+import com.adgeistkit.ads.network.AdRequest
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+object HTML5AdViewManagerImpl {
+    const val NAME = "HTML5AdNativeComponent"
+    private const val TAG = "HTML5AdViewManagerImpl"
+
+    const val EVENT_AD_LOADED = "onAdLoaded"
+    const val EVENT_AD_FAILED_TO_LOAD = "onAdFailedToLoad"
+    const val EVENT_AD_OPENED = "onAdOpened"
+    const val EVENT_AD_CLOSED = "onAdClosed"
+    const val EVENT_AD_CLICKED = "onAdClicked"
+
+    fun createViewInstance(reactContext: ThemedReactContext): AdView {
+        return AdView(reactContext)
+    }
+
+    fun setAdUnitID(view: AdView, adUnitID: String?) {
+        if (adUnitID != null) {
+            view.adUnitId = adUnitID
+        }
+    }
+
+    fun setAdIsResponsive(view: AdView, adIsResponsive: Boolean) {
+        view.adIsResponsive = adIsResponsive
+    }
+
+    fun setAdSize(view: AdView, adSizeMap: ReadableMap?) {
+        if (adSizeMap != null) {
+            try {
+                val width = adSizeMap.getInt("width")
+                val height = adSizeMap.getInt("height")
+
+                val adSize = AdSize(width, height)
+
+                view.setAdDimension(adSize)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error setting ad size", e)
+            }
+        }
+    }
+
+    fun setAdType(view: AdView, adType: String?) {
+        if (adType != null) {
+            view.adType = adType
+        }
+    }
+
+    @RequiresPermission("android.permission.INTERNET")
+    fun loadAd(view: AdView, isTestMode: Boolean) {
+        try {
+            val adRequestBuilder = AdRequest.Builder()
+            adRequestBuilder.setTestMode(isTestMode)
+
+
+            val adRequest = adRequestBuilder.build()
+
+            view.setAdListener(object : AdListener() {
+                override fun onAdLoaded() {
+                  view.post {
+                    sendEvent(view, EVENT_AD_LOADED, Arguments.createMap())
+                    measureAndLayout(view)
+                  }
+                }
+
+                override fun onAdFailedToLoad(error: String) {
+                    val event = Arguments.createMap().apply {
+                        putString("error", error)
+                    }
+                    sendEvent(view, EVENT_AD_FAILED_TO_LOAD, event)
+                }
+
+                override fun onAdOpened() {
+                    sendEvent(view, EVENT_AD_OPENED, Arguments.createMap())
+                }
+
+                override fun onAdClosed() {
+                    sendEvent(view, EVENT_AD_CLOSED, Arguments.createMap())
+                }
+
+                override fun onAdClicked() {
+                    sendEvent(view, EVENT_AD_CLICKED, Arguments.createMap())
+                }
+            })
+
+            view.loadAd(adRequest)
+        } catch (e: Exception) {
+            val event = Arguments.createMap().apply {
+                putString("error", e.message ?: "Unknown error")
+            }
+            sendEvent(view, EVENT_AD_FAILED_TO_LOAD, event)
+        }
+    }
+
+    fun destroyAd(view: AdView) {
+        view.destroy()
+    }
+
+    private fun measureAndLayout(view: AdView) {
+        view.measure(
+            View.MeasureSpec.makeMeasureSpec(view.width, View.MeasureSpec.EXACTLY),
+            View.MeasureSpec.makeMeasureSpec(view.height, View.MeasureSpec.EXACTLY)
+        )
+        view.layout(view.left, view.top, view.right, view.bottom)
+    }
+
+    private fun sendEvent(view: AdView, eventName: String, params: WritableMap) {
+        val reactContext = view.context as ThemedReactContext
+        reactContext
+            .getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(view.id, eventName, params)
+    }
+}

package/android/src/main/java/com/adgeist/modules/AdgeistImpl.kt

@@ -0,0 +1,114 @@
+package com.adgeist.modules
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.adgeistkit.AdgeistCore
+import com.adgeistkit.data.models.CPMAdResponse
+import com.adgeistkit.data.models.Event
+import com.adgeistkit.data.models.FixedAdResponse
+import com.adgeistkit.data.models.UserDetails
+import com.adgeistkit.data.network.CreativeAnalytics
+import com.adgeistkit.data.network.FetchCreative
+
+import com.facebook.react.bridge.ReadableMap
+import com.adgeist.utils.toWritableMap
+import com.adgeistkit.ads.network.AnalyticsRequest
+import com.adgeistkit.ads.network.AnalyticsRequestDEPRECATED
+
+class AdgeistImpl internal constructor(private val context: ReactApplicationContext) {
+
+  private var adgeistInstance: AdgeistCore? = null
+  private var getAd: FetchCreative? = null
+  private var postCreativeAnalytic: CreativeAnalytics? = null
+
+  fun initializeSdk(customBidRequestBackendDomain: String?, customPackageOrBundleID: String?, customAdgeistAppID: String?, promise: Promise) {
+    try {
+      adgeistInstance = AdgeistCore.initialize(context.applicationContext, customBidRequestBackendDomain, customPackageOrBundleID, customAdgeistAppID)
+      getAd = adgeistInstance?.getCreative()
+      postCreativeAnalytic = adgeistInstance?.postCreativeAnalytics()
+      promise.resolve("SDK initialized with domain: ${customBidRequestBackendDomain ?: "default"}")
+    } catch (e: Exception) {
+      promise.reject("INIT_FAILED", "SDK initialization failed", e)
+    }
+  }
+
+  fun destroySdk(promise: Promise) {
+    AdgeistCore.destroy()
+    promise.resolve("SDK destroyed")
+  }
+
+  fun fetchCreative(adSpaceId: String, buyType: String, isTestEnvironment: Boolean, promise: Promise) {
+    getAd?.fetchCreative(adSpaceId, buyType, isTestEnvironment) { adData ->
+      if (adData != null) {
+        when (adData) {
+          is CPMAdResponse -> {
+            promise.resolve(adData.toWritableMap())
+          }
+          is FixedAdResponse -> {
+            promise.resolve(adData.toWritableMap())
+          }
+          else -> {
+            promise.resolve(null)
+          }
+        }
+      } else {
+        promise.reject("NO_AD", "Ad data not available")
+      }
+    } ?: promise.reject("NOT_INITIALIZED", "SDK not initialized")
+  }
+
+  fun sendCreativeAnalytics(analyticsRequestDEPRECATED : AnalyticsRequestDEPRECATED, promise: Promise) {
+    postCreativeAnalytic?.sendTrackingData(analyticsRequestDEPRECATED)
+    promise.resolve("Event sent successfully")
+  }
+
+  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)
+  }
+
+  companion object {
+    const val NAME = "Adgeist"
+  }
+}
+
+fun ReadableMap.getStringSafe(key: String): String? =
+    if (this.hasKey(key) && !this.isNull(key)) this.getString(key) else null

package/android/src/main/java/com/adgeist/utils/CreativeExtensions.kt

@@ -0,0 +1,151 @@
+package com.adgeist.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.adgeistkit.data.models.*
+
+fun CPMAdResponse.toWritableMap(): WritableMap {
+  val map = Arguments.createMap()
+
+  map.putBoolean("success", success)
+  map.putString("message", message)
+
+  val dataMap = Arguments.createMap()
+  val d = data
+
+  if (d != null) {
+    dataMap.putString("id", d.id)
+    dataMap.putString("bidId", d.bidId)
+    dataMap.putString("cur", d.cur)
+
+    val seatBidArray = Arguments.createArray()
+    d.seatBid.forEach { seatBid ->
+      val seatMap = Arguments.createMap()
+      seatMap.putString("bidId", seatBid.bidId)
+
+      val bidArr = Arguments.createArray()
+      seatBid.bid.forEach { bid ->
+        val bidMap = Arguments.createMap()
+        bidMap.putString("id", bid.id)
+        bidMap.putString("impId", bid.impId)
+        bidMap.putDouble("price", bid.price)
+
+        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)
+        bidArr.pushMap(bidMap)
+      }
+      seatMap.putArray("bid", bidArr)
+      seatBidArray.pushMap(seatMap)
+    }
+
+    dataMap.putArray("seatBid", seatBidArray)
+  }
+
+  map.putMap("data", dataMap)
+  return map
+}
+
+fun FixedAdResponse.toWritableMap(): WritableMap {
+  val map = Arguments.createMap()
+
+  map.putString("metaData", metaData)
+  map.putString("id", id)
+  map.putString("generatedAt", generatedAt)
+  map.putString("campaignId", campaignId)
+  map.putString("type", type)
+  map.putString("loadType", loadType)
+  map.putInt("frontendCacheDurationSeconds", frontendCacheDurationSeconds ?: 0)
+
+  advertiser?.let {
+    val advMap = Arguments.createMap()
+    advMap.putString("id", it.id)
+    advMap.putString("name", it.name)
+    advMap.putString("logoUrl", it.logoUrl)
+    map.putMap("advertiser", advMap)
+  }
+
+  campaignValidity?.let {
+    val cvMap = Arguments.createMap()
+    cvMap.putString("startTime", it.startTime)
+    cvMap.putString("endTime", it.endTime)
+    map.putMap("campaignValidity", cvMap)
+  }
+
+  creatives?.let { list ->
+    val arr = Arguments.createArray()
+    list.forEach { creative ->
+      val cMap = Arguments.createMap()
+      cMap.putString("ctaUrl", creative.ctaUrl)
+      cMap.putString("description", creative.description)
+      cMap.putString("fileName", creative.fileName)
+      cMap.putInt("fileSize", creative.fileSize ?: 0)
+      cMap.putString("fileUrl", creative.fileUrl)
+      cMap.putString("thumbnailUrl", creative.thumbnailUrl)
+      cMap.putString("title", creative.title)
+      cMap.putString("type", creative.type)
+
+      creative.contentModerationResult?.let {
+        val cm = Arguments.createMap()
+        cm.putString("\$oid", it.`$oid`)
+        cMap.putMap("contentModerationResult", cm)
+      }
+
+      creative.createdAt?.let {
+        val cm = Arguments.createMap()
+        cm.putDouble("\$date", it.`$date`?.toDouble() ?: 0.0)
+        cMap.putMap("createdAt", cm)
+      }
+
+      creative.updatedAt?.let {
+        val cm = Arguments.createMap()
+        cm.putDouble("\$date", it.`$date`?.toDouble() ?: 0.0)
+        cMap.putMap("updatedAt", cm)
+      }
+
+      arr.pushMap(cMap)
+    }
+    map.putArray("creatives", arr)
+  }
+
+  displayOptions?.let { opt ->
+    val opMap = Arguments.createMap()
+    opMap.putBoolean("isResponsive", opt.isResponsive ?: false)
+    opMap.putString("responsiveType", opt.responsiveType)
+
+    opt.dimensions?.let {
+      val dim = Arguments.createMap()
+      dim.putInt("height", it.height ?: 0)
+      dim.putInt("width", it.width ?: 0)
+      opMap.putMap("dimensions", dim)
+    }
+
+    opt.styleOptions?.let {
+      val st = Arguments.createMap()
+      st.putString("fontColor", it.fontColor)
+      st.putString("fontFamily", it.fontFamily)
+      opMap.putMap("styleOptions", st)
+    }
+
+    opt.allowedFormats?.let { list ->
+      val arr = Arguments.createArray()
+      list.forEach { arr.pushString(it) }
+      opMap.putArray("allowedFormats", arr)
+    }
+
+    map.putMap("displayOptions", opMap)
+  }
+
+  impressionRequirements?.let {
+    val ir = Arguments.createMap()
+    ir.putString("impressionType", it.impressionType)
+    ir.putInt("minViewDurationSeconds", it.minViewDurationSeconds ?: 0)
+    map.putMap("impressionRequirements", ir)
+  }
+
+  return map
+}