novvy-ads-react-native 1.0.0-beta.1

package/ios/NovvyAds.mm

@@ -0,0 +1,168 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTUtils.h>
+
+// Swift implementation (generated umbrella header for this pod's Swift module).
+#import "NovvyAdsReactNative-Swift.h"
+
+// Codegen'd TurboModule spec (present when the new architecture is enabled).
+#import "NovvyAdsSpec.h"
+
+/**
+ * TurboModule entry point. All business logic lives in the Swift
+ * `NovvyAdsImpl` (which calls the NovvyAds SDK); this thin ObjC++ layer only
+ * bridges codegen method calls and the `onAdEvent` emitter to it.
+ */
+@interface NovvyAds : NativeNovvyAdsSpecBase <NativeNovvyAdsSpec>
+@end
+
+@implementation NovvyAds {
+  NovvyAdsImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(NovvyAds)
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _impl = NovvyAdsImpl.shared;
+    __weak NovvyAds *weakSelf = self;
+    _impl.eventSink = ^(NSDictionary *value) {
+      [weakSelf emitOnAdEvent:value];
+    };
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+// All methods touch UIKit views (Fabric containers) or the Novvy SDK's inline
+// player, both of which are main-thread-only. Force every TurboModule call
+// onto the main queue instead of RN's default serial GCD queue.
+- (dispatch_queue_t)methodQueue {
+  return dispatch_get_main_queue();
+}
+
+// MARK: - SDK & context
+
+RCT_EXPORT_METHOD(initialize:(NSString *)appId
+                  endpoint:(NSString *)endpoint
+                  apiKey:(NSString *)apiKey
+                  userContext:(NSDictionary *)userContext
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  [_impl initializeWithAppId:appId
+                    endpoint:endpoint
+                      apiKey:apiKey
+                 userContext:userContext
+                  completion:^(BOOL success) { resolve(@(success)); }];
+}
+
+RCT_EXPORT_METHOD(setUserContext:(NSDictionary *)context) {
+  [_impl setUserContext:context];
+}
+
+RCT_EXPORT_METHOD(updateUserContext:(NSDictionary *)partial) {
+  [_impl updateUserContext:partial];
+}
+
+RCT_EXPORT_METHOD(setContentContext:(NSDictionary *)context) {
+  [_impl setContentContext:context];
+}
+
+RCT_EXPORT_METHOD(updateContentContext:(NSDictionary *)partial) {
+  [_impl updateContentContext:partial];
+}
+
+// MARK: - Full-screen ads
+
+RCT_EXPORT_METHOD(loadInterstitialAd:(NSString *)adUnitId adObjectId:(NSString *)adObjectId) {
+  [_impl loadInterstitialAdWithAdUnitId:adUnitId adObjectId:adObjectId];
+}
+RCT_EXPORT_METHOD(showInterstitialAd:(NSString *)adObjectId) {
+  [_impl showInterstitialAdWithAdObjectId:adObjectId];
+}
+
+RCT_EXPORT_METHOD(loadRewardedAd:(NSString *)adUnitId adObjectId:(NSString *)adObjectId) {
+  [_impl loadRewardedAdWithAdUnitId:adUnitId adObjectId:adObjectId];
+}
+RCT_EXPORT_METHOD(showRewardedAd:(NSString *)adObjectId) {
+  [_impl showRewardedAdWithAdObjectId:adObjectId];
+}
+
+RCT_EXPORT_METHOD(loadMidAd:(NSString *)adUnitId adObjectId:(NSString *)adObjectId) {
+  [_impl loadMidAdWithAdUnitId:adUnitId adObjectId:adObjectId];
+}
+RCT_EXPORT_METHOD(showMidAd:(NSString *)adObjectId) {
+  [_impl showMidAdWithAdObjectId:adObjectId];
+}
+
+RCT_EXPORT_METHOD(loadEndAd:(NSString *)adUnitId adObjectId:(NSString *)adObjectId) {
+  [_impl loadEndAdWithAdUnitId:adUnitId adObjectId:adObjectId];
+}
+RCT_EXPORT_METHOD(showEndAd:(NSString *)adObjectId) {
+  [_impl showEndAdWithAdObjectId:adObjectId];
+}
+
+// MARK: - Scroll
+
+RCT_EXPORT_METHOD(loadScrollAd:(NSString *)adUnitId
+                  adObjectId:(NSString *)adObjectId
+                  episodeNumber:(NSNumber *)episodeNumber) {
+  [_impl loadScrollAdWithAdUnitId:adUnitId adObjectId:adObjectId episodeNumber:episodeNumber];
+}
+
+RCT_EXPORT_METHOD(attachScrollAd:(NSString *)adObjectId
+                  durationSeconds:(NSNumber *)durationSeconds
+                  useDefaultSwipeOverlay:(BOOL)useDefaultSwipeOverlay) {
+  [_impl attachScrollAdWithAdObjectId:adObjectId
+                      durationSeconds:durationSeconds
+               useDefaultSwipeOverlay:useDefaultSwipeOverlay];
+}
+
+RCT_EXPORT_METHOD(setScrollAdPlaying:(NSString *)adObjectId playing:(BOOL)playing) {
+  [_impl setScrollAdPlayingWithAdObjectId:adObjectId playing:playing];
+}
+
+RCT_EXPORT_METHOD(detachScrollAd:(NSString *)adObjectId) {
+  [_impl detachScrollAdWithAdObjectId:adObjectId];
+}
+
+// MARK: - Pause
+
+RCT_EXPORT_METHOD(attachPauseAd:(NSString *)adUnitId
+                  adObjectId:(NSString *)adObjectId
+                  positionMs:(double)positionMs
+                  isPlaying:(BOOL)isPlaying) {
+  [_impl attachPauseAdWithAdUnitId:adUnitId
+                       adObjectId:adObjectId
+                       positionMs:(int64_t)positionMs
+                        isPlaying:isPlaying];
+}
+
+RCT_EXPORT_METHOD(updatePauseAdPlayerState:(NSString *)adObjectId
+                  positionMs:(double)positionMs
+                  isPlaying:(BOOL)isPlaying) {
+  [_impl updatePauseAdPlayerStateWithAdObjectId:adObjectId
+                                     positionMs:(int64_t)positionMs
+                                      isPlaying:isPlaying];
+}
+
+RCT_EXPORT_METHOD(detachPauseAd:(NSString *)adObjectId) {
+  [_impl detachPauseAdWithAdObjectId:adObjectId];
+}
+
+// MARK: - Common
+
+RCT_EXPORT_METHOD(disposeAd:(NSString *)adObjectId) {
+  [_impl disposeAdWithAdObjectId:adObjectId];
+}
+
+// MARK: - TurboModule
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeNovvyAdsSpecJSI>(params);
+}
+
+@end

package/ios/NovvyAdsImpl.swift

@@ -0,0 +1,409 @@
+import Foundation
+import UIKit
+import NovvyAds
+
+/**
+ * Business logic bridging the Novvy iOS ad SDK to React Native.
+ *
+ * Mirrors the Flutter plugin's `NovvyAdsApiImpl.swift` one-to-one. A single
+ * `eventSink` closure multiplexes every ad's lifecycle events to JS as an
+ * `NSDictionary`; each JS ad object filters by its own `adObjectId`.
+ *
+ * A process-wide `shared` instance lets the Fabric view classes register their
+ * containers with the same object the TurboModule drives.
+ */
+@objc public final class NovvyAdsImpl: NSObject {
+
+  @objc public static let shared = NovvyAdsImpl()
+
+  /// Set by the TurboModule; forwards event dictionaries to `emitOnAdEvent`.
+  @objc public var eventSink: ((NSDictionary) -> Void)?
+
+  private var adMap: [String: AnyObject] = [:]
+  private var scrollContainerMap: [String: UIView] = [:]
+  private var pauseContainerMap: [String: UIView] = [:]
+  private var pauseAdapterMap: [String: RnPlayerAdapter] = [:]
+  /// The SDK holds delegates weakly, so retain them here per ad.
+  private var delegateMap: [String: AnyObject] = [:]
+
+  // Event name constants — must match the NovvyAdEvent string union in TS.
+  private enum Ev {
+    static let loaded = "loaded"
+    static let failed = "failedToLoad"
+    static let showed = "showed"
+    static let dismissed = "dismissed"
+    static let hidden = "hidden"
+    static let earnedReward = "earnedReward"
+    static let playbackTick = "playbackTick"
+  }
+
+  // MARK: - Event emission
+
+  private func emit(
+    _ adObjectId: String,
+    _ adUnitId: String,
+    _ event: String,
+    error: String? = nil,
+    remainingSeconds: Int? = nil
+  ) {
+    let dict = NSMutableDictionary()
+    dict["adObjectId"] = adObjectId
+    dict["adUnitId"] = adUnitId
+    dict["event"] = event
+    if let error { dict["error"] = error }
+    if let remainingSeconds { dict["remainingSeconds"] = remainingSeconds }
+    let sink = eventSink
+    if Thread.isMainThread {
+      sink?(dict)
+    } else {
+      DispatchQueue.main.async { sink?(dict) }
+    }
+  }
+
+  private func makeEmit(_ adObjectId: String, _ adUnitId: String)
+    -> (String, String?, Int?) -> Void {
+    return { [weak self] event, error, remaining in
+      self?.emit(adObjectId, adUnitId, event, error: error, remainingSeconds: remaining)
+    }
+  }
+
+  // MARK: - Initialization & context
+
+  @objc public func initialize(
+    appId: String,
+    endpoint: String,
+    apiKey: String,
+    userContext: NSDictionary?,
+    completion: @escaping (Bool) -> Void
+  ) {
+    NovvySDK.shared.initialize(
+      appId: appId,
+      endpoint: endpoint,
+      apiKey: apiKey,
+      userContext: userContext?.toSdkUserContext(),
+      completion: { success in
+        if Thread.isMainThread { completion(success) }
+        else { DispatchQueue.main.async { completion(success) } }
+      }
+    )
+  }
+
+  @objc public func setUserContext(_ context: NSDictionary) {
+    NovvySDK.shared.setUserContext(context.toSdkUserContext())
+  }
+
+  @objc public func updateUserContext(_ partial: NSDictionary) {
+    NovvySDK.shared.updateUserContext(
+      userId: partial.optString("userId"),
+      hashedEmail: partial.optString("hashedEmail"),
+      isPaidUser: partial.optBool("isPaidUser"),
+      age: partial.optInt("age"),
+      gender: partial.optString("gender"),
+      dramaWatchHistory: (partial["dramaWatchHistory"] as? [NSDictionary])?.toSdkRecords(),
+      maximumAdsInOneDrama: partial.optInt("maximumAdsInOneDrama")
+    )
+  }
+
+  @objc public func setContentContext(_ context: NSDictionary) {
+    NovvySDK.shared.setContentContext(NovvyAds.NovvyContentContext(
+      seriesName: context.optString("seriesName"),
+      episodeNumber: context.optInt("episodeNumber"),
+      url: context.optString("url")
+    ))
+  }
+
+  @objc public func updateContentContext(_ partial: NSDictionary) {
+    NovvySDK.shared.updateContentContext(
+      seriesName: partial.optString("seriesName"),
+      episodeNumber: partial.optInt("episodeNumber"),
+      url: partial.optString("url")
+    )
+  }
+
+  // MARK: - Interstitial
+
+  @objc public func loadInterstitialAd(adUnitId: String, adObjectId: String) {
+    let ad = NovvyInterstitialAd(adUnitId: adUnitId)
+    let delegate = InterstitialDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.load()
+  }
+
+  @objc public func showInterstitialAd(adObjectId: String) {
+    guard let ad = adMap[adObjectId] as? NovvyInterstitialAd else { return }
+    guard let vc = Self.topViewController() else {
+      emit(adObjectId, ad.adUnitId, Ev.failed, error: "No active ViewController available")
+      return
+    }
+    ad.show(from: vc)
+  }
+
+  // MARK: - Rewarded
+
+  @objc public func loadRewardedAd(adUnitId: String, adObjectId: String) {
+    let ad = NovvyRewardedAd(adUnitId: adUnitId)
+    let delegate = RewardedDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.load()
+  }
+
+  @objc public func showRewardedAd(adObjectId: String) {
+    guard let ad = adMap[adObjectId] as? NovvyRewardedAd else { return }
+    guard let vc = Self.topViewController() else {
+      emit(adObjectId, ad.adUnitId, Ev.failed, error: "No active ViewController available")
+      return
+    }
+    ad.show(from: vc)
+  }
+
+  // MARK: - Mid-roll
+
+  @objc public func loadMidAd(adUnitId: String, adObjectId: String) {
+    let ad = NovvyMidAd(adUnitId: adUnitId)
+    let delegate = MidDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.load()
+  }
+
+  @objc public func showMidAd(adObjectId: String) {
+    guard let ad = adMap[adObjectId] as? NovvyMidAd else { return }
+    guard let vc = Self.topViewController() else {
+      emit(adObjectId, ad.adUnitId, Ev.failed, error: "No active ViewController available")
+      return
+    }
+    ad.show(from: vc)
+  }
+
+  // MARK: - End-roll
+
+  @objc public func loadEndAd(adUnitId: String, adObjectId: String) {
+    let ad = NovvyEndAd(adUnitId: adUnitId)
+    let delegate = EndDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.load()
+  }
+
+  @objc public func showEndAd(adObjectId: String) {
+    guard let ad = adMap[adObjectId] as? NovvyEndAd else { return }
+    guard let vc = Self.topViewController() else {
+      emit(adObjectId, ad.adUnitId, Ev.failed, error: "No active ViewController available")
+      return
+    }
+    ad.show(from: vc)
+  }
+
+  // MARK: - Scroll (inline feed)
+
+  @objc public func loadScrollAd(adUnitId: String, adObjectId: String, episodeNumber: NSNumber?) {
+    let ad = NovvyScrollAd(adUnitId: adUnitId, episode: episodeNumber?.intValue)
+    let delegate = ScrollDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.load()
+  }
+
+  @objc public func attachScrollAd(adObjectId: String, durationSeconds: NSNumber?, useDefaultSwipeOverlay: Bool) {
+    guard let ad = adMap[adObjectId] as? NovvyScrollAd,
+          let container = scrollContainerMap[adObjectId] else { return }
+    ad.attach(
+      to: container,
+      durationSeconds: durationSeconds?.intValue,
+      useDefaultSwipeOverlay: useDefaultSwipeOverlay,
+      onAdPlaybackTick: { [weak self] remaining in
+        self?.emit(adObjectId, "", Ev.playbackTick, remainingSeconds: remaining)
+      }
+    )
+  }
+
+  @objc public func setScrollAdPlaying(adObjectId: String, playing: Bool) {
+    (adMap[adObjectId] as? NovvyScrollAd)?.setPlaying(playing)
+  }
+
+  @objc public func detachScrollAd(adObjectId: String) {
+    (adMap[adObjectId] as? NovvyScrollAd)?.detach()
+    scrollContainerMap.removeValue(forKey: adObjectId)
+  }
+
+  // MARK: - Pause (realtime pause card)
+
+  @objc public func attachPauseAd(adUnitId: String, adObjectId: String, positionMs: Int64, isPlaying: Bool) {
+    guard let container = pauseContainerMap[adObjectId] else { return }
+    let adapter = RnPlayerAdapter()
+    adapter.currentPositionMs = positionMs
+    adapter.isPlaying = isPlaying
+    pauseAdapterMap[adObjectId] = adapter
+
+    let ad = NovvyPauseAd(adUnitId: adUnitId)
+    let delegate = PauseDelegate(emit: makeEmit(adObjectId, adUnitId))
+    ad.delegate = delegate
+    adMap[adObjectId] = ad
+    delegateMap[adObjectId] = delegate
+    ad.attach(to: container, player: adapter)
+  }
+
+  @objc public func updatePauseAdPlayerState(adObjectId: String, positionMs: Int64, isPlaying: Bool) {
+    guard let adapter = pauseAdapterMap[adObjectId] else { return }
+    adapter.currentPositionMs = positionMs
+    adapter.isPlaying = isPlaying
+  }
+
+  @objc public func detachPauseAd(adObjectId: String) {
+    (adMap[adObjectId] as? NovvyPauseAd)?.detach()
+    pauseContainerMap.removeValue(forKey: adObjectId)
+    pauseAdapterMap.removeValue(forKey: adObjectId)
+  }
+
+  // MARK: - Dispose
+
+  @objc public func disposeAd(adObjectId: String) {
+    switch adMap[adObjectId] {
+    case let ad as NovvyPauseAd:
+      ad.detach(); ad.destroy()
+      pauseContainerMap.removeValue(forKey: adObjectId)
+      pauseAdapterMap.removeValue(forKey: adObjectId)
+    case let ad as NovvyScrollAd:
+      ad.detach(); ad.destroy()
+      scrollContainerMap.removeValue(forKey: adObjectId)
+    case let ad as NovvyRewardedAd: ad.destroy()
+    case let ad as NovvyInterstitialAd: ad.destroy()
+    case let ad as NovvyMidAd: ad.destroy()
+    case let ad as NovvyEndAd: ad.destroy()
+    default: break
+    }
+    adMap.removeValue(forKey: adObjectId)
+    delegateMap.removeValue(forKey: adObjectId)
+  }
+
+  // MARK: - Platform view helpers (called by Fabric view classes)
+
+  @objc public func registerScrollContainer(adObjectId: String, container: UIView) {
+    scrollContainerMap[adObjectId] = container
+  }
+
+  @objc public func registerPauseContainer(adObjectId: String, container: UIView) {
+    pauseContainerMap[adObjectId] = container
+  }
+
+  @objc public func onScrollViewDisposed(adObjectId: String) {
+    detachScrollAd(adObjectId: adObjectId)
+  }
+
+  @objc public func onPauseViewDisposed(adObjectId: String) {
+    detachPauseAd(adObjectId: adObjectId)
+  }
+
+  // MARK: - Helpers
+
+  private static func topViewController() -> UIViewController? {
+    let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+    let activeScene = scenes.first(where: { $0.activationState == .foregroundActive }) ?? scenes.first
+    let keyWindow = activeScene?.windows.first(where: { $0.isKeyWindow }) ?? activeScene?.windows.first
+    var top = keyWindow?.rootViewController
+    while let presented = top?.presentedViewController {
+      top = presented
+    }
+    return top
+  }
+}
+
+// MARK: - NSDictionary parsing helpers
+
+private extension NSDictionary {
+  func optString(_ key: String) -> String? { self[key] as? String }
+  func optBool(_ key: String) -> Bool? { (self[key] as? NSNumber)?.boolValue }
+  func optInt(_ key: String) -> Int? { (self[key] as? NSNumber)?.intValue }
+
+  func toSdkUserContext() -> NovvyAds.NovvyUserContext {
+    NovvyAds.NovvyUserContext(
+      userId: optString("userId"),
+      hashedEmail: optString("hashedEmail"),
+      isPaidUser: optBool("isPaidUser"),
+      age: optInt("age"),
+      gender: optString("gender"),
+      dramaWatchHistory: (self["dramaWatchHistory"] as? [NSDictionary])?.toSdkRecords(),
+      maximumAdsInOneDrama: optInt("maximumAdsInOneDrama")
+    )
+  }
+}
+
+private extension Array where Element == NSDictionary {
+  func toSdkRecords() -> [NovvyAds.NovvyDramaRecord] {
+    compactMap { record in
+      guard let seriesId = record["seriesId"] as? String else { return nil }
+      return NovvyAds.NovvyDramaRecord(
+        dramaTitle: record["dramaTitle"] as? String,
+        seriesId: seriesId,
+        lastWatchedEpisode: (record["lastWatchedEpisode"] as? NSNumber)?.intValue ?? 0,
+        unlockedEpisode: (record["unlockedEpisode"] as? NSNumber)?.intValue ?? 0
+      )
+    }
+  }
+}
+
+// MARK: - Delegate adapters
+//
+// Each captures an `emit` closure translating SDK delegate callbacks into
+// event strings. Retained in `delegateMap` because the SDK holds delegates weakly.
+
+private final class InterstitialDelegate: NSObject, NovvyInterstitialAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func interstitialAdDidLoad(_ ad: NovvyInterstitialAd) { emit("loaded", nil, nil) }
+  func interstitialAd(_ ad: NovvyInterstitialAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func interstitialAdDidShow(_ ad: NovvyInterstitialAd) { emit("showed", nil, nil) }
+  func interstitialAdDidClose(_ ad: NovvyInterstitialAd) { emit("dismissed", nil, nil) }
+}
+
+private final class RewardedDelegate: NSObject, NovvyRewardedAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func rewardedAdDidLoad(_ ad: NovvyRewardedAd) { emit("loaded", nil, nil) }
+  func rewardedAd(_ ad: NovvyRewardedAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func rewardedAdDidShow(_ ad: NovvyRewardedAd) { emit("showed", nil, nil) }
+  func rewardedAd(_ ad: NovvyRewardedAd, didEarnReward reward: NovvyReward) { emit("earnedReward", nil, nil) }
+  func rewardedAdDidClose(_ ad: NovvyRewardedAd) { emit("dismissed", nil, nil) }
+}
+
+private final class MidDelegate: NSObject, NovvyMidAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func midAdDidLoad(_ ad: NovvyMidAd) { emit("loaded", nil, nil) }
+  func midAd(_ ad: NovvyMidAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func midAdDidShow(_ ad: NovvyMidAd) { emit("showed", nil, nil) }
+  func midAdDidClose(_ ad: NovvyMidAd) { emit("dismissed", nil, nil) }
+}
+
+private final class EndDelegate: NSObject, NovvyEndAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func endAdDidLoad(_ ad: NovvyEndAd) { emit("loaded", nil, nil) }
+  func endAd(_ ad: NovvyEndAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func endAdDidShow(_ ad: NovvyEndAd) { emit("showed", nil, nil) }
+  func endAdDidClose(_ ad: NovvyEndAd) { emit("dismissed", nil, nil) }
+}
+
+private final class ScrollDelegate: NSObject, NovvyScrollAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func scrollAdDidLoad(_ ad: NovvyScrollAd) { emit("loaded", nil, nil) }
+  func scrollAd(_ ad: NovvyScrollAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func scrollAdDidShow(_ ad: NovvyScrollAd) { emit("showed", nil, nil) }
+  func scrollAdDidClose(_ ad: NovvyScrollAd) { emit("hidden", nil, nil) }
+}
+
+private final class PauseDelegate: NSObject, NovvyPauseAdDelegate {
+  let emit: (String, String?, Int?) -> Void
+  init(emit: @escaping (String, String?, Int?) -> Void) { self.emit = emit }
+  func pauseAd(_ ad: NovvyPauseAd, didFailToLoadWithError error: NovvyError) { emit("failedToLoad", error.localizedDescription, nil) }
+  func pauseAdDidShow(_ ad: NovvyPauseAd) { emit("showed", nil, nil) }
+  func pauseAdDidFinish(_ ad: NovvyPauseAd) { emit("hidden", nil, nil) }
+}

package/ios/NovvyPauseAdView.mm

@@ -0,0 +1,79 @@
+#import "NovvyAdsReactNative-Swift.h"
+
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/NovvyAdsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/NovvyAdsSpec/EventEmitters.h>
+#import <react/renderer/components/NovvyAdsSpec/Props.h>
+#import <react/renderer/components/NovvyAdsSpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+/**
+ * Fabric component for the inline realtime pause-card ad container.
+ *
+ * Registers a transparent container with `NovvyAdsImpl` keyed by `adObjectId`,
+ * then fires `onViewReady` so JS issues `attachPauseAd` (no load step). Mirrors
+ * the Flutter plugin's `NovvyPausePlatformView`.
+ */
+@interface NovvyPauseAdView : RCTViewComponentView
+@end
+
+@implementation NovvyPauseAdView {
+  UIView *_container;
+  NSString *_adObjectId;
+  // Fabric calls `updateProps` BEFORE `updateEventEmitter`, so the emitter is
+  // nil at the moment we learn the adObjectId. Buffer the ready-emit and fire
+  // it from `finalizeUpdates:`, which runs after both are set.
+  BOOL _viewReadyPending;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<NovvyPauseAdViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const NovvyPauseAdViewProps>();
+    _props = defaultProps;
+    _container = [[UIView alloc] initWithFrame:self.bounds];
+    _container.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    _container.backgroundColor = UIColor.clearColor;
+    self.contentView = _container;
+  }
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<const NovvyPauseAdViewProps>(props);
+  NSString *adObjectId = [NSString stringWithUTF8String:newProps.adObjectId.c_str()];
+  if (adObjectId.length > 0 && ![adObjectId isEqualToString:_adObjectId]) {
+    _adObjectId = adObjectId;
+    [NovvyAdsImpl.shared registerPauseContainerWithAdObjectId:adObjectId container:_container];
+    _viewReadyPending = YES;
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+  if (_viewReadyPending && _eventEmitter && _adObjectId.length > 0) {
+    _viewReadyPending = NO;
+    auto emitter = std::static_pointer_cast<const NovvyPauseAdViewEventEmitter>(_eventEmitter);
+    emitter->onViewReady({.adObjectId = std::string(_adObjectId.UTF8String)});
+  }
+}
+
+- (void)prepareForRecycle {
+  if (_adObjectId != nil) {
+    [NovvyAdsImpl.shared onPauseViewDisposedWithAdObjectId:_adObjectId];
+    _adObjectId = nil;
+  }
+  _viewReadyPending = NO;
+  [super prepareForRecycle];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> NovvyPauseAdViewCls(void) {
+  return NovvyPauseAdView.class;
+}