react-native-pangleads 0.1.0

package/android/src/main/java/com/margelo/nitro/pangleads/HybridPangleRewardedAd.kt

@@ -0,0 +1,139 @@
+package com.margelo.nitro.pangleads
+
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.Keep
+import com.bytedance.sdk.openadsdk.api.init.PAGConfig
+import com.bytedance.sdk.openadsdk.api.reward.PAGRewardItem
+import com.bytedance.sdk.openadsdk.api.reward.PAGRewardedAd
+import com.bytedance.sdk.openadsdk.api.reward.PAGRewardedAdInteractionListener
+import com.bytedance.sdk.openadsdk.api.reward.PAGRewardedAdLoadListener
+import com.bytedance.sdk.openadsdk.api.reward.PAGRewardedRequest
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@DoNotStrip
+@Keep
+class HybridPangleRewardedAd(
+  private val context: ReactApplicationContext,
+  private val placementId: String,
+) : HybridPangleRewardedAdSpec(), PAGRewardedAdInteractionListener {
+  private val events = PangleAdEventEmitter()
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private var ad: PAGRewardedAd? = null
+  private var showTimeout: Runnable? = null
+
+  override fun load(verification: PangleAdVerificationOptions?) {
+    context.runOnUiQueueThread {
+      // Pangle's S2S reward callback fills `user_id` from this SDK-wide
+      // setting, not from PAGRewardedRequest.extraInfo — without it Pangle
+      // reports the callback with its own placeholder user id.
+      verification?.userId?.takeIf { it.isNotEmpty() }?.let(PAGConfig::setUserData)
+      val request = buildRewardedRequest(verification)
+      PAGRewardedAd.loadAd(
+        placementId,
+        request,
+        object : PAGRewardedAdLoadListener {
+          override fun onError(code: Int, message: String) {
+            mainHandler.post {
+              events.emit(
+                PangleAdEventType.ERROR,
+                pangleException("load", code, message).toPangleEventPayload(),
+              )
+            }
+          }
+
+          override fun onAdLoaded(rewardedAd: PAGRewardedAd) {
+            mainHandler.post {
+              rewardedAd.setAdInteractionListener(this@HybridPangleRewardedAd)
+              ad = rewardedAd
+              events.emit(PangleAdEventType.REWARDED_LOADED)
+            }
+          }
+        },
+      )
+    }
+  }
+
+  private fun buildRewardedRequest(verification: PangleAdVerificationOptions?): PAGRewardedRequest {
+    val request = PAGRewardedRequest()
+    val extraInfo = extraInfoFrom(verification)
+    if (extraInfo.isNotEmpty()) {
+      request.extraInfo = extraInfo
+    }
+    return request
+  }
+
+  private fun extraInfoFrom(verification: PangleAdVerificationOptions?): Map<String, String> = buildMap {
+    verification?.userId?.takeIf { it.isNotEmpty() }?.let { put("userId", it) }
+    verification?.customData?.takeIf { it.isNotEmpty() }?.let { put("customData", it) }
+  }
+
+  override fun show(): Promise<Unit> = Promise.async {
+    withContext(Dispatchers.Main) {
+      val activity = context.requireCurrentActivity()
+      val current = ad ?: error("Pangle rewarded ad is not ready")
+      armShowTimeout()
+      current.show(activity)
+    }
+  }
+
+  override fun addAdEventListener(
+    eventType: PangleAdEventType,
+    listener: (payload: PangleAdEventPayload?) -> Unit,
+  ) = events.add(eventType, listener)
+
+  override fun removeAdEventListener(subscriptionId: Double) {
+    events.remove(subscriptionId)
+  }
+
+  override fun removeAllListeners() {
+    events.removeAll()
+  }
+
+  override fun onAdShowed() {
+    disarmShowTimeout()
+    events.emit(PangleAdEventType.OPENED)
+  }
+
+  override fun onAdClicked() {
+    events.emit(PangleAdEventType.CLICKED)
+  }
+
+  override fun onAdDismissed() {
+    disarmShowTimeout()
+    ad = null
+    events.emit(PangleAdEventType.CLOSED)
+  }
+
+  override fun onUserEarnedReward(rewardItem: PAGRewardItem) {
+    disarmShowTimeout()
+    events.emit(PangleAdEventType.REWARDED_EARNED_REWARD)
+  }
+
+  override fun onUserEarnedRewardFail(errorCode: Int, errorMsg: String) {
+    events.emit(
+      PangleAdEventType.ERROR,
+      pangleException("reward", errorCode, errorMsg).toPangleEventPayload(),
+    )
+  }
+
+  private fun armShowTimeout() {
+    disarmShowTimeout()
+    val runnable = Runnable {
+      showTimeout = null
+      ad = null
+      events.emit(PangleAdEventType.ERROR, pangleShowTimeoutPayload())
+    }
+    showTimeout = runnable
+    mainHandler.postDelayed(runnable, PANGLE_SHOW_TIMEOUT_MS)
+  }
+
+  private fun disarmShowTimeout() {
+    showTimeout?.let(mainHandler::removeCallbacks)
+    showTimeout = null
+  }
+}

package/android/src/main/java/com/margelo/nitro/pangleads/NitroPangleAdsPackage.java

@@ -0,0 +1,27 @@
+package com.margelo.nitro.pangleads;
+
+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 NitroPangleAdsPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return HashMap::new;
+  }
+
+  static {
+    NitroPangleAdsOnLoad.initializeNative();
+  }
+}

package/android/src/main/java/com/margelo/nitro/pangleads/PangleAdEventEmitter.kt

@@ -0,0 +1,41 @@
+package com.margelo.nitro.pangleads
+
+internal class PangleAdEventEmitter {
+  private val lock = Any()
+  private val listeners = mutableMapOf<Double, Listener>()
+  private var nextSubscriptionId = 1.0
+
+  fun add(
+    eventType: PangleAdEventType,
+    listener: (payload: PangleAdEventPayload?) -> 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: PangleAdEventType,
+    payload: PangleAdEventPayload? = 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: PangleAdEventType,
+    val callback: (payload: PangleAdEventPayload?) -> Unit,
+  )
+}

package/android/src/main/java/com/margelo/nitro/pangleads/PangleAndroidUtils.kt

@@ -0,0 +1,32 @@
+package com.margelo.nitro.pangleads
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+// PAGInterstitialAdInteractionListener/PAGRewardedAdInteractionListener have no
+// show-failure callback, so a show() that the SDK silently drops would
+// otherwise never emit CLOSED/ERROR and hang the caller forever. show() call
+// sites arm a timeout via this value and clear it once a real callback fires.
+internal const val PANGLE_SHOW_TIMEOUT_MS = 10_000L
+
+internal class PangleLoadException(
+  val code: Int,
+  message: String,
+) : IllegalStateException(message)
+
+internal fun pangleException(stage: String, code: Int, message: String) =
+  PangleLoadException(code, "Pangle $stage failed ($code): $message")
+
+internal fun pangleShowTimeoutPayload(): PangleAdEventPayload =
+  PangleAdEventPayload(
+    errorCode = null,
+    errorMessage = "Pangle ad show() timed out without a response from the SDK",
+  )
+
+internal fun ReactApplicationContext.requireCurrentActivity() =
+  currentActivity ?: error("Cannot show Pangle ad without an active Activity")
+
+internal fun Throwable.toPangleEventPayload(): PangleAdEventPayload =
+  PangleAdEventPayload(
+    errorCode = (this as? PangleLoadException)?.code?.toDouble(),
+    errorMessage = message ?: localizedMessage,
+  )

package/ios/HybridPangleAds.swift

@@ -0,0 +1,120 @@
+import Foundation
+import NitroModules
+import PAGAdSDK
+
+final class HybridPangleAds: HybridPangleAdsSpec, @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 pangleError("Pangle app ID is empty")
+    }
+
+    return Promise.async {
+      try await withCheckedThrowingContinuation { continuation in
+        DispatchQueue.main.async {
+          self.stateLock.lock()
+          if let existing = self.initializedAppId {
+            self.stateLock.unlock()
+            if existing != appId {
+              continuation.resume(
+                throwing: pangleError("Pangle SDK was initialized with another app ID")
+              )
+            } else {
+              continuation.resume()
+            }
+            return
+          }
+
+          if self.isInitializing, self.initializingAppId != appId {
+            self.stateLock.unlock()
+            continuation.resume(
+              throwing: pangleError("Pangle 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()
+
+          let config = PAGConfig.share()
+          config.appID = appId
+
+          PAGSdk.start(with: config, completionHandler: { success, error in
+            self.stateLock.lock()
+            let continuations = self.initializationContinuations
+            self.initializationContinuations.removeAll()
+            self.isInitializing = false
+            self.initializingAppId = nil
+            if success { self.initializedAppId = appId }
+            self.stateLock.unlock()
+
+            continuations.forEach { item in
+              if !success {
+                item.resume(throwing: error ?? pangleError("Pangle SDK initialization failed"))
+              } else {
+                item.resume()
+              }
+            }
+          })
+        }
+      }
+    }
+  }
+
+  // PAGAdSDK 8.x collapsed the separate GDPRConsent/doNotSell properties into a single
+  // paConsent flag, so GDPR and CCPA consent are no longer distinguishable on iOS.
+  func setGDPRConsent(optIn: Bool) throws {
+    runOnMain {
+      PAGConfig.share().paConsent = optIn ? .consent : .noConsent
+    }
+  }
+
+  func setCCPAConsent(optIn: Bool) throws {
+    runOnMain {
+      PAGConfig.share().paConsent = optIn ? .consent : .noConsent
+    }
+  }
+
+  // PAGAdSDK 8.x removed the dedicated COPPA/child-directed API (PAGChildDirectedType);
+  // there is no longer a public way to flag child-directed traffic to Pangle on iOS.
+  func setCOPPA(isUserCoppa: Bool) throws {}
+
+  func createInterstitialAd(
+    placementId: String
+  ) throws -> any HybridPangleInterstitialAdSpec {
+    try requireInitialized(placementId: placementId)
+    return HybridPangleInterstitialAd(placementId: placementId)
+  }
+
+  func createRewardedAd(
+    placementId: String
+  ) throws -> any HybridPangleRewardedAdSpec {
+    try requireInitialized(placementId: placementId)
+    return HybridPangleRewardedAd(placementId: placementId)
+  }
+
+  private func requireInitialized(placementId: String) throws {
+    stateLock.lock()
+    let initialized = initializedAppId != nil
+    stateLock.unlock()
+
+    guard initialized else {
+      throw pangleError("Pangle SDK is not initialized")
+    }
+    guard !placementId.isEmpty else {
+      throw pangleError("Pangle placement ID is empty")
+    }
+  }
+}

package/ios/HybridPangleInterstitialAd.swift

@@ -0,0 +1,110 @@
+import Foundation
+import NitroModules
+import PAGAdSDK
+
+final class HybridPangleInterstitialAd:
+  HybridPangleInterstitialAdSpec, @unchecked Sendable {
+  fileprivate let events = PangleAdEventEmitter()
+  private let placementId: String
+  fileprivate var ad: PAGLInterstitialAd?
+  fileprivate let showTimeout = PangleShowTimeoutController()
+  private lazy var delegate = PangleInterstitialDelegate(owner: self)
+
+  init(placementId: String) {
+    self.placementId = placementId
+  }
+
+  func load() throws {
+    DispatchQueue.main.async {
+      let request = PAGInterstitialRequest()
+      PAGLInterstitialAd.load(withSlotID: self.placementId, request: request) {
+        interstitialAd, error in
+        DispatchQueue.main.async {
+          guard let interstitialAd else {
+            self.events.emit(.error, error: error ?? pangleError("Pangle interstitial ad failed to load"))
+            return
+          }
+          interstitialAd.delegate = self.delegate
+          self.ad = interstitialAd
+          self.events.emit(.loaded)
+        }
+      }
+    }
+  }
+
+  func show() throws -> Promise<Void> {
+    Promise.async {
+      do {
+        let viewController = try await currentViewController()
+        try await withCheckedThrowingContinuation {
+          (continuation: CheckedContinuation<Void, Error>) in
+          DispatchQueue.main.async {
+            guard let ad = self.ad else {
+              continuation.resume(
+                throwing: pangleError("Pangle interstitial ad is not ready")
+              )
+              return
+            }
+            self.showTimeout.arm { [weak self] in
+              guard let self else { return }
+              self.ad = nil
+              self.events.emit(.error, payload: PangleAdEventPayload(
+                errorCode: nil,
+                errorMessage: "Pangle ad show() timed out without a response from the SDK"
+              ))
+            }
+            ad.present(fromRootViewController: viewController)
+            continuation.resume()
+          }
+        }
+      } catch {
+        self.events.emit(.error, error: error)
+        throw error
+      }
+    }
+  }
+
+  func addAdEventListener(
+    eventType: PangleAdEventType,
+    listener: @escaping (PangleAdEventPayload?) -> 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 PangleInterstitialDelegate: NSObject, PAGLInterstitialAdDelegate {
+  private weak var owner: HybridPangleInterstitialAd?
+
+  init(owner: HybridPangleInterstitialAd) {
+    self.owner = owner
+  }
+
+  func adDidShow(_ ad: any PAGAdProtocol) {
+    owner?.showTimeout.disarm()
+    owner?.events.emit(.opened)
+  }
+
+  func adDidClick(_ ad: any PAGAdProtocol) {
+    owner?.events.emit(.clicked)
+  }
+
+  func adDidDismiss(_ ad: any PAGAdProtocol) {
+    owner?.showTimeout.disarm()
+    owner?.ad = nil
+    owner?.events.emit(.closed)
+  }
+
+  func adDidShowFail(_ ad: any PAGAdProtocol, error: Error) {
+    owner?.showTimeout.disarm()
+    owner?.ad = nil
+    owner?.events.emit(.error, error: error)
+  }
+}

package/ios/HybridPangleRewardedAd.swift

@@ -0,0 +1,143 @@
+import Foundation
+import NitroModules
+import PAGAdSDK
+
+final class HybridPangleRewardedAd:
+  HybridPangleRewardedAdSpec, @unchecked Sendable {
+  fileprivate let events = PangleAdEventEmitter()
+  private let placementId: String
+  fileprivate var ad: PAGRewardedAd?
+  fileprivate let showTimeout = PangleShowTimeoutController()
+  private lazy var delegate = PangleRewardedDelegate(owner: self)
+
+  init(placementId: String) {
+    self.placementId = placementId
+  }
+
+  func load(verification: PangleAdVerificationOptions?) throws {
+    DispatchQueue.main.async {
+      // Pangle's S2S reward callback fills `user_id` from this SDK-wide
+      // setting, not from PAGRewardedRequest.extraInfo — without it Pangle
+      // reports the callback with its own placeholder user id.
+      if let userId = verification?.userId, !userId.isEmpty {
+        PAGConfig.share().userDataString = userId
+      }
+      let request = Self.makeRewardedRequest(verification: verification)
+      PAGRewardedAd.load(withSlotID: self.placementId, request: request) {
+        rewardedAd, error in
+        DispatchQueue.main.async {
+          guard let rewardedAd else {
+            self.events.emit(.error, error: error ?? pangleError("Pangle rewarded ad failed to load"))
+            return
+          }
+          rewardedAd.delegate = self.delegate
+          self.ad = rewardedAd
+          self.events.emit(.rewardedLoaded)
+        }
+      }
+    }
+  }
+
+  private static func makeRewardedRequest(
+    verification: PangleAdVerificationOptions?
+  ) -> PAGRewardedRequest {
+    let request = PAGRewardedRequest()
+    let extraInfo = extraInfo(from: verification)
+    if !extraInfo.isEmpty {
+      request.extraInfo = extraInfo
+    }
+    return request
+  }
+
+  private static func extraInfo(from verification: PangleAdVerificationOptions?) -> [String: String] {
+    var extraInfo: [String: String] = [:]
+    if let userId = verification?.userId, !userId.isEmpty {
+      extraInfo["userId"] = userId
+    }
+    if let customData = verification?.customData, !customData.isEmpty {
+      extraInfo["customData"] = customData
+    }
+    return extraInfo
+  }
+
+  func show() throws -> Promise<Void> {
+    Promise.async {
+      do {
+        let viewController = try await currentViewController()
+        try await withCheckedThrowingContinuation {
+          (continuation: CheckedContinuation<Void, Error>) in
+          DispatchQueue.main.async {
+            guard let ad = self.ad else {
+              continuation.resume(
+                throwing: pangleError("Pangle rewarded ad is not ready")
+              )
+              return
+            }
+            self.showTimeout.arm { [weak self] in
+              guard let self else { return }
+              self.ad = nil
+              self.events.emit(.error, payload: PangleAdEventPayload(
+                errorCode: nil,
+                errorMessage: "Pangle ad show() timed out without a response from the SDK"
+              ))
+            }
+            ad.present(fromRootViewController: viewController)
+            continuation.resume()
+          }
+        }
+      } catch {
+        self.events.emit(.error, error: error)
+        throw error
+      }
+    }
+  }
+
+  func addAdEventListener(
+    eventType: PangleAdEventType,
+    listener: @escaping (PangleAdEventPayload?) -> 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 PangleRewardedDelegate: NSObject, PAGRewardedAdDelegate {
+  private weak var owner: HybridPangleRewardedAd?
+
+  init(owner: HybridPangleRewardedAd) {
+    self.owner = owner
+  }
+
+  func adDidShow(_ ad: any PAGAdProtocol) {
+    owner?.showTimeout.disarm()
+    owner?.events.emit(.opened)
+  }
+
+  func adDidClick(_ ad: any PAGAdProtocol) {
+    owner?.events.emit(.clicked)
+  }
+
+  func adDidDismiss(_ ad: any PAGAdProtocol) {
+    owner?.showTimeout.disarm()
+    owner?.ad = nil
+    owner?.events.emit(.closed)
+  }
+
+  func rewardedAd(_ rewardedAd: PAGRewardedAd, userDidEarnReward rewardModel: PAGRewardModel) {
+    owner?.showTimeout.disarm()
+    owner?.events.emit(.rewardedEarnedReward)
+  }
+
+  func adDidShowFail(_ ad: any PAGAdProtocol, error: Error) {
+    owner?.showTimeout.disarm()
+    owner?.ad = nil
+    owner?.events.emit(.error, error: error)
+  }
+}