react-native-liftoffads 0.0.1

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/NitroLiftoffAds.podspec

@@ -0,0 +1,26 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroLiftoffAds"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/exzos28/react-native-liftoffads"
+  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/NitroLiftoffAds+autolinking.rb"
+  add_nitrogen_files(s)
+
+  s.dependency "React-Core"
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
+  s.dependency "VungleAds", "7.7.5"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,61 @@
+# react-native-liftoffads
+
+[Nitro Modules](https://nitro.margelo.com/) bridge for Liftoff Monetize
+(Vungle) interstitial and rewarded ads.
+
+## Install
+
+```sh
+npm install react-native-liftoffads react-native-nitro-modules
+```
+
+## Usage
+
+```ts
+import MobileAds, {
+  AdEventType,
+  InterstitialAd,
+  RewardedAd,
+  RewardedAdEventType,
+} from 'react-native-liftoffads';
+
+await MobileAds().initialize('YOUR_LIFTOFF_APP_ID');
+MobileAds().setGDPRConsent(true, '1.0');
+MobileAds().setCCPAConsent(true);
+MobileAds().setCOPPA(false);
+
+const interstitial = InterstitialAd.createForAdRequest('YOUR_PLACEMENT_ID');
+interstitial.addAdEventListener(AdEventType.LOADED, () => {
+  interstitial.show({immersiveModeEnabled: true});
+});
+interstitial.addAdEventListener(AdEventType.CLOSED, () => {
+  interstitial.load(); // reuse the same instance for the next impression
+});
+interstitial.load();
+
+const rewarded = RewardedAd.createForAdRequest('YOUR_PLACEMENT_ID');
+rewarded.setUserId('your-user-id'); // optional, for SSV
+rewarded.addAdEventListener(RewardedAdEventType.LOADED, () => rewarded.show());
+rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD, () => {
+  // grant the reward
+});
+rewarded.load();
+```
+
+## Notes
+
+- Ad instances are meant to be reused — call `load()` again on the same
+  `InterstitialAd`/`RewardedAd` after `CLOSED` instead of creating a new one.
+- Liftoff 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/LiftoffAds.nitro.ts`](src/specs/LiftoffAds.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(NitroLiftoffAds)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME NitroLiftoffAds)
+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/NitroLiftoffAds+autolinking.cmake)
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  android
+)

package/android/build.gradle

@@ -0,0 +1,132 @@
+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/NitroLiftoffAds+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["NitroLiftoffAds_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroLiftoffAds_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.liftoffads"
+
+  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()
+}
+
+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.vungle:vungle-ads:7.7.7"
+  implementation "com.google.android.gms:play-services-tasks:18.2.1"
+  implementation "com.google.android.gms:play-services-appset:16.1.0"
+  implementation "com.google.android.gms:play-services-basement:18.6.0"
+  implementation "com.google.android.gms:play-services-ads-identifier:18.2.0"
+}

package/android/consumer-rules.pro

@@ -0,0 +1,2 @@
+-keep class com.margelo.nitro.liftoffads.** { *; }
+-keep class com.vungle.ads.** { *; }

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 @@
+NitroLiftoffAds_kotlinVersion=2.1.20
+NitroLiftoffAds_minSdkVersion=24
+NitroLiftoffAds_targetSdkVersion=36
+NitroLiftoffAds_compileSdkVersion=36
+NitroLiftoffAds_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 "NitroLiftoffAdsOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::liftoffads::initialize(vm);
+}

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

@@ -0,0 +1,121 @@
+package com.margelo.nitro.liftoffads
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.vungle.ads.InitializationListener
+import com.vungle.ads.VungleAds
+import com.vungle.ads.VungleError
+import com.vungle.ads.VunglePrivacySettings
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@DoNotStrip
+@Keep
+class HybridLiftoffAds : HybridLiftoffAdsSpec() {
+  private val context: ReactApplicationContext by lazy {
+    NitroModules.applicationContext as? ReactApplicationContext
+      ?: error("Liftoff 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()) { "Liftoff app ID is empty" }
+
+    val alreadyInitialized = synchronized(stateLock) {
+      if (VungleAds.isInitialized()) {
+        val existing = initializedAppId
+        if (existing != null && existing != appId) {
+          error("Liftoff SDK was already initialized with another app ID")
+        }
+        initializedAppId = appId
+        true
+      } else {
+        false
+      }
+    }
+    if (alreadyInitialized) return@async
+
+    val (deferred, shouldStart) = synchronized(stateLock) {
+      val current = initialization
+      if (current != null) {
+        if (initializingAppId != appId) {
+          error("Liftoff SDK is being initialized with another app ID")
+        }
+        current to false
+      } else {
+        CompletableDeferred<Unit>().also {
+          initialization = it
+          initializingAppId = appId
+        } to true
+      }
+    }
+
+    if (shouldStart) {
+      withContext(Dispatchers.Main) {
+        VungleAds.init(
+          context.applicationContext,
+          appId,
+          object : InitializationListener {
+            override fun onSuccess() {
+              synchronized(stateLock) {
+                initializedAppId = appId
+                initialization = null
+                initializingAppId = null
+              }
+              deferred.complete(Unit)
+            }
+
+            override fun onError(vungleError: VungleError) {
+              synchronized(stateLock) {
+                if (initialization === deferred) initialization = null
+                initializingAppId = null
+              }
+              deferred.completeExceptionally(
+                liftoffException("initialize", vungleError),
+              )
+            }
+          },
+        )
+      }
+    }
+
+    deferred.await()
+  }
+
+  override fun setGDPRConsent(optIn: Boolean, consentMessageVersion: String) {
+    VunglePrivacySettings.setGDPRStatus(optIn, consentMessageVersion)
+  }
+
+  override fun setCCPAConsent(optIn: Boolean) {
+    VunglePrivacySettings.setCCPAStatus(optIn)
+  }
+
+  override fun setCOPPA(isUserCoppa: Boolean) {
+    VunglePrivacySettings.setCOPPAStatus(isUserCoppa)
+  }
+
+  override fun createInterstitialAd(
+    placementId: String,
+  ): HybridLiftoffInterstitialAdSpec {
+    requireInitialized(placementId)
+    return HybridLiftoffInterstitialAd(context, placementId)
+  }
+
+  override fun createRewardedAd(placementId: String): HybridLiftoffRewardedAdSpec {
+    requireInitialized(placementId)
+    return HybridLiftoffRewardedAd(context, placementId)
+  }
+
+  private fun requireInitialized(placementId: String) {
+    require(VungleAds.isInitialized()) { "Liftoff SDK is not initialized" }
+    require(placementId.isNotBlank()) { "Liftoff placement ID is empty" }
+  }
+}

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

@@ -0,0 +1,96 @@
+package com.margelo.nitro.liftoffads
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.core.Promise
+import com.vungle.ads.AdConfig
+import com.vungle.ads.BaseAd
+import com.vungle.ads.InterstitialAd
+import com.vungle.ads.InterstitialAdListener
+import com.vungle.ads.VungleError
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@DoNotStrip
+@Keep
+class HybridLiftoffInterstitialAd(
+  private val context: ReactApplicationContext,
+  placementId: String,
+) : HybridLiftoffInterstitialAdSpec(), InterstitialAdListener {
+  private val events = LiftoffAdEventEmitter()
+  private val immersiveMode = ImmersiveModeController()
+  private val ad = InterstitialAd(context, placementId, AdConfig())
+
+  init {
+    ad.adListener = this
+  }
+
+  override fun load() {
+    context.runOnUiQueueThread { ad.load() }
+  }
+
+  override fun show(options: LiftoffAdShowOptions?): Promise<Unit> = Promise.async {
+    try {
+      withContext(Dispatchers.Main) {
+        val activity = context.requireCurrentActivity()
+        if (!ad.canPlayAd()) error("Liftoff interstitial ad is not ready")
+        if (options?.immersiveModeEnabled == true) immersiveMode.enable(activity)
+        ad.play(activity)
+      }
+    } catch (error: Throwable) {
+      immersiveMode.restore()
+      events.emit(LiftoffAdEventType.ERROR, error.toLiftoffEventPayload())
+      throw error
+    }
+  }
+
+  override fun addAdEventListener(
+    eventType: LiftoffAdEventType,
+    listener: (payload: LiftoffAdEventPayload?) -> Unit,
+  ) = events.add(eventType, listener)
+
+  override fun removeAdEventListener(subscriptionId: Double) {
+    events.remove(subscriptionId)
+  }
+
+  override fun removeAllListeners() {
+    events.removeAll()
+  }
+
+  override fun onAdLoaded(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.LOADED)
+  }
+
+  override fun onAdStart(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.OPENED)
+  }
+
+  override fun onAdImpression(baseAd: BaseAd) = Unit
+
+  override fun onAdClicked(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.CLICKED)
+  }
+
+  override fun onAdLeftApplication(baseAd: BaseAd) = Unit
+
+  override fun onAdEnd(baseAd: BaseAd) {
+    immersiveMode.restore()
+    events.emit(LiftoffAdEventType.CLOSED)
+  }
+
+  override fun onAdFailedToLoad(baseAd: BaseAd, adError: VungleError) {
+    events.emit(
+      LiftoffAdEventType.ERROR,
+      liftoffException("load", adError).toLiftoffEventPayload(),
+    )
+  }
+
+  override fun onAdFailedToPlay(baseAd: BaseAd, adError: VungleError) {
+    immersiveMode.restore()
+    events.emit(
+      LiftoffAdEventType.ERROR,
+      liftoffException("show", adError).toLiftoffEventPayload(),
+    )
+  }
+}

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

@@ -0,0 +1,104 @@
+package com.margelo.nitro.liftoffads
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.core.Promise
+import com.vungle.ads.AdConfig
+import com.vungle.ads.BaseAd
+import com.vungle.ads.RewardedAd
+import com.vungle.ads.RewardedAdListener
+import com.vungle.ads.VungleError
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@DoNotStrip
+@Keep
+class HybridLiftoffRewardedAd(
+  private val context: ReactApplicationContext,
+  placementId: String,
+) : HybridLiftoffRewardedAdSpec(), RewardedAdListener {
+  private val events = LiftoffAdEventEmitter()
+  private val immersiveMode = ImmersiveModeController()
+  private val ad = RewardedAd(context, placementId, AdConfig())
+
+  init {
+    ad.adListener = this
+  }
+
+  override fun load() {
+    context.runOnUiQueueThread { ad.load() }
+  }
+
+  override fun setUserId(userId: String) {
+    context.runOnUiQueueThread { ad.setUserId(userId) }
+  }
+
+  override fun show(options: LiftoffAdShowOptions?): Promise<Unit> = Promise.async {
+    try {
+      withContext(Dispatchers.Main) {
+        val activity = context.requireCurrentActivity()
+        if (!ad.canPlayAd()) error("Liftoff rewarded ad is not ready")
+        if (options?.immersiveModeEnabled == true) immersiveMode.enable(activity)
+        ad.play(activity)
+      }
+    } catch (error: Throwable) {
+      immersiveMode.restore()
+      events.emit(LiftoffAdEventType.ERROR, error.toLiftoffEventPayload())
+      throw error
+    }
+  }
+
+  override fun addAdEventListener(
+    eventType: LiftoffAdEventType,
+    listener: (payload: LiftoffAdEventPayload?) -> Unit,
+  ) = events.add(eventType, listener)
+
+  override fun removeAdEventListener(subscriptionId: Double) {
+    events.remove(subscriptionId)
+  }
+
+  override fun removeAllListeners() {
+    events.removeAll()
+  }
+
+  override fun onAdLoaded(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.REWARDED_LOADED)
+  }
+
+  override fun onAdStart(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.OPENED)
+  }
+
+  override fun onAdImpression(baseAd: BaseAd) = Unit
+
+  override fun onAdClicked(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.CLICKED)
+  }
+
+  override fun onAdLeftApplication(baseAd: BaseAd) = Unit
+
+  override fun onAdRewarded(baseAd: BaseAd) {
+    events.emit(LiftoffAdEventType.REWARDED_EARNED_REWARD)
+  }
+
+  override fun onAdEnd(baseAd: BaseAd) {
+    immersiveMode.restore()
+    events.emit(LiftoffAdEventType.CLOSED)
+  }
+
+  override fun onAdFailedToLoad(baseAd: BaseAd, adError: VungleError) {
+    events.emit(
+      LiftoffAdEventType.ERROR,
+      liftoffException("load", adError).toLiftoffEventPayload(),
+    )
+  }
+
+  override fun onAdFailedToPlay(baseAd: BaseAd, adError: VungleError) {
+    immersiveMode.restore()
+    events.emit(
+      LiftoffAdEventType.ERROR,
+      liftoffException("show", adError).toLiftoffEventPayload(),
+    )
+  }
+}