react-native-daro 1.0.13 → 1.0.16

package/android/src/main/java/com/daro/reactnative/DaroMModule.kt

@@ -0,0 +1,257 @@
+package com.daro.reactnative
+
+import android.app.Application
+import android.content.Context
+import com.daro.reactnative.constants.InternalDaroMBannerSize
+import com.daro.reactnative.event.AppOpenEvent
+import com.daro.reactnative.event.DaroMEvent
+import com.daro.reactnative.event.InterstitialEvent
+import com.daro.reactnative.event.LightPopupEvent
+import com.daro.reactnative.event.RewardedEvent
+import com.daro.reactnative.impl.DaroMBannerViewModuleImpl
+import com.daro.reactnative.impl.DaroMInterstitialModuleImpl
+import com.daro.reactnative.impl.DaroMLightPopupModuleImpl
+import com.daro.reactnative.impl.DaroMRewardedAdModuleImpl
+import com.daro.reactnative.util.EventEmitterUtil
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import droom.daro.SDKConfig
+
+class DaroMModule(reactContext: ReactApplicationContext) :
+  DaroMModuleSpec(reactContext) {
+
+  companion object {
+    const val NAME = "DaroMModule"
+    private const val APP_OPEN_UNSUPPORTED_CODE = "APP_OPEN_UNSUPPORTED"
+    private const val APP_OPEN_UNSUPPORTED_MESSAGE = "AppOpen ad is not supported on Android"
+  }
+
+  private val context: Context = reactApplicationContext
+
+  private var isInitialized: Boolean = false
+
+  @ReactMethod
+  override fun addListener(eventName: String) = Unit
+
+  @ReactMethod
+  override fun removeListeners(count: Double) = Unit
+
+  @ReactMethod
+  override fun initializeSdk(promise: Promise) {
+    DaroSdkBridge.initialize(
+      application = context.applicationContext as Application,
+      sdkConfig = SDKConfig.Builder()
+        .setDebugMode(false)
+        .build()
+    )
+
+    isInitialized = true
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun isInitialized(promise: Promise) {
+    promise.resolve(isInitialized)
+  }
+
+  @ReactMethod
+  override fun showMediationDebugger(promise: Promise) {
+    DaroSdkBridge.openDebugger(context)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun setUserId(userId: String, promise: Promise) {
+    DaroSdkBridge.setUserId(context, userId)
+    promise.resolve(null)
+  }
+
+  protected override fun getTypedExportedConstants(): MutableMap<String, Any> {
+    val constants = mutableMapOf<String, Any>()
+    constants.putAll(daroMInterstitialModule.getComponents())
+    constants.putAll(daroMRewardedModule.getComponents())
+    constants.putAll(daroMLightPopupModule.getComponents())
+    constants.putAll(daroMAppOpenModule.getComponents())
+    constants.putAll(daroMBannerModule.getComponents())
+
+    return constants
+  }
+
+  internal abstract class DaroMComponentModule(protected val context: ReactContext) {
+    abstract fun getComponents(): MutableMap<String, Any>
+
+    fun sendNativeEvent(event: DaroMEvent, params: WritableMap?) {
+      EventEmitterUtil.sendReactNativeEvent(
+        reactContext = context,
+        event = event,
+        params = params,
+      )
+    }
+  }
+
+  @OptIn(ExperimentalStdlibApi::class)
+  internal abstract class DaroMInterstitialModule(context: ReactContext) :
+    DaroMComponentModule(context) {
+    abstract fun isInterstitialReady(requestId: Int, adUnitId: String, promise: Promise)
+    abstract fun loadInterstitial(requestId: Int, adUnitId: String)
+    abstract fun showInterstitial(requestId: Int, adUnitId: String)
+
+    override fun getComponents(): MutableMap<String, Any> {
+      return InterstitialEvent.entries.associate { it.value to it.value }.toMutableMap()
+    }
+  }
+
+  private val daroMInterstitialModule: DaroMInterstitialModule =
+    DaroMInterstitialModuleImpl(
+      context = reactContext,
+      getCurrentActivity = { reactApplicationContext.currentActivity }
+    )
+
+  @ReactMethod
+  override fun isInterstitialReady(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMInterstitialModule.isInterstitialReady(requestId.toInt(), adUnitId, promise)
+  }
+
+  @ReactMethod
+  override fun loadInterstitial(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMInterstitialModule.loadInterstitial(requestId.toInt(), adUnitId)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun showInterstitial(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMInterstitialModule.showInterstitial(requestId.toInt(), adUnitId)
+    promise.resolve(null)
+  }
+
+  @OptIn(ExperimentalStdlibApi::class)
+  internal abstract class DaroMRewardedModule(context: ReactContext) :
+    DaroMComponentModule(context) {
+    abstract fun isRewardedAdReady(requestId: Int, adUnitId: String, promise: Promise)
+    abstract fun loadRewardedAd(requestId: Int, adUnitId: String)
+    abstract fun showRewardedAd(requestId: Int, adUnitId: String, customData: String?)
+
+    override fun getComponents(): MutableMap<String, Any> {
+      return RewardedEvent.entries.associate { it.value to it.value }.toMutableMap()
+    }
+  }
+
+  private val daroMRewardedModule: DaroMRewardedModule =
+    DaroMRewardedAdModuleImpl(
+      context = reactContext,
+      getCurrentActivity = { reactApplicationContext.currentActivity }
+    )
+
+  @ReactMethod
+  override fun isRewardedAdReady(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMRewardedModule.isRewardedAdReady(requestId.toInt(), adUnitId, promise)
+  }
+
+  @ReactMethod
+  override fun loadRewardedAd(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMRewardedModule.loadRewardedAd(requestId.toInt(), adUnitId)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun showRewardedAd(
+    requestId: Double,
+    adUnitId: String,
+    customData: String?,
+    promise: Promise,
+  ) {
+    daroMRewardedModule.showRewardedAd(requestId.toInt(), adUnitId, customData)
+    promise.resolve(null)
+  }
+
+  @OptIn(ExperimentalStdlibApi::class)
+  internal abstract class DaroMLightPopupModule(context: ReactContext) :
+    DaroMComponentModule(context) {
+    abstract fun isLightPopupReady(requestId: Int, adUnitId: String, promise: Promise)
+    abstract fun loadLightPopup(requestId: Int, adUnitId: String)
+    abstract fun showLightPopup(requestId: Int, adUnitId: String)
+
+    abstract fun setLightPopupAdConfiguration(requestId: Int, adUnitId: String, parameterMap: ReadableMap)
+
+    override fun getComponents(): MutableMap<String, Any> {
+      return LightPopupEvent.entries.associate { it.value to it.value }.toMutableMap()
+    }
+  }
+
+  private val daroMLightPopupModule: DaroMLightPopupModule = DaroMLightPopupModuleImpl(
+    context = reactContext,
+    getCurrentActivity = { reactApplicationContext.currentActivity }
+  )
+
+  @ReactMethod
+  override fun isLightPopupReady(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMLightPopupModule.isLightPopupReady(requestId.toInt(), adUnitId, promise)
+  }
+
+  @ReactMethod
+  override fun loadLightPopup(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMLightPopupModule.loadLightPopup(requestId.toInt(), adUnitId)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun showLightPopup(requestId: Double, adUnitId: String, promise: Promise) {
+    daroMLightPopupModule.showLightPopup(requestId.toInt(), adUnitId)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun setLightPopupAdConfiguration(
+    requestId: Double,
+    adUnitId: String,
+    configuration: ReadableMap,
+    promise: Promise,
+  ) {
+    daroMLightPopupModule.setLightPopupAdConfiguration(requestId.toInt(), adUnitId, configuration)
+    promise.resolve(null)
+  }
+
+  @OptIn(ExperimentalStdlibApi::class)
+  internal abstract class DaroMAppOpenModule(context: ReactContext) : DaroMComponentModule(context) {
+    override fun getComponents(): MutableMap<String, Any> {
+      return AppOpenEvent.entries.associate { it.value to it.value }.toMutableMap()
+    }
+  }
+
+  private val daroMAppOpenModule: DaroMAppOpenModule = object : DaroMAppOpenModule(reactContext) {}
+
+  @ReactMethod
+  override fun isAppOpenAdReady(requestId: Double, adUnitId: String, promise: Promise) {
+    promise.reject(APP_OPEN_UNSUPPORTED_CODE, APP_OPEN_UNSUPPORTED_MESSAGE)
+  }
+
+  @ReactMethod
+  override fun loadAppOpenAd(requestId: Double, adUnitId: String, promise: Promise) {
+    promise.reject(APP_OPEN_UNSUPPORTED_CODE, APP_OPEN_UNSUPPORTED_MESSAGE)
+  }
+
+  @ReactMethod
+  override fun showAppOpenAd(
+    requestId: Double,
+    adUnitId: String,
+    placement: String?,
+    customData: String?,
+    promise: Promise,
+  ) {
+    promise.reject(APP_OPEN_UNSUPPORTED_CODE, APP_OPEN_UNSUPPORTED_MESSAGE)
+  }
+
+  @OptIn(ExperimentalStdlibApi::class)
+  internal abstract class DaroMBannerModule(context: ReactContext) : DaroMComponentModule(context) {
+    override fun getComponents(): MutableMap<String, Any> {
+      return InternalDaroMBannerSize.entries.associate { it.key to it.name }.toMutableMap()
+    }
+  }
+
+  private val daroMBannerModule: DaroMBannerModule =
+    DaroMBannerViewModuleImpl(context = reactContext)
+}

package/android/src/main/java/com/daro/reactnative/DaroMPackage.kt

@@ -0,0 +1,45 @@
+@file:Suppress("DEPRECATION")
+
+package com.daro.reactnative
+
+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
+
+
+class DaroMPackage : TurboReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return when (name) {
+      DaroMModule.NAME -> DaroMModule(reactContext)
+      else -> null
+    }
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return listOf(
+      DaroMAdBannerViewManager(),
+      DaroMAdNativeViewManager(),
+      DaroMediaViewManager(),
+    )
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+        DaroMModule.NAME to ReactModuleInfo(
+          DaroMModule.NAME,
+          DaroMModule::class.java.name,
+          false,
+          false,
+          true,
+          false,
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+        )
+      )
+    }
+  }
+}

package/android/src/main/java/com/daro/reactnative/DaroMediaViewManager.kt

@@ -0,0 +1,25 @@
+package com.daro.reactnative
+
+import com.daro.reactnative.view.DaroMediaView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.viewmanagers.DaroMediaViewManagerDelegate
+import com.facebook.react.viewmanagers.DaroMediaViewManagerInterface
+
+class DaroMediaViewManager : ViewGroupManager<DaroMediaView>(),
+  DaroMediaViewManagerInterface<DaroMediaView> {
+
+  private val delegate: ViewManagerDelegate<DaroMediaView> =
+    DaroMediaViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<DaroMediaView> = delegate
+
+  override fun getName(): String {
+    return "DaroMediaView"
+  }
+
+  override fun createViewInstance(context: ThemedReactContext): DaroMediaView {
+    return DaroMediaView(context)
+  }
+}

package/android/src/main/java/com/{darom → daro/reactnative}/constants/InternalDaroMBannerSize.kt

@@ -1,4 +1,4 @@
-package com.darom.constants
+package com.daro.reactnative.constants
 
 import droom.daro.core.model.DaroBannerSize
 

package/android/src/main/java/com/{darom → daro/reactnative}/event/DaroMEvent.kt

@@ -1,4 +1,4 @@
-package com.darom.event
+package com.daro.reactnative.event
 
 internal interface DaroMEvent{
   val value: String
@@ -44,14 +44,25 @@ internal enum class LightPopupEvent : DaroMEvent {
     get() = name
 }
 
-internal enum class AdViewEvent(
-  val key: String
-): DaroMEvent {
-  ON_AD_CLICKED("onAdClickedEvent"),
-  ON_AD_FAILED_TO_LOAD("onAdLoadFailedEvent"),
-  ON_AD_IMPRESSION("onAdImpressionRecordedEvent"),
-  ON_AD_LOADED("onAdLoadedEvent");
+internal enum class AppOpenEvent : DaroMEvent {
+  ON_APPOPEN_AD_LOADED_EVENT,
+  ON_APPOPEN_AD_LOAD_FAILED_EVENT,
+  ON_APPOPEN_AD_CLICKED_EVENT,
+  ON_APPOPEN_AD_DISPLAYED_EVENT,
+  ON_APPOPEN_AD_FAILED_TO_DISPLAY_EVENT,
+  ON_APPOPEN_AD_HIDDEN_EVENT,
+  ON_APPOPEN_AD_IMPRESSION_RECORDED;
 
   override val value: String
     get() = name
 }
+
+internal enum class AdViewEvent(
+  val registrationName: String,
+  override val value: String,
+): DaroMEvent {
+  ON_AD_CLICKED("onAdClickedEvent", "topAdClickedEvent"),
+  ON_AD_FAILED_TO_LOAD("onAdLoadFailedEvent", "topAdLoadFailedEvent"),
+  ON_AD_IMPRESSION("onAdImpressionRecordedEvent", "topAdImpressionRecordedEvent"),
+  ON_AD_LOADED("onAdLoadedEvent", "topAdLoadedEvent");
+}

package/android/src/main/java/com/{darom → daro/reactnative}/impl/DaroMBannerViewModuleImpl.kt

@@ -1,6 +1,6 @@
-package com.darom.impl
+package com.daro.reactnative.impl
 
-import com.darom.DaroMModule
+import com.daro.reactnative.DaroMModule
 import com.facebook.react.bridge.ReactApplicationContext
 
 internal class DaroMBannerViewModuleImpl(

package/android/src/main/java/com/{darom → daro/reactnative}/impl/DaroMInterstitialModuleImpl.kt

@@ -1,9 +1,9 @@
-package com.darom.impl
+package com.daro.reactnative.impl
 
 import android.app.Activity
-import com.darom.DaroMModule
-import com.darom.event.InterstitialEvent
-import com.darom.util.AdInfoUtil
+import com.daro.reactnative.DaroMModule
+import com.daro.reactnative.event.InterstitialEvent
+import com.daro.reactnative.util.AdInfoUtil
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import droom.daro.core.adunit.DaroInterstitialAdUnit
@@ -23,56 +23,56 @@ internal class DaroMInterstitialModuleImpl(
   private val currentActivity: Activity?
     get() = getCurrentActivity()
 
-  private val loaderMap: MutableMap<String, DaroInterstitialAdLoader> = mutableMapOf()
-  private val interstitialAdMap: MutableMap<String, DaroInterstitialAd> = mutableMapOf()
+  private val loaderMap: MutableMap<Int, DaroInterstitialAdLoader> = mutableMapOf()
+  private val interstitialAdMap: MutableMap<Int, DaroInterstitialAd> = mutableMapOf()
 
 
-  override fun isInterstitialReady(adUnitId: String, promise: Promise) {
-    promise.resolve(retrieveAd(adUnitId) != null)
+  override fun isInterstitialReady(requestId: Int, adUnitId: String, promise: Promise) {
+    promise.resolve(retrieveAd(requestId) != null)
   }
 
-  override fun loadInterstitial(adUnitId: String) {
-    retrieveLoader(adUnitId).load()
+  override fun loadInterstitial(requestId: Int, adUnitId: String) {
+    retrieveLoader(requestId, adUnitId).load()
   }
 
-  override fun showInterstitial(adUnitId: String) {
+  override fun showInterstitial(requestId: Int, adUnitId: String) {
     currentActivity?.let {
-      retrieveAd(adUnitId)?.apply {
+      retrieveAd(requestId)?.apply {
         setListener(object : DaroInterstitialAdListener {
           override fun onDismiss(ad: DaroAdInfo) {
             sendNativeEvent(
               event = InterstitialEvent.ON_INTERSTITIAL_HIDDEN_EVENT,
-              params = AdInfoUtil.getAdInfo(adUnitId, ad),
+              params = AdInfoUtil.getAdInfo(requestId, adUnitId, ad),
             )
           }
 
           override fun onFailedToShow(ad: DaroAdInfo, error: DaroAdDisplayFailError) {
             sendNativeEvent(
               event = InterstitialEvent.ON_INTERSTITIAL_AD_FAILED_TO_DISPLAY_EVENT,
-              params = AdInfoUtil.getAdDisplayFailedInfo(adUnitId, ad, error),
+              params = AdInfoUtil.getAdDisplayFailedInfo(requestId, adUnitId, ad, error),
             )
           }
 
           override fun onShown(ad: DaroAdInfo) {
             sendNativeEvent(
               event = InterstitialEvent.ON_INTERSTITIAL_DISPLAYED_EVENT,
-              params = AdInfoUtil.getAdInfo(adUnitId, ad),
+              params = AdInfoUtil.getAdInfo(requestId, adUnitId, ad),
             )
 
-            interstitialAdMap.remove(adUnitId)
+            interstitialAdMap.remove(requestId)
           }
 
           override fun onAdClicked(responseInfo: DaroAdInfo) {
             sendNativeEvent(
               event = InterstitialEvent.ON_INTERSTITIAL_CLICKED_EVENT,
-              params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+              params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
             )
           }
 
           override fun onAdImpression(responseInfo: DaroAdInfo) {
             sendNativeEvent(
               event = InterstitialEvent.ON_INTERSTITIAL_AD_IMPRESSION_RECORDED,
-              params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+              params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
             )
           }
         })
@@ -82,32 +82,32 @@ internal class DaroMInterstitialModuleImpl(
     }
   }
 
-  private fun retrieveLoader(adUnitId: String): DaroInterstitialAdLoader {
-    return loaderMap[adUnitId] ?: DaroInterstitialAdLoader(
+  private fun retrieveLoader(requestId: Int, adUnitId: String): DaroInterstitialAdLoader {
+    return loaderMap[requestId] ?: DaroInterstitialAdLoader(
       context,
       DaroInterstitialAdUnit(adUnitId, adUnitId)
     ).also {
-      loaderMap[adUnitId] = it
+      loaderMap[requestId] = it
       it.setListener(object : DaroInterstitialAdLoaderListener {
         override fun onAdLoadSuccess(ad: DaroInterstitialAd, responseInfo: DaroAdInfo) {
-          interstitialAdMap[adUnitId] = ad
+          interstitialAdMap[requestId] = ad
           sendNativeEvent(
             event = InterstitialEvent.ON_INTERSTITIAL_LOADED_EVENT,
-            params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+            params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
           )
         }
 
         override fun onAdLoadFail(err: DaroAdLoadError) {
           sendNativeEvent(
             event = InterstitialEvent.ON_INTERSTITIAL_LOAD_FAILED_EVENT,
-            params = AdInfoUtil.getAdLoadFailedInfo(adUnitId, err),
+            params = AdInfoUtil.getAdLoadFailedInfo(requestId, adUnitId, err),
           )
         }
       })
     }
   }
 
-  private fun retrieveAd(adUnitId: String): DaroInterstitialAd? {
-    return interstitialAdMap[adUnitId]
+  private fun retrieveAd(requestId: Int): DaroInterstitialAd? {
+    return interstitialAdMap[requestId]
   }
 }

package/android/src/main/java/com/{darom → daro/reactnative}/impl/DaroMLightPopupModuleImpl.kt

@@ -1,10 +1,10 @@
-package com.darom.impl
+package com.daro.reactnative.impl
 
 import android.app.Activity
 import androidx.core.graphics.toColorInt
-import com.darom.DaroMModule
-import com.darom.event.LightPopupEvent
-import com.darom.util.AdInfoUtil
+import com.daro.reactnative.DaroMModule
+import com.daro.reactnative.event.LightPopupEvent
+import com.daro.reactnative.util.AdInfoUtil
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
@@ -26,21 +26,22 @@ internal class DaroMLightPopupModuleImpl(
   private val currentActivity: Activity?
     get() = getCurrentActivity()
 
-  private val lightpopupAdMap: MutableMap<String, DaroLightPopupAd> = mutableMapOf()
-  private val optionMap: MutableMap<String, DaroLightPopupAdOptions> = mutableMapOf()
-  private val loaderMap: MutableMap<String, DaroLightPopupAdLoader> = mutableMapOf()
+  private val lightpopupAdMap: MutableMap<Int, DaroLightPopupAd> = mutableMapOf()
+  private val optionMap: MutableMap<Int, DaroLightPopupAdOptions> = mutableMapOf()
+  private val loaderMap: MutableMap<Int, DaroLightPopupAdLoader> = mutableMapOf()
 
-  override fun isLightPopupReady(adUnitId: String, promise: Promise) {
-    promise.resolve(retrieveAd(adUnitId) != null)
+  override fun isLightPopupReady(requestId: Int, adUnitId: String, promise: Promise) {
+    promise.resolve(retrieveAd(requestId) != null)
   }
 
-  override fun loadLightPopup(adUnitId: String) {
+  override fun loadLightPopup(requestId: Int, adUnitId: String) {
     context.runOnUiQueueThread {
-      retrieveLoader(adUnitId).load()
+      retrieveLoader(requestId, adUnitId).load()
     }
   }
 
   override fun setLightPopupAdConfiguration(
+    requestId: Int,
     adUnitId: String,
     parameterMap: ReadableMap,
   ) {
@@ -66,48 +67,48 @@ internal class DaroMLightPopupModuleImpl(
       )
     }
 
-    optionMap[adUnitId] = newOption
+    optionMap[requestId] = newOption
   }
 
-  override fun showLightPopup(adUnitId: String) {
+  override fun showLightPopup(requestId: Int, adUnitId: String) {
     currentActivity?.let {
       it.runOnUiThread {
-        retrieveAd(adUnitId)?.apply {
+        retrieveAd(requestId)?.apply {
           setListener(object : DaroLightPopupAdListener {
             override fun onDismiss(ad: DaroAdInfo) {
               sendNativeEvent(
                 event = LightPopupEvent.ON_LIGHTPOPUP_HIDDEN_EVENT,
-                params = AdInfoUtil.getAdInfo(adUnitId, ad),
+                params = AdInfoUtil.getAdInfo(requestId, adUnitId, ad),
               )
             }
 
             override fun onFailedToShow(ad: DaroAdInfo, error: DaroAdDisplayFailError) {
               sendNativeEvent(
                 event = LightPopupEvent.ON_LIGHTPOPUP_AD_FAILED_TO_DISPLAY_EVENT,
-                params = AdInfoUtil.getAdDisplayFailedInfo(adUnitId, ad, error),
+                params = AdInfoUtil.getAdDisplayFailedInfo(requestId, adUnitId, ad, error),
               )
             }
 
             override fun onShown(ad: DaroAdInfo) {
               sendNativeEvent(
                 event = LightPopupEvent.ON_LIGHTPOPUP_DISPLAYED_EVENT,
-                params = AdInfoUtil.getAdInfo(adUnitId, ad),
+                params = AdInfoUtil.getAdInfo(requestId, adUnitId, ad),
               )
 
-              lightpopupAdMap.remove(adUnitId)
+              lightpopupAdMap.remove(requestId)
             }
 
             override fun onAdClicked(responseInfo: DaroAdInfo) {
               sendNativeEvent(
                 event = LightPopupEvent.ON_LIGHTPOPUP_CLICKED_EVENT,
-                params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+                params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
               )
             }
 
             override fun onAdImpression(responseInfo: DaroAdInfo) {
               sendNativeEvent(
                 event = LightPopupEvent.ON_LIGHTPOPUP_AD_IMPRESSION_RECORDED,
-                params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+                params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
               )
             }
           })
@@ -118,32 +119,32 @@ internal class DaroMLightPopupModuleImpl(
     }
   }
 
-  private fun retrieveLoader(adUnitId: String): DaroLightPopupAdLoader {
-    return loaderMap[adUnitId] ?: DaroLightPopupAdLoader(
+  private fun retrieveLoader(requestId: Int, adUnitId: String): DaroLightPopupAdLoader {
+    return loaderMap[requestId] ?: DaroLightPopupAdLoader(
       context,
-      DaroLightPopupAdUnit(adUnitId, adUnitId, optionMap[adUnitId] ?: DaroLightPopupAdOptions())
+      DaroLightPopupAdUnit(adUnitId, adUnitId, optionMap[requestId] ?: DaroLightPopupAdOptions())
     ).also {
-      loaderMap[adUnitId] = it
+      loaderMap[requestId] = it
       it.setListener(object : DaroLightPopupAdLoaderListener {
         override fun onAdLoadSuccess(ad: DaroLightPopupAd, responseInfo: DaroAdInfo) {
-          lightpopupAdMap[adUnitId] = ad
+          lightpopupAdMap[requestId] = ad
           sendNativeEvent(
             event = LightPopupEvent.ON_LIGHTPOPUP_LOADED_EVENT,
-            params = AdInfoUtil.getAdInfo(adUnitId, responseInfo),
+            params = AdInfoUtil.getAdInfo(requestId, adUnitId, responseInfo),
           )
         }
 
         override fun onAdLoadFail(err: DaroAdLoadError) {
           sendNativeEvent(
             event = LightPopupEvent.ON_LIGHTPOPUP_LOAD_FAILED_EVENT,
-            params = AdInfoUtil.getAdLoadFailedInfo(adUnitId, err),
+            params = AdInfoUtil.getAdLoadFailedInfo(requestId, adUnitId, err),
           )
         }
       })
     }
   }
 
-  private fun retrieveAd(adUnitId: String): DaroLightPopupAd? {
-    return lightpopupAdMap[adUnitId]
+  private fun retrieveAd(requestId: Int): DaroLightPopupAd? {
+    return lightpopupAdMap[requestId]
   }
 }