react-native-levelplayads 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/NitroLevelPlayAds.podspec

@@ -0,0 +1,28 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroLevelPlayAds"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/exzos28/react-native-levelplayads"
+  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/NitroLevelPlayAds+autolinking.rb"
+  add_nitrogen_files(s)
+
+  s.dependency "React-Core"
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
+  # Verified against CocoaPods trunk (https://trunk.cocoapods.org/api/v1/pods/IronSourceSDK) —
+  # the real pod name is "IronSourceSDK" (module name `IronSource`), not "IronSourceMediation".
+  s.dependency "IronSourceSDK", "~> 9.5.0.0"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,52 @@
+# react-native-levelplayads
+
+[Nitro Modules](https://nitro.margelo.com/) bridge for the LevelPlay
+(ironSource) mediation SDK — interstitial and rewarded ads.
+
+## Install
+
+```sh
+npm install react-native-levelplayads react-native-nitro-modules
+```
+
+## Usage
+
+There's no `InterstitialAd`/`RewardedAd` class or event listeners here —
+just `load`/`show`, keyed by ad type and ad unit ID, resolving through
+promises.
+
+```ts
+import LevelPlayAds from 'react-native-levelplayads';
+
+await LevelPlayAds().initialize('YOUR_LEVELPLAY_APP_KEY', {testMode: true});
+LevelPlayAds().setGDPRConsent(true);
+LevelPlayAds().setCCPAConsent(true);
+LevelPlayAds().setCOPPA(false);
+
+await LevelPlayAds().load('interstitial', 'YOUR_AD_UNIT_ID');
+const result = await LevelPlayAds().show('interstitial', 'YOUR_AD_UNIT_ID');
+// result.state: 'completed' | 'skipped'
+
+await LevelPlayAds().load('rewarded', 'YOUR_REWARDED_AD_UNIT_ID');
+const rewardResult = await LevelPlayAds().show(
+  'rewarded',
+  'YOUR_REWARDED_AD_UNIT_ID',
+);
+if (rewardResult.state === 'completed') {
+  // grant the reward
+}
+```
+
+## Notes
+
+- `load()`/`show()` reject on failure — no separate `ERROR` event.
+- `result.state === 'completed'` is also how you know a rewarded ad earned
+  its reward; LevelPlay doesn't send a distinct "reward earned" signal.
+- Call `load()` again after each `show()` to prepare the next impression.
+
+See [`src/specs/LevelPlayAds.nitro.ts`](src/specs/LevelPlayAds.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(NitroLevelPlayAds)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME NitroLevelPlayAds)
+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/NitroLevelPlayAds+autolinking.cmake)
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  android
+)

package/android/build.gradle

@@ -0,0 +1,130 @@
+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/NitroLevelPlayAds+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["NitroLevelPlayAds_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroLevelPlayAds_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.levelplayads"
+
+  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"
+  // android-sdk.is.com was deprecated 2025-06-30 and frozen at 9.2.0, which drops
+  // onAdClosed/onAdRewarded on Android; LevelPlay now ships on Maven Central.
+  implementation "com.unity3d.ads-mediation:mediation-sdk:9.5.0"
+}

package/android/consumer-rules.pro

@@ -0,0 +1,3 @@
+-keep class com.margelo.nitro.levelplayads.** { *; }
+-keep class com.ironsource.** { *; }
+-keep class com.unity3d.mediation.** { *; }

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 @@
+NitroLevelPlayAds_kotlinVersion=2.1.20
+NitroLevelPlayAds_minSdkVersion=24
+NitroLevelPlayAds_targetSdkVersion=36
+NitroLevelPlayAds_compileSdkVersion=36
+NitroLevelPlayAds_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 "NitroLevelPlayAdsOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::levelplayads::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/levelplayads/HybridLevelPlayAds.kt

@@ -0,0 +1,287 @@
+package com.margelo.nitro.levelplayads
+
+import android.util.Log
+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.unity3d.mediation.LevelPlay
+import com.unity3d.mediation.LevelPlayAdError
+import com.unity3d.mediation.LevelPlayAdInfo
+import com.unity3d.mediation.LevelPlayInitError
+import com.unity3d.mediation.LevelPlayInitRequest
+import com.unity3d.mediation.interstitial.LevelPlayInterstitialAd
+import com.unity3d.mediation.interstitial.LevelPlayInterstitialAdListener
+import com.unity3d.mediation.rewarded.LevelPlayReward
+import com.unity3d.mediation.rewarded.LevelPlayRewardedAd
+import com.unity3d.mediation.rewarded.LevelPlayRewardedAdListener
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+// Verified against the real com.ironsource.sdk:mediationsdk:9.2.0 AAR (javap on
+// the downloaded classes.jar, https://android-sdk.is.com/) — the unified LevelPlay
+// API lives under `com.unity3d.mediation`. LevelPlayInitRequest.Builder has no
+// withLegacyAdFormats() in 9.2.0 (removed since the previous 8.6.0 generation),
+// and setConsent/setMetaData/setAdaptersDebug now live on `LevelPlay` itself
+// rather than the legacy `com.ironsource.mediationsdk.IronSource` facade, whose
+// surface was stripped down in this release.
+@DoNotStrip
+@Keep
+class HybridLevelPlayAds : HybridLevelPlayAdsSpec() {
+  private companion object {
+    const val TAG = "LevelPlayAds"
+  }
+
+  private val context: ReactApplicationContext by lazy {
+    NitroModules.applicationContext as? ReactApplicationContext
+      ?: error("LevelPlay requires a ReactApplicationContext")
+  }
+
+  private val stateLock = Any()
+  private var isInitialized = false
+  private var initializedAppKey: String? = null
+  private var initializingAppKey: String? = null
+  private var initialization: CompletableDeferred<Unit>? = null
+
+  // LevelPlay requires the SDK listener to be set exactly once, before the first
+  // loadAd() call, and reused for the ad's whole lifetime. Re-registering a
+  // different listener object right before showAd() (as this module used to do)
+  // silently drops onAdClosed on Android: the internal IronSource event fires
+  // (confirmed via logcat, tag "IronSource"), but the unified
+  // LevelPlayInterstitialAdListener/LevelPlayRewardedAdListener never sees it
+  // once its listener has been swapped. So the SDK listener is installed once
+  // in the holder's init{} block, and load()/show() only swap out our own
+  // plain-Kotlin callback fields, never the SDK listener.
+  private abstract class AdHolder {
+    var onLoaded: (() -> Unit)? = null
+    var onLoadFailed: ((LevelPlayAdError) -> Unit)? = null
+    var onDisplayed: (() -> Unit)? = null
+    var onDisplayFailed: ((LevelPlayAdError) -> Unit)? = null
+    var onClosed: (() -> Unit)? = null
+  }
+
+  private class InterstitialHolder(adUnitId: String) : AdHolder() {
+    val ad = LevelPlayInterstitialAd(adUnitId)
+
+    init {
+      ad.setListener(object : LevelPlayInterstitialAdListener {
+        override fun onAdLoaded(adInfo: LevelPlayAdInfo) = onLoaded?.invoke() ?: Unit
+        override fun onAdLoadFailed(error: LevelPlayAdError) = onLoadFailed?.invoke(error) ?: Unit
+        override fun onAdDisplayed(adInfo: LevelPlayAdInfo) = onDisplayed?.invoke() ?: Unit
+        override fun onAdDisplayFailed(error: LevelPlayAdError, adInfo: LevelPlayAdInfo) =
+          onDisplayFailed?.invoke(error) ?: Unit
+        override fun onAdClosed(adInfo: LevelPlayAdInfo) = onClosed?.invoke() ?: Unit
+      })
+    }
+  }
+
+  private class RewardedHolder(adUnitId: String) : AdHolder() {
+    val ad = LevelPlayRewardedAd(adUnitId)
+    var onRewarded: (() -> Unit)? = null
+
+    init {
+      ad.setListener(object : LevelPlayRewardedAdListener {
+        override fun onAdLoaded(adInfo: LevelPlayAdInfo) = onLoaded?.invoke() ?: Unit
+        override fun onAdLoadFailed(error: LevelPlayAdError) = onLoadFailed?.invoke(error) ?: Unit
+        override fun onAdDisplayed(adInfo: LevelPlayAdInfo) = onDisplayed?.invoke() ?: Unit
+        override fun onAdDisplayFailed(error: LevelPlayAdError, adInfo: LevelPlayAdInfo) =
+          onDisplayFailed?.invoke(error) ?: Unit
+        override fun onAdRewarded(reward: LevelPlayReward, adInfo: LevelPlayAdInfo) = onRewarded?.invoke() ?: Unit
+        override fun onAdClosed(adInfo: LevelPlayAdInfo) = onClosed?.invoke() ?: Unit
+      })
+    }
+  }
+
+  // Keyed by adUnitId: load() and show() are separate calls in this module's
+  // spec, so the loaded ad object has to be held onto between the two calls.
+  private val loadedInterstitials = mutableMapOf<String, InterstitialHolder>()
+  private val loadedRewarded = mutableMapOf<String, RewardedHolder>()
+
+  override fun initialize(appKey: String, testMode: Boolean): Promise<Unit> = Promise.async {
+    require(appKey.isNotBlank()) { "LevelPlay app key is empty" }
+
+    val (deferred, shouldStart) = synchronized(stateLock) {
+      if (isInitialized) {
+        require(initializedAppKey == appKey) {
+          "LevelPlay SDK was already initialized with another app key"
+        }
+        return@async
+      }
+
+      val current = initialization
+      if (current != null) {
+        require(initializingAppKey == appKey) {
+          "LevelPlay SDK is being initialized with another app key"
+        }
+        current to false
+      } else {
+        CompletableDeferred<Unit>().also {
+          initialization = it
+          initializingAppKey = appKey
+        } to true
+      }
+    }
+
+    if (shouldStart) {
+      withContext(Dispatchers.Main) {
+        if (testMode) {
+          LevelPlay.setAdaptersDebug(true)
+        }
+
+        val initRequest = LevelPlayInitRequest.Builder(appKey).build()
+
+        LevelPlay.init(
+          context,
+          initRequest,
+          object : com.unity3d.mediation.LevelPlayInitListener {
+            override fun onInitSuccess(configuration: com.unity3d.mediation.LevelPlayConfiguration) {
+              synchronized(stateLock) {
+                isInitialized = true
+                initializedAppKey = appKey
+                initialization = null
+                initializingAppKey = null
+              }
+              deferred.complete(Unit)
+            }
+
+            override fun onInitFailed(error: LevelPlayInitError) {
+              synchronized(stateLock) {
+                initialization = null
+                initializingAppKey = null
+              }
+              deferred.completeExceptionally(
+                levelPlayAdsException("initialize", error.errorCode.toString(), error.errorMessage),
+              )
+            }
+          },
+        )
+      }
+    }
+
+    deferred.await()
+  }
+
+  override fun load(adType: LevelPlayAdType, adUnitId: String): Promise<Unit> = Promise.async {
+    require(adUnitId.isNotBlank()) { "LevelPlay ad unit ID is empty" }
+    val deferred = CompletableDeferred<Unit>()
+
+    withContext(Dispatchers.Main) {
+      when (adType) {
+        LevelPlayAdType.INTERSTITIAL -> {
+          val holder = InterstitialHolder(adUnitId)
+          holder.onLoaded = {
+            synchronized(stateLock) { loadedInterstitials[adUnitId] = holder }
+            deferred.complete(Unit)
+          }
+          holder.onLoadFailed = { error ->
+            deferred.completeExceptionally(
+              levelPlayAdsException("load", error.getErrorCode().toString(), error.getErrorMessage()),
+            )
+          }
+          holder.ad.loadAd()
+        }
+        LevelPlayAdType.REWARDED -> {
+          val holder = RewardedHolder(adUnitId)
+          holder.onLoaded = {
+            synchronized(stateLock) { loadedRewarded[adUnitId] = holder }
+            deferred.complete(Unit)
+          }
+          holder.onLoadFailed = { error ->
+            deferred.completeExceptionally(
+              levelPlayAdsException("load", error.getErrorCode().toString(), error.getErrorMessage()),
+            )
+          }
+          holder.ad.loadAd()
+        }
+      }
+    }
+
+    deferred.await()
+  }
+
+  private fun onShowDisplayFailed(
+    kind: String,
+    adUnitId: String,
+    error: LevelPlayAdError,
+    deferred: CompletableDeferred<*>,
+  ) {
+    Log.d(TAG, "show($kind, $adUnitId): onAdDisplayFailed (${error.getErrorCode()}) ${error.getErrorMessage()}")
+    deferred.completeExceptionally(
+      levelPlayAdsException("show", error.getErrorCode().toString(), error.getErrorMessage()),
+    )
+  }
+
+  override fun show(adType: LevelPlayAdType, adUnitId: String): Promise<LevelPlayAdShowResult> = Promise.async {
+    require(adUnitId.isNotBlank()) { "LevelPlay ad unit ID is empty" }
+    val activity = context.requireCurrentActivity()
+    val deferred = CompletableDeferred<LevelPlayAdShowResult>()
+
+    when (adType) {
+      LevelPlayAdType.INTERSTITIAL -> {
+        val holder = synchronized(stateLock) { loadedInterstitials.remove(adUnitId) }
+          ?: error("LevelPlay interstitial ad is not ready")
+        // Reuse the same SDK listener that was registered in load() — swapping
+        // in a different listener object here is what used to drop onAdClosed.
+        holder.onLoaded = null
+        holder.onLoadFailed = null
+        holder.onDisplayed = {
+          Log.d(TAG, "show(interstitial, $adUnitId): onAdDisplayed")
+        }
+        holder.onDisplayFailed = { error -> onShowDisplayFailed("interstitial", adUnitId, error, deferred) }
+        holder.onClosed = {
+          Log.d(TAG, "show(interstitial, $adUnitId): onAdClosed")
+          deferred.complete(LevelPlayAdShowResult(LevelPlayAdShowState.COMPLETED))
+        }
+        Log.d(TAG, "show(interstitial, $adUnitId): calling showAd")
+        withContext(Dispatchers.Main) { holder.ad.showAd(activity) }
+      }
+      LevelPlayAdType.REWARDED -> {
+        val holder = synchronized(stateLock) { loadedRewarded.remove(adUnitId) }
+          ?: error("LevelPlay rewarded ad is not ready")
+        // Rewarded ads don't carry a Unity-style "finish state" — LevelPlay fires a
+        // separate onAdRewarded event before onAdClosed, so completion is derived
+        // from whether that event happened at all before the ad closed.
+        var didReceiveReward = false
+        holder.onLoaded = null
+        holder.onLoadFailed = null
+        holder.onDisplayed = {
+          Log.d(TAG, "show(rewarded, $adUnitId): onAdDisplayed")
+        }
+        holder.onRewarded = {
+          Log.d(TAG, "show(rewarded, $adUnitId): onAdRewarded")
+          didReceiveReward = true
+        }
+        holder.onDisplayFailed = { error -> onShowDisplayFailed("rewarded", adUnitId, error, deferred) }
+        holder.onClosed = {
+          Log.d(TAG, "show(rewarded, $adUnitId): onAdClosed (didReceiveReward=$didReceiveReward)")
+          val state = if (didReceiveReward) {
+            LevelPlayAdShowState.COMPLETED
+          } else {
+            LevelPlayAdShowState.SKIPPED
+          }
+          deferred.complete(LevelPlayAdShowResult(state))
+        }
+        Log.d(TAG, "show(rewarded, $adUnitId): calling showAd")
+        withContext(Dispatchers.Main) { holder.ad.showAd(activity) }
+      }
+    }
+
+    deferred.await()
+  }
+
+  override fun setGDPRConsent(optIn: Boolean) {
+    LevelPlay.setConsent(optIn)
+  }
+
+  // CCPA flag semantics are "opted out of sale", the inverse of our `optIn`
+  // (personalized-ads-allowed) flag.
+  override fun setCCPAConsent(optIn: Boolean) {
+    LevelPlay.setMetaData("do_not_sell", if (optIn) "false" else "true")
+  }
+
+  override fun setCOPPA(isCoppa: Boolean) {
+    LevelPlay.setMetaData("is_child_directed", if (isCoppa) "true" else "false")
+  }
+}

package/android/src/main/java/com/margelo/nitro/levelplayads/LevelPlayAndroidUtils.kt

@@ -0,0 +1,30 @@
+package com.margelo.nitro.levelplayads
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.ReactApplicationContext
+import java.util.concurrent.CountDownLatch
+
+internal fun ReactApplicationContext.requireCurrentActivity(): Activity =
+  currentActivity ?: error("Cannot show LevelPlay ad without an active Activity")
+
+internal fun levelPlayAdsException(stage: String, errorCode: String, message: String) =
+  IllegalStateException("LevelPlay $stage failed ($errorCode): $message")
+
+/** Mirrors HybridLevelPlayAds.swift's `runOnMain` so consent metadata writes happen on the same thread on both platforms. */
+internal fun runOnMain(body: () -> Unit) {
+  if (Looper.myLooper() == Looper.getMainLooper()) {
+    body()
+    return
+  }
+  val latch = CountDownLatch(1)
+  Handler(Looper.getMainLooper()).post {
+    try {
+      body()
+    } finally {
+      latch.countDown()
+    }
+  }
+  latch.await()
+}

package/android/src/main/java/com/margelo/nitro/levelplayads/NitroLevelPlayAdsPackage.java

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