@ezoic/react-native-sdk 1.1.0 → 1.3.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.1"
+  s.dependency "EzoicAdsSDK", "~> 1.3"
+  # 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 and rewarded 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` and `EzoicNativeAdView` Fabric
+components.
 
 ## Requirements
 
@@ -68,6 +69,28 @@ 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')}
+/>;
+```
+
 ## API
 
 - `EzoicAds.initialize(config)` → `Promise<void>`
@@ -76,6 +99,7 @@ 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 />`
 
 ## 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.1.0"
+  implementation "com.ezoic.sdk:ezoic-ads-sdk:1.3.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,9 @@ 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.EzoicInterstitialAd
+import com.ezoic.ads.sdk.adunits.EzoicInterstitialAdListener
+import com.ezoic.ads.sdk.adunits.EzoicInterstitialAdListenerAdapter
 import com.ezoic.ads.sdk.adunits.EzoicReward
 import com.ezoic.ads.sdk.adunits.EzoicRewardedAd
 import com.ezoic.ads.sdk.adunits.EzoicRewardedAdListener
@@ -32,6 +35,22 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
     @Volatile var reward: EzoicReward? = null
   }
 
+  /** Loaded interstitial ads awaiting `show`, keyed by ad unit id. */
+  private val interstitialAds = ConcurrentHashMap<Int, EzoicInterstitialAd>()
+
+  /** In-flight interstitial `show` calls, keyed by ad unit id. */
+  private val pendingInterstitialShows = ConcurrentHashMap<Int, InterstitialShow>()
+
+  private class InterstitialShow(val promise: Promise) {
+    @Volatile var settled = false
+  }
+
+  /** Ad unit ids with an in-flight rewarded `load`. */
+  private val loadingRewarded = ConcurrentHashMap.newKeySet<Int>()
+
+  /** Ad unit ids with an in-flight interstitial `load`. */
+  private val loadingInterstitial = ConcurrentHashMap.newKeySet<Int>()
+
   override fun initialize(config: ReadableMap, promise: Promise) {
     val domain = if (config.hasKey("domain")) config.getString("domain") else null
     if (domain.isNullOrEmpty()) {
@@ -79,7 +98,12 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
       promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
       return
     }
+    if (rewardedAds.containsKey(id) || !loadingRewarded.add(id)) {
+      promise.reject("EzoicAds", "An ad is already loaded/loading for ad unit $adUnitIdentifier")
+      return
+    }
     EzoicRewardedAd.load(reactApplicationContext, id) { result ->
+      loadingRewarded.remove(id)
       result.onSuccess { ad ->
         ad.listener = makeListener(adUnitIdentifier)
         rewardedAds[id] = ad
@@ -97,6 +121,10 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
       promise.reject("EzoicAds", "Rewarded ad not loaded for $adUnitIdentifier")
       return
     }
+    if (pendingShows.containsKey(id)) {
+      promise.reject("EzoicAds", "A show is already in progress for ad unit $adUnitIdentifier")
+      return
+    }
     val activity = currentActivity
     if (activity == null) {
       promise.reject("EzoicAds", "No current Activity to present the rewarded ad")
@@ -138,6 +166,75 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun loadInterstitialAd(adUnitIdentifier: String, promise: Promise) {
+    val id = adUnitIdentifier.toIntOrNull()
+    if (id == null) {
+      promise.reject("EzoicAds", "Invalid adUnitIdentifier: $adUnitIdentifier")
+      return
+    }
+    if (interstitialAds.containsKey(id) || !loadingInterstitial.add(id)) {
+      promise.reject("EzoicAds", "An ad is already loaded/loading for ad unit $adUnitIdentifier")
+      return
+    }
+    EzoicInterstitialAd.load(reactApplicationContext, id) { result ->
+      loadingInterstitial.remove(id)
+      result.onSuccess { ad ->
+        ad.listener = makeInterstitialListener(adUnitIdentifier)
+        interstitialAds[id] = ad
+        promise.resolve(null)
+      }.onFailure { e ->
+        promise.reject("EzoicAds", e.message ?: "Interstitial ad failed to load", e)
+      }
+    }
+  }
+
+  override fun showInterstitialAd(adUnitIdentifier: String, promise: Promise) {
+    val id = adUnitIdentifier.toIntOrNull()
+    val ad = if (id != null) interstitialAds[id] else null
+    if (id == null || ad == null) {
+      promise.reject("EzoicAds", "Interstitial ad not loaded for $adUnitIdentifier")
+      return
+    }
+    if (pendingInterstitialShows.containsKey(id)) {
+      promise.reject("EzoicAds", "A show is already in progress for ad unit $adUnitIdentifier")
+      return
+    }
+    val activity = currentActivity
+    if (activity == null) {
+      promise.reject("EzoicAds", "No current Activity to present the interstitial ad")
+      return
+    }
+
+    pendingInterstitialShows[id] = InterstitialShow(promise)
+
+    // Native show(activity) has no completion lambda, so replace the load-time
+    // listener with one that settles the promise on terminal events
+    // (dismiss = resolve, failed-to-show = reject).
+    ad.listener = makeInterstitialListener(
+      adUnitIdentifier,
+      onDismiss = {
+        interstitialAds.remove(id)
+        val pending = pendingInterstitialShows.remove(id)
+        if (pending != null && !pending.settled) {
+          pending.settled = true
+          pending.promise.resolve(null)
+        }
+      },
+      onFailedToShow = { message ->
+        interstitialAds.remove(id)
+        val pending = pendingInterstitialShows.remove(id)
+        if (pending != null && !pending.settled) {
+          pending.settled = true
+          pending.promise.reject("EzoicAds", message)
+        }
+      }
+    )
+
+    activity.runOnUiThread {
+      ad.show(activity)
+    }
+  }
+
   override fun addListener(eventName: String) {
     // No-op: required by the React Native NativeEventEmitter contract.
   }
@@ -158,6 +255,7 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
     override fun onRewardedAdFailedToShow(rewardedAd: EzoicRewardedAd, error: EzoicError) {
       emitRewardedEvent(adUnitIdentifier, "failedToShow") {
         putString("message", error.message)
+        putInt("code", error.code)
       }
       onFailedToShow?.invoke(error.message)
     }
@@ -197,11 +295,57 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
       .emit(REWARDED_EVENT, map)
   }
 
+  private fun makeInterstitialListener(
+    adUnitIdentifier: String,
+    onDismiss: (() -> Unit)? = null,
+    onFailedToShow: ((String) -> Unit)? = null
+  ): EzoicInterstitialAdListener = object : EzoicInterstitialAdListenerAdapter() {
+    override fun onInterstitialAdShown(interstitialAd: EzoicInterstitialAd) {
+      emitInterstitialEvent(adUnitIdentifier, "shown")
+    }
+
+    override fun onInterstitialAdFailedToShow(interstitialAd: EzoicInterstitialAd, error: EzoicError) {
+      emitInterstitialEvent(adUnitIdentifier, "failedToShow") {
+        putString("message", error.message)
+        putInt("code", error.code)
+      }
+      onFailedToShow?.invoke(error.message)
+    }
+
+    override fun onInterstitialAdImpression(interstitialAd: EzoicInterstitialAd) {
+      emitInterstitialEvent(adUnitIdentifier, "impression")
+    }
+
+    override fun onInterstitialAdClicked(interstitialAd: EzoicInterstitialAd) {
+      emitInterstitialEvent(adUnitIdentifier, "clicked")
+    }
+
+    override fun onInterstitialAdDismissed(interstitialAd: EzoicInterstitialAd) {
+      emitInterstitialEvent(adUnitIdentifier, "dismissed")
+      onDismiss?.invoke()
+    }
+  }
+
+  private fun emitInterstitialEvent(
+    adUnitIdentifier: String,
+    type: String,
+    extra: (WritableMap.() -> Unit)? = null
+  ) {
+    val map = Arguments.createMap()
+    map.putString("adUnitIdentifier", adUnitIdentifier)
+    map.putString("type", type)
+    extra?.invoke(map)
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(INTERSTITIAL_EVENT, map)
+  }
+
   private fun ReadableMap.optBool(key: String, default: Boolean): Boolean =
     if (hasKey(key) && !isNull(key)) getBoolean(key) else default
 
   companion object {
     const val NAME = NativeEzoicAdsSpec.NAME
     private const val REWARDED_EVENT = "EzoicRewardedAdEvent"
+    private const val INTERSTITIAL_EVENT = "EzoicInterstitialAdEvent"
   }
 }

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"
+  }
+}

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

@@ -19,7 +19,10 @@ class EzoicReactNativeSdkPackage : BaseReactPackage() {
   override fun createViewManagers(
     reactContext: ReactApplicationContext
   ): List<ViewManager<*, *>> {
-    return listOf(EzoicBannerViewManager(reactContext))
+    return listOf(
+      EzoicBannerViewManager(reactContext),
+      EzoicNativeAdViewManager(reactContext)
+    )
   }
 
   override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {