expo-ads 0.1.3 → 1.0.0

package/.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*.{kt,kts}]
+indent_style = space
+indent_size = 2

package/android/src/main/java/expo/modules/ads/meta/MetaAdsInitializer.kt

@@ -21,6 +21,8 @@ object MetaAdsInitializer : AudienceNetworkAds.InitListener {
 
   fun isReady(): Boolean = synchronized(lock) { state == State.READY }
 
+  fun clearPending() = synchronized(lock) { pending.clear() }
+
   fun whenReady(context: Context, callback: (success: Boolean, message: String) -> Unit) {
     val appContext = context.applicationContext
     var startInit = false

package/android/src/main/java/expo/modules/ads/meta/MetaAdsModule.kt

@@ -8,90 +8,295 @@ import expo.modules.kotlin.modules.ModuleDefinition
 
 class MetaAdsModule : Module() {
   init {
-    Log.d("ExpoAdsMeta", "🔥 MetaAdsModule INSTANCE CREATED")
+    Log.d("MetaAds", "🔥 MetaAdsModule INSTANCE CREATED")
   }
-  
-  override fun definition() = ModuleDefinition {
-    Name("MetaAds")   // the name JS uses to find this module (import from "expo-ads/meta")
-
-    // Runs automatically when the module loads (warm-up)
-    OnCreate {
-      val ctx = appContext.reactContext
-      if (ctx == null) {
-        Log.w(MetaAdsInitializer.TAG, "[Module] OnCreate: React context is null, skipping warm-up")
-      } else {
-        Log.d(MetaAdsInitializer.TAG, "[Module] OnCreate: starting SDK warm-up")
-        MetaAdsInitializer.whenReady(ctx) { _, _ -> }
+
+  override fun definition() =
+    ModuleDefinition {
+      Name("MetaAds") // the name JS uses to find this module (import from "expo-ads/meta")
+
+      // Runs automatically when the module loads (warm-up)
+      OnCreate {
+        val ctx = appContext.reactContext
+        if (ctx == null) {
+          Log.w(MetaAdsInitializer.TAG, "[Module] OnCreate: React context is null, skipping warm-up")
+        } else {
+          Log.d(MetaAdsInitializer.TAG, "[Module] OnCreate: starting SDK warm-up")
+          MetaAdsInitializer.whenReady(ctx) { _, _ -> }
+        }
       }
-    }
 
-    // Lets JS call: await MetaAds.initialize()
-    AsyncFunction("initialize") { promise: Promise ->
-      val ctx = appContext.reactContext
-      if (ctx == null) {
-        Log.e(MetaAdsInitializer.TAG, "[Module] initialize() called from JS but React context is null")
-        promise.reject("ERR_NO_CONTEXT", "React context not available", null)
-        return@AsyncFunction
+      OnDestroy {
+        MetaAdsInitializer.clearPending()
+        MetaInterstitialManager.destroyAll()
+        MetaRewardedInterstitialManager.destroyAll()
       }
-      Log.d(MetaAdsInitializer.TAG, "[Module] initialize() called from JS")
-      MetaAdsInitializer.whenReady(ctx) { ok, msg ->
-        if (ok) promise.resolve(msg) else promise.reject("ERR_META_INIT", msg, null)
+
+      Events("onInterstitialEvent", "onRewardedEvent", "onRewardedInterstitialEvent")
+
+      // Lets JS call: await MetaAds.initialize()
+      AsyncFunction("initialize") { promise: Promise ->
+        val ctx = appContext.reactContext
+        if (ctx == null) {
+          Log.e(MetaAdsInitializer.TAG, "[Module] initialize() called from JS but React context is null")
+          promise.reject("ERR_NO_CONTEXT", "React context not available", null)
+          return@AsyncFunction
+        }
+        Log.d(MetaAdsInitializer.TAG, "[Module] initialize() called from JS")
+        MetaAdsInitializer.whenReady(ctx) { ok, msg ->
+          if (ok) promise.resolve(msg) else promise.reject("ERR_META_INIT", msg, null)
+        }
       }
-    }
 
-    // Lets JS call: await MetaAds.setTestMode(true)
-    //
-    // This is a plain static AdSettings toggle with no I/O, so it's a synchronous Function
-    // rather than an AsyncFunction — but it's still safe (and expected) to `await` it from
-    // JS, since every native function on this module returns a Promise from the JS side
-    // regardless of whether it's sync or async natively.
-    //
-    // Deliberately NOT gated on MetaAdsInitializer.isReady(): Meta's own docs call this
-    // (and addTestDevices) *before* the SDK finishes async initialization — test mode and
-    // test devices must be registered before the first loadAd() call, not after init.
-    Function("setTestMode") { enabled: Boolean ->
-      Log.d(MetaAdsInitializer.TAG, "[Module] setTestMode($enabled)")
-      AdSettings.setTestMode(enabled)
-    }
+      // Lets JS call: await MetaAds.setTestMode(true)
+      //
+      // This is a plain static AdSettings toggle with no I/O, so it's a synchronous Function
+      // rather than an AsyncFunction — but it's still safe (and expected) to `await` it from
+      // JS, since every native function on this module returns a Promise from the JS side
+      // regardless of whether it's sync or async natively.
+      //
+      // Deliberately NOT gated on MetaAdsInitializer.isReady(): Meta's own docs call this
+      // (and addTestDevices) *before* the SDK finishes async initialization — test mode and
+      // test devices must be registered before the first loadAd() call, not after init.
+      Function("setTestMode") { enabled: Boolean ->
+        Log.d(MetaAdsInitializer.TAG, "[Module] setTestMode($enabled)")
+        AdSettings.setTestMode(enabled)
+      }
 
-    // Lets JS call: await MetaAds.addTestDevices(["HASHED_ID_1", "HASHED_ID_2"])
-    //
-    // Accepts a list so a single call can register every test device hash at once; each
-    // hash is normally copied from Logcat the first time a real ad request is made on that
-    // device (see MetaAdsInitializer's warm-up call in OnCreate above, or any loadAd()).
-    Function("addTestDevices") { deviceHashes: List<String> ->
-      Log.d(MetaAdsInitializer.TAG, "[Module] addTestDevices(${deviceHashes.size} device(s))")
-      AdSettings.addTestDevices(deviceHashes)
-    }
+      // Lets JS call: await MetaAds.addTestDevices(["HASHED_ID_1", "HASHED_ID_2"])
+      //
+      // Accepts a list so a single call can register every test device hash at once; each
+      // hash is normally copied from Logcat the first time a real ad request is made on that
+      // device (see MetaAdsInitializer's warm-up call in OnCreate above, or any loadAd()).
+      Function("addTestDevices") { deviceHashes: List<String> ->
+        Log.d(MetaAdsInitializer.TAG, "[Module] addTestDevices(${deviceHashes.size} device(s))")
+        AdSettings.addTestDevices(deviceHashes)
+      }
 
-    // Lets JS call: await MetaAds.clearTestDevices()
-    //
-    // Mirrors Meta's documented "before shipping" cleanup step
-    // (AdSettings.setTestMode(false); AdSettings.clearTestDevices();). Exposed separately
-    // from setTestMode(false) so callers can clear registered device hashes independently.
-    Function("clearTestDevices") {
-      Log.d(MetaAdsInitializer.TAG, "[Module] clearTestDevices()")
-      AdSettings.clearTestDevices()
-    }
+      // Lets JS call: await MetaAds.clearTestDevices()
+      //
+      // Mirrors Meta's documented "before shipping" cleanup step
+      // (AdSettings.setTestMode(false); AdSettings.clearTestDevices();). Exposed separately
+      // from setTestMode(false) so callers can clear registered device hashes independently.
+      Function("clearTestDevices") {
+        Log.d(MetaAdsInitializer.TAG, "[Module] clearTestDevices()")
+        AdSettings.clearTestDevices()
+      }
 
-    // Banner ad native view, exposed to JS as <ExpoAdsMetaBannerView>.
-    View(MetaBannerAdView::class) {
-      Events("onAdLoaded", "onAdFailedToLoad", "onAdClicked", "onLoggingImpression")
+      AsyncFunction("interstitialLoad") { requestId: Int, unitId: String ->
+        val emit: InterstitialEmitter = { body ->
+          try {
+            sendEvent("onInterstitialEvent", body)
+          } catch (
+            e: Exception,
+          ) {
+            Log.w(MetaAdsInitializer.TAG, "[Interstitial] sendEvent failed: ${e.message}")
+          }
+        }
+        val ctx = appContext.currentActivity ?: appContext.reactContext
+        if (ctx == null) {
+          emit(
+            mapOf(
+              "requestId" to requestId,
+              "type" to "error",
+              "code" to "ERR_NO_CONTEXT",
+              "message" to "No Activity/React context available",
+            ),
+          )
+          return@AsyncFunction
+        }
+        MetaInterstitialManager.runOnMain {
+          MetaInterstitialManager.load(ctx, requestId, unitId, emit)
+        }
+      }
+
+      AsyncFunction("interstitialShow") { requestId: Int, promise: Promise ->
+        MetaInterstitialManager.runOnMain {
+          val failure = MetaInterstitialManager.show(requestId)
+          if (failure == null) {
+            promise.resolve(null)
+          } else {
+            promise.reject(failure.first, failure.second, null)
+          }
+        }
+      }
 
-      Prop("unitId") { view: MetaBannerAdView, value: String? ->
-        view.setUnitId(value)
+      Function("interstitialDestroy") { requestId: Int ->
+        MetaInterstitialManager.runOnMain { MetaInterstitialManager.destroy(requestId) }
       }
-      
-      Prop("size") { view: MetaBannerAdView, value: MetaBannerAdSize ->
-        view.setSize(value)
+
+      AsyncFunction("rewardedLoad") { requestId: Int, unitId: String, userId: String?, currency: String? ->
+        val emit: RewardedEmitter = { body ->
+          try {
+            sendEvent("onRewardedEvent", body)
+          } catch (e: Exception) {
+            Log.w(MetaAdsInitializer.TAG, "[Rewarded] sendEvent failed: ${e.message}")
+          }
+        }
+        val ctx = appContext.currentActivity ?: appContext.reactContext
+        if (ctx == null) {
+          emit(
+            mapOf(
+              "requestId" to requestId,
+              "type" to "error",
+              "code" to "ERR_NO_CONTEXT",
+              "message" to "No Activity/React context available",
+            ),
+          )
+          return@AsyncFunction
+        }
+        MetaRewardedManager.runOnMain {
+          MetaRewardedManager.load(ctx, requestId, unitId, userId, currency, emit)
+        }
+      }
+
+      AsyncFunction("rewardedShow") { requestId: Int, promise: Promise ->
+        val emit: RewardedEmitter = { body ->
+          try {
+            sendEvent("onRewardedEvent", body)
+          } catch (e: Exception) {
+            Log.w(MetaAdsInitializer.TAG, "[Rewarded] sendEvent failed: ${e.message}")
+          }
+        }
+        MetaRewardedManager.runOnMain {
+          val failure = MetaRewardedManager.show(requestId, emit)
+          if (failure == null) promise.resolve(null) else promise.reject(failure.first, failure.second, null)
+        }
       }
 
-      // Fires after unitId/size are applied for this commit, mirroring the
-      // onAfterUpdateTransaction "props changed -> (re)request" pattern used by the reference
-      // Google Mobile Ads ViewManager, but expressed as an Expo Modules view lifecycle hook.
-      OnViewDidUpdateProps { view: MetaBannerAdView ->
-        view.requestAd()
+      AsyncFunction("rewardedIsValid") { requestId: Int, promise: Promise ->
+        MetaRewardedManager.runOnMain { promise.resolve(MetaRewardedManager.isValid(requestId)) }
+      }
+
+      Function("rewardedDestroy") { requestId: Int ->
+        MetaRewardedManager.runOnMain { MetaRewardedManager.destroy(requestId) }
+      }
+
+      AsyncFunction("rewardedInterstitialLoad") { requestId: Int, unitId: String, userId: String?, currency: String? ->
+        val emit: RewardedInterstitialEmitter = { body ->
+          try {
+            sendEvent("onRewardedInterstitialEvent", body)
+          } catch (
+            e: Exception,
+          ) {
+            Log.w(MetaAdsInitializer.TAG, "[RewardedInterstitial] sendEvent failed: ${e.message}")
+          }
+        }
+        val ctx = appContext.currentActivity ?: appContext.reactContext
+        if (ctx == null) {
+          emit(
+            mapOf(
+              "requestId" to requestId,
+              "type" to "error",
+              "code" to "ERR_NO_CONTEXT",
+              "message" to "No Activity/React context available",
+            ),
+          )
+          return@AsyncFunction
+        }
+        MetaRewardedInterstitialManager.runOnMain {
+          MetaRewardedInterstitialManager.load(ctx, requestId, unitId, userId, currency, emit)
+        }
+      }
+
+      AsyncFunction("rewardedInterstitialShow") { requestId: Int, promise: Promise ->
+        val emit: RewardedInterstitialEmitter = { body ->
+          try {
+            sendEvent("onRewardedInterstitialEvent", body)
+          } catch (
+            e: Exception,
+          ) {
+            Log.w(MetaAdsInitializer.TAG, "[RewardedInterstitial] sendEvent failed: ${e.message}")
+          }
+        }
+        MetaRewardedInterstitialManager.runOnMain {
+          val failure = MetaRewardedInterstitialManager.show(requestId, emit)
+          if (failure == null) promise.resolve(null) else promise.reject(failure.first, failure.second, null)
+        }
+      }
+
+      AsyncFunction("rewardedInterstitialIsValid") { requestId: Int, promise: Promise ->
+        MetaRewardedInterstitialManager.runOnMain { promise.resolve(MetaRewardedInterstitialManager.isValid(requestId)) }
+      }
+
+      Function("rewardedInterstitialDestroy") { requestId: Int ->
+        MetaRewardedInterstitialManager.runOnMain { MetaRewardedInterstitialManager.destroy(requestId) }
+      }
+
+      // Banner ad native view, exposed to JS as <MetaBannerAdView>.
+      View(MetaBannerAdView::class) {
+        Events("onAdLoaded", "onAdFailedToLoad", "onAdClicked", "onLoggingImpression")
+
+        Prop("unitId") { view: MetaBannerAdView, value: String? ->
+          view.setUnitId(value)
+        }
+
+        Prop("size") { view: MetaBannerAdView, value: MetaBannerAdSize ->
+          view.setSize(value)
+        }
+
+        // Fires after unitId/size are applied for this commit, mirroring the
+        // onAfterUpdateTransaction "props changed -> (re)request" pattern used by the reference
+        // Google Mobile Ads ViewManager, but expressed as an Expo Modules view lifecycle hook.
+        OnViewDidUpdateProps { view: MetaBannerAdView -> view.requestAd() }
+
+        OnViewDestroys { view: MetaBannerAdView -> view.cleanup() }
+      }
+
+      AsyncFunction("nativeAdLoad") { unitId: String, promise: Promise ->
+        val ctx = appContext.currentActivity ?: appContext.reactContext
+        if (ctx == null) {
+          promise.reject("ERR_NO_CONTEXT", "No Activity/React context available", null)
+          return@AsyncFunction
+        }
+        MetaNativeAdManager.runOnMain {
+          MetaNativeAdManager.load(
+            ctx,
+            unitId,
+            emit = { body ->
+              try {
+                sendEvent("onNativeAdEvent", body)
+              } catch (
+                e: Exception,
+              ) {
+                Log.w(MetaAdsInitializer.TAG, "[Native] sendEvent failed: ${e.message}")
+              }
+            },
+            onLoaded = { promise.resolve(it) },
+            onFailed = { code, msg -> promise.reject(code, msg, null) },
+          )
+        }
+      }
+
+      Function("nativeAdDestroy") { adId: String ->
+        MetaNativeAdManager.runOnMain { MetaNativeAdManager.destroy(adId) }
+      }
+
+      View(MetaNativeAdView::class) {
+        Prop("adId") { view: MetaNativeAdView, value: String? -> view.setAdId(value) }
+
+        AsyncFunction("registerAsset") { view: MetaNativeAdView, assetType: String, reactTag: Int ->
+          view.registerAsset(assetType, reactTag)
+        }
+
+        GroupView<MetaNativeAdView> {
+          AddChildView { parent: MetaNativeAdView, child: android.view.View, index: Int ->
+            parent.addChild(child, index)
+          }
+          GetChildCount { parent -> parent.childCount() }
+          GetChildViewAt { parent, index -> parent.childAt(index) }
+          RemoveChildViewAt { parent, index -> parent.removeChildAt(index) }
+        }
+
+        OnViewDestroys { view: MetaNativeAdView -> view.cleanup() }
+      }
+      View(MetaNativeMediaView::class) {}
+      View(MetaNativeIconView::class) {}
+      View(MetaNativeAdOptionsView::class) {
+        Prop("orientation") { view: MetaNativeAdOptionsView, v: String? -> view.setOrientation(v) }
+        Prop("iconSize") { view: MetaNativeAdOptionsView, v: Int? -> view.setIconSize(v) }
+        Prop("iconColor") { view: MetaNativeAdOptionsView, v: Int? -> view.setIconColor(v) }
+        OnViewDidUpdateProps { view: MetaNativeAdOptionsView -> view.rebuild() }
       }
     }
-  }
-}
+}

package/android/src/main/java/expo/modules/ads/meta/MetaBannerAdView.kt

@@ -18,88 +18,101 @@ class MetaBannerAdView(context: Context, appContext: AppContext) : ExpoView(cont
   private var adView: AdView? = null
   private var unitId: String? = null
   private var size: MetaBannerAdSize = MetaBannerAdSize.BANNER_HEIGHT_50
+  private var loadedUnitId: String? = null
+  private var loadedSize: MetaBannerAdSize? = null
+  private var destroyed = false
 
   private val onAdLoaded by EventDispatcher()
   private val onAdFailedToLoad by EventDispatcher()
   private val onAdClicked by EventDispatcher()
   private val onLoggingImpression by EventDispatcher()
 
-  fun setUnitId(value: String?) {
-    unitId = value
-  }
+  fun setUnitId(value: String?) { unitId = value }
+  fun setSize(value: MetaBannerAdSize) { size = value }
 
-  fun setSize(value: MetaBannerAdSize) {
-    size = value
+  // Swallows dispatches to a dead React context instead of crashing
+  private fun safeDispatch(block: () -> Unit) {
+    if (destroyed) return
+    try {
+      block()
+    } catch (e: Exception) {
+      Log.w(TAG, "[Banner] event dispatch failed: ${e.message}")
+    }
   }
 
-  /**
-   * Called from `OnViewDidUpdateProps` in MetaAdsModule after unitId/size are applied for a
-   * commit (mirroring the "props changed -> (re)request" pattern from the reference Google
-   * Mobile Ads ViewManager's onAfterUpdateTransaction). Runs the two required guards, in
-   * order, before ever touching the SDK:
-   *   1. Ad unit must be configured — otherwise don't build a request at all.
-   *   2. SDK must already report READY — otherwise tell the caller to initialize first.
-   * Neither failure throws; both are surfaced to JS as onAdFailedToLoad so callers can
-   * handle them the same way they'd handle any other load failure.
-   */
   fun requestAd() {
+    if (destroyed) return
     val currentUnitId = unitId
 
     if (currentUnitId.isNullOrBlank()) {
       val message = "Meta banner ad request skipped: no adUnitId was provided. Set the " +
         "`unitId` prop on <MetaBannerAd> to a valid Audience Network placement ID."
       Log.e(TAG, "[Banner] $message")
-      onAdFailedToLoad(mapOf("code" to "ERR_NO_AD_UNIT", "message" to message))
+      safeDispatch { onAdFailedToLoad(mapOf("code" to "ERR_NO_AD_UNIT", "message" to message)) }
       return
     }
 
     if (!MetaAdsInitializer.isReady()) {
       val message = "Meta banner ad request skipped: Audience Network SDK is not initialized " +
-        "yet. Call ExpoAdsMeta.initialize() and wait for it to resolve before requesting a " +
+        "yet. Call MetaAds.initialize() and wait for it to resolve before requesting a " +
         "banner ad."
       Log.e(TAG, "[Banner] $message")
-      onAdFailedToLoad(mapOf("code" to "ERR_NOT_INITIALIZED", "message" to message))
+      safeDispatch { onAdFailedToLoad(mapOf("code" to "ERR_NOT_INITIALIZED", "message" to message)) }
       return
     }
 
+    // Skip redundant reloads when nothing changed
+    if (adView != null && loadedUnitId == currentUnitId && loadedSize == size) return
+
     loadAd(currentUnitId, size)
   }
 
   private fun loadAd(currentUnitId: String, currentSize: MetaBannerAdSize) {
-    // Tear down any previous ad view before creating a new one (unit or size may have changed).
     destroyAdView()
+    loadedUnitId = currentUnitId
+    loadedSize = currentSize
 
     val newAdView = AdView(context, currentUnitId, currentSize.toFacebookAdSize())
     adView = newAdView
 
     val adListener = object : AdListener {
       override fun onError(ad: Ad, adError: AdError) {
+        if (adView !== newAdView) return // stale callback from a replaced ad
         Log.e(TAG, "[Banner] onError: ${adError.errorCode} ${adError.errorMessage}")
-        onAdFailedToLoad(
-          mapOf(
-            "code" to adError.errorCode.toString(),
-            "message" to adError.errorMessage,
+        safeDispatch {
+          onAdFailedToLoad(
+            mapOf(
+              "code" to adError.errorCode.toString(),
+              "message" to adError.errorMessage,
+            )
           )
-        )
+        }
       }
 
       override fun onAdLoaded(ad: Ad) {
+        if (adView !== newAdView) return
         Log.d(TAG, "[Banner] onAdLoaded")
-        onAdLoaded(
-          mapOf(
-            "width" to currentSize.toFacebookAdSize().width,
-            "height" to currentSize.toFacebookAdSize().height,
+        safeDispatch {
+          onAdLoaded(
+            mapOf(
+              "width" to currentSize.toFacebookAdSize().width,
+              "height" to currentSize.toFacebookAdSize().height,
+            )
           )
-        )
+        }
+        // Force a layout pass so RN shows the natively-added child
+        post {
+          measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+          )
+          layout(left, top, right, bottom)
+        }
       }
 
-      override fun onAdClicked(ad: Ad) {
-        onAdClicked(emptyMap())
-      }
+      override fun onAdClicked(ad: Ad) = safeDispatch { onAdClicked(emptyMap()) }
 
-      override fun onLoggingImpression(ad: Ad) {
-        onLoggingImpression(emptyMap())
-      }
+      override fun onLoggingImpression(ad: Ad) = safeDispatch { onLoggingImpression(emptyMap()) }
     }
 
     addView(
@@ -107,21 +120,48 @@ class MetaBannerAdView(context: Context, appContext: AppContext) : ExpoView(cont
       ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
     )
 
-    // AdView has no setAdListener(...) setter — the listener is attached through the
-    // load-config builder and only takes effect for this particular loadAd() call.
     newAdView.loadAd(newAdView.buildLoadAdConfig().withAdListener(adListener).build())
   }
 
   private fun destroyAdView() {
     adView?.let {
-      removeView(it)
-      it.destroy()
+      try {
+        removeView(it)
+        it.destroy()
+      } catch (e: Exception) {
+        Log.w(TAG, "[Banner] destroy failed: ${e.message}")
+      }
     }
     adView = null
+    loadedUnitId = null
+    loadedSize = null
+  }
+
+  // Called from OnViewDestroys in MetaAdsModule when React drops this view
+  fun cleanup() {
+    destroyed = true
+    destroyAdView()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    destroyed = false
   }
 
   override fun onDetachedFromWindow() {
     destroyAdView()
     super.onDetachedFromWindow()
   }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+    adView?.measure(
+      MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.AT_MOST)
+    )
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    adView?.let { it.layout(0, 0, it.measuredWidth, it.measuredHeight) }
+  }
 }