cloudx-react-native 3.7.0 → 3.8.0

package/android/build.gradle

@@ -158,8 +158,9 @@ repositories {
 dependencies {
     implementation "com.facebook.react:react-native:0.76.2"
 
-    implementation "io.cloudx:sdk:4.5.0"
+    implementation "io.cloudx:sdk:4.6.0"
 
     testImplementation "junit:junit:4.13.2"
     testImplementation "io.mockk:mockk:1.13.10"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2"
 }

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

@@ -9,6 +9,7 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.LinearLayout
 import android.widget.RelativeLayout
+import androidx.annotation.VisibleForTesting
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
@@ -87,42 +88,67 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
         return currentActivity
     }
 
+    // =========================================================================
+    // Threading
+    // =========================================================================
+
+    /*
+     * Every public module method runs its whole body on the UI thread, including reads of the
+     * module's own state. React Native invokes Android native-module methods on a shared
+     * background thread, so a method that did work inline could execute before a previously
+     * posted one (e.g. loadInterstitial() running on an instance that a queued
+     * destroyInterstitial() then destroys). Posting everything here keeps JS call order intact,
+     * makes the lazy retrieveX() create paths single-threaded, and matches the iOS module, whose
+     * methodQueue is the main queue.
+     */
+    private inline fun onUiThread(crossinline block: () -> Unit) {
+        reactApplicationContext.runOnUiQueueThread { block() }
+    }
+
     // =========================================================================
     // Initialization
     // =========================================================================
 
     fun isInitialized(promise: Promise) {
-        promise.resolve(CloudX.isInitialized())
+        onUiThread {
+            promise.resolve(CloudX.isInitialized())
+        }
     }
 
     fun initialize(pluginVersion: String, appKey: String, promise: Promise) {
-        val config = CloudXInitializationConfiguration.builder(appKey)
-            .setPluginVersion(pluginVersion)
-            .build()
-
-        CloudX.initialize(reactApplicationContext, config, object : CloudXInitializationListener {
-            override fun onInitialized(configuration: CloudXSdkConfiguration) {
-                setupOrientationListener()
-                val result = Arguments.createMap()
-                result.putBoolean("success", true)
-                result.putString("message", "SDK initialized successfully")
-                promise.resolve(result)
-            }
+        onUiThread {
+            val config = CloudXInitializationConfiguration.builder(appKey)
+                .setPluginVersion(pluginVersion)
+                .build()
+
+            CloudX.initialize(reactApplicationContext, config, object : CloudXInitializationListener {
+                override fun onInitialized(configuration: CloudXSdkConfiguration) {
+                    setupOrientationListener()
+                    val result = Arguments.createMap()
+                    result.putBoolean("success", true)
+                    result.putString("message", "SDK initialized successfully")
+                    promise.resolve(result)
+                }
 
-            override fun onInitializationFailed(cloudXError: CloudXError) {
-                Log.e(TAG, "CloudX SDK initialization failed: ${cloudXError.message}")
-                promise.reject(cloudXError.code.name, cloudXError.message, null)
-            }
-        })
+                override fun onInitializationFailed(cloudXError: CloudXError) {
+                    Log.e(TAG, "CloudX SDK initialization failed: ${cloudXError.message}")
+                    promise.reject(cloudXError.code.name, cloudXError.message, null)
+                }
+            })
+        }
     }
 
     fun isTablet(promise: Promise) {
-        val isTablet = reactApplicationContext.resources.configuration.smallestScreenWidthDp >= 600
-        promise.resolve(isTablet)
+        onUiThread {
+            val isTablet = reactApplicationContext.resources.configuration.smallestScreenWidthDp >= 600
+            promise.resolve(isTablet)
+        }
     }
 
     fun getVersion(promise: Promise) {
-        promise.resolve(CloudX.getVersion())
+        onUiThread {
+            promise.resolve(CloudX.getVersion())
+        }
     }
 
     // =========================================================================
@@ -130,16 +156,18 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun setMinLogLevel(level: String) {
-        val logLevel = when (level.lowercase()) {
-            "verbose" -> CloudXLogLevel.VERBOSE
-            "debug" -> CloudXLogLevel.DEBUG
-            "info" -> CloudXLogLevel.INFO
-            "warn" -> CloudXLogLevel.WARN
-            "error" -> CloudXLogLevel.ERROR
-            "none" -> CloudXLogLevel.NONE
-            else -> CloudXLogLevel.INFO
+        onUiThread {
+            val logLevel = when (level.lowercase()) {
+                "verbose" -> CloudXLogLevel.VERBOSE
+                "debug" -> CloudXLogLevel.DEBUG
+                "info" -> CloudXLogLevel.INFO
+                "warn" -> CloudXLogLevel.WARN
+                "error" -> CloudXLogLevel.ERROR
+                "none" -> CloudXLogLevel.NONE
+                else -> CloudXLogLevel.INFO
+            }
+            CloudX.setMinLogLevel(logLevel)
         }
-        CloudX.setMinLogLevel(logLevel)
     }
 
     fun setVisualDebuggingEnabled(enabled: Boolean) {
@@ -151,19 +179,27 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun setHashedUserID(hashedUserID: String) {
-        CloudX.setHashedUserId(hashedUserID)
+        onUiThread {
+            CloudX.setHashedUserId(hashedUserID)
+        }
     }
 
     fun setUserKeyValue(key: String, value: String) {
-        CloudX.setUserKeyValue(key, value)
+        onUiThread {
+            CloudX.setUserKeyValue(key, value)
+        }
     }
 
     fun setAppKeyValue(key: String, value: String) {
-        CloudX.setAppKeyValue(key, value)
+        onUiThread {
+            CloudX.setAppKeyValue(key, value)
+        }
     }
 
     fun clearAllKeyValues() {
-        CloudX.clearAllKeyValues()
+        onUiThread {
+            CloudX.clearAllKeyValues()
+        }
     }
 
     // =========================================================================
@@ -171,11 +207,15 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun setHasUserConsent(hasUserConsent: Boolean?) {
-        CloudX.setHasUserConsent(hasUserConsent)
+        onUiThread {
+            CloudX.setHasUserConsent(hasUserConsent)
+        }
     }
 
     fun setDoNotSell(isDoNotSell: Boolean?) {
-        CloudX.setDoNotSell(isDoNotSell)
+        onUiThread {
+            CloudX.setDoNotSell(isDoNotSell)
+        }
     }
 
     // =========================================================================
@@ -183,27 +223,31 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun arbiter(configuration: ReadableMap, promise: Promise) {
-        val bids = arbiterBids(configuration)
-        if (bids.isEmpty()) {
-            promise.resolve(emptyArbiterResult())
-            return
-        }
-
-        val arbiterConfiguration = CloudXArbiterConfiguration.builder(bids).build()
-        CloudX.arbiter(arbiterConfiguration, object : CloudXArbiterListener {
-            override fun onCompleted(result: CloudXArbiterResult) {
-                promise.resolve(result.toWritableMap())
+        onUiThread {
+            val bids = arbiterBids(configuration)
+            if (bids.isEmpty()) {
+                promise.resolve(emptyArbiterResult())
+                return@onUiThread
             }
-        })
+
+            val arbiterConfiguration = CloudXArbiterConfiguration.builder(bids).build()
+            CloudX.arbiter(arbiterConfiguration, object : CloudXArbiterListener {
+                override fun onCompleted(result: CloudXArbiterResult) {
+                    promise.resolve(result.toWritableMap())
+                }
+            })
+        }
     }
 
     fun reportRevenueData(data: ReadableMap, promise: Promise) {
-        val revenueData = data.toRevenueData()
-        if (revenueData == null) {
-            promise.resolve(false)
-            return
+        onUiThread {
+            val revenueData = data.toRevenueData()
+            if (revenueData == null) {
+                promise.resolve(false)
+                return@onUiThread
+            }
+            promise.resolve(CloudX.reportRevenueData(revenueData))
         }
-        promise.resolve(CloudX.reportRevenueData(revenueData))
     }
 
     // =========================================================================
@@ -216,8 +260,8 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     fun setBannerPlacement(adUnitId: String, placement: String?) = setAdViewPlacement(adUnitId, CloudXAdFormat.BANNER, placement)
     fun setBannerCustomData(adUnitId: String, customData: String?) = setAdViewCustomData(adUnitId, CloudXAdFormat.BANNER, customData)
     fun setBannerExtraParameters(adUnitId: String, extraParameters: ReadableMap) = setAdViewExtraParameters(adUnitId, CloudXAdFormat.BANNER, extraParameters)
-    fun updateBannerPosition(adUnitId: String, position: String) = updateAdViewPosition(adUnitId, CloudXAdFormat.BANNER, position, adViewOffsetsDp[adUnitId] ?: DEFAULT_AD_VIEW_OFFSET_DP)
-    fun updateBannerOffsets(adUnitId: String, xOffset: Double, yOffset: Double) = updateAdViewPosition(adUnitId, CloudXAdFormat.BANNER, adViewPositions[adUnitId], Pair(xOffset.toFloat(), yOffset.toFloat()))
+    fun updateBannerPosition(adUnitId: String, position: String) = updateAdViewPosition(adUnitId, CloudXAdFormat.BANNER, position, null)
+    fun updateBannerOffsets(adUnitId: String, xOffset: Double, yOffset: Double) = updateAdViewPosition(adUnitId, CloudXAdFormat.BANNER, null, Pair(xOffset.toFloat(), yOffset.toFloat()))
     fun startBannerAutoRefresh(adUnitId: String) = startAdViewAutoRefresh(adUnitId, CloudXAdFormat.BANNER)
     fun stopBannerAutoRefresh(adUnitId: String) = stopAdViewAutoRefresh(adUnitId, CloudXAdFormat.BANNER)
     fun showBanner(adUnitId: String) = showAdView(adUnitId, CloudXAdFormat.BANNER)
@@ -234,8 +278,8 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     fun setMRECPlacement(adUnitId: String, placement: String?) = setAdViewPlacement(adUnitId, CloudXAdFormat.MREC, placement)
     fun setMRECCustomData(adUnitId: String, customData: String?) = setAdViewCustomData(adUnitId, CloudXAdFormat.MREC, customData)
     fun setMRECExtraParameters(adUnitId: String, extraParameters: ReadableMap) = setAdViewExtraParameters(adUnitId, CloudXAdFormat.MREC, extraParameters)
-    fun updateMRECPosition(adUnitId: String, position: String) = updateAdViewPosition(adUnitId, CloudXAdFormat.MREC, position, adViewOffsetsDp[adUnitId] ?: DEFAULT_AD_VIEW_OFFSET_DP)
-    fun updateMRECOffsets(adUnitId: String, xOffset: Double, yOffset: Double) = updateAdViewPosition(adUnitId, CloudXAdFormat.MREC, adViewPositions[adUnitId], Pair(xOffset.toFloat(), yOffset.toFloat()))
+    fun updateMRECPosition(adUnitId: String, position: String) = updateAdViewPosition(adUnitId, CloudXAdFormat.MREC, position, null)
+    fun updateMRECOffsets(adUnitId: String, xOffset: Double, yOffset: Double) = updateAdViewPosition(adUnitId, CloudXAdFormat.MREC, null, Pair(xOffset.toFloat(), yOffset.toFloat()))
     fun startMRECAutoRefresh(adUnitId: String) = startAdViewAutoRefresh(adUnitId, CloudXAdFormat.MREC)
     fun stopMRECAutoRefresh(adUnitId: String) = stopAdViewAutoRefresh(adUnitId, CloudXAdFormat.MREC)
     fun showMREC(adUnitId: String) = showAdView(adUnitId, CloudXAdFormat.MREC)
@@ -247,21 +291,27 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun loadInterstitial(adUnitId: String) {
-        retrieveInterstitial(adUnitId).load()
+        onUiThread {
+            retrieveInterstitial(adUnitId).load()
+        }
     }
 
     fun setInterstitialExtraParameters(adUnitId: String, extraParameters: ReadableMap) {
-        CloudXExtraParameters.forEach(extraParameters) { key, value ->
-            retrieveInterstitial(adUnitId).setExtraParameter(key, value)
+        onUiThread {
+            CloudXExtraParameters.forEach(extraParameters) { key, value ->
+                retrieveInterstitial(adUnitId).setExtraParameter(key, value)
+            }
         }
     }
 
     fun isInterstitialReady(adUnitId: String, promise: Promise) {
-        promise.resolve(retrieveInterstitial(adUnitId).isAdReady)
+        onUiThread {
+            promise.resolve(retrieveInterstitial(adUnitId).isAdReady)
+        }
     }
 
     fun showInterstitial(adUnitId: String, placement: String?, customData: String?) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val interstitial = retrieveInterstitial(adUnitId)
             val activity = maybeGetCurrentActivity()
             if (activity == null) {
@@ -270,14 +320,14 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
                     CloudXAdEvents.ON_INTERSTITIAL_DISPLAY_FAILED_EVENT,
                     getNoActivityDisplayFailedInfo(adUnitId),
                 )
-                return@runOnUiQueueThread
+                return@onUiThread
             }
             interstitial.show(activity, placement, customData)
         }
     }
 
     fun destroyInterstitial(adUnitId: String) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             interstitials.remove(adUnitId)?.let {
                 it.listener = null
                 it.revenueListener = null
@@ -291,21 +341,27 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun loadAppOpen(adUnitId: String) {
-        retrieveAppOpen(adUnitId).load()
+        onUiThread {
+            retrieveAppOpen(adUnitId).load()
+        }
     }
 
     fun setAppOpenExtraParameters(adUnitId: String, extraParameters: ReadableMap) {
-        CloudXExtraParameters.forEach(extraParameters) { key, value ->
-            retrieveAppOpen(adUnitId).setExtraParameter(key, value)
+        onUiThread {
+            CloudXExtraParameters.forEach(extraParameters) { key, value ->
+                retrieveAppOpen(adUnitId).setExtraParameter(key, value)
+            }
         }
     }
 
     fun isAppOpenReady(adUnitId: String, promise: Promise) {
-        promise.resolve(retrieveAppOpen(adUnitId).isAdReady)
+        onUiThread {
+            promise.resolve(retrieveAppOpen(adUnitId).isAdReady)
+        }
     }
 
     fun showAppOpen(adUnitId: String, placement: String?, customData: String?) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val appOpen = retrieveAppOpen(adUnitId)
             val activity = maybeGetCurrentActivity()
             if (activity == null) {
@@ -314,14 +370,14 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
                     CloudXAdEvents.ON_APPOPEN_DISPLAY_FAILED_EVENT,
                     getNoActivityDisplayFailedInfo(adUnitId),
                 )
-                return@runOnUiQueueThread
+                return@onUiThread
             }
             appOpen.show(activity, placement, customData)
         }
     }
 
     fun destroyAppOpen(adUnitId: String) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             appOpenAds.remove(adUnitId)?.let {
                 it.listener = null
                 it.revenueListener = null
@@ -335,21 +391,27 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     // =========================================================================
 
     fun loadRewarded(adUnitId: String) {
-        retrieveRewarded(adUnitId).load()
+        onUiThread {
+            retrieveRewarded(adUnitId).load()
+        }
     }
 
     fun setRewardedExtraParameters(adUnitId: String, extraParameters: ReadableMap) {
-        CloudXExtraParameters.forEach(extraParameters) { key, value ->
-            retrieveRewarded(adUnitId).setExtraParameter(key, value)
+        onUiThread {
+            CloudXExtraParameters.forEach(extraParameters) { key, value ->
+                retrieveRewarded(adUnitId).setExtraParameter(key, value)
+            }
         }
     }
 
     fun isRewardedReady(adUnitId: String, promise: Promise) {
-        promise.resolve(retrieveRewarded(adUnitId).isAdReady)
+        onUiThread {
+            promise.resolve(retrieveRewarded(adUnitId).isAdReady)
+        }
     }
 
     fun showRewarded(adUnitId: String, placement: String?, customData: String?) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val rewarded = retrieveRewarded(adUnitId)
             val activity = maybeGetCurrentActivity()
             if (activity == null) {
@@ -358,14 +420,14 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
                     CloudXAdEvents.ON_REWARDED_AD_DISPLAY_FAILED_EVENT,
                     getNoActivityDisplayFailedInfo(adUnitId),
                 )
-                return@runOnUiQueueThread
+                return@onUiThread
             }
             rewarded.show(activity, placement, customData)
         }
     }
 
     fun destroyRewarded(adUnitId: String) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             rewardedAds.remove(adUnitId)?.let {
                 it.listener = null
                 it.revenueListener = null
@@ -513,7 +575,7 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
 
     private fun createAdView(adUnitId: String, adFormat: CloudXAdFormat, position: String, xOffset: Double, yOffset: Double) {
         // Run on main thread to ensure there are no concurrency issues with other ad view methods
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             // Intentionally load the ad view while detached from any window.
             // Attaching-then-hiding-then-loading causes the underlying banner
             // to take a prefetch code path whose hidden->visible transition
@@ -522,7 +584,7 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
             // (~30s). Detached loads use the "display when added to a window"
             // path, so showAdView attaches and displays immediately.
             val adView = retrieveAdView(adUnitId, adFormat, position, Pair(xOffset.toFloat(), yOffset.toFloat()))
-                ?: return@runOnUiQueueThread
+                ?: return@onUiThread
 
             adViewAdFormats[adUnitId] = adFormat
             applyPendingExtraParameters(adUnitId, adView)
@@ -538,27 +600,27 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     }
 
     private fun setAdViewPlacement(adUnitId: String, adFormat: CloudXAdFormat, placement: String?) {
-        reactApplicationContext.runOnUiQueueThread {
-            val adView = retrieveAdView(adUnitId, adFormat, "", DEFAULT_AD_VIEW_OFFSET_DP) ?: return@runOnUiQueueThread
+        onUiThread {
+            val adView = retrieveAdView(adUnitId, adFormat, "", DEFAULT_AD_VIEW_OFFSET_DP) ?: return@onUiThread
             adView.setPlacement(placement)
         }
     }
 
     private fun setAdViewCustomData(adUnitId: String, adFormat: CloudXAdFormat, customData: String?) {
-        reactApplicationContext.runOnUiQueueThread {
-            val adView = retrieveAdView(adUnitId, adFormat, "", DEFAULT_AD_VIEW_OFFSET_DP) ?: return@runOnUiQueueThread
+        onUiThread {
+            val adView = retrieveAdView(adUnitId, adFormat, "", DEFAULT_AD_VIEW_OFFSET_DP) ?: return@onUiThread
             adView.setCustomData(customData)
         }
     }
 
     private fun setAdViewExtraParameters(adUnitId: String, adFormat: CloudXAdFormat, extraParameters: ReadableMap) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val adView = retrieveAdView(adUnitId, adFormat)
             if (adView != null) {
                 CloudXExtraParameters.forEach(extraParameters) { key, value ->
                     adView.setExtraParameter(key, value)
                 }
-                return@runOnUiQueueThread
+                return@onUiThread
             }
 
             val pending = adViewExtraParameters.getOrPut(adUnitId) { ConcurrentHashMap() }
@@ -840,21 +902,29 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
         override val adValues: Map<String, String>,
     ) : CloudXAd
 
-    private fun updateAdViewPosition(adUnitId: String, adFormat: CloudXAdFormat, position: String?, offsetsDp: Pair<Float, Float>) {
-        reactApplicationContext.runOnUiQueueThread {
-            val adView = retrieveAdView(adUnitId, adFormat) ?: return@runOnUiQueueThread
-            adViewPositions[adUnitId] = position ?: return@runOnUiQueueThread
-            adViewOffsetsDp[adUnitId] = offsetsDp
+    /*
+     * A null [position] or [offsetsDp] means "keep the current value". The current value is read
+     * inside the posted block, so a position update followed by an offsets update from JS cannot
+     * overwrite the first call's position with the value that was current before it ran.
+     */
+    private fun updateAdViewPosition(adUnitId: String, adFormat: CloudXAdFormat, position: String?, offsetsDp: Pair<Float, Float>?) {
+        onUiThread {
+            val adView = retrieveAdView(adUnitId, adFormat) ?: return@onUiThread
+            adViewPositions[adUnitId] = position ?: adViewPositions[adUnitId] ?: return@onUiThread
+            adViewOffsetsDp[adUnitId] = offsetsDp ?: adViewOffsetsDp[adUnitId] ?: DEFAULT_AD_VIEW_OFFSET_DP
             positionAdView(adUnitId, adFormat)
         }
     }
 
+    @VisibleForTesting
+    internal fun adViewPositionForTesting(adUnitId: String): String? = adViewPositions[adUnitId]
+
     private fun showAdView(adUnitId: String, adFormat: CloudXAdFormat) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val adView = retrieveAdView(adUnitId, adFormat)
             if (adView == null) {
                 adUnitIdsToShowAfterCreate.add(adUnitId)
-                return@runOnUiQueueThread
+                return@onUiThread
             }
 
             // Lazily attach and position on first show. Attaching here — not
@@ -872,18 +942,18 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     }
 
     private fun hideAdView(adUnitId: String, adFormat: CloudXAdFormat) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             adUnitIdsToShowAfterCreate.remove(adUnitId)
-            val adView = retrieveAdView(adUnitId, adFormat) ?: return@runOnUiQueueThread
+            val adView = retrieveAdView(adUnitId, adFormat) ?: return@onUiThread
             adView.visibility = View.GONE
             adView.stopAutoRefresh()
         }
     }
 
     private fun destroyAdView(adUnitId: String, adFormat: CloudXAdFormat) {
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             val adView = retrieveAdView(adUnitId, adFormat)
-            if (adView == null) return@runOnUiQueueThread
+            if (adView == null) return@onUiThread
 
             val parent = adView.parent
             if (parent is ViewGroup) {
@@ -904,8 +974,8 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     }
 
     private fun setAdViewBackgroundColor(adUnitId: String, adFormat: CloudXAdFormat, hexColorString: String) {
-        reactApplicationContext.runOnUiQueueThread {
-            val adView = retrieveAdView(adUnitId, adFormat) ?: return@runOnUiQueueThread
+        onUiThread {
+            val adView = retrieveAdView(adUnitId, adFormat) ?: return@onUiThread
             try {
                 adView.setBackgroundColor(Color.parseColor(hexColorString))
             } catch (e: IllegalArgumentException) {
@@ -915,11 +985,11 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
     }
 
     private fun startAdViewAutoRefresh(adUnitId: String, adFormat: CloudXAdFormat) {
-        reactApplicationContext.runOnUiQueueThread { retrieveAdView(adUnitId, adFormat)?.startAutoRefresh() }
+        onUiThread { retrieveAdView(adUnitId, adFormat)?.startAutoRefresh() }
     }
 
     private fun stopAdViewAutoRefresh(adUnitId: String, adFormat: CloudXAdFormat) {
-        reactApplicationContext.runOnUiQueueThread { retrieveAdView(adUnitId, adFormat)?.stopAutoRefresh() }
+        onUiThread { retrieveAdView(adUnitId, adFormat)?.stopAutoRefresh() }
     }
 
     // =========================================================================
@@ -1105,7 +1175,7 @@ class CloudXModuleImpl(private val reactApplicationContext: ReactApplicationCont
             destroyAdView(adUnitId, adFormat)
         }
 
-        reactApplicationContext.runOnUiQueueThread {
+        onUiThread {
             for (interstitial in interstitials.values) {
                 interstitial.destroy()
             }

package/android/src/test/java/com/cloudxreactnative/CloudXModuleImplThreadingTest.kt

@@ -0,0 +1,170 @@
+package com.cloudxreactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import io.cloudx.sdk.CloudX
+import io.cloudx.sdk.CloudXAppOpenAd
+import io.cloudx.sdk.CloudXInterstitialAd
+import io.cloudx.sdk.CloudXRewardedAd
+import io.cloudx.sdk.CloudXAdView
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import io.mockk.verify
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Covers the module's UI-thread invariant: every public method posts its body via
+ * [ReactApplicationContext.runOnUiQueueThread], so JS call order is preserved and a destroy
+ * followed by a load always operates on a fresh native ad instance.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class CloudXModuleImplThreadingTest {
+
+    private val adUnitId = "unit-1"
+    private val queuedRunnables = mutableListOf<Runnable>()
+
+    @Before
+    fun setUp() {
+        // CloudX's static initializer resolves Dispatchers.Main, which needs a main looper on the JVM.
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        mockkStatic(CloudX::class)
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+        Dispatchers.resetMain()
+    }
+
+    // Simulates the UI thread's FIFO queue by running every posted runnable immediately.
+    private fun moduleWithInlineUiThread(): CloudXModuleImpl {
+        val context = mockk<ReactApplicationContext>(relaxed = true)
+        every { context.runOnUiQueueThread(any()) } answers { firstArg<Runnable>().run() }
+        return CloudXModuleImpl(context)
+    }
+
+    // Swallows every posted runnable, so anything that runs is running off the UI thread.
+    private fun moduleWithStalledUiThread(): CloudXModuleImpl {
+        val context = mockk<ReactApplicationContext>(relaxed = true)
+        every { context.runOnUiQueueThread(any()) } returns Unit
+        return CloudXModuleImpl(context)
+    }
+
+    // Queues posted runnables into [queuedRunnables]; call [drainUiThread] to run them in FIFO order.
+    private fun moduleWithQueuedUiThread(): CloudXModuleImpl {
+        val context = mockk<ReactApplicationContext>(relaxed = true)
+        every { context.runOnUiQueueThread(any()) } answers { queuedRunnables.add(firstArg()) }
+        return CloudXModuleImpl(context)
+    }
+
+    private fun drainUiThread() {
+        while (queuedRunnables.isNotEmpty()) queuedRunnables.removeAt(0).run()
+    }
+
+    @Test
+    fun `destroy then load on same ad unit loads a fresh interstitial`() {
+        // Arrange
+        val first = mockk<CloudXInterstitialAd>(relaxed = true)
+        val second = mockk<CloudXInterstitialAd>(relaxed = true)
+        every { CloudX.createInterstitial(any(), any()) } returnsMany listOf(first, second)
+        val subject = moduleWithInlineUiThread()
+        subject.loadInterstitial(adUnitId)
+
+        // Act
+        subject.destroyInterstitial(adUnitId)
+        subject.loadInterstitial(adUnitId)
+
+        // Assert
+        verify(exactly = 1) { first.load() }
+        verify(exactly = 1) { first.destroy() }
+        verify(exactly = 1) { second.load() }
+    }
+
+    @Test
+    fun `destroy then load on same ad unit loads a fresh app open ad`() {
+        // Arrange
+        val first = mockk<CloudXAppOpenAd>(relaxed = true)
+        val second = mockk<CloudXAppOpenAd>(relaxed = true)
+        every { CloudX.createAppOpen(any(), any()) } returnsMany listOf(first, second)
+        val subject = moduleWithInlineUiThread()
+        subject.loadAppOpen(adUnitId)
+
+        // Act
+        subject.destroyAppOpen(adUnitId)
+        subject.loadAppOpen(adUnitId)
+
+        // Assert
+        verify(exactly = 1) { first.load() }
+        verify(exactly = 1) { first.destroy() }
+        verify(exactly = 1) { second.load() }
+    }
+
+    @Test
+    fun `destroy then load on same ad unit loads a fresh rewarded ad`() {
+        // Arrange
+        val first = mockk<CloudXRewardedAd>(relaxed = true)
+        val second = mockk<CloudXRewardedAd>(relaxed = true)
+        every { CloudX.createRewarded(any(), any()) } returnsMany listOf(first, second)
+        val subject = moduleWithInlineUiThread()
+        subject.loadRewarded(adUnitId)
+
+        // Act
+        subject.destroyRewarded(adUnitId)
+        subject.loadRewarded(adUnitId)
+
+        // Assert
+        verify(exactly = 1) { first.load() }
+        verify(exactly = 1) { first.destroy() }
+        verify(exactly = 1) { second.load() }
+    }
+
+    @Test
+    fun `load does not touch the SDK before the UI runnable runs`() {
+        // Arrange
+        val subject = moduleWithStalledUiThread()
+
+        // Act
+        subject.loadInterstitial(adUnitId)
+
+        // Assert
+        verify(exactly = 0) { CloudX.createInterstitial(any(), any()) }
+    }
+
+    @Test
+    fun `position update followed by offsets update keeps the new position`() {
+        // Arrange
+        every { CloudX.createBanner(any(), any()) } returns mockk<CloudXAdView>(relaxed = true)
+        val subject = moduleWithQueuedUiThread()
+        subject.createBanner(adUnitId, "top")
+        drainUiThread()
+
+        // Act
+        subject.updateBannerPosition(adUnitId, "bottom")
+        subject.updateBannerOffsets(adUnitId, 1.0, 2.0)
+        drainUiThread()
+
+        // Assert
+        assertEquals("bottom", subject.adViewPositionForTesting(adUnitId))
+    }
+
+    @Test
+    fun `config setter does not touch the SDK before the UI runnable runs`() {
+        // Arrange
+        val subject = moduleWithStalledUiThread()
+
+        // Act
+        subject.setHashedUserID("hashed")
+
+        // Assert
+        verify(exactly = 0) { CloudX.setHashedUserId(any()) }
+    }
+}

package/cloudx-react-native.podspec

@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
 
   s.requires_arc = true
 
-  s.dependency "CloudXCore", "~> 3.7.0"
+  s.dependency "CloudXCore", "~> 3.8.0"
 
   s.source_files = "ios/**/*.{h,mm}"
 

package/lib/commonjs/version.js

@@ -9,5 +9,5 @@ exports.PLUGIN_VERSION = void 0;
 // This value is reported to the native SDK in CloudX.initialize() and is used
 // for wrapper-version telemetry/attribution, so a stale value mis-attributes
 // installs to the wrong release.
-const PLUGIN_VERSION = exports.PLUGIN_VERSION = '3.7.0';
+const PLUGIN_VERSION = exports.PLUGIN_VERSION = '3.8.0';
 //# sourceMappingURL=version.js.map

package/lib/module/version.js

@@ -3,5 +3,5 @@
 // This value is reported to the native SDK in CloudX.initialize() and is used
 // for wrapper-version telemetry/attribution, so a stale value mis-attributes
 // installs to the wrong release.
-export const PLUGIN_VERSION = '3.7.0';
+export const PLUGIN_VERSION = '3.8.0';
 //# sourceMappingURL=version.js.map

package/lib/typescript/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PLUGIN_VERSION = "3.7.0";
+export declare const PLUGIN_VERSION = "3.8.0";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudx-react-native",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "React Native wrapper for CloudX SDK (iOS & Android)",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/version.ts

@@ -3,4 +3,4 @@
 // This value is reported to the native SDK in CloudX.initialize() and is used
 // for wrapper-version telemetry/attribution, so a stale value mis-attributes
 // installs to the wrong release.
-export const PLUGIN_VERSION = '3.7.0';
+export const PLUGIN_VERSION = '3.8.0';