react-native-liftoffads 0.0.1

package/android/src/main/java/com/margelo/nitro/liftoffads/LiftoffAdEventEmitter.kt

@@ -0,0 +1,51 @@
+package com.margelo.nitro.liftoffads
+
+internal class LiftoffAdEventEmitter {
+  private val lock = Any()
+  private val listeners = mutableMapOf<Double, Listener>()
+  private var nextSubscriptionId = 1.0
+
+  fun add(
+    eventType: LiftoffAdEventType,
+    listener: (payload: LiftoffAdEventPayload?) -> Unit,
+  ): Double = synchronized(lock) {
+    val subscriptionId = nextSubscriptionId++
+    listeners[subscriptionId] = Listener(eventType, listener)
+    subscriptionId
+  }
+
+  fun remove(subscriptionId: Double) {
+    synchronized(lock) { listeners.remove(subscriptionId) }
+  }
+
+  fun removeAll() {
+    synchronized(lock) { listeners.clear() }
+  }
+
+  fun emit(
+    eventType: LiftoffAdEventType,
+    payload: LiftoffAdEventPayload? = null,
+  ) {
+    val callbacks = synchronized(lock) {
+      listeners.values
+        .filter { it.eventType == eventType }
+        .map { it.callback }
+    }
+    callbacks.forEach { callback -> runCatching { callback(payload) } }
+  }
+
+  private data class Listener(
+    val eventType: LiftoffAdEventType,
+    val callback: (payload: LiftoffAdEventPayload?) -> Unit,
+  )
+}
+
+internal fun Throwable.toLiftoffEventPayload(): LiftoffAdEventPayload {
+  val vungleError =
+    this as? com.vungle.ads.VungleError
+      ?: cause as? com.vungle.ads.VungleError
+  return LiftoffAdEventPayload(
+    errorCode = vungleError?.code?.toDouble(),
+    errorMessage = message ?: localizedMessage,
+  )
+}

package/android/src/main/java/com/margelo/nitro/liftoffads/LiftoffAndroidUtils.kt

@@ -0,0 +1,54 @@
+package com.margelo.nitro.liftoffads
+
+import android.app.Activity
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.vungle.ads.VungleError
+import java.lang.ref.WeakReference
+
+internal fun ReactApplicationContext.requireCurrentActivity(): Activity =
+  currentActivity ?: error("Cannot show Liftoff ad without an active Activity")
+
+internal class ImmersiveModeController {
+  private var activityReference: WeakReference<Activity>? = null
+  private var previousSystemUiVisibility: Int? = null
+
+  fun enable(activity: Activity) {
+    restore()
+
+    @Suppress("DEPRECATION")
+    val decorView = activity.window.decorView
+    @Suppress("DEPRECATION")
+    previousSystemUiVisibility = decorView.systemUiVisibility
+    activityReference = WeakReference(activity)
+
+    @Suppress("DEPRECATION")
+    decorView.systemUiVisibility =
+      View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY or
+        View.SYSTEM_UI_FLAG_FULLSCREEN or
+        View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
+        View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
+        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+        View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+  }
+
+  fun restore() {
+    val activity = activityReference?.get()
+    val visibility = previousSystemUiVisibility
+    activityReference = null
+    previousSystemUiVisibility = null
+
+    if (activity != null && visibility != null) {
+      activity.runOnUiThread {
+        @Suppress("DEPRECATION")
+        activity.window.decorView.systemUiVisibility = visibility
+      }
+    }
+  }
+}
+
+internal fun liftoffException(stage: String, error: VungleError) =
+  IllegalStateException(
+    "Liftoff $stage failed (${error.code}): ${error.localizedMessage}",
+    error,
+  )

package/android/src/main/java/com/margelo/nitro/liftoffads/NitroLiftoffAdsPackage.java

@@ -0,0 +1,27 @@
+package com.margelo.nitro.liftoffads;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+
+public class NitroLiftoffAdsPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return HashMap::new;
+  }
+
+  static {
+    NitroLiftoffAdsOnLoad.initializeNative();
+  }
+}

package/ios/HybridLiftoffAds.swift

@@ -0,0 +1,113 @@
+import Foundation
+import NitroModules
+import VungleAdsSDK
+
+final class HybridLiftoffAds: HybridLiftoffAdsSpec, @unchecked Sendable {
+  private let stateLock = NSLock()
+  private var initializedAppId: String?
+  private var initializingAppId: String?
+  private var initializationContinuations: [CheckedContinuation<Void, Error>] = []
+  private var isInitializing = false
+
+  func initialize(appId: String) throws -> Promise<Void> {
+    guard !appId.isEmpty else {
+      throw liftoffError("Liftoff app ID is empty")
+    }
+
+    return Promise.async {
+      try await withCheckedThrowingContinuation { continuation in
+        DispatchQueue.main.async {
+          self.stateLock.lock()
+          if VungleAds.isInitialized() {
+            let existing = self.initializedAppId
+            if existing == nil { self.initializedAppId = appId }
+            self.stateLock.unlock()
+
+            if let existing, existing != appId {
+              continuation.resume(
+                throwing: liftoffError("Liftoff SDK was initialized with another app ID")
+              )
+            } else {
+              continuation.resume()
+            }
+            return
+          }
+
+          if self.isInitializing, self.initializingAppId != appId {
+            self.stateLock.unlock()
+            continuation.resume(
+              throwing: liftoffError("Liftoff SDK is being initialized with another app ID")
+            )
+            return
+          }
+
+          self.initializationContinuations.append(continuation)
+          if self.isInitializing {
+            self.stateLock.unlock()
+            return
+          }
+
+          self.isInitializing = true
+          self.initializingAppId = appId
+          self.stateLock.unlock()
+
+          VungleAds.initWithAppId(appId) { error in
+            self.stateLock.lock()
+            let continuations = self.initializationContinuations
+            self.initializationContinuations.removeAll()
+            self.isInitializing = false
+            self.initializingAppId = nil
+            if error == nil { self.initializedAppId = appId }
+            self.stateLock.unlock()
+
+            continuations.forEach { item in
+              if let error {
+                item.resume(throwing: error)
+              } else {
+                item.resume()
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  func setGDPRConsent(optIn: Bool, consentMessageVersion: String) throws {
+    runOnMain {
+      VunglePrivacySettings.setGDPRStatus(optIn)
+      VunglePrivacySettings.setGDPRMessageVersion(consentMessageVersion)
+    }
+  }
+
+  func setCCPAConsent(optIn: Bool) throws {
+    runOnMain { VunglePrivacySettings.setCCPAStatus(optIn) }
+  }
+
+  func setCOPPA(isUserCoppa: Bool) throws {
+    runOnMain { VunglePrivacySettings.setCOPPAStatus(isUserCoppa) }
+  }
+
+  func createInterstitialAd(
+    placementId: String
+  ) throws -> any HybridLiftoffInterstitialAdSpec {
+    try requireInitialized(placementId: placementId)
+    return HybridLiftoffInterstitialAd(placementId: placementId)
+  }
+
+  func createRewardedAd(
+    placementId: String
+  ) throws -> any HybridLiftoffRewardedAdSpec {
+    try requireInitialized(placementId: placementId)
+    return HybridLiftoffRewardedAd(placementId: placementId)
+  }
+
+  private func requireInitialized(placementId: String) throws {
+    guard VungleAds.isInitialized() else {
+      throw liftoffError("Liftoff SDK is not initialized")
+    }
+    guard !placementId.isEmpty else {
+      throw liftoffError("Liftoff placement ID is empty")
+    }
+  }
+}

package/ios/HybridLiftoffInterstitialAd.swift

@@ -0,0 +1,98 @@
+import Foundation
+import NitroModules
+import VungleAdsSDK
+
+final class HybridLiftoffInterstitialAd:
+  HybridLiftoffInterstitialAdSpec, @unchecked Sendable {
+  fileprivate let events = LiftoffAdEventEmitter()
+  private let ad: VungleInterstitial
+  private lazy var delegate = LiftoffInterstitialDelegate(owner: self)
+
+  init(placementId: String) {
+    self.ad = VungleInterstitial(placementId: placementId)
+    super.init()
+    self.ad.delegate = delegate
+  }
+
+  func load() throws {
+    DispatchQueue.main.async { self.ad.load() }
+  }
+
+  func show(options: LiftoffAdShowOptions?) throws -> Promise<Void> {
+    Promise.async {
+      do {
+        let viewController = try await currentViewController()
+        try await withCheckedThrowingContinuation {
+          (continuation: CheckedContinuation<Void, Error>) in
+          DispatchQueue.main.async {
+            guard self.ad.canPlayAd() else {
+              continuation.resume(
+                throwing: liftoffError("Liftoff interstitial ad is not ready")
+              )
+              return
+            }
+            self.ad.present(with: viewController)
+            continuation.resume()
+          }
+        }
+      } catch {
+        self.events.emit(.error, error: error)
+        throw error
+      }
+    }
+  }
+
+  func addAdEventListener(
+    eventType: LiftoffAdEventType,
+    listener: @escaping (LiftoffAdEventPayload?) -> Void
+  ) throws -> Double {
+    events.add(eventType: eventType, listener: listener)
+  }
+
+  func removeAdEventListener(subscriptionId: Double) throws {
+    events.remove(subscriptionId: subscriptionId)
+  }
+
+  func removeAllListeners() throws {
+    events.removeAll()
+  }
+
+}
+
+private final class LiftoffInterstitialDelegate: NSObject, VungleInterstitialDelegate {
+  private weak var owner: HybridLiftoffInterstitialAd?
+
+  init(owner: HybridLiftoffInterstitialAd) {
+    self.owner = owner
+  }
+
+  func interstitialAdDidLoad(_ interstitial: VungleInterstitial) {
+    owner?.events.emit(.loaded)
+  }
+
+  func interstitialAdDidFailToLoad(
+    _ interstitial: VungleInterstitial,
+    withError error: NSError
+  ) {
+    owner?.events.emit(.error, error: error)
+  }
+
+  func interstitialAdDidFailToPresent(
+    _ interstitial: VungleInterstitial,
+    withError error: NSError
+  ) {
+    owner?.events.emit(.error, error: error)
+  }
+
+  func interstitialAdDidPresent(_ interstitial: VungleInterstitial) {
+    owner?.events.emit(.opened)
+  }
+
+  func interstitialAdDidClick(_ interstitial: VungleInterstitial) {
+    owner?.events.emit(.clicked)
+  }
+
+  func interstitialAdDidClose(_ interstitial: VungleInterstitial) {
+    owner?.events.emit(.closed)
+  }
+}

package/ios/HybridLiftoffRewardedAd.swift

@@ -0,0 +1,100 @@
+import Foundation
+import NitroModules
+import VungleAdsSDK
+
+final class HybridLiftoffRewardedAd:
+  HybridLiftoffRewardedAdSpec, @unchecked Sendable {
+  fileprivate let events = LiftoffAdEventEmitter()
+  private let ad: VungleRewarded
+  private lazy var delegate = LiftoffRewardedDelegate(owner: self)
+
+  init(placementId: String) {
+    self.ad = VungleRewarded(placementId: placementId)
+    super.init()
+    self.ad.delegate = delegate
+  }
+
+  func load() throws {
+    DispatchQueue.main.async { self.ad.load() }
+  }
+
+  func setUserId(userId: String) throws {
+    DispatchQueue.main.async { self.ad.setUserId(userId: userId) }
+  }
+
+  func show(options: LiftoffAdShowOptions?) throws -> Promise<Void> {
+    Promise.async {
+      do {
+        let viewController = try await currentViewController()
+        try await withCheckedThrowingContinuation {
+          (continuation: CheckedContinuation<Void, Error>) in
+          DispatchQueue.main.async {
+            guard self.ad.canPlayAd() else {
+              continuation.resume(
+                throwing: liftoffError("Liftoff rewarded ad is not ready")
+              )
+              return
+            }
+            self.ad.present(with: viewController)
+            continuation.resume()
+          }
+        }
+      } catch {
+        self.events.emit(.error, error: error)
+        throw error
+      }
+    }
+  }
+
+  func addAdEventListener(
+    eventType: LiftoffAdEventType,
+    listener: @escaping (LiftoffAdEventPayload?) -> Void
+  ) throws -> Double {
+    events.add(eventType: eventType, listener: listener)
+  }
+
+  func removeAdEventListener(subscriptionId: Double) throws {
+    events.remove(subscriptionId: subscriptionId)
+  }
+
+  func removeAllListeners() throws {
+    events.removeAll()
+  }
+
+}
+
+private final class LiftoffRewardedDelegate: NSObject, VungleRewardedDelegate {
+  private weak var owner: HybridLiftoffRewardedAd?
+
+  init(owner: HybridLiftoffRewardedAd) {
+    self.owner = owner
+  }
+
+  func rewardedAdDidLoad(_ rewarded: VungleRewarded) {
+    owner?.events.emit(.rewardedLoaded)
+  }
+
+  func rewardedAdDidFailToLoad(_ rewarded: VungleRewarded, withError error: NSError) {
+    owner?.events.emit(.error, error: error)
+  }
+
+  func rewardedAdDidFailToPresent(_ rewarded: VungleRewarded, withError error: NSError) {
+    owner?.events.emit(.error, error: error)
+  }
+
+  func rewardedAdDidPresent(_ rewarded: VungleRewarded) {
+    owner?.events.emit(.opened)
+  }
+
+  func rewardedAdDidClick(_ rewarded: VungleRewarded) {
+    owner?.events.emit(.clicked)
+  }
+
+  func rewardedAdDidRewardUser(_ rewarded: VungleRewarded) {
+    owner?.events.emit(.rewardedEarnedReward)
+  }
+
+  func rewardedAdDidClose(_ rewarded: VungleRewarded) {
+    owner?.events.emit(.closed)
+  }
+}

package/ios/LiftoffSupport.swift

@@ -0,0 +1,106 @@
+import Foundation
+import UIKit
+
+let liftoffErrorDomain = "NitroLiftoffAds"
+
+func liftoffError(_ message: String, code: Int = 1) -> NSError {
+  NSError(
+    domain: liftoffErrorDomain,
+    code: code,
+    userInfo: [NSLocalizedDescriptionKey: message]
+  )
+}
+
+func runOnMain(_ body: @escaping () -> Void) {
+  if Thread.isMainThread {
+    body()
+  } else {
+    DispatchQueue.main.sync(execute: body)
+  }
+}
+
+func currentViewController() async throws -> UIViewController {
+  try await withCheckedThrowingContinuation { continuation in
+    DispatchQueue.main.async {
+      let root = UIApplication.shared.connectedScenes
+        .compactMap { $0 as? UIWindowScene }
+        .flatMap(\.windows)
+        .first(where: \.isKeyWindow)?
+        .rootViewController
+
+      guard let root else {
+        continuation.resume(
+          throwing: liftoffError("Cannot show Liftoff ad without a view controller")
+        )
+        return
+      }
+      continuation.resume(returning: topViewController(root))
+    }
+  }
+}
+
+private func topViewController(_ viewController: UIViewController) -> UIViewController {
+  if let presented = viewController.presentedViewController {
+    return topViewController(presented)
+  }
+  if let navigation = viewController as? UINavigationController,
+     let visible = navigation.visibleViewController {
+    return topViewController(visible)
+  }
+  if let tab = viewController as? UITabBarController,
+     let selected = tab.selectedViewController {
+    return topViewController(selected)
+  }
+  return viewController
+}
+
+final class LiftoffAdEventEmitter {
+  typealias Listener = (LiftoffAdEventPayload?) -> Void
+
+  private let lock = NSLock()
+  private var listeners: [Double: (eventType: String, listener: Listener)] = [:]
+  private var nextSubscriptionId = 1.0
+
+  func add(eventType: LiftoffAdEventType, listener: @escaping Listener) -> Double {
+    lock.lock()
+    defer { lock.unlock() }
+
+    let subscriptionId = nextSubscriptionId
+    nextSubscriptionId += 1
+    listeners[subscriptionId] = (eventType.stringValue, listener)
+    return subscriptionId
+  }
+
+  func remove(subscriptionId: Double) {
+    lock.lock()
+    listeners.removeValue(forKey: subscriptionId)
+    lock.unlock()
+  }
+
+  func removeAll() {
+    lock.lock()
+    listeners.removeAll()
+    lock.unlock()
+  }
+
+  func emit(
+    _ eventType: LiftoffAdEventType,
+    error: Error? = nil,
+    payload: LiftoffAdEventPayload? = nil
+  ) {
+    lock.lock()
+    let callbacks = listeners.values
+      .filter { $0.eventType == eventType.stringValue }
+      .map(\.listener)
+    lock.unlock()
+
+    let resolvedPayload = payload ?? error.map { error in
+      let nsError = error as NSError
+      return LiftoffAdEventPayload(
+        errorCode: Double(nsError.code),
+        errorMessage: nsError.localizedDescription
+      )
+    }
+    callbacks.forEach { $0(resolvedPayload) }
+  }
+}