cloudx-react-native 3.4.6 → 3.6.0

package/android/build.gradle

@@ -72,5 +72,5 @@ repositories {
 dependencies {
     implementation "com.facebook.react:react-native:0.76.2"
 
-    implementation "io.cloudx:sdk:4.1.5"
+    implementation "io.cloudx:sdk:4.4.0"
 }

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

@@ -17,6 +17,13 @@ object CloudXAdEvents {
     const val ON_MREC_AD_COLLAPSED_EVENT = "OnMRecAdCollapsedEvent"
     const val ON_MREC_AD_REVENUE_PAID = "OnMRecAdRevenuePaid"
 
+    // In-tree Ad View component (CloudXBannerView / CloudXMRECView) per-view direct events.
+    // These strings are both the event key and the JS prop registrationName.
+    const val ON_AD_VIEW_LOADED_EVENT = "onAdLoadedEvent"
+    const val ON_AD_VIEW_LOAD_FAILED_EVENT = "onAdLoadFailedEvent"
+    const val ON_AD_VIEW_CLICKED_EVENT = "onAdClickedEvent"
+    const val ON_AD_VIEW_REVENUE_PAID_EVENT = "onAdRevenuePaidEvent"
+
     // Interstitial Events
     const val ON_INTERSTITIAL_LOADED_EVENT = "OnInterstitialLoadedEvent"
     const val ON_INTERSTITIAL_LOAD_FAILED_EVENT = "OnInterstitialLoadFailedEvent"
@@ -26,6 +33,15 @@ object CloudXAdEvents {
     const val ON_INTERSTITIAL_HIDDEN_EVENT = "OnInterstitialHiddenEvent"
     const val ON_INTERSTITIAL_AD_REVENUE_PAID = "OnInterstitialAdRevenuePaid"
 
+    // App Open Events
+    const val ON_APPOPEN_LOADED_EVENT = "OnAppOpenLoadedEvent"
+    const val ON_APPOPEN_LOAD_FAILED_EVENT = "OnAppOpenLoadFailedEvent"
+    const val ON_APPOPEN_CLICKED_EVENT = "OnAppOpenClickedEvent"
+    const val ON_APPOPEN_DISPLAYED_EVENT = "OnAppOpenDisplayedEvent"
+    const val ON_APPOPEN_DISPLAY_FAILED_EVENT = "OnAppOpenDisplayFailedEvent"
+    const val ON_APPOPEN_HIDDEN_EVENT = "OnAppOpenHiddenEvent"
+    const val ON_APPOPEN_AD_REVENUE_PAID = "OnAppOpenAdRevenuePaid"
+
     // Rewarded Events
     const val ON_REWARDED_AD_LOADED_EVENT = "OnRewardedAdLoadedEvent"
     const val ON_REWARDED_AD_LOAD_FAILED_EVENT = "OnRewardedAdLoadFailedEvent"

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

@@ -39,3 +39,17 @@ fun getAdDisplayFailedInfo(ad: CloudXAd, error: CloudXError): WritableMap {
     map.putString("message", error.message)
     return map
 }
+
+/**
+ * Synthetic display-failure payload for the no-current-activity show path.
+ * Mirrors the iOS no-view-controller payload ({adUnitId, code: -1, message})
+ * so JS can reset its isLoaded state instead of hanging on a show that
+ * silently never happened.
+ */
+fun getNoActivityDisplayFailedInfo(adUnitId: String): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("adUnitId", adUnitId)
+    map.putInt("code", -1)
+    map.putString("message", "No activity available to show the ad from")
+    return map
+}

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

@@ -0,0 +1,238 @@
+package com.cloudxreactnative
+
+import android.util.Log
+import android.widget.FrameLayout
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import io.cloudx.sdk.CloudX
+import io.cloudx.sdk.CloudXAd
+import io.cloudx.sdk.CloudXAdRevenueListener
+import io.cloudx.sdk.CloudXAdView as SdkAdView
+import io.cloudx.sdk.CloudXAdViewListener
+import io.cloudx.sdk.CloudXError
+import org.json.JSONObject
+
+/**
+ * In-tree banner/MREC view component.
+ *
+ * Extends [FrameLayout] (not ReactViewGroup, whose requestLayout is a no-op that
+ * would leave the hosted ad view at 0x0) and hosts the CloudX SDK ad view as a
+ * real child. Because it lives in the React view tree, app overlays such as
+ * toasts layer above it via normal RN z-ordering.
+ */
+class CloudXAdView(private val reactContext: ThemedReactContext) : FrameLayout(reactContext) {
+
+    private companion object {
+        const val TAG = "CloudXAdView"
+    }
+
+    // adUnitId / adFormat are immutable once the ad view is created. Changing
+    // them on a mounted view is ignored (with a warning) — remount via a React
+    // key instead. The value check keeps benign same-value re-renders quiet.
+    var adUnitId: String? = null
+        set(value) {
+            if (adView != null && value != field) {
+                Log.w(TAG, "adUnitId cannot change after the ad view is created; remount the component (e.g. via a React key).")
+                return
+            }
+            field = value
+        }
+    var adFormat: String? = null
+        set(value) {
+            if (adView != null && value != field) {
+                Log.w(TAG, "adFormat cannot change after the ad view is created; remount the component (e.g. via a React key).")
+                return
+            }
+            field = value
+        }
+    var placement: String? = null
+        set(value) {
+            field = value
+            adView?.setPlacement(value)
+        }
+    var customData: String? = null
+        set(value) {
+            field = value
+            adView?.setCustomData(value)
+        }
+
+    /** Latest declarative extra parameters from the RN component. */
+    var extraParameters: Map<String, Any?> = emptyMap()
+        set(value) {
+            field = value
+            applyExtraParametersIfReady()
+        }
+
+    private var adView: SdkAdView? = null
+    private var appliedExtraParameterKeys: Set<String> = emptySet()
+
+    private val measureAndLayoutRunnable = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+        )
+        layout(left, top, right, bottom)
+    }
+
+    /*
+     * ReactViewGroup no-ops requestLayout, and getWidth()/getHeight() are 0 on
+     * attach — re-run measure/layout on the next frame so the hosted ad renders.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        removeCallbacks(measureAndLayoutRunnable)
+        post(measureAndLayoutRunnable)
+    }
+
+    /** Invoked from the ViewManager's onAfterUpdateTransaction, after all props are set. */
+    fun onSetProps() {
+        maybeAttachAdView()
+    }
+
+    private fun maybeAttachAdView() {
+        if (adView != null) return
+        val unitId = adUnitId ?: return
+        val format = adFormat ?: return
+
+        val created = if (format.equals("MREC", ignoreCase = true)) {
+            CloudX.createMREC(reactContext, unitId)
+        } else {
+            CloudX.createBanner(reactContext, unitId)
+        }
+
+        created.listener = createListener()
+        created.revenueListener = createRevenueListener()
+        placement?.let { created.setPlacement(it) }
+        customData?.let { created.setCustomData(it) }
+
+        adView = created
+        applyExtraParametersIfReady()
+        addView(created)
+        created.load()
+        updateAutoRefresh()
+    }
+
+    private fun updateAutoRefresh() {
+        val view = adView ?: return
+        if (isAttachedToWindow) view.startAutoRefresh() else view.stopAutoRefresh()
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        adView?.startAutoRefresh()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        adView?.stopAutoRefresh()
+
+        // Defer one frame: a tab switch detaches but keeps the parent, a real
+        // unmount removes it. Destroy only on a genuine unmount.
+        post {
+            if (parent == null) {
+                destroyAdView()
+            } else {
+                /*
+                 * Still parented on the deferred frame = a tab switch, not an
+                 * unmount, so re-arm refresh. If the view is instead being
+                 * dropped, CloudXAdViewManagerImpl.onDropViewInstance calls
+                 * destroyAdView() first (nulling adView), so this stays a
+                 * null-safe no-op — refresh is never armed on a dead view.
+                 */
+                adView?.startAutoRefresh()
+            }
+        }
+    }
+
+    fun destroyAdView() {
+        val view = adView ?: return
+        view.stopAutoRefresh()
+        view.listener = null
+        view.revenueListener = null
+        view.destroy()
+        removeView(view)
+        adView = null
+        appliedExtraParameterKeys = emptySet()
+    }
+
+    private fun applyExtraParametersIfReady() {
+        val view = adView ?: return
+        CloudXExtraParameters.applyToAdView(view, extraParameters)
+
+        val currentKeys = extraParameters.keys.toSet()
+        for (key in appliedExtraParameterKeys - currentKeys) {
+            view.setExtraParameter(key, null)
+        }
+        appliedExtraParameterKeys = currentKeys
+    }
+
+    private fun dispatchAdEvent(eventName: String, payload: WritableMap) {
+        val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id) ?: return
+        val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+        dispatcher.dispatchEvent(CloudXAdViewEvent(surfaceId, id, eventName, payload))
+    }
+
+    private fun createListener(): CloudXAdViewListener = object : CloudXAdViewListener {
+        override fun onAdLoaded(cloudXAd: CloudXAd) {
+            dispatchAdEvent(CloudXAdEvents.ON_AD_VIEW_LOADED_EVENT, adInfoPayload(cloudXAd))
+        }
+
+        override fun onAdLoadFailed(failedAdUnitId: String, cloudXError: CloudXError) {
+            dispatchAdEvent(CloudXAdEvents.ON_AD_VIEW_LOAD_FAILED_EVENT, loadFailedPayload(failedAdUnitId, cloudXError))
+        }
+
+        override fun onAdClicked(cloudXAd: CloudXAd) {
+            dispatchAdEvent(CloudXAdEvents.ON_AD_VIEW_CLICKED_EVENT, adInfoPayload(cloudXAd))
+        }
+
+        override fun onAdExpanded(cloudXAd: CloudXAd) = Unit
+
+        override fun onAdCollapsed(cloudXAd: CloudXAd) = Unit
+    }
+
+    private fun createRevenueListener(): CloudXAdRevenueListener = object : CloudXAdRevenueListener {
+        override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
+            dispatchAdEvent(CloudXAdEvents.ON_AD_VIEW_REVENUE_PAID_EVENT, adInfoPayload(cloudXAd))
+        }
+    }
+
+    /*
+     * Codegen cannot express Record<string,string>, so ad values are serialized
+     * to a JSON string here and re-parsed by the JS wrapper.
+     */
+    private fun adInfoPayload(ad: CloudXAd): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("adUnitId", ad.adUnitId)
+        map.putString("adFormat", ad.adFormat.name)
+        map.putString("networkName", ad.networkName)
+        map.putString("networkPlacement", ad.networkPlacement ?: "")
+        map.putString("placement", ad.placement ?: "")
+        map.putDouble("revenue", ad.revenue)
+        /*
+         * The SDK types adValues as Map<String, String>, so the cast is safe
+         * today. Guard defensively anyway: an unexpected type or serialization
+         * failure here would otherwise crash the ad listener. Log rather than
+         * swallow silently so a genuine SDK contract change stays visible.
+         */
+        val adValuesJson = try {
+            JSONObject(ad.adValues as Map<*, *>).toString()
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to serialize adValues; delivering empty object", e)
+            "{}"
+        }
+        map.putString("adValuesJson", adValuesJson)
+        return map
+    }
+
+    private fun loadFailedPayload(failedAdUnitId: String, error: CloudXError): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("adUnitId", failedAdUnitId)
+        // Codegen spec declares `code` as Double; emit a double to match (and
+        // to stay consistent with `revenue` and the iOS side).
+        map.putDouble("code", error.code.code.toDouble())
+        map.putString("message", error.message)
+        return map
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.cloudxreactnative
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * A per-view direct event for the in-tree CloudXAdView. The event name doubles
+ * as the JS prop registrationName (see CloudXAdViewManagerImpl).
+ */
+class CloudXAdViewEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val eventName: String,
+    private val payload: WritableMap,
+) : Event<CloudXAdViewEvent>(surfaceId, viewId) {
+
+    override fun getEventName(): String = eventName
+
+    override fun getEventData(): WritableMap = payload
+
+    /*
+     * Ad-lifecycle events are discrete and must never be dropped. The default
+     * (true) lets the dispatcher coalesce events sharing the same
+     * (eventName, viewId) within a batch, keeping only the latest — which would
+     * silently drop, e.g., back-to-back revenue events on the same view.
+     */
+    override fun canCoalesce(): Boolean = false
+}

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

@@ -0,0 +1,54 @@
+package com.cloudxreactnative
+
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * Shared logic for the CloudXAdView view manager, used by both the Old (Paper)
+ * and New (Fabric) architecture manager variants under src/oldarch and src/newarch.
+ */
+object CloudXAdViewManagerImpl {
+
+    const val NAME = "CloudXAdView"
+
+    fun createViewInstance(reactContext: ThemedReactContext): CloudXAdView = CloudXAdView(reactContext)
+
+    fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
+        MapBuilder.builder<String, Any>()
+            .put(CloudXAdEvents.ON_AD_VIEW_LOADED_EVENT, eventRegistration(CloudXAdEvents.ON_AD_VIEW_LOADED_EVENT))
+            .put(CloudXAdEvents.ON_AD_VIEW_LOAD_FAILED_EVENT, eventRegistration(CloudXAdEvents.ON_AD_VIEW_LOAD_FAILED_EVENT))
+            .put(CloudXAdEvents.ON_AD_VIEW_CLICKED_EVENT, eventRegistration(CloudXAdEvents.ON_AD_VIEW_CLICKED_EVENT))
+            .put(CloudXAdEvents.ON_AD_VIEW_REVENUE_PAID_EVENT, eventRegistration(CloudXAdEvents.ON_AD_VIEW_REVENUE_PAID_EVENT))
+            .build()
+
+    private fun eventRegistration(name: String): Map<String, String> = MapBuilder.of("registrationName", name)
+
+    fun setAdUnitId(view: CloudXAdView, adUnitId: String?) {
+        view.adUnitId = adUnitId
+    }
+
+    fun setAdFormat(view: CloudXAdView, adFormat: String?) {
+        view.adFormat = adFormat
+    }
+
+    fun setPlacement(view: CloudXAdView, placement: String?) {
+        view.placement = placement
+    }
+
+    fun setCustomData(view: CloudXAdView, customData: String?) {
+        view.customData = customData
+    }
+
+    fun setExtraParameters(view: CloudXAdView, extraParameters: ReadableArray?) {
+        view.extraParameters = CloudXExtraParameters.entryArrayToMap(extraParameters)
+    }
+
+    fun onAfterUpdateTransaction(view: CloudXAdView) {
+        view.onSetProps()
+    }
+
+    fun onDropViewInstance(view: CloudXAdView) {
+        view.destroyAdView()
+    }
+}

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

@@ -0,0 +1,101 @@
+package com.cloudxreactnative
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import io.cloudx.sdk.CloudXAdView as SdkAdView
+
+/**
+ * Shared conversion and application helpers for CloudX extra parameters.
+ *
+ * Programmatic APIs receive a [ReadableMap], while component props receive a
+ * [ReadableArray] of key/value entries from codegen. Both paths normalize into
+ * Kotlin values before calling the same SDK setter behavior.
+ */
+object CloudXExtraParameters {
+
+    /**
+     * Iterates a programmatic [ReadableMap], ignoring blank keys and preserving
+     * nested arrays/maps as Kotlin collections.
+     */
+    fun forEach(extraParameters: ReadableMap, apply: (String, Any?) -> Unit) {
+        val iterator = extraParameters.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            if (key.isBlank()) continue
+            apply(key, readableMapValue(extraParameters, key))
+        }
+    }
+
+    /**
+     * Converts component prop entries into a key/value map that can be diffed
+     * by the owning component view before being applied.
+     */
+    fun entryArrayToMap(extraParameters: ReadableArray?): Map<String, Any?> {
+        if (extraParameters == null) {
+            return emptyMap()
+        }
+
+        val result = linkedMapOf<String, Any?>()
+        for (index in 0 until extraParameters.size()) {
+            if (extraParameters.getType(index) != ReadableType.Map) continue
+
+            val entry = extraParameters.getMap(index) ?: continue
+            if (!entry.hasKey("key") || entry.getType("key") != ReadableType.String) continue
+
+            val key = entry.getString("key") ?: continue
+            if (key.isBlank()) continue
+            result[key] = if (entry.hasKey("value")) readableMapValue(entry, "value") else null
+        }
+        return result
+    }
+
+    /**
+     * Applies already-normalized extra parameters to [adView].
+     */
+    fun applyToAdView(adView: SdkAdView, extraParameters: Map<String, Any?>) {
+        for ((key, value) in extraParameters) {
+            adView.setExtraParameter(key, value)
+        }
+    }
+
+    private fun readableMapValue(map: ReadableMap, key: String): Any? {
+        return when (map.getType(key)) {
+            ReadableType.Null -> null
+            ReadableType.Boolean -> map.getBoolean(key)
+            ReadableType.Number -> map.getDouble(key)
+            ReadableType.String -> map.getString(key)
+            ReadableType.Map -> map.getMap(key)?.let(::readableMapToMap)
+            ReadableType.Array -> map.getArray(key)?.let(::readableArrayToList)
+        }
+    }
+
+    private fun readableMapToMap(readableMap: ReadableMap): Map<String, Any?> {
+        val result = mutableMapOf<String, Any?>()
+        val iterator = readableMap.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            result[key] = readableMapValue(readableMap, key)
+        }
+        return result
+    }
+
+    private fun readableArrayToList(readableArray: ReadableArray): List<Any?> {
+        val result = mutableListOf<Any?>()
+        for (index in 0 until readableArray.size()) {
+            result.add(readableArrayValue(readableArray, index))
+        }
+        return result
+    }
+
+    private fun readableArrayValue(array: ReadableArray, index: Int): Any? {
+        return when (array.getType(index)) {
+            ReadableType.Null -> null
+            ReadableType.Boolean -> array.getBoolean(index)
+            ReadableType.Number -> array.getDouble(index)
+            ReadableType.String -> array.getString(index)
+            ReadableType.Map -> array.getMap(index)?.let(::readableMapToMap)
+            ReadableType.Array -> array.getArray(index)?.let(::readableArrayToList)
+        }
+    }
+}