react-native-daro 1.0.13 → 1.0.16

package/android/src/main/java/com/daro/reactnative/view/DaroMediaView.kt

@@ -0,0 +1,123 @@
+package com.daro.reactnative.view
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
+import android.widget.FrameLayout
+
+class DaroMediaView(context: Context) : FrameLayout(context) {
+
+  private var relayoutPending = false
+  private var scanZeroCount = 0
+  private var scanViewCount = 0
+  private var lastZeroSignature = 0L
+  private var zeroSizeRelayoutAttempts = 0
+
+  private companion object {
+    private const val MAX_ZERO_SIZE_RELAYOUT_ATTEMPTS = 3
+  }
+
+  private val relayoutRunnable = Runnable {
+    relayoutPending = false
+    relayoutChildren()
+  }
+
+  private val preDrawListener = ViewTreeObserver.OnPreDrawListener {
+    if (width > 0 && height > 0 && childCount > 0) {
+      scanZeroCount = 0
+      scanViewCount = 0
+      scanSubtree(this)
+
+      if (scanZeroCount == 0) {
+        lastZeroSignature = 0L
+        zeroSizeRelayoutAttempts = 0
+      } else {
+        val signature = (scanZeroCount.toLong() shl 32) or scanViewCount.toLong()
+        if (signature != lastZeroSignature) {
+          lastZeroSignature = signature
+          zeroSizeRelayoutAttempts = 0
+        }
+
+        if (zeroSizeRelayoutAttempts < MAX_ZERO_SIZE_RELAYOUT_ATTEMPTS) {
+          zeroSizeRelayoutAttempts++
+          relayoutChildren()
+        }
+      }
+    }
+    true
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    scheduleRelayout()
+  }
+
+  override fun onViewAdded(child: View?) {
+    super.onViewAdded(child)
+    relayoutChildren()
+    scheduleRelayout()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    relayoutChildren()
+    relayoutPending = false
+    removeCallbacks(relayoutRunnable)
+    scheduleRelayout()
+    viewTreeObserver.addOnPreDrawListener(preDrawListener)
+  }
+
+  override fun onDetachedFromWindow() {
+    viewTreeObserver.removeOnPreDrawListener(preDrawListener)
+    removeCallbacks(relayoutRunnable)
+    relayoutPending = false
+    super.onDetachedFromWindow()
+  }
+
+  private fun scheduleRelayout() {
+    lastZeroSignature = 0L
+    zeroSizeRelayoutAttempts = 0
+
+    if (relayoutPending) return
+
+    relayoutPending = true
+    post(relayoutRunnable)
+  }
+
+  private fun relayoutChildren() {
+    val width = width
+    val height = height
+
+    if (width <= 0 || height <= 0) return
+
+    for (i in 0 until childCount) {
+      val child = getChildAt(i)
+      if (child.visibility == GONE) continue
+
+      forceLayoutRecursive(child)
+      child.measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+      )
+      child.layout(0, 0, width, height)
+    }
+  }
+
+  private fun forceLayoutRecursive(view: View) {
+    view.forceLayout()
+    if (view is ViewGroup) {
+      for (i in 0 until view.childCount) forceLayoutRecursive(view.getChildAt(i))
+    }
+  }
+
+  private fun scanSubtree(parent: ViewGroup) {
+    for (i in 0 until parent.childCount) {
+      val child = parent.getChildAt(i)
+      scanViewCount++
+      if (child.visibility != View.VISIBLE) continue
+      if (child.width <= 0 || child.height <= 0) scanZeroCount++
+      if (child is ViewGroup) scanSubtree(child)
+    }
+  }
+}

package/android/src/newarch/java/com/daro/reactnative/DaroMModuleSpec.kt

@@ -0,0 +1,6 @@
+package com.daro.reactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class DaroMModuleSpec(reactContext: ReactApplicationContext) :
+  NativeDaroModuleSpec(reactContext)

package/android/src/oldarch/java/com/daro/reactnative/DaroMModuleSpec.kt

@@ -0,0 +1,90 @@
+package com.daro.reactnative
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+
+abstract class DaroMModuleSpec(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String = DaroMModule.NAME
+
+  protected abstract fun getTypedExportedConstants(): MutableMap<String, Any>
+
+  override fun getConstants(): MutableMap<String, Any> = getTypedExportedConstants()
+
+  @ReactMethod
+  abstract fun addListener(eventName: String)
+
+  @ReactMethod
+  abstract fun removeListeners(count: Double)
+
+  @ReactMethod
+  abstract fun isInitialized(promise: Promise)
+
+  @ReactMethod
+  abstract fun initializeSdk(promise: Promise)
+
+  @ReactMethod
+  abstract fun setUserId(userId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun showMediationDebugger(promise: Promise)
+
+  @ReactMethod
+  abstract fun isInterstitialReady(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun loadInterstitial(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun showInterstitial(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun isRewardedAdReady(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun loadRewardedAd(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun showRewardedAd(
+    requestId: Double,
+    adUnitId: String,
+    customData: String?,
+    promise: Promise,
+  )
+
+  @ReactMethod
+  abstract fun isAppOpenAdReady(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun loadAppOpenAd(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun showAppOpenAd(
+    requestId: Double,
+    adUnitId: String,
+    placement: String?,
+    customData: String?,
+    promise: Promise,
+  )
+
+  @ReactMethod
+  abstract fun isLightPopupReady(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun loadLightPopup(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun showLightPopup(requestId: Double, adUnitId: String, promise: Promise)
+
+  @ReactMethod
+  abstract fun setLightPopupAdConfiguration(
+    requestId: Double,
+    adUnitId: String,
+    configuration: ReadableMap,
+    promise: Promise,
+  )
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build').default;

package/ios/DaroMModule+AppOpen.swift

@@ -1,42 +1,49 @@
-import Daro
+import React
 
 // MARK: - AppOpen Ad Methods
 
 extension DaroMModule {
-    
-    @objc(isAppOpenAdReady:::)
+
+    @objc(isAppOpenAdReady:adUnitId:resolve:reject:)
     func isAppOpenAdReady(
-        _ adUnitId: String,
+        requestId: Double,
+        adUnitId: String,
         resolve: RCTPromiseResolveBlock,
         reject: RCTPromiseRejectBlock
     ) {
+      let requestId = Int(requestId)
       if !Self.sdkInitialized {
         DaroMModule.logger.debug("[DaroMMobileAds] !isInitialized")
         resolve(false)
         return
       }
-      resolve(appOpenAds[adUnitId]?.loadedAd != nil)
+      resolve(appOpenAds[requestId]?.loadedAd != nil)
     }
 
-    @objc(loadAppOpenAd:::)
+    @objc(loadAppOpenAd:adUnitId:resolve:reject:)
     func loadAppOpenAd(
-        _ adUnitId: String,
+        requestId: Double,
+        adUnitId: String,
         resolve: RCTPromiseResolveBlock,
         reject: RCTPromiseRejectBlock
     ) {
-        let appOpenAdLoader = retrieveAppOpenLoader(for: adUnitId)
+      let requestId = Int(requestId)
+      let appOpenAdLoader = retrieveAppOpenLoader(requestId: requestId, adUnitId: adUnitId)
       appOpenAdLoader.loadAd()
-        resolve(Void())
+      resolve(Void())
     }
 
-    @objc(showAppOpenAd::::)
+    @objc(showAppOpenAd:adUnitId:placement:customData:resolve:reject:)
     func showAppOpenAd(
-        _ adUnitId: String,
+        requestId: Double,
+        adUnitId: String,
+        placement: String?,
         customData: String?,
         resolve: @escaping RCTPromiseResolveBlock,
         reject: RCTPromiseRejectBlock
     ) {
-      guard let loadedAd = appOpenAds[adUnitId]?.loadedAd else {
+      let requestId = Int(requestId)
+      guard let loadedAd = appOpenAds[requestId]?.loadedAd else {
         reject("APPOPEN_NOT_LOADED", "AppOpen ad not loaded", nil)
         return
       }
@@ -46,53 +53,52 @@ extension DaroMModule {
       }
     }
 
-  func retrieveAppOpenLoader(for unitId: String) -> DaroAppOpenAdLoader {
-    if let appOpenLoader = appOpenAds[unitId] {
+  func retrieveAppOpenLoader(requestId: Int, adUnitId: String) -> DaroAppOpenAdLoader {
+    if let appOpenLoader = appOpenAds[requestId] {
       return appOpenLoader.loader
     } else {
-      let appOpenLoader = DaroAppOpenAdLoader(unit: DaroAdUnit(unitId: unitId))
+      let appOpenLoader = DaroAppOpenAdLoader(unit: DaroAdUnit(unitId: adUnitId))
       appOpenLoader.listener.onAdClicked = { [weak self] adInfo in
-        DaroMModule.logger.debug("[DARO] Sample Interstitial Ad clicked")
-        self?.sendEvent(with: .onAppOpenAdClickedEvent, body: adInfo?.toBody)
+        DaroMModule.logger.debug("[DARO] Sample AppOpen Ad clicked")
+        self?.sendEvent(with: .onAppOpenAdClickedEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       appOpenLoader.listener.onAdImpression = { [weak self] adInfo in
-        DaroMModule.logger.debug("[DARO] Sample Interstitial Ad impression")
-        self?.interstitials[unitId]?.loadedAd = nil
-        self?.sendEvent(with: .onAppOpenAdImpressionRecordedEvent, body: adInfo?.toBody)
+        DaroMModule.logger.debug("[DARO] Sample AppOpen Ad impression")
+        self?.appOpenAds[requestId]?.loadedAd = nil
+        self?.sendEvent(with: .onAppOpenAdImpressionRecordedEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       appOpenLoader.listener.onAdLoadSuccess = { [weak self] ad, adInfo in
-        DaroMModule.logger.debug("[DARO] Sample Interstitial Ad loaded")
-        self?.appOpenAds[unitId]?.loadedAd = ad
-        self?.sendEvent(with: .onAppOpenAdLoadedEvent, body: adInfo?.toBody)
-        self?.setupAppOpenListener(for: ad)
+        DaroMModule.logger.debug("[DARO] Sample AppOpen Ad loaded")
+        self?.appOpenAds[requestId]?.loadedAd = ad
+        self?.sendEvent(with: .onAppOpenAdLoadedEvent, body: adInfo?.toBody(requestId: requestId))
+        self?.setupAppOpenListener(for: ad, requestId: requestId)
       }
 
       appOpenLoader.listener.onAdLoadFail = { [weak self] error in
-        DaroMModule.logger.debug("[DARO] Sample Interstitial Ad failed: \(error)")
-        self?.sendEvent(with: .onAppOpenAdLoadFailedEvent, body: error.toBody)
+        DaroMModule.logger.debug("[DARO] Sample AppOpen Ad failed: \(error)")
+        self?.sendEvent(with: .onAppOpenAdLoadFailedEvent, body: error.toBody(requestId: requestId))
       }
-      self.appOpenAds[unitId] = AppOpenAd(loader: appOpenLoader)
+      self.appOpenAds[requestId] = AppOpenAd(loader: appOpenLoader)
       return appOpenLoader
     }
   }
 
-  private func setupAppOpenListener(for ad: DaroAppOpenAd) {
+  private func setupAppOpenListener(for ad: DaroAppOpenAd, requestId: Int) {
     ad.appOpenAdListener.onShown = { [weak self] adInfo in
       DaroMModule.logger.debug("[DARO] Sample AppOpen Ad displayed")
-      self?.sendEvent(with: .onAppOpenAdDisplayedEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onAppOpenAdDisplayedEvent, body: adInfo?.toBody(requestId: requestId))
     }
 
     ad.appOpenAdListener.onDismiss = { [weak self] adInfo in
       DaroMModule.logger.debug("[DARO] Sample AppOpen Ad hidden")
-      self?.sendEvent(with: .onAppOpenAdHiddenEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onAppOpenAdHiddenEvent, body: adInfo?.toBody(requestId: requestId))
     }
 
     ad.appOpenAdListener.onFailedToShow = { [weak self] adInfo, error in
       DaroMModule.logger.debug("[DARO] Sample AppOpen Ad failed to display")
-      self?.sendEvent(with: .onAppOpenAdFailedToDisplayEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onAppOpenAdFailedToDisplayEvent, body: adInfo?.toBody(requestId: requestId))
     }
   }
 }
-

package/ios/DaroMModule+Interstitial.swift

@@ -1,41 +1,47 @@
-import Daro
+import React
 
 // MARK: - Interstitial Ad Methods
 
 extension DaroMModule {
-    
-  @objc(isInterstitialReady:::)
+
+  @objc(isInterstitialReady:adUnitId:resolve:reject:)
     func isInterstitialReady(
-      _ adUnitId: String,
+      requestId: Double,
+      adUnitId: String,
       resolve: RCTPromiseResolveBlock,
       reject: RCTPromiseRejectBlock
     ) {
+      let requestId = Int(requestId)
       if !Self.sdkInitialized {
         DaroMModule.logger.debug("[DaroMMobileAds] !isInitialized")
         resolve(false)
         return
       }
-      resolve(interstitials[adUnitId]?.loadedAd != nil)
+      resolve(interstitials[requestId]?.loadedAd != nil)
     }
 
-    @objc(loadInterstitial:::)
+    @objc(loadInterstitial:adUnitId:resolve:reject:)
     func loadInterstitial(
-      _ adUnitId: String,
+      requestId: Double,
+      adUnitId: String,
       resolve: RCTPromiseResolveBlock,
       reject: RCTPromiseRejectBlock
     ) {
-      let interstitialLoader = retrieveInterstitialLoader(for: adUnitId)
+      let requestId = Int(requestId)
+      let interstitialLoader = retrieveInterstitialLoader(requestId: requestId, adUnitId: adUnitId)
       interstitialLoader.loadAd()
       resolve(Void())
     }
 
-    @objc(showInterstitial:::)
+    @objc(showInterstitial:adUnitId:resolve:reject:)
     func showInterstitial(
-      _ adUnitId: String,
+      requestId: Double,
+      adUnitId: String,
       resolve: @escaping RCTPromiseResolveBlock,
       reject: @escaping RCTPromiseRejectBlock
     ) {
-      guard let loadedAd = interstitials[adUnitId]?.loadedAd else {
+      let requestId = Int(requestId)
+      guard let loadedAd = interstitials[requestId]?.loadedAd else {
         reject("INTERSTITIAL_NOT_LOADED", "Interstitial ad not loaded", nil)
         return
       }
@@ -49,52 +55,52 @@ extension DaroMModule {
       }
     }
 
-    func retrieveInterstitialLoader(for unitId: String) -> DaroInterstitialAdLoader {
-      if let interstitialAd = interstitials[unitId] {
+    func retrieveInterstitialLoader(requestId: Int, adUnitId: String) -> DaroInterstitialAdLoader {
+      if let interstitialAd = interstitials[requestId] {
         return interstitialAd.loader
       } else {
-        let interstitialLoader = DaroInterstitialAdLoader(unit: DaroAdUnit(unitId: unitId))
+        let interstitialLoader = DaroInterstitialAdLoader(unit: DaroAdUnit(unitId: adUnitId))
         interstitialLoader.listener.onAdClicked = { [weak self] adInfo in
           DaroMModule.logger.debug("[DARO] Sample Interstitial Ad clicked")
-          self?.sendEvent(with: .onInterstitialClickedEvent, body: adInfo?.toBody)
+          self?.sendEvent(with: .onInterstitialClickedEvent, body: adInfo?.toBody(requestId: requestId))
         }
 
         interstitialLoader.listener.onAdImpression = { [weak self] adInfo in
           DaroMModule.logger.debug("[DARO] Sample Interstitial Ad impression")
-          self?.interstitials[unitId]?.loadedAd = nil
-          self?.sendEvent(with: .onInterstitialAdImpressionRecordedEvent, body: adInfo?.toBody)
+          self?.interstitials[requestId]?.loadedAd = nil
+          self?.sendEvent(with: .onInterstitialAdImpressionRecordedEvent, body: adInfo?.toBody(requestId: requestId))
         }
 
         interstitialLoader.listener.onAdLoadSuccess = { [weak self] ad, adInfo in
           DaroMModule.logger.debug("[DARO] Sample Interstitial Ad loaded")
-          self?.interstitials[unitId]?.loadedAd = ad
-          self?.sendEvent(with: .onInterstitialLoadedEvent, body: adInfo?.toBody)
-          self?.setupInterstitialListener(for: ad)
+          self?.interstitials[requestId]?.loadedAd = ad
+          self?.sendEvent(with: .onInterstitialLoadedEvent, body: adInfo?.toBody(requestId: requestId))
+          self?.setupInterstitialListener(for: ad, requestId: requestId)
         }
 
         interstitialLoader.listener.onAdLoadFail = { [weak self] error in
           DaroMModule.logger.debug("[DARO] Sample Interstitial Ad failed: \(error)")
-          self?.sendEvent(with: .onInterstitialLoadFailedEvent, body: error.toBody)
+          self?.sendEvent(with: .onInterstitialLoadFailedEvent, body: error.toBody(requestId: requestId))
         }
-        self.interstitials[unitId] = InterstitialAd(loader: interstitialLoader)
+        self.interstitials[requestId] = InterstitialAd(loader: interstitialLoader)
         return interstitialLoader
       }
     }
 
-    private func setupInterstitialListener(for ad: DaroInterstitialAd) {
+    private func setupInterstitialListener(for ad: DaroInterstitialAd, requestId: Int) {
       ad.interstitialListener.onShown = { [weak self] adInfo in
         DaroMModule.logger.debug("[DARO] Sample Interstitial Ad displayed")
-        self?.sendEvent(with: .onInterstitialDisplayedEvent, body: adInfo?.toBody)
+        self?.sendEvent(with: .onInterstitialDisplayedEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       ad.interstitialListener.onDismiss = { [weak self] adInfo in
         DaroMModule.logger.debug("[DARO] Sample Interstitial Ad hidden")
-        self?.sendEvent(with: .onInterstitialHiddenEvent, body: adInfo?.toBody)
+        self?.sendEvent(with: .onInterstitialHiddenEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       ad.interstitialListener.onFailedToShow = { [weak self] adInfo, error in
         DaroMModule.logger.debug("[DARO] Sample Interstitial Ad failed to display")
-        self?.sendEvent(with: .onInterstitialAdFailedToDisplayEvent, body: adInfo?.toBody)
+        self?.sendEvent(with: .onInterstitialAdFailedToDisplayEvent, body: adInfo?.toBody(requestId: requestId))
       }
     }
 }

package/ios/DaroMModule+LightPopup.swift

@@ -1,74 +1,84 @@
-import Daro
+import React
 import UIKit
 // MARK: - LightPopup Ad
 extension DaroMModule {
 
-  @objc(isLightPopupReady:::)
+  @objc(isLightPopupReady:adUnitId:resolve:reject:)
   func isLightPopupReady(
-    _ adUnitId: String,
+    requestId: Double,
+    adUnitId: String,
     resolve: RCTPromiseResolveBlock,
     reject: RCTPromiseRejectBlock
   ) {
+    let requestId = Int(requestId)
     if !Self.sdkInitialized {
       DaroMModule.logger.debug("[DaroMMobileAds] !isInitialized")
       resolve(false)
       return
     }
-    resolve(lightPopups[adUnitId]?.loadedAd != nil)
+    resolve(lightPopups[requestId]?.loadedAd != nil)
   }
 
-  @objc(loadLightPopup:::)
+  @objc(loadLightPopup:adUnitId:resolve:reject:)
   func loadLightPopup(
-    _ adUnitId: String,
+    requestId: Double,
+    adUnitId: String,
     resolve: RCTPromiseResolveBlock,
     reject: RCTPromiseRejectBlock
   ) {
-    let lightPopupLoader = retrieveLightPopupLoader(for: adUnitId)
+    let requestId = Int(requestId)
+    let lightPopupLoader = retrieveLightPopupLoader(requestId: requestId, adUnitId: adUnitId)
     lightPopupLoader.loadAd()
     resolve(Void())
   }
 
-  @objc(showLightPopup:::)
+  @objc(showLightPopup:adUnitId:resolve:reject:)
   func showLightPopup(
-    _ adUnitId: String,
+    requestId: Double,
+    adUnitId: String,
     resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ) {
-    guard let loadedAd = lightPopups[adUnitId]?.loadedAd else {
+    let requestId = Int(requestId)
+    guard let loadedAd = lightPopups[requestId]?.loadedAd else {
       reject("LIGHTPOPUP_NOT_LOADED", "LightPopup ad not loaded", nil)
       return
     }
+    let reqIdInt = requestId
     executeOnMainThread { [weak self] in
       guard let viewController = UIApplication.shared.windows.first?.rootViewController else {
         reject("VIEW_CONTROLLER_NOT_FOUND", "Root view controller not found", nil)
         return
       }
-      self?.applyStoredConfiguration(to: loadedAd, for: adUnitId)
+      self?.applyStoredConfiguration(to: loadedAd, for: reqIdInt)
       loadedAd.show(viewController: viewController)
       resolve(Void())
     }
   }
 
-  @objc(setLightPopupAdConfiguration::::)
+  @objc(setLightPopupAdConfiguration:adUnitId:configuration:resolve:reject:)
     func setLightPopupAdConfiguration(
-      _ adUnitId: String,
+      requestId: Double,
+      adUnitId: String,
       configuration: [String: Any],
       resolve: RCTPromiseResolveBlock,
       reject: RCTPromiseRejectBlock
     ) {
-      guard let loadedAd = lightPopups[adUnitId]?.loadedAd else {
-        lightPopupConfigurations[adUnitId] = configuration
+      let reqIdInt = Int(requestId)
+      guard let loadedAd = lightPopups[reqIdInt]?.loadedAd else {
+        lightPopupConfigurations[reqIdInt] = configuration
         resolve(Void())
         return
       }
+      lightPopupConfigurations[reqIdInt] = configuration
       executeOnMainThread { [weak self] in
-          self?.applyStoredConfiguration(to: loadedAd, for: adUnitId)
+          self?.applyStoredConfiguration(to: loadedAd, for: reqIdInt)
       }
       resolve(Void())
     }
 
-    func applyStoredConfiguration(to ad: DaroLightPopupAd, for unitId: String) {
-        if let configuration = lightPopupConfigurations[unitId] {
+    func applyStoredConfiguration(to ad: DaroLightPopupAd, for requestId: Int) {
+        if let configuration = lightPopupConfigurations[requestId] {
             let lightPopupConfig = DaroLightPopupConfiguration()
 
             func setColorIfValid(_ key: String, setter: (UIColor) -> Void) {
@@ -95,47 +105,47 @@ extension DaroMModule {
         }
     }
 
-  func retrieveLightPopupLoader(for unitId: String) -> DaroLightPopupAdLoader {
-    if let lightPopupAd = lightPopups[unitId] {
+  func retrieveLightPopupLoader(requestId: Int, adUnitId: String) -> DaroLightPopupAdLoader {
+    if let lightPopupAd = lightPopups[requestId] {
       return lightPopupAd.loader
     } else {
-      let lightPopupLoader = DaroLightPopupAdLoader(unit: DaroAdUnit(unitId: unitId))
+      let lightPopupLoader = DaroLightPopupAdLoader(unit: DaroAdUnit(unitId: adUnitId))
 
       lightPopupLoader.listener.onAdClicked = { [weak self] adInfo in
-        self?.sendEvent(with: .onLightPopupClickedEvent, body: adInfo?.toBody)
+        self?.sendEvent(with: .onLightPopupClickedEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       lightPopupLoader.listener.onAdImpression = { [weak self] adInfo in
-        self?.lightPopups[unitId]?.loadedAd = nil
-        self?.sendEvent(with: .onLightPopupAdImpressionRecordedEvent, body: adInfo?.toBody)
+        self?.lightPopups[requestId]?.loadedAd = nil
+        self?.sendEvent(with: .onLightPopupAdImpressionRecordedEvent, body: adInfo?.toBody(requestId: requestId))
       }
 
       lightPopupLoader.listener.onAdLoadSuccess = { [weak self] ad, adInfo in
-        self?.lightPopups[unitId]?.loadedAd = ad
-        self?.sendEvent(with: .onLightPopupLoadedEvent, body: adInfo?.toBody)
-        self?.setupLightPopupListener(for: ad)
+        self?.lightPopups[requestId]?.loadedAd = ad
+        self?.sendEvent(with: .onLightPopupLoadedEvent, body: adInfo?.toBody(requestId: requestId))
+        self?.setupLightPopupListener(for: ad, requestId: requestId)
       }
 
       lightPopupLoader.listener.onAdLoadFail = { [weak self] error in
-        self?.sendEvent(with: .onLightPopupLoadFailedEvent, body: error.toBody)
+        self?.sendEvent(with: .onLightPopupLoadFailedEvent, body: error.toBody(requestId: requestId))
       }
 
-      self.lightPopups[unitId] = LightPopupAd(loader: lightPopupLoader)
+      self.lightPopups[requestId] = LightPopupAd(loader: lightPopupLoader)
       return lightPopupLoader
     }
   }
 
-  private func setupLightPopupListener(for ad: DaroLightPopupAd) {
+  private func setupLightPopupListener(for ad: DaroLightPopupAd, requestId: Int) {
     ad.lightPopupAdListener.onShown = { [weak self] adInfo in
-      self?.sendEvent(with: .onLightPopupDisplayedEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onLightPopupDisplayedEvent, body: adInfo?.toBody(requestId: requestId))
     }
 
     ad.lightPopupAdListener.onDismiss = { [weak self] adInfo in
-      self?.sendEvent(with: .onLightPopupHiddenEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onLightPopupHiddenEvent, body: adInfo?.toBody(requestId: requestId))
     }
 
     ad.lightPopupAdListener.onFailedToShow = { [weak self] adInfo, error in
-      self?.sendEvent(with: .onLightPopupAdFailedToDisplayEvent, body: adInfo?.toBody)
+      self?.sendEvent(with: .onLightPopupAdFailedToDisplayEvent, body: adInfo?.toBody(requestId: requestId))
     }
   }