react-native-pangleads 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 exzos
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NitroPangleAds.podspec

@@ -0,0 +1,26 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroPangleAds"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/exzos28/react-native-pangleads"
+  s.license      = { :type => "MIT" }
+  s.authors      = { "exzos" => "oleksandr.kurinnyi.work@gmail.com" }
+  s.platforms    = { :ios => "15.1" }
+  s.source       = { :path => "." }
+
+  s.source_files = ["ios/**/*.{swift,m,mm}"]
+
+  load "nitrogen/generated/ios/NitroPangleAds+autolinking.rb"
+  add_nitrogen_files(s)
+
+  s.dependency "React-Core"
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
+  s.dependency "Ads-Global/PangleSDK", "8.2.0.7"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,80 @@
+# react-native-pangleads
+
+[Nitro Modules](https://nitro.margelo.com/) bridge for Pangle interstitial
+and rewarded ads.
+
+## Install
+
+```sh
+npm install react-native-pangleads react-native-nitro-modules
+```
+
+Pangle's Android SDK lives outside Google's default Maven repos. With Expo
+CNG, enable the bundled config plugin:
+
+```json
+{
+  "expo": {
+    "plugins": ["react-native-pangleads"]
+  }
+}
+```
+
+Without CNG, add the repo to your app's `android/build.gradle` yourself:
+
+```groovy
+allprojects {
+  repositories {
+    maven { url "https://artifact.bytedance.com/repository/pangle" }
+  }
+}
+```
+
+## Usage
+
+```ts
+import MobileAds, {
+  AdEventType,
+  InterstitialAd,
+  RewardedAd,
+  RewardedAdEventType,
+} from 'react-native-pangleads';
+
+await MobileAds().initialize('YOUR_PANGLE_APP_ID');
+MobileAds().setGDPRConsent(true);
+MobileAds().setCCPAConsent(true);
+MobileAds().setCOPPA(false);
+
+const interstitial = InterstitialAd.createForAdRequest('YOUR_PLACEMENT_ID');
+interstitial.addAdEventListener(AdEventType.LOADED, () => interstitial.show());
+interstitial.addAdEventListener(AdEventType.CLOSED, () => {
+  interstitial.load(); // reuse the same instance for the next impression
+});
+interstitial.load();
+
+const rewarded = RewardedAd.createForAdRequest('YOUR_PLACEMENT_ID');
+rewarded.addAdEventListener(RewardedAdEventType.LOADED, () => rewarded.show());
+rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD, () => {
+  // grant the reward
+});
+rewarded.load({userId: 'your-user-id'}); // optional, for SSV
+```
+
+## Notes
+
+- Ad instances are meant to be reused — call `load()` again on the same
+  `InterstitialAd`/`RewardedAd` after `CLOSED` instead of creating a new one.
+- No `AdEventType.PAID` event (unlike Liftoff/Google Mobile Ads).
+- Pangle doesn't report reward type/amount, so `LOADED`/`EARNED_REWARD`
+  payloads are always `undefined` — treat them as signals only.
+- Use `RewardedAdEventType.LOADED`, not `AdEventType.LOADED`, on a
+  `RewardedAd`.
+- No built-in consent UI (no UMP equivalent) — plug your own and forward the
+  result via `setGDPRConsent`/`setCCPAConsent`/`setCOPPA`.
+
+See [`src/specs/PangleAds.nitro.ts`](src/specs/PangleAds.nitro.ts) for the
+full native interface and [`example`](example) for a runnable demo.
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,20 @@
+project(NitroPangleAds)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME NitroPangleAds)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+add_library(${PACKAGE_NAME} SHARED
+  src/main/cpp/cpp-adapter.cpp
+)
+
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroPangleAds+autolinking.cmake)
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  android
+)

package/android/build.gradle

@@ -0,0 +1,129 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.12.1"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.20"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def nitroAutolinkingFile = file("../nitrogen/generated/android/NitroPangleAds+autolinking.gradle")
+if (nitroAutolinkingFile.exists()) {
+  apply from: nitroAutolinkingFile
+}
+apply from: "./fix-prefab.gradle"
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroPangleAds_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroPangleAds_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.pangleads"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    consumerProguardFiles "consumer-rules.pro"
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
+}
+
+repositories {
+  google()
+  mavenCentral()
+  maven { url "https://artifact.bytedance.com/repository/pangle" }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation project(":react-native-nitro-modules")
+
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+  implementation "com.pangle.global:pag-sdk:8.2.0.4"
+}

package/android/consumer-rules.pro

@@ -0,0 +1,2 @@
+-keep class com.margelo.nitro.pangleads.** { *; }
+-keep class com.bytedance.sdk.openadsdk.** { *; }

package/android/fix-prefab.gradle

@@ -0,0 +1,46 @@
+tasks.configureEach { task ->
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin("com.android.application") &&
+        !proj.plugins.hasPlugin("com.android.library")) {
+      return
+    }
+
+    def variants = proj.android.hasProperty("applicationVariants") ?
+      proj.android.applicationVariants : proj.android.libraryVariants
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroPangleAds_kotlinVersion=2.1.20
+NitroPangleAds_minSdkVersion=24
+NitroPangleAds_targetSdkVersion=36
+NitroPangleAds_compileSdkVersion=36
+NitroPangleAds_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,7 @@
+#include <jni.h>
+
+#include "NitroPangleAdsOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::pangleads::initialize(vm);
+}

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

@@ -0,0 +1,123 @@
+package com.margelo.nitro.pangleads
+
+import androidx.annotation.Keep
+import com.bytedance.sdk.openadsdk.api.PAGConstant.PAGPAConsentType
+import com.bytedance.sdk.openadsdk.api.init.PAGConfig
+import com.bytedance.sdk.openadsdk.api.init.PAGSdk
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@DoNotStrip
+@Keep
+class HybridPangleAds : HybridPangleAdsSpec() {
+  private val context: ReactApplicationContext by lazy {
+    NitroModules.applicationContext as? ReactApplicationContext
+      ?: error("Pangle Ads requires a ReactApplicationContext")
+  }
+
+  private val stateLock = Any()
+  private var initializedAppId: String? = null
+  private var initializingAppId: String? = null
+  private var initialization: CompletableDeferred<Unit>? = null
+
+  override fun initialize(appId: String): Promise<Unit> = Promise.async {
+    require(appId.isNotBlank()) { "Pangle app ID is empty" }
+
+    val alreadyInitialized = synchronized(stateLock) {
+      val existing = initializedAppId
+      if (existing != null && existing != appId) {
+        error("Pangle SDK was already initialized with another app ID")
+      }
+      existing == appId
+    }
+    if (alreadyInitialized) return@async
+
+    val (deferred, shouldStart) = synchronized(stateLock) {
+      val current = initialization
+      if (current != null) {
+        if (initializingAppId != appId) {
+          error("Pangle SDK is being initialized with another app ID")
+        }
+        current to false
+      } else {
+        CompletableDeferred<Unit>().also {
+          initialization = it
+          initializingAppId = appId
+        } to true
+      }
+    }
+
+    if (shouldStart) {
+      val config = PAGConfig.Builder().appId(appId).build()
+      withContext(Dispatchers.Main) {
+        PAGSdk.init(
+          context.applicationContext,
+          config,
+          object : PAGSdk.PAGInitCallback {
+            override fun success() {
+              synchronized(stateLock) {
+                initializedAppId = appId
+                initialization = null
+                initializingAppId = null
+              }
+              deferred.complete(Unit)
+            }
+
+            override fun fail(code: Int, msg: String) {
+              synchronized(stateLock) {
+                if (initialization === deferred) initialization = null
+                initializingAppId = null
+              }
+              deferred.completeExceptionally(pangleException("initialize", code, msg))
+            }
+          },
+        )
+      }
+    }
+
+    deferred.await()
+  }
+
+  // pag-sdk 8.x collapsed the separate GDPR/DoNotSell/ChildDirected APIs into a single
+  // PAConsent flag, so GDPR/CCPA consent are no longer distinguishable, and there is no
+  // longer a public way to flag child-directed (COPPA) traffic to Pangle on Android.
+  override fun setGDPRConsent(optIn: Boolean) {
+    PAGConfig.setPAConsent(
+      if (optIn) PAGPAConsentType.PAG_PA_CONSENT_TYPE_CONSENT
+      else PAGPAConsentType.PAG_PA_CONSENT_TYPE_NO_CONSENT,
+    )
+  }
+
+  override fun setCCPAConsent(optIn: Boolean) {
+    PAGConfig.setPAConsent(
+      if (optIn) PAGPAConsentType.PAG_PA_CONSENT_TYPE_CONSENT
+      else PAGPAConsentType.PAG_PA_CONSENT_TYPE_NO_CONSENT,
+    )
+  }
+
+  override fun setCOPPA(isUserCoppa: Boolean) {}
+
+  override fun createInterstitialAd(
+    placementId: String,
+  ): HybridPangleInterstitialAdSpec {
+    requireInitialized(placementId)
+    return HybridPangleInterstitialAd(context, placementId)
+  }
+
+  override fun createRewardedAd(placementId: String): HybridPangleRewardedAdSpec {
+    requireInitialized(placementId)
+    return HybridPangleRewardedAd(context, placementId)
+  }
+
+  private fun requireInitialized(placementId: String) {
+    require(synchronized(stateLock) { initializedAppId != null }) {
+      "Pangle SDK is not initialized"
+    }
+    require(placementId.isNotBlank()) { "Pangle placement ID is empty" }
+  }
+}

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

@@ -0,0 +1,106 @@
+package com.margelo.nitro.pangleads
+
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.Keep
+import com.bytedance.sdk.openadsdk.api.interstitial.PAGInterstitialAd
+import com.bytedance.sdk.openadsdk.api.interstitial.PAGInterstitialAdInteractionListener
+import com.bytedance.sdk.openadsdk.api.interstitial.PAGInterstitialAdLoadListener
+import com.bytedance.sdk.openadsdk.api.interstitial.PAGInterstitialRequest
+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 HybridPangleInterstitialAd(
+  private val context: ReactApplicationContext,
+  private val placementId: String,
+) : HybridPangleInterstitialAdSpec(), PAGInterstitialAdInteractionListener {
+  private val events = PangleAdEventEmitter()
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private var ad: PAGInterstitialAd? = null
+  private var showTimeout: Runnable? = null
+
+  override fun load() {
+    context.runOnUiQueueThread {
+      PAGInterstitialAd.loadAd(
+        placementId,
+        PAGInterstitialRequest(),
+        object : PAGInterstitialAdLoadListener {
+          override fun onError(code: Int, message: String) {
+            mainHandler.post {
+              events.emit(
+                PangleAdEventType.ERROR,
+                pangleException("load", code, message).toPangleEventPayload(),
+              )
+            }
+          }
+
+          override fun onAdLoaded(interstitialAd: PAGInterstitialAd) {
+            mainHandler.post {
+              interstitialAd.setAdInteractionListener(this@HybridPangleInterstitialAd)
+              ad = interstitialAd
+              events.emit(PangleAdEventType.LOADED)
+            }
+          }
+        },
+      )
+    }
+  }
+
+  override fun show(): Promise<Unit> = Promise.async {
+    withContext(Dispatchers.Main) {
+      val activity = context.requireCurrentActivity()
+      val current = ad ?: error("Pangle interstitial 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)
+  }
+
+  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
+  }
+}