@ezoic/react-native-sdk 1.2.0 → 1.4.0

package/EzoicReactNativeSdk.podspec

@@ -20,6 +20,9 @@ Pod::Spec.new do |s|
 
   # Native Ezoic Ads SDK (vends the `EzoicAdsSDKBinary` module). Brings in
   # PrebidMobile + Google-Mobile-Ads-SDK transitively.
-  s.dependency "EzoicAdsSDK", "~> 1.2"
+  s.dependency "EzoicAdsSDK", "~> 1.4"
+  # The native-ad host imports GoogleMobileAds directly (NativeAdView,
+  # MediaView, NativeAd). Pin GMA 12 so the module is on the compile path.
+  s.dependency "Google-Mobile-Ads-SDK", "~> 12.0"
   s.swift_version = "5.9"
 end

package/README.md

@@ -1,11 +1,12 @@
 # @ezoic/react-native-sdk
 
-Ezoic Ads SDK for React Native (Prebid + Google Ad Manager banner ads).
+Ezoic Ads SDK for React Native (Prebid + Google Ad Manager banner, native, interstitial, rewarded, outstream and instream video ads).
 
 A thin React Native (New Architecture) wrapper over the native Ezoic Ads SDKs
 for iOS (`EzoicAdsSDK`, via CocoaPods) and Android
 (`com.ezoic.sdk:ezoic-ads-sdk`, via Maven Central). It exposes an imperative
-`EzoicAds` TurboModule and an `EzoicBannerView` Fabric component.
+`EzoicAds` TurboModule plus `EzoicBannerView`, `EzoicNativeAdView` and
+`EzoicOutstreamAdView` Fabric components, and the `EzoicInstreamAd` controller.
 
 ## Requirements
 
@@ -68,6 +69,82 @@ const tracked = await EzoicAds.trackPageview();
 `adUnitIdentifier` is a string coerced to a native integer. `size` is a `"WxH"`
 string or comma-separated list (e.g. `"300x250"`, `"300x250,320x50"`).
 
+### Native ads
+
+`EzoicNativeAdView` loads a native ad and renders it in an SDK-built template
+`NativeAdView` (headline, icon, media, body and a call-to-action). Unlike the
+banner it has no `size` prop — size it with `style` and the template lays its
+assets out inside those bounds.
+
+```tsx
+import { EzoicAds, EzoicNativeAdView } from '@ezoic/react-native-sdk';
+
+<EzoicNativeAdView
+  adUnitIdentifier="123456"
+  style={{ width: '100%', height: 300 }}
+  onLoad={() => console.log('loaded')}
+  onError={(e) => console.log('error', e.message, e.code)}
+  onImpression={() => console.log('impression')}
+  onClick={() => console.log('click')}
+  onOpen={() => console.log('open')}
+  onClose={() => console.log('close')}
+/>;
+```
+
+### Outstream video
+
+`EzoicOutstreamAdView` loads and renders a self-contained outstream video ad.
+Like the native ad it has no `size` prop — size it with `style` and the native
+view lays the player out inside those bounds. It is view-managed: mounting the
+component loads the ad, unmounting destroys it.
+
+```tsx
+import { EzoicAds, EzoicOutstreamAdView } from '@ezoic/react-native-sdk';
+
+<EzoicOutstreamAdView
+  adUnitIdentifier="123456"
+  style={{ width: '100%', height: 250 }}
+  onLoad={() => console.log('loaded')}
+  onError={(e) => console.log('error', e.message, e.code)}
+  onImpression={() => console.log('impression')}
+  onClick={() => console.log('click')}
+  onOpen={() => console.log('open')}
+  onClose={() => console.log('close')}
+/>;
+```
+
+### Instream video
+
+`EzoicInstreamAd` is a view-less controller for instream (pre/mid/post-roll)
+video. **The host owns the video player and the Google IMA SDK** — the SDK
+renders nothing; its sole deliverable is a GAM VAST ad-tag URL string you feed
+to your own IMA `AdsRequest`. A controller is multi-use and prefetchable: it is
+not auto-destroyed, so you `load()` it repeatedly and `destroy()` it yourself.
+
+```tsx
+import { EzoicInstreamAd } from '@ezoic/react-native-sdk';
+
+const instream = new EzoicInstreamAd('123456');
+
+// Resolve the VAST ad-tag URL and hand it to your IMA player.
+const adTagUrl = await instream.load({ contentUrl: playingVideoUrl });
+adsLoader.requestAds({ adTagUrl });
+
+// On an IMA ad error, walk down the floor waterfall to the next tag.
+const next = await instream.getNextAdTagUrl(); // null once exhausted
+if (next) adsLoader.requestAds({ adTagUrl: next });
+
+// On the IMA STARTED event, fire the Ezoic impression pixel.
+await instream.reportImpression({ revenueUsd: 0.012 });
+
+// Release the native controller when done.
+await instream.destroy();
+```
+
+`load()` rejects on no fill, an uninitialized SDK, or an overlapping load
+already in flight for this id; it is safe to call again after a previous load
+resolves. `contentUrl` and `revenueUsd` are optional.
+
 ## API
 
 - `EzoicAds.initialize(config)` → `Promise<void>`
@@ -76,6 +153,13 @@ string or comma-separated list (e.g. `"300x250"`, `"300x250,320x50"`).
 - `EzoicAds.setSubjectToCOPPA(value)` → `void`
 - `EzoicAds.trackPageview()` → `Promise<boolean>`
 - `<EzoicBannerView adUnitIdentifier size onLoad onError onImpression onClick onOpen onClose />`
+- `<EzoicNativeAdView adUnitIdentifier onLoad onError onImpression onClick onOpen onClose />`
+- `<EzoicOutstreamAdView adUnitIdentifier onLoad onError onImpression onClick onOpen onClose />`
+- `new EzoicInstreamAd(adUnitIdentifier)`
+  - `.load({ contentUrl? })` → `Promise<string>` (GAM VAST ad-tag URL)
+  - `.getNextAdTagUrl()` → `Promise<string | null>`
+  - `.reportImpression({ revenueUsd? })` → `Promise<void>`
+  - `.destroy()` → `Promise<void>`
 
 ## License
 

package/android/build.gradle

@@ -68,5 +68,11 @@ dependencies {
   // Native Ezoic Ads SDK (resolved from Maven Central). Brings in Google Mobile
   // Ads + Prebid transitively. Requires mavenCentral() + google() in the
   // consuming app's repositories (the RN template provides both).
-  implementation "com.ezoic.sdk:ezoic-ads-sdk:1.2.0"
+  implementation "com.ezoic.sdk:ezoic-ads-sdk:1.4.0"
+
+  // The native-ad wrapper references GMA's NativeAdView/MediaView/NativeAd
+  // types at compile time. The Ezoic SDK POM scopes Google Mobile Ads at
+  // runtime only, so pin the compile-time classpath here (runtime resolution
+  // still comes transitively from the Ezoic SDK).
+  compileOnly "com.google.android.gms:play-services-ads:22.6.0"
 }

package/android/src/main/java/com/ezoic/reactnative/EzoicAdsModule.kt

@@ -7,6 +7,8 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.ezoic.ads.sdk.adunits.EzoicInstreamAd
+import com.ezoic.ads.sdk.adunits.EzoicInstreamAdListener
 import com.ezoic.ads.sdk.adunits.EzoicInterstitialAd
 import com.ezoic.ads.sdk.adunits.EzoicInterstitialAdListener
 import com.ezoic.ads.sdk.adunits.EzoicInterstitialAdListenerAdapter
@@ -18,6 +20,7 @@ import com.ezoic.ads.sdk.core.EzoicAds
 import com.ezoic.ads.sdk.core.EzoicConfiguration
 import com.ezoic.ads.sdk.core.EzoicError
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
 
 class EzoicAdsModule(reactContext: ReactApplicationContext) :
   NativeEzoicAdsSpec(reactContext) {
@@ -51,6 +54,28 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
   /** Ad unit ids with an in-flight interstitial `load`. */
   private val loadingInterstitial = ConcurrentHashMap.newKeySet<Int>()
 
+  /**
+   * Instream controllers, keyed by ad unit id. Instream is multi-use and
+   * prefetchable, so a controller is created-or-reused per id and NOT
+   * auto-destroyed — it lives until [destroyInstreamAd] or module teardown.
+   */
+  private val instreamAds = ConcurrentHashMap<Int, EzoicInstreamAd>()
+
+  /**
+   * In-flight instream `load` calls, keyed by ad unit id. Doubles as the
+   * duplicate-load guard: the native `load` is a SILENT no-op while already
+   * loading, so an overlapping load must be rejected here or its promise hangs
+   * forever.
+   */
+  private val loadingInstream = ConcurrentHashMap<Int, InstreamLoad>()
+
+  private class InstreamLoad(val promise: Promise) {
+    // destroy/invalidate run on the JS thread while listener callbacks run on
+    // main, so settling must be an atomic claim (compareAndSet) rather than a
+    // check-then-set, or both sides can settle the same promise.
+    val settled = AtomicBoolean(false)
+  }
+
   override fun initialize(config: ReadableMap, promise: Promise) {
     val domain = if (config.hasKey("domain")) config.getString("domain") else null
     if (domain.isNullOrEmpty()) {
@@ -235,6 +260,110 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun loadInstreamAd(adUnitIdentifier: Double, contentUrl: String?, promise: Promise) {
+    val id = adUnitIdentifier.toInt()
+    if (id <= 0) {
+      promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
+      return
+    }
+    // Reject overlapping loads for this id: the native load silently no-ops
+    // while loading (a second load on the reused controller, or a load from a
+    // fresh JS instance sharing the id), which would hang the promise.
+    if (loadingInstream.containsKey(id)) {
+      promise.reject("EzoicAds", "An instream ad is already loading for ad unit $id")
+      return
+    }
+
+    // Create-or-reuse: instream is multi-use, so a repeat load on the same id
+    // reuses the existing native controller (preserving its tag/waterfall state).
+    val ad = instreamAds.getOrPut(id) { EzoicInstreamAd(id) }
+
+    val holder = InstreamLoad(promise)
+    loadingInstream[id] = holder
+    // The native load uses the context only for parity (it is not retained);
+    // pass the same reactApplicationContext the rewarded/interstitial loads use.
+    // The native SDK already posts these callbacks to main, so settle directly
+    // here — no need to re-post via a Handler.
+    ad.load(reactApplicationContext, contentUrl, object : EzoicInstreamAdListener {
+      override fun onAdTagReady(adTagUrl: String) {
+        // CAS guard: after a destroy->reload a stale callback must not evict
+        // the newer load's holder (only the winning settle removes it).
+        if (holder.settled.compareAndSet(false, true)) {
+          loadingInstream.remove(id)
+          promise.resolve(adTagUrl)
+        }
+      }
+
+      override fun onAdFailedToLoad(error: EzoicError) {
+        if (holder.settled.compareAndSet(false, true)) {
+          loadingInstream.remove(id)
+          val userInfo = Arguments.createMap()
+          userInfo.putInt("code", error.code)
+          promise.reject("EzoicAds", error.message ?: "Instream ad failed to load", userInfo)
+        }
+      }
+    })
+  }
+
+  override fun getInstreamNextAdTagUrl(adUnitIdentifier: Double, promise: Promise) {
+    val id = adUnitIdentifier.toInt()
+    if (id <= 0) {
+      promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
+      return
+    }
+    // Synchronous native call; resolves the next waterfall tag or null when
+    // exhausted / before a successful load / after destroy.
+    promise.resolve(instreamAds[id]?.getNextAdTagUrl())
+  }
+
+  override fun reportInstreamImpression(
+    adUnitIdentifier: Double,
+    revenueUsd: Double?,
+    promise: Promise
+  ) {
+    val id = adUnitIdentifier.toInt()
+    if (id <= 0) {
+      promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
+      return
+    }
+    // No-op natively when no tag has been delivered or after destroy.
+    instreamAds[id]?.reportImpression(revenueUsd)
+    promise.resolve(null)
+  }
+
+  override fun destroyInstreamAd(adUnitIdentifier: Double, promise: Promise) {
+    val id = adUnitIdentifier.toInt()
+    if (id <= 0) {
+      promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
+      return
+    }
+    // The native SDK suppresses load callbacks once destroyed (load tokens), so
+    // settle any pending load's promise HERE first or it hangs forever. The CAS
+    // claim also disarms a listener callback racing in on main concurrently.
+    val pending = loadingInstream.remove(id)
+    if (pending != null && pending.settled.compareAndSet(false, true)) {
+      pending.promise.reject("EzoicAds", "Instream ad was destroyed while loading")
+    }
+    instreamAds.remove(id)?.destroy()
+    promise.resolve(null)
+  }
+
+  override fun invalidate() {
+    // Module teardown: settle every pending instream load with an error and
+    // destroy every controller so no promise hangs and no native resource leaks.
+    for ((_, holder) in loadingInstream) {
+      if (holder.settled.compareAndSet(false, true)) {
+        holder.promise.reject("EzoicAds", "Module was destroyed while loading")
+      }
+    }
+    loadingInstream.clear()
+    for ((_, ad) in instreamAds) {
+      ad.destroy()
+    }
+    instreamAds.clear()
+    super.invalidate()
+  }
+
   override fun addListener(eventName: String) {
     // No-op: required by the React Native NativeEventEmitter contract.
   }

package/android/src/main/java/com/ezoic/reactnative/EzoicNativeAdViewManager.kt

@@ -0,0 +1,314 @@
+package com.ezoic.reactnative
+
+import android.content.Context
+import android.graphics.Typeface
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.ezoic.ads.sdk.adunits.EzoicNativeAd
+import com.ezoic.ads.sdk.adunits.EzoicNativeAdListener
+import com.ezoic.ads.sdk.adunits.EzoicNativeAdLoadListener
+import com.ezoic.ads.sdk.core.EzoicError
+import com.google.android.gms.ads.nativead.MediaView
+import com.google.android.gms.ads.nativead.NativeAd
+import com.google.android.gms.ads.nativead.NativeAdView
+
+@ReactModule(name = EzoicNativeAdViewManager.NAME)
+class EzoicNativeAdViewManager(private val ctx: ReactApplicationContext) :
+  SimpleViewManager<EzoicNativeAdViewManager.NativeAdContainer>() {
+
+  override fun getName() = NAME
+
+  override fun createViewInstance(reactContext: ThemedReactContext): NativeAdContainer {
+    val container = NativeAdContainer(reactContext)
+    container.layoutParams = ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
+    )
+    return container
+  }
+
+  @ReactProp(name = "adUnitIdentifier")
+  fun setAdUnitIdentifier(view: NativeAdContainer, value: String?) {
+    val newAdUnitId = value?.toIntOrNull() ?: 0
+    // Ad unit changed after a load already started: tear down the loaded/loading
+    // ad and clear the started flag so onAfterUpdateTransaction's maybeLoad
+    // starts a fresh load for the new id.
+    if (newAdUnitId != view.adUnitId && view.loadStarted) {
+      view.ezoicNativeAd?.destroy()
+      view.ezoicNativeAd = null
+      view.removeAllViews()
+      view.loadStarted = false
+      view.loadGeneration++
+    }
+    view.adUnitId = newAdUnitId
+    view.rawAdUnitId = value ?: ""
+  }
+
+  // Fabric sets every prop for the mount transaction before this runs, so the
+  // ad unit id is final here. `view.post` escapes the mount transaction so the
+  // synchronous native-SDK failure path (uninitialized) can't reenter the
+  // mounting layer; the started flag survives repeated transactions.
+  override fun onAfterUpdateTransaction(view: NativeAdContainer) {
+    super.onAfterUpdateTransaction(view)
+    view.post { maybeLoad(view) }
+  }
+
+  private fun maybeLoad(view: NativeAdContainer) {
+    if (view.loadStarted || view.disposed) return
+    if (view.adUnitId <= 0) {
+      // Non-numeric or missing id coerces to 0 in setAdUnitIdentifier. Only
+      // emit an error when a prop was actually supplied (non-empty raw
+      // string); an unset prop should stay silent.
+      if (view.rawAdUnitId.isNotEmpty()) {
+        view.loadStarted = true
+        emit(view, "topError", errorMap("Invalid ad unit identifier", 0))
+      }
+      return
+    }
+    view.loadStarted = true
+    val generation = view.loadGeneration
+    EzoicNativeAd.load(view.context, view.adUnitId, object : EzoicNativeAdLoadListener {
+      override fun onNativeAdLoaded(nativeAd: EzoicNativeAd) {
+        // dispose() and this callback both arrive on the main thread, so the
+        // check is race-free. A late-arriving ad is destroyed, not rendered.
+        // A generation mismatch means the ad unit changed mid-load (mirrors
+        // the SDK's isCurrentLoad token pattern): destroy and emit nothing.
+        if (view.disposed || view.loadGeneration != generation) {
+          nativeAd.destroy()
+          return
+        }
+        val gmaAd = nativeAd.nativeAd ?: run {
+          // Empty-content ad: destroy it instead of keeping an unrenderable,
+          // errored ad alive on the view.
+          nativeAd.destroy()
+          emit(view, "topError", errorMap("Native ad loaded without content", 0))
+          return
+        }
+        view.ezoicNativeAd = nativeAd
+        // Attach the lifecycle listener before the rendered NativeAdView
+        // registers — the impression fires as soon as the view is displayed.
+        nativeAd.listener = object : EzoicNativeAdListener {
+          override fun onNativeAdImpression(nativeAd: EzoicNativeAd) =
+            emit(view, "topImpression", Arguments.createMap())
+          override fun onNativeAdClicked(nativeAd: EzoicNativeAd) =
+            emit(view, "topAdClick", Arguments.createMap())
+          override fun onNativeAdOpened(nativeAd: EzoicNativeAd) =
+            emit(view, "topOpen", Arguments.createMap())
+          override fun onNativeAdClosed(nativeAd: EzoicNativeAd) =
+            emit(view, "topClose", Arguments.createMap())
+        }
+        val adView = buildTemplate(view.context, gmaAd)
+        view.removeAllViews()
+        view.addView(adView)
+        emit(view, "topLoad", Arguments.createMap())
+      }
+
+      override fun onNativeAdFailedToLoad(error: EzoicError) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topError", errorMap(error.message, error.code))
+      }
+    })
+  }
+
+  /**
+   * Builds a template [NativeAdView] entirely in code (the module ships no
+   * `res/` layouts). Layout: a vertical column of a header row (icon +
+   * headline/advertiser), a [MediaView], the body text and a call-to-action
+   * button. Only the asset views actually present on [gmaAd] are created and
+   * registered; [NativeAdView.setNativeAd] is called last, as GMA requires.
+   */
+  private fun buildTemplate(context: Context, gmaAd: NativeAd): NativeAdView {
+    val adView = NativeAdView(context)
+
+    val root = LinearLayout(context).apply {
+      orientation = LinearLayout.VERTICAL
+      layoutParams = FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.WRAP_CONTENT,
+      )
+      val pad = dp(context, 8)
+      setPadding(pad, pad, pad, pad)
+    }
+
+    val headerRow = LinearLayout(context).apply {
+      orientation = LinearLayout.HORIZONTAL
+      layoutParams = LinearLayout.LayoutParams(
+        LinearLayout.LayoutParams.MATCH_PARENT,
+        LinearLayout.LayoutParams.WRAP_CONTENT,
+      )
+    }
+
+    var iconView: ImageView? = null
+    gmaAd.icon?.drawable?.let { drawable ->
+      val iv = ImageView(context).apply {
+        layoutParams = LinearLayout.LayoutParams(dp(context, 40), dp(context, 40))
+        setImageDrawable(drawable)
+      }
+      headerRow.addView(iv)
+      iconView = iv
+    }
+
+    val textColumn = LinearLayout(context).apply {
+      orientation = LinearLayout.VERTICAL
+      layoutParams = LinearLayout.LayoutParams(
+        0,
+        LinearLayout.LayoutParams.WRAP_CONTENT,
+        1f,
+      ).apply { leftMargin = dp(context, 8) }
+    }
+
+    var headlineView: TextView? = null
+    gmaAd.headline?.let { text ->
+      val tv = TextView(context).apply {
+        this.text = text
+        setTypeface(typeface, Typeface.BOLD)
+        textSize = 16f
+      }
+      textColumn.addView(tv)
+      headlineView = tv
+    }
+
+    var advertiserView: TextView? = null
+    gmaAd.advertiser?.let { text ->
+      val tv = TextView(context).apply {
+        this.text = text
+        textSize = 12f
+      }
+      textColumn.addView(tv)
+      advertiserView = tv
+    }
+
+    headerRow.addView(textColumn)
+    root.addView(headerRow)
+
+    var mediaView: MediaView? = null
+    gmaAd.mediaContent?.let { content ->
+      val mv = MediaView(context).apply {
+        layoutParams = LinearLayout.LayoutParams(
+          LinearLayout.LayoutParams.MATCH_PARENT,
+          dp(context, 175),
+        ).apply { topMargin = dp(context, 8) }
+        mediaContent = content
+      }
+      root.addView(mv)
+      mediaView = mv
+    }
+
+    var bodyView: TextView? = null
+    gmaAd.body?.let { text ->
+      val tv = TextView(context).apply {
+        this.text = text
+        textSize = 14f
+        setPadding(0, dp(context, 8), 0, 0)
+      }
+      root.addView(tv)
+      bodyView = tv
+    }
+
+    var callToActionView: Button? = null
+    gmaAd.callToAction?.let { text ->
+      val btn = Button(context).apply {
+        this.text = text
+        layoutParams = LinearLayout.LayoutParams(
+          LinearLayout.LayoutParams.MATCH_PARENT,
+          LinearLayout.LayoutParams.WRAP_CONTENT,
+        ).apply { topMargin = dp(context, 8) }
+      }
+      root.addView(btn)
+      callToActionView = btn
+    }
+
+    adView.addView(root)
+    // Register only the asset views that were populated; a null assignment
+    // leaves that asset unregistered.
+    adView.headlineView = headlineView
+    adView.bodyView = bodyView
+    adView.iconView = iconView
+    adView.advertiserView = advertiserView
+    adView.callToActionView = callToActionView
+    adView.mediaView = mediaView
+    adView.setNativeAd(gmaAd)
+    return adView
+  }
+
+  override fun onDropViewInstance(view: NativeAdContainer) {
+    super.onDropViewInstance(view)
+    view.disposed = true
+    view.loadGeneration++
+    view.ezoicNativeAd?.destroy()
+    view.ezoicNativeAd = null
+    view.removeAllViews()
+  }
+
+  private fun emit(view: NativeAdContainer, event: String, payload: WritableMap) {
+    if (view.disposed) return
+    ctx.getJSModule(RCTEventEmitter::class.java).receiveEvent(view.id, event, payload)
+  }
+
+  private fun errorMap(message: String?, code: Int): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("message", message ?: "")
+    map.putInt("code", code)
+    return map
+  }
+
+  private fun dp(context: Context, value: Int): Int =
+    (value * context.resources.displayMetrics.density).toInt()
+
+  override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
+    fun reg(on: String) = mapOf("phasedRegistrationNames" to mapOf("bubbled" to on))
+    return mapOf(
+      "topLoad" to reg("onLoad"),
+      "topError" to reg("onError"),
+      "topImpression" to reg("onImpression"),
+      "topAdClick" to reg("onAdClick"),
+      "topOpen" to reg("onOpen"),
+      "topClose" to reg("onClose")
+    )
+  }
+
+  /**
+   * Container for the template ad view. RN lays out only Yoga-managed views;
+   * the template [NativeAdView] is added from native code and stays unmeasured
+   * (blank) unless we force a measure/layout pass. Overriding [requestLayout]
+   * to post a manual measure(EXACTLY)+layout of the current bounds is the
+   * proven fix (react-native-google-mobile-ads uses the same approach).
+   */
+  class NativeAdContainer(context: Context) : FrameLayout(context) {
+    var adUnitId: Int = 0
+    var rawAdUnitId: String = ""
+    var loadStarted: Boolean = false
+    var disposed: Boolean = false
+    var loadGeneration: Int = 0
+    var ezoicNativeAd: EzoicNativeAd? = null
+
+    private val measureAndLayout = Runnable {
+      measure(
+        View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+        View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
+      )
+      layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+      super.requestLayout()
+      post(measureAndLayout)
+    }
+  }
+
+  companion object {
+    const val NAME = "EzoicNativeAdView"
+  }
+}