@ezoic/react-native-sdk 1.1.0 → 1.3.0

package/ios/EzoicAdsImpl.swift

@@ -22,65 +22,118 @@ import EzoicAdsSDKBinary
     }
   }
 
+  /// 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) {
-    guard let id = Int(adUnitIdentifier) else {
-      reject("EzoicAds", "Invalid adUnitIdentifier: \(adUnitIdentifier)", nil)
-      return
-    }
-    EzoicRewardedAd.load(adUnitIdentifier: id) { [weak self] result in
+    onMain { [weak self] in
       guard let self = self else { return }
-      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)
+      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)
+          }
+        }
       }
     }
   }
@@ -88,14 +141,21 @@ import EzoicAdsSDKBinary
   @objc public func showRewardedAd(_ adUnitIdentifier: String,
                                    resolve: @escaping (Any?) -> Void,
                                    reject: @escaping (String, String, NSError?) -> Void) {
-    guard let id = Int(adUnitIdentifier), let ad = rewardedAds[id] else {
-      reject("EzoicAds", "Rewarded ad not loaded for \(adUnitIdentifier)", nil)
-      return
-    }
-    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?.pendingShows[id]?.reward = reward
+    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 }
+      }
     }
   }
 
@@ -107,6 +167,67 @@ import EzoicAdsSDKBinary
     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
@@ -118,7 +239,7 @@ extension EzoicAdsImpl: EzoicRewardedAdDelegate {
   }
 
   public func rewardedAd(_ rewardedAd: EzoicRewardedAd, didFailToPresentWithError error: EzoicError) {
-    emit(rewardedAd, "failedToShow", ["message": error.localizedDescription])
+    emit(rewardedAd, "failedToShow", ["message": error.localizedDescription, "code": error.code])
     let id = rewardedAd.adUnitIdentifier
     rewardedAds.removeValue(forKey: id)
     if let pending = pendingShows.removeValue(forKey: id) {
@@ -154,3 +275,38 @@ extension EzoicAdsImpl: EzoicRewardedAdDelegate {
     }
   }
 }
+
+// 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/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

package/ios/EzoicReactNativeSdk.mm

@@ -2,6 +2,7 @@
 #import <EzoicReactNativeSdk/EzoicReactNativeSdk-Swift.h>
 
 static NSString *const kEzoicRewardedEvent = @"EzoicRewardedAdEvent";
+static NSString *const kEzoicInterstitialEvent = @"EzoicInterstitialAdEvent";
 
 @implementation EzoicReactNativeSdk {
   EzoicAdsImpl *_impl;
@@ -30,7 +31,7 @@ static NSString *const kEzoicRewardedEvent = @"EzoicRewardedAdEvent";
 }
 
 - (NSArray<NSString *> *)supportedEvents {
-  return @[ kEzoicRewardedEvent ];
+  return @[ kEzoicRewardedEvent, kEzoicInterstitialEvent ];
 }
 
 - (void)startObserving {
@@ -88,6 +89,22 @@ static NSString *const kEzoicRewardedEvent = @"EzoicRewardedAdEvent";
                  reject:^(NSString *code, NSString *msg, NSError *_Nullable e) { reject(code, msg, e); }];
 }
 
+- (void)loadInterstitialAd:(NSString *)adUnitIdentifier
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  [_impl loadInterstitialAd:adUnitIdentifier
+                    resolve:^(id _Nullable v) { resolve(v); }
+                     reject:^(NSString *code, NSString *msg, NSError *_Nullable e) { reject(code, msg, e); }];
+}
+
+- (void)showInterstitialAd:(NSString *)adUnitIdentifier
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  [_impl showInterstitialAd:adUnitIdentifier
+                    resolve:^(id _Nullable v) { resolve(v); }
+                     reject:^(NSString *code, NSString *msg, NSError *_Nullable e) { reject(code, msg, e); }];
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeEzoicAdsSpecJSI>(params);