@ezoic/react-native-sdk 1.2.0 → 1.4.0

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

@@ -0,0 +1,191 @@
+package com.ezoic.reactnative
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+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.EzoicOutstreamAdView
+import com.ezoic.ads.sdk.adunits.EzoicOutstreamAdViewListener
+import com.ezoic.ads.sdk.core.EzoicError
+
+/**
+ * Fabric view manager for the outstream video component. Mirrors
+ * [EzoicNativeAdViewManager] exactly (deferred load, load guards, teardown,
+ * manual measure/layout fix, bubbling-event registry) and differs only in the
+ * body of [maybeLoad]: the native [EzoicOutstreamAdView] is itself the rendered
+ * view (a `FrameLayout` that attaches its own GAM `AdManagerAdView`), so this
+ * manager adds that native view as the container's child and lets it render —
+ * there is no template to build as the native-ad manager does.
+ */
+@ReactModule(name = EzoicOutstreamAdViewManager.NAME)
+class EzoicOutstreamAdViewManager(private val ctx: ReactApplicationContext) :
+  SimpleViewManager<EzoicOutstreamAdViewManager.OutstreamAdContainer>() {
+
+  override fun getName() = NAME
+
+  override fun createViewInstance(reactContext: ThemedReactContext): OutstreamAdContainer {
+    val container = OutstreamAdContainer(reactContext)
+    container.layoutParams = ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
+    )
+    return container
+  }
+
+  @ReactProp(name = "adUnitIdentifier")
+  fun setAdUnitIdentifier(view: OutstreamAdContainer, 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.ezoicOutstreamAd?.destroy()
+      view.ezoicOutstreamAd = 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: OutstreamAdContainer) {
+    super.onAfterUpdateTransaction(view)
+    view.post { maybeLoad(view) }
+  }
+
+  private fun maybeLoad(view: OutstreamAdContainer) {
+    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
+    // The native outstream view renders itself. Attach the listener BEFORE
+    // loadAd() so no early lifecycle callback is missed, add it to the
+    // container, then load.
+    val outstreamAd = EzoicOutstreamAdView(view.context, view.adUnitId)
+    outstreamAd.listener = object : EzoicOutstreamAdViewListener {
+      override fun onOutstreamLoaded(adView: EzoicOutstreamAdView) {
+        // dispose() and this callback both arrive on the main thread, so the
+        // check is race-free. A generation mismatch means the ad unit changed
+        // mid-load (mirrors the SDK's isCurrentLoad token pattern): emit nothing.
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topLoad", Arguments.createMap())
+      }
+
+      override fun onOutstreamLoadFailed(adView: EzoicOutstreamAdView, error: EzoicError) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topError", errorMap(error.message, error.code))
+      }
+
+      override fun onOutstreamImpression(adView: EzoicOutstreamAdView) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topImpression", Arguments.createMap())
+      }
+
+      override fun onOutstreamClicked(adView: EzoicOutstreamAdView) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topAdClick", Arguments.createMap())
+      }
+
+      override fun onOutstreamOpened(adView: EzoicOutstreamAdView) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topOpen", Arguments.createMap())
+      }
+
+      override fun onOutstreamClosed(adView: EzoicOutstreamAdView) {
+        if (view.disposed || view.loadGeneration != generation) return
+        emit(view, "topClose", Arguments.createMap())
+      }
+    }
+    view.ezoicOutstreamAd = outstreamAd
+    view.removeAllViews()
+    view.addView(outstreamAd)
+    outstreamAd.loadAd()
+  }
+
+  override fun onDropViewInstance(view: OutstreamAdContainer) {
+    super.onDropViewInstance(view)
+    view.disposed = true
+    view.loadGeneration++
+    view.ezoicOutstreamAd?.destroy()
+    view.ezoicOutstreamAd = null
+    view.removeAllViews()
+  }
+
+  private fun emit(view: OutstreamAdContainer, 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
+  }
+
+  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 native outstream view. RN lays out only Yoga-managed
+   * views; the native [EzoicOutstreamAdView] 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 (identical to [EzoicNativeAdViewManager]).
+   */
+  class OutstreamAdContainer(context: Context) : FrameLayout(context) {
+    var adUnitId: Int = 0
+    var rawAdUnitId: String = ""
+    var loadStarted: Boolean = false
+    var disposed: Boolean = false
+    var loadGeneration: Int = 0
+    var ezoicOutstreamAd: EzoicOutstreamAdView? = 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 = "EzoicOutstreamAdView"
+  }
+}

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

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

package/ios/EzoicAdsImpl.swift

@@ -43,6 +43,28 @@ import EzoicAdsSDKBinary
   /// Ad unit ids with an in-flight interstitial `load`.
   private var loadingInterstitial: Set<Int> = []
 
+  /// Active instream controllers, keyed by ad unit id. Instream is multi-use and
+  /// NOT auto-destroying, so this impl retains each controller across load
+  /// cycles (and is its `weak` delegate) until `destroyInstreamAd`.
+  private var instreamAds: [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 unguarded second promise would hang forever.
+  private var pendingInstreamLoads: [Int: PendingInstreamLoad] = [:]
+
+  private final class PendingInstreamLoad {
+    let resolve: (Any?) -> Void
+    let reject: (String, String, NSError?) -> Void
+    /// Set once the promise is fulfilled so a late delegate callback (or a
+    /// destroy that already settled it) cannot double-settle it.
+    var settled: Bool = false
+    init(resolve: @escaping (Any?) -> Void, reject: @escaping (String, String, NSError?) -> Void) {
+      self.resolve = resolve
+      self.reject = reject
+    }
+  }
+
   /// Runs `work` on the main thread. The ad/pending/loading dictionaries and
   /// every native load/show call touch UIKit and this shared state, so they must
   /// only run on main. Delegate callbacks already arrive on main.
@@ -228,6 +250,113 @@ import EzoicAdsSDKBinary
     for (key, value) in extra { body[key] = value }
     eventEmitter?("EzoicInterstitialAdEvent", body)
   }
+
+  // MARK: - Instream video
+
+  /// Converts a bridge `Double` ad unit id to a native `Int`, rejecting NaN,
+  /// infinite, and out-of-`Int` ids. `Number("abc")` on the JS side arrives as
+  /// NaN, and `Int(Double.nan)` traps; likewise `Int(1e20)` traps even though
+  /// 1e20 is finite, so the upper bound must be checked before the `Int(...)`
+  /// conversion. Bounded to `Int32.max` and requires >= 1 to match Android's
+  /// rejection of ids <= 0.
+  private func instreamId(_ adUnitIdentifier: Double,
+                          _ reject: (String, String, NSError?) -> Void) -> Int? {
+    guard adUnitIdentifier.isFinite,
+          adUnitIdentifier >= 1,
+          adUnitIdentifier <= Double(Int32.max) else {
+      reject("EzoicAds", "Invalid adUnitIdentifier: \(adUnitIdentifier)", nil)
+      return nil
+    }
+    return Int(adUnitIdentifier)
+  }
+
+  @objc public func loadInstreamAd(_ adUnitIdentifier: Double,
+                                   contentUrl: String?,
+                                   resolve: @escaping (Any?) -> Void,
+                                   reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = self.instreamId(adUnitIdentifier, reject) else { return }
+      // Reject overlapping loads: the native load silently no-ops while an
+      // earlier one is in flight, which would hang this promise forever.
+      if self.pendingInstreamLoads[id] != nil {
+        reject("EzoicAds", "An instream ad is already loading for ad unit \(id)", nil)
+        return
+      }
+      // Create-or-reuse: instream is multi-use, so a repeat load on the same id
+      // reuses the existing native controller (preserving its tag state).
+      let ad: EzoicInstreamAd
+      if let existing = self.instreamAds[id] {
+        ad = existing
+      } else {
+        ad = EzoicInstreamAd(adUnitId: id)
+        self.instreamAds[id] = ad
+      }
+      // Register the pending holder BEFORE calling load: early validation
+      // failures deliver the delegate callback synchronously.
+      self.pendingInstreamLoads[id] = PendingInstreamLoad(resolve: resolve, reject: reject)
+      ad.load(contentUrl: contentUrl, delegate: self)
+    }
+  }
+
+  @objc public func getInstreamNextAdTagUrl(_ adUnitIdentifier: Double,
+                                            resolve: @escaping (Any?) -> Void,
+                                            reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = self.instreamId(adUnitIdentifier, reject) else { return }
+      // Native getNextAdTagUrl returns nil once the waterfall is exhausted,
+      // before a successful load, or after destroy — surface that as JS null.
+      resolve(self.instreamAds[id]?.getNextAdTagUrl())
+    }
+  }
+
+  @objc public func reportInstreamImpression(_ adUnitIdentifier: Double,
+                                             revenueUsd: NSNumber?,
+                                             resolve: @escaping (Any?) -> Void,
+                                             reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = self.instreamId(adUnitIdentifier, reject) else { return }
+      self.instreamAds[id]?.reportImpression(revenueUsd: revenueUsd?.doubleValue)
+      resolve(nil)
+    }
+  }
+
+  @objc public func destroyInstreamAd(_ adUnitIdentifier: Double,
+                                      resolve: @escaping (Any?) -> Void,
+                                      reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = self.instreamId(adUnitIdentifier, reject) else { return }
+      // Native suppresses load callbacks once destroyed, so settle any pending
+      // load's promise here first or it hangs forever.
+      if let pending = self.pendingInstreamLoads.removeValue(forKey: id), !pending.settled {
+        pending.settled = true
+        pending.reject("EzoicAds", "Instream ad was destroyed while loading", nil)
+      }
+      self.instreamAds.removeValue(forKey: id)?.destroy()
+      resolve(nil)
+    }
+  }
+
+  /// Module teardown parity with Android's `EzoicAdsModule.invalidate`: settle
+  /// every pending instream load with an error and destroy every controller so
+  /// no promise hangs and no native resource leaks.
+  @objc public func invalidate() {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      for (_, pending) in self.pendingInstreamLoads where !pending.settled {
+        pending.settled = true
+        pending.reject("EzoicAds", "Module was destroyed while loading", nil)
+      }
+      self.pendingInstreamLoads.removeAll()
+      for (_, ad) in self.instreamAds {
+        ad.destroy()
+      }
+      self.instreamAds.removeAll()
+    }
+  }
 }
 
 // MARK: - EzoicRewardedAdDelegate
@@ -310,3 +439,34 @@ extension EzoicAdsImpl: EzoicInterstitialAdDelegate {
     }
   }
 }
+
+// MARK: - EzoicInstreamAdDelegate
+
+extension EzoicAdsImpl: EzoicInstreamAdDelegate {
+
+  // Delegate callbacks arrive on main (see `onMain`), matching the rewarded /
+  // interstitial extensions which touch shared state directly. Removal happens
+  // only inside the not-yet-settled branch (settled-conditional removal) so a
+  // stale callback can't evict a newer load's holder after destroy→reload.
+  public func instreamAd(_ instreamAd: EzoicInstreamAd, didReceiveAdTag adTagUrl: String) {
+    let id = instreamAd.adUnitId
+    // Identity check: after destroy->reload for this id, a late callback from
+    // the destroyed controller must not settle the newer load's promise.
+    guard self.instreamAds[id] === instreamAd else { return }
+    guard let pending = pendingInstreamLoads[id], !pending.settled else { return }
+    pending.settled = true
+    pendingInstreamLoads.removeValue(forKey: id)
+    pending.resolve(adTagUrl)
+  }
+
+  public func instreamAd(_ instreamAd: EzoicInstreamAd, didFailToLoadWithError error: EzoicError) {
+    let id = instreamAd.adUnitId
+    // Identity check: after destroy->reload for this id, a late callback from
+    // the destroyed controller must not settle the newer load's promise.
+    guard self.instreamAds[id] === instreamAd else { return }
+    guard let pending = pendingInstreamLoads[id], !pending.settled else { return }
+    pending.settled = true
+    pendingInstreamLoads.removeValue(forKey: id)
+    pending.reject("EzoicAds", error.localizedDescription, error as NSError)
+  }
+}

package/ios/EzoicNativeAdHostView.swift

@@ -0,0 +1,181 @@
+import UIKit
+import EzoicAdsSDKBinary
+import GoogleMobileAds
+
+@objc public protocol EzoicNativeAdHostViewDelegate: AnyObject {
+  func nativeAdDidLoad()
+  func nativeAdDidFail(_ message: String, code: Int)
+  func nativeAdDidRecordImpression()
+  func nativeAdDidRecordClick()
+  func nativeAdWillPresentScreen()
+  func nativeAdDidDismissScreen()
+}
+
+@objc public class EzoicNativeAdHostView: UIView, EzoicNativeAdDelegate {
+
+  @objc public weak var hostDelegate: EzoicNativeAdHostViewDelegate?
+
+  private var adUnitId: Int = 0
+  private var ezoicNativeAd: EzoicNativeAd?
+  private var adView: NativeAdView?
+  private var loadStarted = false
+
+  /// Stores the ad unit id. The load is NOT started here — the Fabric
+  /// component view calls `startLoad()` from `finalizeUpdates`, after the
+  /// event emitter is attached, so a synchronous SDK failure (uninitialized)
+  /// can deliver `onError` instead of being dropped.
+  @objc public func configure(adUnitIdentifier: String) {
+    self.adUnitId = Int(adUnitIdentifier) ?? 0
+  }
+
+  /// Starts the native-ad load once. A second call is a no-op; the guard
+  /// survives repeated `finalizeUpdates` calls.
+  @objc public func startLoad() {
+    if loadStarted { return }
+    loadStarted = true
+    EzoicNativeAd.load(adUnitIdentifier: adUnitId) { [weak self] result in
+      guard let self = self else { return }
+      switch result {
+      case .success(let ad):
+        guard let gmaAd = ad.nativeAd else {
+          // Empty-content ad: destroy it and do not retain it instead of
+          // keeping an unrenderable, errored ad alive.
+          ad.destroy()
+          self.hostDelegate?.nativeAdDidFail("Native ad loaded without content", code: 0)
+          return
+        }
+        self.ezoicNativeAd = ad
+        // Attach the delegate before rendering so the impression, which fires
+        // as soon as the NativeAdView is displayed, is delivered.
+        ad.delegate = self
+        self.render(gmaAd)
+        self.hostDelegate?.nativeAdDidLoad()
+      case .failure(let error):
+        self.hostDelegate?.nativeAdDidFail(error.localizedDescription, code: error.code)
+      }
+    }
+  }
+
+  /// Builds a template `NativeAdView` in code (mirrors the Android template):
+  /// a header row (icon + headline/advertiser), a `MediaView`, the body text
+  /// and a call-to-action button. Optional text/image assets are created and
+  /// registered only when present, but the `MediaView` is always built: on
+  /// GMA 12 `NativeAd.mediaContent` is non-optional and the media view is a
+  /// required asset. `adView.nativeAd` is assigned last.
+  private func render(_ gmaAd: GoogleMobileAds.NativeAd) {
+    let adView = NativeAdView()
+    adView.translatesAutoresizingMaskIntoConstraints = false
+
+    let mainStack = UIStackView()
+    mainStack.axis = .vertical
+    mainStack.spacing = 8
+    mainStack.translatesAutoresizingMaskIntoConstraints = false
+
+    let headerRow = UIStackView()
+    headerRow.axis = .horizontal
+    headerRow.spacing = 8
+    headerRow.alignment = .center
+
+    if let image = gmaAd.icon?.image {
+      let iconView = UIImageView(image: image)
+      iconView.translatesAutoresizingMaskIntoConstraints = false
+      NSLayoutConstraint.activate([
+        iconView.widthAnchor.constraint(equalToConstant: 40),
+        iconView.heightAnchor.constraint(equalToConstant: 40),
+      ])
+      headerRow.addArrangedSubview(iconView)
+      adView.iconView = iconView
+    }
+
+    let textColumn = UIStackView()
+    textColumn.axis = .vertical
+
+    if let headline = gmaAd.headline {
+      let label = UILabel()
+      label.text = headline
+      label.font = .boldSystemFont(ofSize: 16)
+      label.numberOfLines = 0
+      textColumn.addArrangedSubview(label)
+      adView.headlineView = label
+    }
+
+    if let advertiser = gmaAd.advertiser {
+      let label = UILabel()
+      label.text = advertiser
+      label.font = .systemFont(ofSize: 12)
+      textColumn.addArrangedSubview(label)
+      adView.advertiserView = label
+    }
+
+    headerRow.addArrangedSubview(textColumn)
+    mainStack.addArrangedSubview(headerRow)
+
+    let mediaView = MediaView()
+    mediaView.mediaContent = gmaAd.mediaContent
+    mediaView.translatesAutoresizingMaskIntoConstraints = false
+    // Priority 999 so a caller-supplied style shorter than the template's
+    // natural height breaks this constraint instead of spamming
+    // unsatisfiable-constraint logs.
+    let mediaHeight = mediaView.heightAnchor.constraint(equalToConstant: 175)
+    mediaHeight.priority = UILayoutPriority(999)
+    mediaHeight.isActive = true
+    mainStack.addArrangedSubview(mediaView)
+    adView.mediaView = mediaView
+
+    if let body = gmaAd.body {
+      let label = UILabel()
+      label.text = body
+      label.font = .systemFont(ofSize: 14)
+      label.numberOfLines = 0
+      mainStack.addArrangedSubview(label)
+      adView.bodyView = label
+    }
+
+    if let cta = gmaAd.callToAction {
+      let button = UIButton(type: .system)
+      button.setTitle(cta, for: .normal)
+      // The NativeAdView handles the tap; the button must not intercept it.
+      button.isUserInteractionEnabled = false
+      mainStack.addArrangedSubview(button)
+      adView.callToActionView = button
+    }
+
+    adView.addSubview(mainStack)
+    NSLayoutConstraint.activate([
+      mainStack.topAnchor.constraint(equalTo: adView.topAnchor, constant: 8),
+      mainStack.leadingAnchor.constraint(equalTo: adView.leadingAnchor, constant: 8),
+      mainStack.trailingAnchor.constraint(equalTo: adView.trailingAnchor, constant: -8),
+      mainStack.bottomAnchor.constraint(equalTo: adView.bottomAnchor, constant: -8),
+    ])
+
+    self.adView?.removeFromSuperview()
+    addSubview(adView)
+    NSLayoutConstraint.activate([
+      adView.topAnchor.constraint(equalTo: topAnchor),
+      adView.leadingAnchor.constraint(equalTo: leadingAnchor),
+      adView.trailingAnchor.constraint(equalTo: trailingAnchor),
+      adView.bottomAnchor.constraint(equalTo: bottomAnchor),
+    ])
+
+    adView.nativeAd = gmaAd
+    self.adView = adView
+  }
+
+  // MARK: - EzoicNativeAdDelegate
+  public func nativeAdDidRecordImpression(_ nativeAd: EzoicNativeAd) {
+    hostDelegate?.nativeAdDidRecordImpression()
+  }
+  public func nativeAdDidRecordClick(_ nativeAd: EzoicNativeAd) {
+    hostDelegate?.nativeAdDidRecordClick()
+  }
+  public func nativeAdWillPresentScreen(_ nativeAd: EzoicNativeAd) {
+    hostDelegate?.nativeAdWillPresentScreen()
+  }
+  public func nativeAdDidDismissScreen(_ nativeAd: EzoicNativeAd) {
+    hostDelegate?.nativeAdDidDismissScreen()
+  }
+
+  deinit {
+    ezoicNativeAd?.destroy()
+  }
+}

package/ios/EzoicNativeAdViewComponentView.mm

@@ -0,0 +1,99 @@
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/EzoicReactNativeSdkSpec/ComponentDescriptors.h>
+#import <react/renderer/components/EzoicReactNativeSdkSpec/EventEmitters.h>
+#import <react/renderer/components/EzoicReactNativeSdkSpec/Props.h>
+#import <react/renderer/components/EzoicReactNativeSdkSpec/RCTComponentViewHelpers.h>
+#import <EzoicReactNativeSdk/EzoicReactNativeSdk-Swift.h>
+
+using namespace facebook::react;
+
+@interface EzoicNativeAdView : RCTViewComponentView <EzoicNativeAdHostViewDelegate>
+@end
+
+@implementation EzoicNativeAdView {
+  EzoicNativeAdHostView *_host;
+  NSString *_lastAdUnit;
+  BOOL _loadStarted;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<EzoicNativeAdViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _host = [EzoicNativeAdHostView new];
+    _host.hostDelegate = self;
+    self.contentView = _host;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<EzoicNativeAdViewProps const>(props);
+  NSString *adUnit = [NSString stringWithUTF8String:newProps.adUnitIdentifier.c_str()];
+  if (![adUnit isEqualToString:_lastAdUnit]) {
+    // Ad unit changed after a load already started: swap in a fresh host
+    // (mirrors prepareForRecycle) and reset the load guard so
+    // finalizeUpdates starts a new load for the new id.
+    if (_loadStarted) {
+      [_host removeFromSuperview];
+      _host = [EzoicNativeAdHostView new];
+      _host.hostDelegate = self;
+      self.contentView = _host;
+      _loadStarted = NO;
+    }
+    _lastAdUnit = adUnit;
+    [_host configureWithAdUnitIdentifier:adUnit];
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+
+// RCTMountingManager mounts on Insert as updateProps → updateEventEmitter →
+// finalizeUpdates. Starting the load here (not in updateProps) guarantees the
+// event emitter is attached before the native SDK can fail synchronously and
+// emit onError, which would otherwise be dropped while _eventEmitter is nil.
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+  if (!_loadStarted && _lastAdUnit.length > 0) {
+    _loadStarted = YES;
+    [_host startLoad];
+  }
+}
+
+- (void)nativeAdDidLoad {
+  if (_eventEmitter) std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)->onLoad({});
+}
+- (void)nativeAdDidFail:(NSString *)message code:(NSInteger)code {
+  if (_eventEmitter)
+    std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)
+      ->onError({.message = std::string([message UTF8String]), .code = (int)code});
+}
+- (void)nativeAdDidRecordImpression {
+  if (_eventEmitter) std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)->onImpression({});
+}
+- (void)nativeAdDidRecordClick {
+  if (_eventEmitter) std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)->onAdClick({});
+}
+- (void)nativeAdWillPresentScreen {
+  if (_eventEmitter) std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)->onOpen({});
+}
+- (void)nativeAdDidDismissScreen {
+  if (_eventEmitter) std::static_pointer_cast<EzoicNativeAdViewEventEmitter const>(_eventEmitter)->onClose({});
+}
+
+- (void)prepareForRecycle {
+  // Recycled views are reused for a new ad unit; rebuild the host (which owns
+  // the loaded EzoicNativeAd, destroyed on deinit) and reset the load guards.
+  [_host removeFromSuperview];
+  _host = [EzoicNativeAdHostView new];
+  _host.hostDelegate = self;
+  self.contentView = _host;
+  _lastAdUnit = nil;
+  _loadStarted = NO;
+  [super prepareForRecycle];
+}
+
+Class<RCTComponentViewProtocol> EzoicNativeAdViewCls(void) { return EzoicNativeAdView.class; }
+
+@end