@advergic-ads/react-native-sdk 1.0.0

package/ios/AdvergicReactNativeModule.swift

@@ -0,0 +1,363 @@
+//
+//  AdvergicReactNativeModule.swift
+//  AdvergicReactNative
+//
+//  React Native bridge for the Advergic iOS SDK.
+//  Exposed to JavaScript as `NativeModules.AdvergicSDK`, mirroring the
+//  Android `AdvergicReactNativeModule` so the shared TypeScript layer works
+//  identically on both platforms.
+//
+
+import Foundation
+import UIKit
+import React
+import AdvergicSDK
+
+@objc(AdvergicSDK)
+class AdvergicReactNativeModule: RCTEventEmitter {
+
+  // The native iOS SDK exposes a single delegate per instance, so we keep one
+  // shared instance and act as its delegate, fanning callbacks out to JS.
+  static weak var shared: AdvergicReactNativeModule?
+
+  private let sdk = AdvergicSdk()
+  private var hasListeners = false
+
+  // The iOS SDK callbacks don't echo back the ad unit id, so we remember the
+  // last requested id per format to attach it to emitted events.
+  private var lastInterstitialAdUnitId = ""
+  private var lastRewardedAdUnitId = ""
+  private var lastAppOpenAdUnitId = ""
+
+  // The currently mounted banner view, used to forward click / impression
+  // delegate callbacks (which are not tied to a specific banner by the SDK).
+  private weak var activeBannerView: AdvergicBannerView?
+
+  override init() {
+    super.init()
+    sdk.advergicDelegate = self
+    AdvergicReactNativeModule.shared = self
+  }
+
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  override func supportedEvents() -> [String]! {
+    return [
+      "OnSDKInitialized",
+      "OnBotDetectionResult",
+      "OnBannerAdLoaded",
+      "OnBannerAdFailedToLoad",
+      "OnBannerAdClicked",
+      "OnBannerAdImpression",
+      "OnInterstitialAdLoaded",
+      "OnInterstitialAdFailedToLoad",
+      "OnInterstitialAdShowed",
+      "OnInterstitialAdDismissed",
+      "OnInterstitialAdFailedToShow",
+      "OnInterstitialAdClicked",
+      "OnInterstitialAdImpression",
+      "OnRewardedAdLoaded",
+      "OnRewardedAdFailedToLoad",
+      "OnRewardedAdShowed",
+      "OnRewardedAdFailedToShow",
+      "OnRewardedAdOpened",
+      "OnRewardedAdClicked",
+      "OnRewardedAdClosed",
+      "OnUserEarnedReward",
+      "OnAppOpenAdLoaded",
+      "OnAppOpenAdFailedToLoad",
+      "OnAppOpenAdShowed",
+      "OnAppOpenAdDismissed",
+      "OnAppOpenAdFailedToShow",
+      "OnAppOpenAdClicked",
+      "OnAppOpenAdImpression",
+      "OnNativeAdLoaded",
+      "OnNativeAdFailedToLoad",
+      "OnNativeAdClicked",
+      "OnNativeAdImpression",
+      "OnNativePrebidAdNotFound",
+      "OnNativePrebidAdNotValid",
+    ]
+  }
+
+  override func startObserving() {
+    hasListeners = true
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+  }
+
+  private func emit(_ name: String, _ body: [String: Any]) {
+    guard hasListeners else { return }
+    sendEvent(withName: name, body: body)
+  }
+
+  private func adUnitBody(_ adUnitId: String) -> [String: Any] {
+    return ["adUnitId": adUnitId]
+  }
+
+  private func errorBody(_ adUnitId: String, _ error: String) -> [String: Any] {
+    return ["adUnitId": adUnitId, "error": error]
+  }
+
+  // MARK: - View controller helper
+
+  static func topViewController() -> UIViewController? {
+    var keyWindow: UIWindow?
+    keyWindow = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }
+      .first { $0.isKeyWindow }
+    if keyWindow == nil {
+      keyWindow = UIApplication.shared.windows.first { $0.isKeyWindow }
+    }
+    var top = keyWindow?.rootViewController
+    while let presented = top?.presentedViewController {
+      top = presented
+    }
+    return top
+  }
+
+  // MARK: - Initialization
+
+  @objc(initialize:resolver:rejecter:)
+  func initialize(_ apiKey: String,
+                  resolver resolve: @escaping RCTPromiseResolveBlock,
+                  rejecter reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      self.sdk.Init(apiKey: apiKey)
+      // The iOS SDK loads its config asynchronously and exposes no completion
+      // callback, so we poll for ad units to mirror the Android contract of
+      // resolving `true` once the SDK is ready to serve.
+      self.waitForInit(attempt: 0, resolve: resolve)
+    }
+  }
+
+  private func waitForInit(attempt: Int, resolve: @escaping RCTPromiseResolveBlock) {
+    let units = sdk.getAdvergicAdUnits()
+    if !units.isEmpty {
+      emit("OnSDKInitialized", ["initialized": true, "adUnitCount": units.count])
+      resolve(true)
+      return
+    }
+    // ~12s budget (40 * 300ms) before giving up and resolving anyway.
+    if attempt >= 40 {
+      resolve(true)
+      return
+    }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+      self.waitForInit(attempt: attempt + 1, resolve: resolve)
+    }
+  }
+
+  @objc(canServeAds:rejecter:)
+  func canServeAds(_ resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+    resolve(!sdk.getAdvergicAdUnits().isEmpty)
+  }
+
+  @objc(getAdUnits:rejecter:)
+  func getAdUnits(_ resolve: @escaping RCTPromiseResolveBlock,
+                  rejecter reject: @escaping RCTPromiseRejectBlock) {
+    let result: [[String: Any]] = sdk.getAdvergicAdUnits().map { unit in
+      return [
+        "id": unit.configID,
+        "name": unit.configID,
+        "type": unit.adUnitType,
+      ]
+    }
+    resolve(result)
+  }
+
+  @objc(performFollowUpBotDetection)
+  func performFollowUpBotDetection() {
+    // Bot detection runs automatically inside the iOS SDK after init; there is
+    // no public trigger, so this is a no-op for API parity with Android.
+  }
+
+  // MARK: - Banner (called by AdvergicBannerView)
+
+  func loadBanner(adUnitId: String,
+                  container: UIView,
+                  onLoaded: @escaping () -> Void,
+                  onFailed: @escaping (String) -> Void) {
+    activeBannerView = container as? AdvergicBannerView
+    attemptLoadBanner(adUnitId: adUnitId, container: container, attempt: 0,
+                      onLoaded: onLoaded, onFailed: onFailed)
+  }
+
+  private let maxBannerRetries = 10
+
+  private func attemptLoadBanner(adUnitId: String,
+                                 container: UIView,
+                                 attempt: Int,
+                                 onLoaded: @escaping () -> Void,
+                                 onFailed: @escaping (String) -> Void) {
+    // The SDK silently ignores requests before its config is loaded, so retry
+    // until ad units are available (mirrors the Android banner retry logic).
+    if sdk.getAdvergicAdUnits().isEmpty {
+      if attempt >= maxBannerRetries {
+        onFailed("AdvergicSDK not initialized")
+        return
+      }
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.3 * Double(attempt + 1)) {
+        self.attemptLoadBanner(adUnitId: adUnitId, container: container,
+                               attempt: attempt + 1, onLoaded: onLoaded, onFailed: onFailed)
+      }
+      return
+    }
+
+    guard let vc = AdvergicReactNativeModule.topViewController() else {
+      onFailed("No view controller available")
+      return
+    }
+
+    sdk.showBannerAd(adUnitID: adUnitId, viewController: vc, bannerAdView: container) { bannerView, error in
+      if bannerView != nil {
+        onLoaded()
+      } else {
+        onFailed(error?.localizedDescription ?? "Unknown error")
+      }
+    }
+  }
+
+  // Low-level banner API (parity with Android's showBannerAd(adUnitId,
+  // containerId)). The primary path is the `AdvergicBannerAd` component, which
+  // loads automatically; this resolves a container by its React tag and loads
+  // into it, emitting global banner events.
+  @objc(showBannerAd:containerId:)
+  func showBannerAd(_ adUnitId: String, containerId: NSNumber) {
+    bridge.uiManager.addUIBlock { [weak self] _, viewRegistry in
+      guard let self = self else { return }
+      guard let view = viewRegistry?[containerId] else {
+        self.emit("OnBannerAdFailedToLoad", self.errorBody(adUnitId, "Container not found"))
+        return
+      }
+      self.loadBanner(adUnitId: adUnitId, container: view, onLoaded: {
+        self.emit("OnBannerAdLoaded", self.adUnitBody(adUnitId))
+      }, onFailed: { error in
+        self.emit("OnBannerAdFailedToLoad", self.errorBody(adUnitId, error))
+      })
+    }
+  }
+
+  // MARK: - Full-screen formats
+
+  @objc(showInterstitialAd:)
+  func showInterstitialAd(_ adUnitId: String) {
+    DispatchQueue.main.async {
+      guard let vc = AdvergicReactNativeModule.topViewController() else {
+        self.emit("OnInterstitialAdFailedToLoad", self.errorBody(adUnitId, "No view controller available"))
+        return
+      }
+      self.lastInterstitialAdUnitId = adUnitId
+      self.sdk.showInterstitialAd(adUnitID: adUnitId, viewController: vc)
+    }
+  }
+
+  @objc(showRewardedAd:)
+  func showRewardedAd(_ adUnitId: String) {
+    DispatchQueue.main.async {
+      guard let vc = AdvergicReactNativeModule.topViewController() else {
+        self.emit("OnRewardedAdFailedToLoad", self.errorBody(adUnitId, "No view controller available"))
+        return
+      }
+      self.lastRewardedAdUnitId = adUnitId
+      self.sdk.showRewardedAd(adUnitID: adUnitId, viewController: vc)
+    }
+  }
+
+  @objc(showAppOpenAd:)
+  func showAppOpenAd(_ adUnitId: String) {
+    DispatchQueue.main.async {
+      guard let vc = AdvergicReactNativeModule.topViewController() else {
+        self.emit("OnAppOpenAdFailedToLoad", self.errorBody(adUnitId, "No view controller available"))
+        return
+      }
+      self.lastAppOpenAdUnitId = adUnitId
+      self.sdk.showAppOpenAd(adUnitID: adUnitId, viewController: vc)
+    }
+  }
+
+  @objc(showNativeAd:containerId:)
+  func showNativeAd(_ adUnitId: String, containerId: NSNumber) {
+    // Native ads are not supported by the iOS SDK (Android-only). Emit a
+    // failure so callers using the shared JS API get a clear signal.
+    emit("OnNativeAdFailedToLoad", errorBody(adUnitId, "Native ads are not supported on iOS"))
+  }
+}
+
+// MARK: - AdvergicSdkProtocols
+
+extension AdvergicReactNativeModule: AdvergicSdkProtocols {
+
+  // Banner — loaded / failed are handled via the showBannerAd completion in the
+  // banner view; click / impression are only delivered through this delegate,
+  // so we forward them to the active banner view's bubbling events.
+  func advergicBannerDidRecordImpression() {
+    activeBannerView?.dispatchImpression()
+  }
+
+  func advergicBannerAdDidClick() {
+    activeBannerView?.dispatchClicked()
+  }
+
+  // Interstitial
+  func advergicInterstitialDidDissmissAd() {
+    emit("OnInterstitialAdDismissed", adUnitBody(lastInterstitialAdUnitId))
+  }
+
+  func advergicInterstitialFailToShowFullScreenContent(adError: String) {
+    emit("OnInterstitialAdFailedToShow", errorBody(lastInterstitialAdUnitId, adError))
+  }
+
+  func advergicInterstitialDidClickAd() {
+    emit("OnInterstitialAdClicked", adUnitBody(lastInterstitialAdUnitId))
+  }
+
+  func advergicInterstitialDidRecordImpressionAd() {
+    emit("OnInterstitialAdImpression", adUnitBody(lastInterstitialAdUnitId))
+  }
+
+  // Rewarded
+  func advergicRewardReceived() {
+    emit("OnUserEarnedReward", adUnitBody(lastRewardedAdUnitId))
+  }
+
+  func advergicRewardDidDissmissFullScreen() {
+    emit("OnRewardedAdClosed", adUnitBody(lastRewardedAdUnitId))
+  }
+
+  func advergicRewardFailToPresentFullScreenContent(adError: String) {
+    emit("OnRewardedAdFailedToShow", errorBody(lastRewardedAdUnitId, adError))
+  }
+
+  func advergicRewardDidRecordImpression() {
+    emit("OnRewardedAdShowed", adUnitBody(lastRewardedAdUnitId))
+  }
+
+  func advergicRewardDidRecordClick() {
+    emit("OnRewardedAdClicked", adUnitBody(lastRewardedAdUnitId))
+  }
+
+  // App Open
+  func advergicAppOpenDidDissmissFullScreen() {
+    emit("OnAppOpenAdDismissed", adUnitBody(lastAppOpenAdUnitId))
+  }
+
+  func advergicAppOpenFailToPresentFullScreenContent(adError: String) {
+    emit("OnAppOpenAdFailedToShow", errorBody(lastAppOpenAdUnitId, adError))
+  }
+
+  func advergicAppOpenDidRecordImpression() {
+    emit("OnAppOpenAdImpression", adUnitBody(lastAppOpenAdUnitId))
+  }
+
+  func advergicAppOpenDidRecordClick() {
+    emit("OnAppOpenAdClicked", adUnitBody(lastAppOpenAdUnitId))
+  }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@advergic-ads/react-native-sdk",
+  "version": "1.0.0",
+  "description": "Advergic React Native SDK - Integrate Prebid header bidding and mobile advertising into your React Native apps",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "install": "node install.js"
+  },
+  "keywords": [
+    "react-native",
+    "advergic",
+    "advertising",
+    "ads",
+    "banner",
+    "interstitial",
+    "rewarded",
+    "mobile-ads",
+    "admob",
+    "prebid"
+  ],
+  "author": "Advergic <hello@advergic.com>",
+  "license": "MIT",
+  "homepage": "https://advergic.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/advergic/react-native-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/advergic/react-native-sdk/issues"
+  },
+  "peerDependencies": {
+    "react-native": "^0.85.3"
+  },
+  "dependencies": {
+    "react-native-safe-area-context": "^4.12.0"
+  },
+  "devDependencies": {
+    "@types/react-native": "^0.73.0"
+  },
+  "files": [
+    "src/",
+    "android/",
+    "ios/",
+    "install.js",
+    "index.js",
+    "index.d.ts",
+    "react-native.config.js",
+    "AdvergicReactNative.podspec",
+    "SPEC.md",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  project: {
+    ios: {},
+    android: {},
+  },
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: "android/advergic-bridge",
+        packageImportPath: "import com.advergic.reactnative.AdvergicReactNativePackage;",
+        packageInstance: "new AdvergicReactNativePackage()",
+      },
+      ios: {
+        podspecPath: "AdvergicReactNative.podspec",
+      },
+    },
+  },
+};

package/src/advergic/AdvergicBannerAd.tsx

@@ -0,0 +1,51 @@
+import type { NativeSyntheticEvent, ViewStyle } from 'react-native';
+import React from 'react';
+import { requireNativeComponent } from 'react-native';
+
+interface NativeProps {
+  adUnitId?: string;
+  style?: ViewStyle;
+  onAdLoaded?: () => void;
+  onAdFailedToLoad?: (event: NativeSyntheticEvent<{ error: string }>) => void;
+  onAdClicked?: () => void;
+  onAdImpression?: () => void;
+}
+
+const NativeAdvergicBannerView =
+  requireNativeComponent<NativeProps>('AdvergicBannerView');
+
+interface AdvergicBannerAdProps {
+  adUnitId: string;
+  style?: ViewStyle;
+  onAdLoaded?: () => void;
+  onAdFailedToLoad?: (error: string) => void;
+  onAdClicked?: () => void;
+  onAdImpression?: () => void;
+}
+
+export function AdvergicBannerAd({
+  adUnitId,
+  style,
+  onAdLoaded,
+  onAdFailedToLoad,
+  onAdClicked,
+  onAdImpression,
+}: AdvergicBannerAdProps) {
+  const handleFailedToLoad = React.useCallback(
+    (event: NativeSyntheticEvent<{ error: string }>) => {
+      onAdFailedToLoad?.(event.nativeEvent.error);
+    },
+    [onAdFailedToLoad],
+  );
+
+  return (
+    <NativeAdvergicBannerView
+      adUnitId={adUnitId}
+      style={style}
+      onAdLoaded={onAdLoaded}
+      onAdFailedToLoad={handleFailedToLoad}
+      onAdClicked={onAdClicked}
+      onAdImpression={onAdImpression}
+    />
+  );
+}