@ezoic/react-native-sdk 1.0.0 → 1.2.0

package/EzoicReactNativeSdk.podspec

@@ -20,6 +20,6 @@ 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.0"
+  s.dependency "EzoicAdsSDK", "~> 1.2"
   s.swift_version = "5.9"
 end

package/android/build.gradle

@@ -68,5 +68,5 @@ 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.0.0"
+  implementation "com.ezoic.sdk:ezoic-ads-sdk:1.2.0"
 }

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

@@ -1,17 +1,56 @@
 package com.ezoic.reactnative
 
 import android.app.Application
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 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
+import com.ezoic.ads.sdk.adunits.EzoicRewardedAdListenerAdapter
 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
 
 class EzoicAdsModule(reactContext: ReactApplicationContext) :
   NativeEzoicAdsSpec(reactContext) {
 
   override fun getName() = NAME
 
+  /** Loaded rewarded ads awaiting `show`, keyed by ad unit id. */
+  private val rewardedAds = ConcurrentHashMap<Int, EzoicRewardedAd>()
+
+  /** In-flight `show` calls, keyed by ad unit id. */
+  private val pendingShows = ConcurrentHashMap<Int, RewardShow>()
+
+  private class RewardShow(val promise: Promise) {
+    @Volatile var settled = false
+    @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()) {
@@ -53,10 +92,260 @@ class EzoicAdsModule(reactContext: ReactApplicationContext) :
     EzoicAds.instance.trackPageview { success -> promise.resolve(success) }
   }
 
+  override fun loadRewardedAd(adUnitIdentifier: String, promise: Promise) {
+    val id = adUnitIdentifier.toIntOrNull()
+    if (id == null) {
+      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
+        promise.resolve(null)
+      }.onFailure { e ->
+        promise.reject("EzoicAds", e.message ?: "Rewarded ad failed to load", e)
+      }
+    }
+  }
+
+  override fun showRewardedAd(adUnitIdentifier: String, promise: Promise) {
+    val id = adUnitIdentifier.toIntOrNull()
+    val ad = if (id != null) rewardedAds[id] else null
+    if (id == null || ad == null) {
+      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")
+      return
+    }
+
+    val show = RewardShow(promise)
+    pendingShows[id] = show
+
+    // Replace the load-time listener with one that also settles the promise on
+    // terminal events (dismiss = resolve, failed-to-show = reject).
+    ad.listener = makeListener(
+      adUnitIdentifier,
+      onDismiss = {
+        rewardedAds.remove(id)
+        val pending = pendingShows.remove(id)
+        if (pending != null && !pending.settled) {
+          pending.settled = true
+          val reward = pending.reward
+          val map = Arguments.createMap()
+          map.putBoolean("earned", reward != null)
+          map.putString("type", reward?.type ?: "")
+          map.putDouble("amount", (reward?.amount ?: 0).toDouble())
+          pending.promise.resolve(map)
+        }
+      },
+      onFailedToShow = { message ->
+        rewardedAds.remove(id)
+        val pending = pendingShows.remove(id)
+        if (pending != null && !pending.settled) {
+          pending.settled = true
+          pending.promise.reject("EzoicAds", message)
+        }
+      }
+    )
+
+    activity.runOnUiThread {
+      ad.show(activity) { reward -> show.reward = reward }
+    }
+  }
+
+  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.
+  }
+
+  override fun removeListeners(count: Double) {
+    // No-op: required by the React Native NativeEventEmitter contract.
+  }
+
+  private fun makeListener(
+    adUnitIdentifier: String,
+    onDismiss: (() -> Unit)? = null,
+    onFailedToShow: ((String) -> Unit)? = null
+  ): EzoicRewardedAdListener = object : EzoicRewardedAdListenerAdapter() {
+    override fun onRewardedAdShown(rewardedAd: EzoicRewardedAd) {
+      emitRewardedEvent(adUnitIdentifier, "shown")
+    }
+
+    override fun onRewardedAdFailedToShow(rewardedAd: EzoicRewardedAd, error: EzoicError) {
+      emitRewardedEvent(adUnitIdentifier, "failedToShow") {
+        putString("message", error.message)
+        putInt("code", error.code)
+      }
+      onFailedToShow?.invoke(error.message)
+    }
+
+    override fun onRewardedAdImpression(rewardedAd: EzoicRewardedAd) {
+      emitRewardedEvent(adUnitIdentifier, "impression")
+    }
+
+    override fun onRewardedAdClicked(rewardedAd: EzoicRewardedAd) {
+      emitRewardedEvent(adUnitIdentifier, "clicked")
+    }
+
+    override fun onUserEarnedReward(rewardedAd: EzoicRewardedAd, reward: EzoicReward) {
+      emitRewardedEvent(adUnitIdentifier, "reward") {
+        putString("rewardType", reward.type)
+        putDouble("rewardAmount", reward.amount.toDouble())
+      }
+    }
+
+    override fun onRewardedAdDismissed(rewardedAd: EzoicRewardedAd) {
+      emitRewardedEvent(adUnitIdentifier, "dismissed")
+      onDismiss?.invoke()
+    }
+  }
+
+  private fun emitRewardedEvent(
+    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(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/ios/EzoicAdsImpl.swift

@@ -3,46 +3,310 @@ import EzoicAdsSDKBinary
 
 @objc public class EzoicAdsImpl: NSObject {
 
+  /// Set by the Obj-C module to forward rewarded lifecycle events to JS.
+  @objc public var eventEmitter: ((String, [String: Any]) -> Void)?
+
+  /// Loaded rewarded ads awaiting `show`, keyed by ad unit id.
+  private var rewardedAds: [Int: EzoicRewardedAd] = [:]
+
+  /// In-flight `show` calls, keyed by ad unit id.
+  private var pendingShows: [Int: PendingRewardShow] = [:]
+
+  private final class PendingRewardShow {
+    let resolve: (Any?) -> Void
+    let reject: (String, String, NSError?) -> Void
+    var reward: EzoicReward?
+    init(resolve: @escaping (Any?) -> Void, reject: @escaping (String, String, NSError?) -> Void) {
+      self.resolve = resolve
+      self.reject = reject
+    }
+  }
+
+  /// Loaded interstitial ads awaiting `show`, keyed by ad unit id.
+  private var interstitialAds: [Int: EzoicInterstitialAd] = [:]
+
+  /// In-flight interstitial `show` calls, keyed by ad unit id.
+  private var pendingInterstitialShows: [Int: PendingInterstitialShow] = [:]
+
+  private final class PendingInterstitialShow {
+    let resolve: (Any?) -> Void
+    let reject: (String, String, NSError?) -> Void
+    init(resolve: @escaping (Any?) -> Void, reject: @escaping (String, String, NSError?) -> Void) {
+      self.resolve = resolve
+      self.reject = reject
+    }
+  }
+
+  /// Ad unit ids with an in-flight rewarded `load`.
+  private var loadingRewarded: Set<Int> = []
+
+  /// Ad unit ids with an in-flight interstitial `load`.
+  private var loadingInterstitial: Set<Int> = []
+
+  /// 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.
+  private func onMain(_ work: @escaping () -> Void) {
+    if Thread.isMainThread {
+      work()
+    } else {
+      DispatchQueue.main.async(execute: work)
+    }
+  }
+
   @objc public func initialize(_ config: NSDictionary,
                                resolve: @escaping (Any?) -> Void,
                                reject: @escaping (String, String, NSError?) -> Void) {
-    guard let domain = config["domain"] as? String, !domain.isEmpty else {
-      reject("EzoicAds", "initialize requires a non-empty `domain`.", nil)
-      return
-    }
-    let configuration = EzoicConfiguration(
-      domain: domain,
-      autoReadConsent: (config["autoReadConsent"] as? Bool) ?? true,
-      subjectToCOPPA: (config["subjectToCOPPA"] as? Bool) ?? false,
-      requestATTBeforeAds: (config["requestATTBeforeAds"] as? Bool) ?? true,
-      debugEnabled: (config["debugEnabled"] as? Bool) ?? false,
-      testMode: (config["testMode"] as? Bool) ?? false
-    )
-    EzoicAds.shared.initialize(with: configuration) { result in
-      switch result {
-      case .success:
-        resolve(nil)
-      case .failure(let error):
-        reject("EzoicAds", error.localizedDescription, error as NSError)
+    onMain {
+      guard let domain = config["domain"] as? String, !domain.isEmpty else {
+        reject("EzoicAds", "initialize requires a non-empty `domain`.", nil)
+        return
+      }
+      let configuration = EzoicConfiguration(
+        domain: domain,
+        autoReadConsent: (config["autoReadConsent"] as? Bool) ?? true,
+        subjectToCOPPA: (config["subjectToCOPPA"] as? Bool) ?? false,
+        requestATTBeforeAds: (config["requestATTBeforeAds"] as? Bool) ?? true,
+        debugEnabled: (config["debugEnabled"] as? Bool) ?? false,
+        testMode: (config["testMode"] as? Bool) ?? false
+      )
+      EzoicAds.shared.initialize(with: configuration) { result in
+        switch result {
+        case .success:
+          resolve(nil)
+        case .failure(let error):
+          reject("EzoicAds", error.localizedDescription, error as NSError)
+        }
       }
     }
   }
 
   @objc public func setGDPRConsent(_ applies: Bool, consentString: String?) {
-    EzoicAds.shared.setGDPRConsent(applies: applies, consentString: consentString)
+    onMain {
+      EzoicAds.shared.setGDPRConsent(applies: applies, consentString: consentString)
+    }
   }
 
   @objc public func setGPPConsent(_ gppString: String?, sectionIds: String?) {
-    EzoicAds.shared.setGPPConsent(gppString: gppString, sectionIds: sectionIds)
+    onMain {
+      EzoicAds.shared.setGPPConsent(gppString: gppString, sectionIds: sectionIds)
+    }
   }
 
   @objc public func setSubjectToCOPPA(_ value: Bool) {
-    EzoicAds.shared.setSubjectToCOPPA(value)
+    onMain {
+      EzoicAds.shared.setSubjectToCOPPA(value)
+    }
   }
 
   @objc public func trackPageview(_ resolve: @escaping (Any?) -> Void) {
-    EzoicAds.shared.trackPageview { success in
-      resolve(NSNumber(value: success))
+    onMain {
+      EzoicAds.shared.trackPageview { success in
+        resolve(NSNumber(value: success))
+      }
+    }
+  }
+
+  @objc public func loadRewardedAd(_ adUnitIdentifier: String,
+                                   resolve: @escaping (Any?) -> Void,
+                                   reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = Int(adUnitIdentifier) else {
+        reject("EzoicAds", "Invalid adUnitIdentifier: \(adUnitIdentifier)", nil)
+        return
+      }
+      if self.rewardedAds[id] != nil || self.loadingRewarded.contains(id) {
+        reject("EzoicAds", "An ad is already loaded/loading for ad unit \(adUnitIdentifier)", nil)
+        return
+      }
+      self.loadingRewarded.insert(id)
+      EzoicRewardedAd.load(adUnitIdentifier: id) { [weak self] result in
+        guard let self = self else { return }
+        self.onMain {
+          self.loadingRewarded.remove(id)
+          switch result {
+          case .success(let ad):
+            ad.delegate = self
+            self.rewardedAds[id] = ad
+            resolve(nil)
+          case .failure(let error):
+            reject("EzoicAds", error.localizedDescription, error as NSError)
+          }
+        }
+      }
+    }
+  }
+
+  @objc public func showRewardedAd(_ adUnitIdentifier: String,
+                                   resolve: @escaping (Any?) -> Void,
+                                   reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = Int(adUnitIdentifier), let ad = self.rewardedAds[id] else {
+        reject("EzoicAds", "Rewarded ad not loaded for \(adUnitIdentifier)", nil)
+        return
+      }
+      if self.pendingShows[id] != nil {
+        reject("EzoicAds", "A show is already in progress for ad unit \(adUnitIdentifier)", nil)
+        return
+      }
+      self.pendingShows[id] = PendingRewardShow(resolve: resolve, reject: reject)
+      // Presenting from nil lets GMA use the application's top view controller.
+      ad.show(from: nil) { [weak self] reward in
+        self?.onMain { self?.pendingShows[id]?.reward = reward }
+      }
+    }
+  }
+
+  private func emit(_ ad: EzoicRewardedAd, _ type: String, _ extra: [String: Any] = [:]) {
+    var body: [String: Any] = [
+      "adUnitIdentifier": String(ad.adUnitIdentifier),
+      "type": type
+    ]
+    for (key, value) in extra { body[key] = value }
+    eventEmitter?("EzoicRewardedAdEvent", body)
+  }
+
+  @objc public func loadInterstitialAd(_ adUnitIdentifier: String,
+                                       resolve: @escaping (Any?) -> Void,
+                                       reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = Int(adUnitIdentifier) else {
+        reject("EzoicAds", "Invalid adUnitIdentifier: \(adUnitIdentifier)", nil)
+        return
+      }
+      if self.interstitialAds[id] != nil || self.loadingInterstitial.contains(id) {
+        reject("EzoicAds", "An ad is already loaded/loading for ad unit \(adUnitIdentifier)", nil)
+        return
+      }
+      self.loadingInterstitial.insert(id)
+      EzoicInterstitialAd.load(adUnitIdentifier: id) { [weak self] result in
+        guard let self = self else { return }
+        self.onMain {
+          self.loadingInterstitial.remove(id)
+          switch result {
+          case .success(let ad):
+            ad.delegate = self
+            self.interstitialAds[id] = ad
+            resolve(nil)
+          case .failure(let error):
+            reject("EzoicAds", error.localizedDescription, error as NSError)
+          }
+        }
+      }
+    }
+  }
+
+  @objc public func showInterstitialAd(_ adUnitIdentifier: String,
+                                       resolve: @escaping (Any?) -> Void,
+                                       reject: @escaping (String, String, NSError?) -> Void) {
+    onMain { [weak self] in
+      guard let self = self else { return }
+      guard let id = Int(adUnitIdentifier), let ad = self.interstitialAds[id] else {
+        reject("EzoicAds", "Interstitial ad not loaded for \(adUnitIdentifier)", nil)
+        return
+      }
+      if self.pendingInterstitialShows[id] != nil {
+        reject("EzoicAds", "A show is already in progress for ad unit \(adUnitIdentifier)", nil)
+        return
+      }
+      self.pendingInterstitialShows[id] = PendingInterstitialShow(resolve: resolve, reject: reject)
+      // Native show(from:) has no completion handler, so the show promise is
+      // settled from the delegate (dismiss = resolve, failed-to-present = reject).
+      // Presenting from nil lets GMA use the application's top view controller.
+      ad.show(from: nil)
+    }
+  }
+
+  private func emitInterstitial(_ ad: EzoicInterstitialAd, _ type: String, _ extra: [String: Any] = [:]) {
+    var body: [String: Any] = [
+      "adUnitIdentifier": String(ad.adUnitIdentifier),
+      "type": type
+    ]
+    for (key, value) in extra { body[key] = value }
+    eventEmitter?("EzoicInterstitialAdEvent", body)
+  }
+}
+
+// MARK: - EzoicRewardedAdDelegate
+
+extension EzoicAdsImpl: EzoicRewardedAdDelegate {
+
+  public func rewardedAdDidPresent(_ rewardedAd: EzoicRewardedAd) {
+    emit(rewardedAd, "shown")
+  }
+
+  public func rewardedAd(_ rewardedAd: EzoicRewardedAd, didFailToPresentWithError error: EzoicError) {
+    emit(rewardedAd, "failedToShow", ["message": error.localizedDescription, "code": error.code])
+    let id = rewardedAd.adUnitIdentifier
+    rewardedAds.removeValue(forKey: id)
+    if let pending = pendingShows.removeValue(forKey: id) {
+      pending.reject("EzoicAds", error.localizedDescription, error as NSError)
+    }
+  }
+
+  public func rewardedAdDidRecordImpression(_ rewardedAd: EzoicRewardedAd) {
+    emit(rewardedAd, "impression")
+  }
+
+  public func rewardedAdDidRecordClick(_ rewardedAd: EzoicRewardedAd) {
+    emit(rewardedAd, "clicked")
+  }
+
+  public func rewardedAd(_ rewardedAd: EzoicRewardedAd, userDidEarn reward: EzoicReward) {
+    emit(rewardedAd, "reward", ["rewardType": reward.type, "rewardAmount": reward.amount])
+    pendingShows[rewardedAd.adUnitIdentifier]?.reward = reward
+  }
+
+  public func rewardedAdDidDismiss(_ rewardedAd: EzoicRewardedAd) {
+    emit(rewardedAd, "dismissed")
+    let id = rewardedAd.adUnitIdentifier
+    rewardedAds.removeValue(forKey: id)
+    if let pending = pendingShows.removeValue(forKey: id) {
+      let reward = pending.reward
+      let result: [String: Any] = [
+        "earned": reward != nil,
+        "type": reward?.type ?? "",
+        "amount": reward?.amount ?? 0
+      ]
+      pending.resolve(result)
+    }
+  }
+}
+
+// MARK: - EzoicInterstitialAdDelegate
+
+extension EzoicAdsImpl: EzoicInterstitialAdDelegate {
+
+  public func interstitialAdDidPresent(_ interstitialAd: EzoicInterstitialAd) {
+    emitInterstitial(interstitialAd, "shown")
+  }
+
+  public func interstitialAd(_ interstitialAd: EzoicInterstitialAd, didFailToPresentWithError error: EzoicError) {
+    emitInterstitial(interstitialAd, "failedToShow", ["message": error.localizedDescription, "code": error.code])
+    let id = interstitialAd.adUnitIdentifier
+    interstitialAds.removeValue(forKey: id)
+    if let pending = pendingInterstitialShows.removeValue(forKey: id) {
+      pending.reject("EzoicAds", error.localizedDescription, error as NSError)
+    }
+  }
+
+  public func interstitialAdDidRecordImpression(_ interstitialAd: EzoicInterstitialAd) {
+    emitInterstitial(interstitialAd, "impression")
+  }
+
+  public func interstitialAdDidRecordClick(_ interstitialAd: EzoicInterstitialAd) {
+    emitInterstitial(interstitialAd, "clicked")
+  }
+
+  public func interstitialAdDidDismiss(_ interstitialAd: EzoicInterstitialAd) {
+    emitInterstitial(interstitialAd, "dismissed")
+    let id = interstitialAd.adUnitIdentifier
+    interstitialAds.removeValue(forKey: id)
+    if let pending = pendingInterstitialShows.removeValue(forKey: id) {
+      pending.resolve(nil)
     }
   }
 }

package/ios/EzoicReactNativeSdk.h

@@ -1,5 +1,8 @@
 #import <EzoicReactNativeSdkSpec/EzoicReactNativeSdkSpec.h>
+#import <React/RCTEventEmitter.h>
 
-@interface EzoicReactNativeSdk : NSObject <NativeEzoicAdsSpec>
+// Subclasses RCTEventEmitter so the rewarded ad lifecycle can be surfaced to
+// JS via NativeEventEmitter, while still vending the codegen'd TurboModule.
+@interface EzoicReactNativeSdk : RCTEventEmitter <NativeEzoicAdsSpec>
 
 @end