cloudx-react-native 3.11.0 → 3.11.1

package/android/build.gradle

@@ -158,7 +158,7 @@ repositories {
 dependencies {
     implementation "com.facebook.react:react-native:0.76.2"
 
-    implementation "io.cloudx:sdk:4.10.0"
+    implementation "io.cloudx:sdk:4.12.0"
 
     testImplementation "junit:junit:4.13.2"
     testImplementation "io.mockk:mockk:1.13.10"

package/android/src/main/java/com/cloudxreactnative/CloudXAdEvents.kt

@@ -52,12 +52,21 @@ object CloudXAdEvents {
     const val ON_REWARDED_AD_RECEIVED_REWARD_EVENT = "OnRewardedAdReceivedRewardEvent"
     const val ON_REWARDED_AD_REVENUE_PAID = "OnRewardedAdRevenuePaid"
 
+    // Preloaded Native Ad Module Events
+    const val ON_NATIVE_AD_CLICKED_EVENT = "OnNativeAdClickedEvent"
+    const val ON_NATIVE_AD_EXPIRED_EVENT = "OnNativeAdExpiredEvent"
+    const val ON_NATIVE_AD_CLOSED_EVENT = "OnNativeAdClosedEvent"
+    const val ON_NATIVE_AD_REVENUE_PAID = "OnNativeAdRevenuePaid"
 
     // In-tree Native Ad View component (CloudXNativeAdView) per-view direct events.
     // These strings are both the event key and the JS prop registrationName.
     const val ON_NATIVE_AD_VIEW_LOADED_EVENT = "onAdLoadedEvent"
     const val ON_NATIVE_AD_VIEW_LOAD_FAILED_EVENT = "onAdLoadFailedEvent"
+    const val ON_NATIVE_AD_VIEW_DISPLAYED_EVENT = "onAdDisplayedEvent"
     const val ON_NATIVE_AD_VIEW_DISPLAY_FAILED_EVENT = "onAdDisplayFailedEvent"
+    // Internal: native released the view's ad (destroy, expiry, or a newer view
+    // took it), so the JS view clears its asset components. Not a publisher callback.
+    const val ON_NATIVE_AD_VIEW_BINDING_CLEARED_EVENT = "onAdBindingClearedEvent"
     const val ON_NATIVE_AD_VIEW_CLICKED_EVENT = "onAdClickedEvent"
     const val ON_NATIVE_AD_VIEW_EXPIRED_EVENT = "onAdExpiredEvent"
     const val ON_NATIVE_AD_VIEW_CLOSED_EVENT = "onAdClosedEvent"

package/android/src/main/java/com/cloudxreactnative/CloudXAdInfo.kt

@@ -1,11 +1,14 @@
 package com.cloudxreactnative
 
 import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
 import android.util.Base64
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import io.cloudx.sdk.CloudXAd
 import io.cloudx.sdk.CloudXError
+import io.cloudx.sdk.CloudXNativeAd
+import org.json.JSONObject
 import java.io.ByteArrayOutputStream
 
 fun getAdInfo(ad: CloudXAd): WritableMap {
@@ -22,6 +25,79 @@ fun getAdInfo(ad: CloudXAd): WritableMap {
     return map
 }
 
+/**
+ * Single source of truth for native ad metadata JSON serialization.
+ * Used by both CloudXNativeAdView's nativeAdJson string field and the
+ * preloaded module's nativeAd WritableMap dictionary.
+ */
+fun nativeAdMetadataJsonObject(nativeAd: CloudXNativeAd): JSONObject {
+    val iconImageSource = nativeAd.icon?.let { icon ->
+        if (icon.uri == null) {
+            (icon.drawable as? BitmapDrawable)?.bitmap?.let(::bitmapToBase64Png)
+        } else {
+            null
+        }
+    }
+    val json = JSONObject()
+    json.put("title", nativeAd.title ?: JSONObject.NULL)
+    json.put("advertiser", nativeAd.advertiser ?: JSONObject.NULL)
+    json.put("body", nativeAd.body ?: JSONObject.NULL)
+    json.put("callToAction", nativeAd.callToAction ?: JSONObject.NULL)
+    nativeAd.starRating?.let { json.put("starRating", it) }
+    if (nativeAd.mediaContentAspectRatio > 0f) {
+        json.put("mediaContentAspectRatio", nativeAd.mediaContentAspectRatio.toDouble())
+    }
+    val iconAvailable = nativeAd.icon != null
+    json.put("isIconImageAvailable", iconAvailable)
+    json.put("isOptionsViewAvailable", nativeAd.optionsView != null)
+    json.put("isMediaViewAvailable", nativeAd.mediaView != null)
+    nativeAd.icon?.let { icon ->
+        icon.uri?.let { json.put("url", it.toString()) }
+        if (icon.uri == null) {
+            iconImageSource?.let { json.put("imageSource", it) }
+        }
+    }
+    json.put("isVideoContent", nativeAd.isVideoContent)
+    json.put("videoDuration", nativeAd.videoDuration)
+    json.put("isExpired", nativeAd.isExpired)
+    return json
+}
+
+fun nativeAdMetadataJson(nativeAd: CloudXNativeAd): String =
+    nativeAdMetadataJsonObject(nativeAd).toString()
+
+fun nativeAdMetadataMap(nativeAd: CloudXNativeAd): WritableMap {
+    val json = nativeAdMetadataJsonObject(nativeAd)
+    val map = Arguments.createMap()
+    val keys = json.keys()
+    while (keys.hasNext()) {
+        val key = keys.next()
+        if (json.isNull(key)) {
+            map.putNull(key)
+        } else {
+            when (val value = json.get(key)) {
+                is Boolean -> map.putBoolean(key, value)
+                is Double -> map.putDouble(key, value)
+                is Number -> map.putDouble(key, value.toDouble())
+                is String -> map.putString(key, value)
+                else -> map.putString(key, value.toString())
+            }
+        }
+    }
+    return map
+}
+
+fun getNativeAdInfo(ad: CloudXAd, nativeAdId: String? = null): WritableMap {
+    val map = getAdInfo(ad)
+    ad.nativeAd?.let { nativeAd ->
+        map.putMap("nativeAd", nativeAdMetadataMap(nativeAd))
+    }
+    if (nativeAdId != null) {
+        map.putString("nativeAdId", nativeAdId)
+    }
+    return map
+}
+
 /**
  * Icon encoding for CloudXNativeAdView's codegen-typed `nativeAdJson`
  * direct-event field, which can't carry a nested WritableMap. Capped at 96px

package/android/src/main/java/com/cloudxreactnative/CloudXModuleImpl.kt

@@ -30,6 +30,7 @@ import io.cloudx.sdk.CloudXArbiterListener
 import io.cloudx.sdk.CloudXArbiterPrecision
 import io.cloudx.sdk.CloudXArbiterResult
 import io.cloudx.sdk.CloudXError
+import io.cloudx.sdk.CloudXErrorCode
 import io.cloudx.sdk.CloudXInitializationConfiguration
 import io.cloudx.sdk.CloudXInitializationListener
 import io.cloudx.sdk.CloudXAppOpenAd
@@ -44,7 +45,9 @@ import io.cloudx.sdk.CloudXReward
 import io.cloudx.sdk.CloudXRewardedAd
 import io.cloudx.sdk.CloudXRewardedListener
 import io.cloudx.sdk.CloudXSdkConfiguration
+import io.cloudx.sdk.CloudXNativeAdLoader
 import java.util.Locale
+import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 
 class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationContext) : LifecycleEventListener {
@@ -56,6 +59,7 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     private val interstitials = ConcurrentHashMap<String, CloudXInterstitialAd>()
     private val appOpenAds = ConcurrentHashMap<String, CloudXAppOpenAd>()
     private val rewardedAds = ConcurrentHashMap<String, CloudXRewardedAd>()
+    private val nativeAdHolders = ConcurrentHashMap<String, CloudXNativeAdHolder>()
     private val adViews = ConcurrentHashMap<String, SdkAdView>()
     private val adViewAdFormats = ConcurrentHashMap<String, CloudXAdFormat>()
     private val adViewPositions = ConcurrentHashMap<String, String>()
@@ -448,6 +452,91 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
         }
     }
 
+    // =========================================================================
+    // Native (Preloaded)
+    // =========================================================================
+
+    fun getHolder(nativeAdId: String): CloudXNativeAdHolder? = nativeAdHolders[nativeAdId]
+
+    fun loadNativeAd(adUnitId: String, options: ReadableMap, promise: Promise) {
+        onUiThread {
+            if (!CloudX.isInitialized()) {
+                promise.reject(
+                    CloudXErrorCode.NOT_INITIALIZED.code.toString(),
+                    "CloudX SDK is not initialized"
+                )
+                return@onUiThread
+            }
+            if (adUnitId.isBlank()) {
+                promise.reject(
+                    CloudXErrorCode.INVALID_AD_UNIT.code.toString(),
+                    "Invalid or empty adUnitId"
+                )
+                return@onUiThread
+            }
+
+            val nativeAdId = UUID.randomUUID().toString()
+            val loader = CloudX.createNativeAdLoader(reactApplicationContext, adUnitId)
+            applyNativeAdOptions(loader, options)
+
+            val holder = CloudXNativeAdHolder(
+                nativeAdId = nativeAdId,
+                adUnitId = adUnitId,
+                loader = loader,
+                onEvent = { eventName, payload -> sendReactNativeEvent(eventName, payload) },
+                onLoadSuccess = { adInfo ->
+                    val result = Arguments.createMap()
+                    result.putString("nativeAdId", nativeAdId)
+                    result.putMap("adInfo", adInfo)
+                    promise.resolve(result)
+                },
+                onLoadFailure = { error ->
+                    promise.reject(error.code.code.toString(), error.message)
+                    nativeAdHolders.remove(nativeAdId)
+                }
+            )
+
+            nativeAdHolders[nativeAdId] = holder
+            loader.nativeAdListener = holder
+            loader.revenueListener = holder
+
+            try {
+                loader.loadAd()
+            } catch (e: Exception) {
+                Log.e(TAG, "loadNativeAd: failed to start load", e)
+                promise.reject(CloudXErrorCode.INTERNAL_ERROR.code.toString(), e.message ?: "Internal error")
+                nativeAdHolders.remove(nativeAdId)
+                holder.destroy()
+            }
+        }
+    }
+
+    fun destroyNativeAd(nativeAdId: String) {
+        onUiThread {
+            if (nativeAdId.isBlank()) return@onUiThread
+            val holder = nativeAdHolders.remove(nativeAdId) ?: return@onUiThread
+            holder.destroy()
+        }
+    }
+
+    private fun applyNativeAdOptions(loader: CloudXNativeAdLoader, options: ReadableMap) {
+        fun string(key: String) = if (options.hasKey(key) && !options.isNull(key)) options.getString(key) else null
+        fun flag(key: String) = options.hasKey(key) && !options.isNull(key) && options.getBoolean(key)
+        // Extras arrive as {key, value} entries, the wire format CloudXNativeAdView also receives.
+        fun entries(key: String) =
+            if (options.hasKey(key) && !options.isNull(key)) CloudXExtraParameters.entryArrayToMap(options.getArray(key)) else emptyMap()
+
+        loader.applyLoadOptions(
+            placement = string("placement"),
+            customData = string("customData"),
+            disableVideoFullScreen = flag("disableVideoFullScreen"),
+            startVideoUnmuted = flag("startVideoUnmuted"),
+            hideVideoMediaControls = flag("hideVideoMediaControls"),
+        )
+        for ((key, value) in entries("extraParameters")) loader.setExtraParameter(key, value)
+        for ((key, value) in entries("localExtraParameters")) loader.setLocalExtraParameter(key, value)
+    }
+
     // =========================================================================
     // Listener Factories
     // =========================================================================
@@ -1205,6 +1294,23 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
             }
             rewardedAds.clear()
         }
+        // Preloaded native ads are not released here. React Native calls
+        // onHostDestroy whenever the Activity goes away while JS lives on (a
+        // configuration change, or leaving the app and coming back), and a
+        // held ad is the handle's until destroyNativeAd, expiry or module
+        // invalidation. Their loaders use the application context, so they
+        // hold nothing tied to the Activity.
+    }
+
+    fun invalidate() {
+        onHostDestroy()
+        // JS is going away with the module, so no handle remains to own them.
+        onUiThread {
+            for (holder in nativeAdHolders.values) {
+                holder.destroy()
+            }
+            nativeAdHolders.clear()
+        }
     }
 
     // =========================================================================
@@ -1256,5 +1362,9 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
         "ON_REWARDED_AD_HIDDEN_EVENT" to CloudXAdEvents.ON_REWARDED_AD_HIDDEN_EVENT,
         "ON_REWARDED_AD_RECEIVED_REWARD_EVENT" to CloudXAdEvents.ON_REWARDED_AD_RECEIVED_REWARD_EVENT,
         "ON_REWARDED_AD_REVENUE_PAID" to CloudXAdEvents.ON_REWARDED_AD_REVENUE_PAID,
+        "ON_NATIVE_AD_CLICKED_EVENT" to CloudXAdEvents.ON_NATIVE_AD_CLICKED_EVENT,
+        "ON_NATIVE_AD_EXPIRED_EVENT" to CloudXAdEvents.ON_NATIVE_AD_EXPIRED_EVENT,
+        "ON_NATIVE_AD_CLOSED_EVENT" to CloudXAdEvents.ON_NATIVE_AD_CLOSED_EVENT,
+        "ON_NATIVE_AD_REVENUE_PAID" to CloudXAdEvents.ON_NATIVE_AD_REVENUE_PAID,
     )
 }

package/android/src/main/java/com/cloudxreactnative/CloudXNativeAdHolder.kt

@@ -0,0 +1,184 @@
+package com.cloudxreactnative
+
+import android.util.Log
+import com.facebook.react.bridge.WritableMap
+import io.cloudx.sdk.CloudXAd
+import io.cloudx.sdk.CloudXAdRevenueListener
+import io.cloudx.sdk.CloudXError
+import io.cloudx.sdk.CloudXErrorCode
+import io.cloudx.sdk.CloudXNativeAdListener
+import io.cloudx.sdk.CloudXNativeAdLoader
+import io.cloudx.sdk.CloudXNativeAdView as SdkNativeAdView
+import io.cloudx.sdk.toCloudXError
+import java.lang.ref.WeakReference
+
+/**
+ * Holds a preloaded native ad loaded without a view.
+ *
+ * Implements [CloudXNativeAdListener] and [CloudXAdRevenueListener] so all lifecycle
+ * and revenue events fire on the module handle. Bound views borrow the held ad for
+ * display without taking ownership of the loader or ad lifecycle.
+ */
+class CloudXNativeAdHolder(
+    val nativeAdId: String,
+    val adUnitId: String,
+    val loader: CloudXNativeAdLoader,
+    private val onEvent: (String, WritableMap) -> Unit,
+    private var onLoadSuccess: ((WritableMap) -> Unit)? = null,
+    private var onLoadFailure: ((CloudXError) -> Unit)? = null,
+) : CloudXNativeAdListener, CloudXAdRevenueListener {
+
+    private companion object {
+        const val TAG = "CloudXNativeAdHolder"
+    }
+
+    var ad: CloudXAd? = null
+    var expired: Boolean = false
+
+    // Set by the ad's first revenue, which CloudX reports on its impression.
+    // Rendering alone does not count: an ad rendered into a view nobody saw
+    // can still move to another view, and its expiry is still reported.
+    var impressed: Boolean = false
+        private set
+
+    // Set once the ad has registered with a view for click and impression
+    // tracking. The Android one-view rule keys on this, not on the impression:
+    // the SDK tracks an impression before its revenue reaches this holder, so
+    // an impression-keyed rule leaves a window where a second view could
+    // register the ad and a partner could report it twice (CXD-6018).
+    var registered: Boolean = false
+        private set
+
+    fun markRegistered() {
+        registered = true
+    }
+    var boundView: WeakReference<CloudXNativeAdView>? = null
+    var isDestroyed: Boolean = false
+        private set
+
+    private var expiredEventEmitted: Boolean = false
+
+    override fun onNativeAdLoaded(adView: SdkNativeAdView?, ad: CloudXAd) {
+        if (isDestroyed) return
+        this.ad = ad
+        val callback = onLoadSuccess
+        onLoadSuccess = null
+        onLoadFailure = null
+        callback?.invoke(getNativeAdInfo(ad, nativeAdId))
+    }
+
+    override fun onNativeAdLoadFailed(adUnitId: String, error: CloudXError) {
+        if (isDestroyed) return
+        val callback = onLoadFailure
+        onLoadSuccess = null
+        onLoadFailure = null
+        callback?.invoke(error)
+        destroy()
+    }
+
+    override fun onNativeAdClicked(ad: CloudXAd) {
+        if (isDestroyed) return
+        val payload = getNativeAdInfo(ad, nativeAdId)
+        onEvent(CloudXAdEvents.ON_NATIVE_AD_CLICKED_EVENT, payload)
+    }
+
+    override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
+        if (isDestroyed) return
+        impressed = true
+        val payload = getNativeAdInfo(cloudXAd, nativeAdId)
+        onEvent(CloudXAdEvents.ON_NATIVE_AD_REVENUE_PAID, payload)
+    }
+
+    override fun onNativeAdClosed(ad: CloudXAd) {
+        if (isDestroyed) return
+        val payload = getNativeAdInfo(ad, nativeAdId)
+        onEvent(CloudXAdEvents.ON_NATIVE_AD_CLOSED_EVENT, payload)
+    }
+
+    override fun onNativeAdExpired(ad: CloudXAd) {
+        expired = true
+        if (impressed) {
+            Log.d(TAG, "Native ad $nativeAdId expired after its impression; ignoring.")
+            return
+        }
+
+        if (!expiredEventEmitted) {
+            expiredEventEmitted = true
+            val payload = getNativeAdInfo(ad, nativeAdId)
+            onEvent(CloudXAdEvents.ON_NATIVE_AD_EXPIRED_EVENT, payload)
+        }
+
+        // A view may still show the ad (rendered, never seen): clear it there
+        // as well, so nothing keeps showing an ad that can no longer pay.
+        val view = boundView?.get()
+        boundView = null
+        view?.onBoundNativeAdExpired()
+
+        val currentAd = this.ad ?: ad
+        loader.destroy(currentAd)
+        this.ad = null
+    }
+
+    /**
+     * Binds a view to this holder.
+     * One holder -> at most ONE bound view at a time. Latest bind wins:
+     * the previous view clears its rendered ad without emitting an event.
+     */
+    fun bindView(newView: CloudXNativeAdView) {
+        val previousView = boundView?.get()
+        if (previousView != null && previousView !== newView) {
+            previousView.clearRenderedAd()
+        }
+        boundView = WeakReference(newView)
+    }
+
+    fun unbindView(view: CloudXNativeAdView) {
+        if (boundView?.get() === view) {
+            boundView = null
+        }
+    }
+
+    /**
+     * Clears delegates, notifies any bound view of destruction, destroys the ad
+     * and loader, and marks this holder destroyed.
+     */
+    fun destroy() {
+        if (isDestroyed) return
+        isDestroyed = true
+
+        onLoadFailure?.invoke(CloudXErrorCode.AD_NOT_READY.toCloudXError("native ad destroyed"))
+        onLoadSuccess = null
+        onLoadFailure = null
+
+        loader.nativeAdListener = null
+        loader.revenueListener = null
+
+        val view = boundView?.get()
+        boundView = null
+        view?.onBoundNativeAdDestroyed()
+
+        ad?.let { loader.destroy(it) }
+        ad = null
+
+        loader.destroy()
+    }
+}
+
+/**
+ * Applies load-time options to a native ad loader. Shared by the module's
+ * preload path and the view's auto-load path so both configure loaders the
+ * same way.
+ */
+internal fun CloudXNativeAdLoader.applyLoadOptions(
+    placement: String?,
+    customData: String?,
+    disableVideoFullScreen: Boolean,
+    startVideoUnmuted: Boolean,
+    hideVideoMediaControls: Boolean,
+) {
+    setPlacement(placement)
+    setCustomData(customData)
+    isVideoFullScreenDisabled = disableVideoFullScreen
+    isStartVideoUnmuted = startVideoUnmuted
+    isVideoMediaControlsHidden = hideVideoMediaControls
+}