cloudx-react-native 3.6.1 → 3.8.0

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

@@ -0,0 +1,254 @@
+package com.cloudxreactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import io.cloudx.sdk.CloudXArbiterBid
+import io.cloudx.sdk.CloudXArbiterPlatform
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Covers ADMOB bid parsing in [CloudXModuleImpl.arbiterBids], including coexistence with the
+ * pre-existing bid platforms.
+ *
+ * The SDK's AdMobBid class is internal to io.cloudx.sdk, so its adUnitId / networkName /
+ * manualRevenuePerImpressionUSD are not visible from this module. Assertions read them back by
+ * reflection; platform and extras come off the public CloudXArbiterBid surface.
+ */
+class CloudXModuleImplArbiterBidsTest {
+
+    // arbiterBids never touches the context, but the constructor registers a lifecycle listener.
+    private fun module(): CloudXModuleImpl {
+        val context = mockk<ReactApplicationContext>(relaxed = true)
+        every { context.addLifecycleEventListener(any()) } returns Unit
+        return CloudXModuleImpl(context)
+    }
+
+    private fun bidsFrom(vararg bids: Map<String, Any?>): List<CloudXArbiterBid> {
+        val configuration = FakeReadableMap(
+            mapOf("bids" to FakeReadableArray(bids.map { FakeReadableMap(it) }))
+        )
+        return module().arbiterBids(configuration)
+    }
+
+    private fun CloudXArbiterBid.field(name: String): Any? {
+        val field = javaClass.getDeclaredField(name)
+        field.isAccessible = true
+        return field.get(this)
+    }
+
+    @Test
+    fun `routes ADMOB platform to an AdMob bid`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB", "adUnitId" to "unit-1"))
+
+        assertEquals(1, bids.size)
+        assertEquals(CloudXArbiterPlatform.ADMOB, bids[0].platform)
+        assertEquals("unit-1", bids[0].field("adUnitId"))
+    }
+
+    @Test
+    fun `accepts a lowercase platform token`() {
+        val bids = bidsFrom(mapOf("platform" to "admob", "adUnitId" to "unit-1"))
+
+        assertEquals(1, bids.size)
+        assertEquals(CloudXArbiterPlatform.ADMOB, bids[0].platform)
+    }
+
+    @Test
+    fun `defaults networkName to admob when absent`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB", "adUnitId" to "unit-1"))
+
+        assertEquals("admob", bids[0].field("networkName"))
+    }
+
+    @Test
+    fun `defaults networkName to admob when blank`() {
+        val bids = bidsFrom(
+            mapOf("platform" to "ADMOB", "adUnitId" to "unit-1", "networkName" to "   ")
+        )
+
+        assertEquals("admob", bids[0].field("networkName"))
+    }
+
+    @Test
+    fun `passes an explicit networkName through`() {
+        val bids = bidsFrom(
+            mapOf("platform" to "ADMOB", "adUnitId" to "unit-1", "networkName" to "applovin")
+        )
+
+        assertEquals("applovin", bids[0].field("networkName"))
+    }
+
+    @Test
+    fun `drops a bid with a missing adUnitId`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB"))
+
+        assertTrue(bids.isEmpty())
+    }
+
+    @Test
+    fun `drops a bid with a blank adUnitId`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB", "adUnitId" to "   "))
+
+        assertTrue(bids.isEmpty())
+    }
+
+    @Test
+    fun `keeps surrounding bids when one ADMOB bid is dropped`() {
+        val bids = bidsFrom(
+            mapOf("platform" to "ADMOB", "adUnitId" to ""),
+            mapOf("platform" to "ADMOB", "adUnitId" to "unit-2"),
+        )
+
+        assertEquals(1, bids.size)
+        assertEquals("unit-2", bids[0].field("adUnitId"))
+    }
+
+    @Test
+    fun `carries a manual price when present`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "ADMOB",
+                "adUnitId" to "unit-1",
+                "manualRevenuePerImpressionUSD" to 0.004,
+            )
+        )
+
+        assertEquals(0.004, bids[0].field("manualRevenuePerImpressionUSD") as Double, 1e-9)
+    }
+
+    @Test
+    fun `leaves the manual price null when absent`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB", "adUnitId" to "unit-1"))
+
+        assertNull(bids[0].field("manualRevenuePerImpressionUSD"))
+    }
+
+    @Test
+    fun `keeps a zero manual price distinct from absent`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "ADMOB",
+                "adUnitId" to "unit-1",
+                "manualRevenuePerImpressionUSD" to 0.0,
+            )
+        )
+
+        assertEquals(0.0, bids[0].field("manualRevenuePerImpressionUSD") as Double, 1e-9)
+    }
+
+    @Test
+    fun `forwards a negative manual price unchanged`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "ADMOB",
+                "adUnitId" to "unit-1",
+                "manualRevenuePerImpressionUSD" to -1.5,
+            )
+        )
+
+        // The wrapper is transparent about the value it was handed; the native SDK decides to drop it.
+        assertEquals(-1.5, bids[0].field("manualRevenuePerImpressionUSD") as Double, 1e-9)
+    }
+
+    @Test
+    fun `maps a CUSTOM bid alongside an ADMOB bid in order`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "CUSTOM",
+                "platformName" to "CUSTOM_MEDIATOR",
+                "revenuePerImpressionUSD" to 0.002,
+                "precision" to "exact",
+            ),
+            mapOf("platform" to "ADMOB", "adUnitId" to "unit-2"),
+        )
+
+        assertEquals(2, bids.size)
+        assertEquals(CloudXArbiterPlatform.CUSTOM, bids[0].platform)
+        assertEquals("CUSTOM_MEDIATOR", bids[0].platformName)
+        assertEquals(CloudXArbiterPlatform.ADMOB, bids[1].platform)
+        assertEquals("unit-2", bids[1].field("adUnitId"))
+    }
+
+    @Test
+    fun `maps string extras and skips non-string entries`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "ADMOB",
+                "adUnitId" to "unit-1",
+                "extras" to FakeReadableMap(mapOf("k" to "v", "n" to 1.0)),
+            )
+        )
+
+        assertEquals(mapOf("k" to "v"), bids[0].extras)
+    }
+
+    @Test
+    fun `defaults extras to empty when absent`() {
+        val bids = bidsFrom(mapOf("platform" to "ADMOB", "adUnitId" to "unit-1"))
+
+        assertEquals(emptyMap<String, String>(), bids[0].extras)
+    }
+
+    @Test
+    fun `routes GAM platform to a Gam bid with default networkName`() {
+        val bids = bidsFrom(mapOf("platform" to "GAM", "adUnitId" to "/21775744923/example/banner"))
+
+        assertEquals(1, bids.size)
+        assertEquals(CloudXArbiterPlatform.GAM, bids[0].platform)
+        assertEquals("/21775744923/example/banner", bids[0].field("adUnitId"))
+        assertEquals("gam", bids[0].field("networkName"))
+    }
+
+    @Test
+    fun `carries GAM manual price and extras through`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "GAM",
+                "adUnitId" to "/21775744923/example/banner",
+                "networkName" to "reservation",
+                "manualRevenuePerImpressionUSD" to 0.0025,
+                "extras" to FakeReadableMap(mapOf("k" to "v")),
+            )
+        )
+
+        assertEquals("reservation", bids[0].field("networkName"))
+        assertEquals(0.0025, bids[0].field("manualRevenuePerImpressionUSD") as Double, 1e-9)
+        assertEquals(mapOf("k" to "v"), bids[0].extras)
+    }
+
+    @Test
+    fun `keeps a zero GAM manual price distinct from absent`() {
+        val bids = bidsFrom(
+            mapOf(
+                "platform" to "GAM",
+                "adUnitId" to "/21775744923/example/banner",
+                "manualRevenuePerImpressionUSD" to 0.0,
+            )
+        )
+
+        assertEquals(0.0, bids[0].field("manualRevenuePerImpressionUSD") as Double, 1e-9)
+    }
+
+    @Test
+    fun `drops a GAM bid with a blank adUnitId`() {
+        val bids = bidsFrom(mapOf("platform" to "GAM", "adUnitId" to "   "))
+
+        assertTrue(bids.isEmpty())
+    }
+
+    @Test
+    fun `maps an ADMOB bid alongside a GAM bid in order`() {
+        val bids = bidsFrom(
+            mapOf("platform" to "ADMOB", "adUnitId" to "ca-app-pub-1/2"),
+            mapOf("platform" to "GAM", "adUnitId" to "/21775744923/example/banner"),
+        )
+
+        assertEquals(2, bids.size)
+        assertEquals(CloudXArbiterPlatform.ADMOB, bids[0].platform)
+        assertEquals(CloudXArbiterPlatform.GAM, bids[1].platform)
+    }
+}

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/android/src/test/java/com/cloudxreactnative/FakeReadable.kt

@@ -0,0 +1,101 @@
+package com.cloudxreactnative
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import com.facebook.react.bridge.ReadableType
+import java.util.ArrayList
+import java.util.HashMap
+
+/**
+ * Minimal in-memory [ReadableMap] backed by a plain Kotlin map.
+ *
+ * The bridge only ever reads values through hasKey/getType/getString/getDouble/getMap, so the
+ * remaining members throw rather than pretend to work.
+ */
+internal class FakeReadableMap(private val values: Map<String, Any?>) : ReadableMap {
+
+    override val entryIterator: Iterator<Map.Entry<String, Any>>
+        get() = throw UnsupportedOperationException("not used by the bridge")
+
+    override fun hasKey(name: String): Boolean = values.containsKey(name)
+
+    override fun isNull(name: String): Boolean = values[name] == null
+
+    override fun getType(name: String): ReadableType = when (values[name]) {
+        null -> ReadableType.Null
+        is Boolean -> ReadableType.Boolean
+        is Number -> ReadableType.Number
+        is String -> ReadableType.String
+        is ReadableMap -> ReadableType.Map
+        is ReadableArray -> ReadableType.Array
+        else -> throw IllegalArgumentException("unsupported value for key=$name")
+    }
+
+    override fun getString(name: String): String? = values[name] as String?
+
+    override fun getDouble(name: String): Double = (values[name] as Number).toDouble()
+
+    override fun getInt(name: String): Int = (values[name] as Number).toInt()
+
+    override fun getLong(name: String): Long = (values[name] as Number).toLong()
+
+    override fun getBoolean(name: String): Boolean = values[name] as Boolean
+
+    override fun getMap(name: String): ReadableMap? = values[name] as ReadableMap?
+
+    override fun getArray(name: String): ReadableArray? = values[name] as ReadableArray?
+
+    override fun keySetIterator(): ReadableMapKeySetIterator {
+        val keys = values.keys.toList().iterator()
+        return object : ReadableMapKeySetIterator {
+            override fun hasNextKey(): Boolean = keys.hasNext()
+            override fun nextKey(): String = keys.next()
+        }
+    }
+
+    override fun getDynamic(name: String): Dynamic =
+        throw UnsupportedOperationException("not used by the bridge")
+
+    override fun toHashMap(): HashMap<String, Any> =
+        throw UnsupportedOperationException("not used by the bridge")
+}
+
+/** Minimal in-memory [ReadableArray] holding the bid maps handed to the bridge. */
+internal class FakeReadableArray(private val values: List<Any?>) : ReadableArray {
+
+    override fun size(): Int = values.size
+
+    override fun isNull(index: Int): Boolean = values[index] == null
+
+    override fun getType(index: Int): ReadableType = when (values[index]) {
+        null -> ReadableType.Null
+        is Boolean -> ReadableType.Boolean
+        is Number -> ReadableType.Number
+        is String -> ReadableType.String
+        is ReadableMap -> ReadableType.Map
+        is ReadableArray -> ReadableType.Array
+        else -> throw IllegalArgumentException("unsupported value at index=$index")
+    }
+
+    override fun getMap(index: Int): ReadableMap = values[index] as ReadableMap
+
+    override fun getString(index: Int): String = values[index] as String
+
+    override fun getDouble(index: Int): Double = (values[index] as Number).toDouble()
+
+    override fun getInt(index: Int): Int = (values[index] as Number).toInt()
+
+    override fun getLong(index: Int): Long = (values[index] as Number).toLong()
+
+    override fun getBoolean(index: Int): Boolean = values[index] as Boolean
+
+    override fun getArray(index: Int): ReadableArray = values[index] as ReadableArray
+
+    override fun getDynamic(index: Int): Dynamic =
+        throw UnsupportedOperationException("not used by the bridge")
+
+    override fun toArrayList(): ArrayList<Any> =
+        throw UnsupportedOperationException("not used by the bridge")
+}

package/cloudx-react-native.podspec

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

package/ios/CloudX.mm

@@ -141,6 +141,11 @@ static NSString *const ARBITER_PLATFORM_CLOUDX    = @"CLOUDX";
 static NSString *const ARBITER_PLATFORM_LEVELPLAY = @"LEVELPLAY";
 static NSString *const ARBITER_PLATFORM_PUBMATIC  = @"PUBMATIC";
 static NSString *const ARBITER_PLATFORM_CUSTOM    = @"CUSTOM";
+static NSString *const ARBITER_PLATFORM_ADMOB     = @"ADMOB";
+static NSString *const ARBITER_PLATFORM_GAM       = @"GAM";
+
+static NSString *const ADMOB_DEFAULT_NETWORK_NAME = @"admob";
+static NSString *const GAM_DEFAULT_NETWORK_NAME   = @"gam";
 
 static CloudX *CloudXShared;
 
@@ -1644,6 +1649,11 @@ RCT_EXPORT_METHOD(destroyRewarded:(NSString *)adUnitIdentifier)
         return CLXRevenuePlatformAdMob;
     }
 
+    if ( [trimmedPlatform caseInsensitiveCompare: CLXRevenuePlatformGAM] == NSOrderedSame )
+    {
+        return CLXRevenuePlatformGAM;
+    }
+
     if ( [trimmedPlatform caseInsensitiveCompare: CLXRevenuePlatformInMobi] == NSOrderedSame )
     {
         return CLXRevenuePlatformInMobi;
@@ -1792,6 +1802,14 @@ RCT_EXPORT_METHOD(destroyRewarded:(NSString *)adUnitIdentifier)
     {
         return [self customArbiterBidFromDictionary: dictionary];
     }
+    if ( [platform isEqualToString: ARBITER_PLATFORM_ADMOB] )
+    {
+        return [self adMobArbiterBidFromDictionary: dictionary];
+    }
+    if ( [platform isEqualToString: ARBITER_PLATFORM_GAM] )
+    {
+        return [self gamArbiterBidFromDictionary: dictionary];
+    }
     return nil;
 }
 
@@ -1874,6 +1892,50 @@ RCT_EXPORT_METHOD(destroyRewarded:(NSString *)adUnitIdentifier)
                                             extras: [self stringMapFromDictionaryValue: dictionary[@"extras"]]];
 }
 
+- (nullable CLXArbiterBid *)adMobArbiterBidFromDictionary:(NSDictionary<NSString *, id> *)dictionary
+{
+    // Values are passed untrimmed once valid; blankness only decides accept vs default.
+    NSString *adUnitId = [self stringValueFromDictionary: dictionary key: @"adUnitId"];
+    if ( [self isBlankString: adUnitId] )
+    {
+        [self log: @"arbiter: ignoring ADMOB bid with missing adUnitId"];
+        return nil;
+    }
+
+    NSString *networkName = [self stringValueFromDictionary: dictionary key: @"networkName"];
+    if ( [self isBlankString: networkName] )
+    {
+        networkName = ADMOB_DEFAULT_NETWORK_NAME;
+    }
+
+    return [CLXArbiterBid adMobBidWithAdUnitId: adUnitId
+                                   networkName: networkName
+                 manualRevenuePerImpressionUSD: [self revenueNumberValueFromDictionary: dictionary key: @"manualRevenuePerImpressionUSD"]
+                                        extras: [self stringMapFromDictionaryValue: dictionary[@"extras"]]];
+}
+
+- (nullable CLXArbiterBid *)gamArbiterBidFromDictionary:(NSDictionary<NSString *, id> *)dictionary
+{
+    // Same blank-check rationale as the ADMOB parser above.
+    NSString *adUnitId = [self stringValueFromDictionary: dictionary key: @"adUnitId"];
+    if ( [self isBlankString: adUnitId] )
+    {
+        [self log: @"arbiter: ignoring GAM bid with missing adUnitId"];
+        return nil;
+    }
+
+    NSString *networkName = [self stringValueFromDictionary: dictionary key: @"networkName"];
+    if ( [self isBlankString: networkName] )
+    {
+        networkName = GAM_DEFAULT_NETWORK_NAME;
+    }
+
+    return [CLXArbiterBid gamBidWithAdUnitId: adUnitId
+                                 networkName: networkName
+               manualRevenuePerImpressionUSD: [self revenueNumberValueFromDictionary: dictionary key: @"manualRevenuePerImpressionUSD"]
+                                      extras: [self stringMapFromDictionaryValue: dictionary[@"extras"]]];
+}
+
 - (NSDictionary<NSString *, id> *)arbiterResultInfoForResult:(CLXArbiterResult *)result
 {
     return @{@"id":           result.identifier ?: @"",

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_CloudX","_interopRequireWildcard","require","_NativeCloudX","_interopRequireDefault","_EventEmitter","_Arbiter","_RevenueData","_CloudXInterstitialAd","_CloudXAppOpenAd","_CloudXRewardedAd","_CloudXBannerAd","_CloudXMRECAd","_CloudXAdPosition","_CloudXBannerView","_CloudXMRECView","_CloudXErrorCode","_AppTrackingTransparency","_hooks","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","CloudXLogLevel","exports","VERBOSE","DEBUG","INFO","WARN","ERROR","NONE"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,OAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAIA,IAAAG,aAAA,GAAAH,OAAA;AACA,IAAAI,QAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AAGA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,gBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AACA,IAAAU,aAAA,GAAAV,OAAA;AACA,IAAAW,iBAAA,GAAAX,OAAA;AAGA,IAAAY,iBAAA,GAAAZ,OAAA;AACA,IAAAa,eAAA,GAAAb,OAAA;AAIA,IAAAc,gBAAA,GAAAd,OAAA;AAGA,IAAAe,wBAAA,GAAAf,OAAA;AAGA,IAAAgB,MAAA,GAAAhB,OAAA;AAAsG,SAAAE,uBAAAe,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,SAAAlB,wBAAAkB,CAAA,EAAAG,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAtB,uBAAA,YAAAA,CAAAkB,CAAA,EAAAG,CAAA,SAAAA,CAAA,IAAAH,CAAA,IAAAA,CAAA,CAAAC,UAAA,SAAAD,CAAA,MAAAO,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAR,OAAA,EAAAF,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAS,CAAA,MAAAF,CAAA,GAAAJ,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAE,CAAA,CAAAI,GAAA,CAAAX,CAAA,UAAAO,CAAA,CAAAK,GAAA,CAAAZ,CAAA,GAAAO,CAAA,CAAAM,GAAA,CAAAb,CAAA,EAAAS,CAAA,gBAAAN,CAAA,IAAAH,CAAA,gBAAAG,CAAA,OAAAW,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAG,CAAA,OAAAK,CAAA,IAAAD,CAAA,GAAAS,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAG,CAAA,OAAAK,CAAA,CAAAI,GAAA,IAAAJ,CAAA,CAAAK,GAAA,IAAAN,CAAA,CAAAE,CAAA,EAAAN,CAAA,EAAAK,CAAA,IAAAC,CAAA,CAAAN,CAAA,IAAAH,CAAA,CAAAG,CAAA,WAAAM,CAAA,KAAAT,CAAA,EAAAG,CAAA;AA9BtG;;AAGA;AACA;AACA;;AAKA;;AAQA;;AAKA;;AAGA;;AAGA;;AASA;;AAkCA;AACO,MAAMgB,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG;EAC1BE,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,MAAM;EACZC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE;AACV,CAAU","ignoreList":[]}
+{"version":3,"names":["_CloudX","_interopRequireWildcard","require","_NativeCloudX","_interopRequireDefault","_EventEmitter","_Arbiter","_RevenueData","_CloudXInterstitialAd","_CloudXAppOpenAd","_CloudXRewardedAd","_CloudXBannerAd","_CloudXMRECAd","_CloudXAdPosition","_CloudXBannerView","_CloudXMRECView","_CloudXErrorCode","_AppTrackingTransparency","_hooks","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","CloudXLogLevel","exports","VERBOSE","DEBUG","INFO","WARN","ERROR","NONE"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,OAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAIA,IAAAG,aAAA,GAAAH,OAAA;AACA,IAAAI,QAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AAGA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,gBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AACA,IAAAU,aAAA,GAAAV,OAAA;AACA,IAAAW,iBAAA,GAAAX,OAAA;AAGA,IAAAY,iBAAA,GAAAZ,OAAA;AACA,IAAAa,eAAA,GAAAb,OAAA;AAIA,IAAAc,gBAAA,GAAAd,OAAA;AAGA,IAAAe,wBAAA,GAAAf,OAAA;AAGA,IAAAgB,MAAA,GAAAhB,OAAA;AAAsG,SAAAE,uBAAAe,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,SAAAlB,wBAAAkB,CAAA,EAAAG,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAtB,uBAAA,YAAAA,CAAAkB,CAAA,EAAAG,CAAA,SAAAA,CAAA,IAAAH,CAAA,IAAAA,CAAA,CAAAC,UAAA,SAAAD,CAAA,MAAAO,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAR,OAAA,EAAAF,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAS,CAAA,MAAAF,CAAA,GAAAJ,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAE,CAAA,CAAAI,GAAA,CAAAX,CAAA,UAAAO,CAAA,CAAAK,GAAA,CAAAZ,CAAA,GAAAO,CAAA,CAAAM,GAAA,CAAAb,CAAA,EAAAS,CAAA,gBAAAN,CAAA,IAAAH,CAAA,gBAAAG,CAAA,OAAAW,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAG,CAAA,OAAAK,CAAA,IAAAD,CAAA,GAAAS,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAG,CAAA,OAAAK,CAAA,CAAAI,GAAA,IAAAJ,CAAA,CAAAK,GAAA,IAAAN,CAAA,CAAAE,CAAA,EAAAN,CAAA,EAAAK,CAAA,IAAAC,CAAA,CAAAN,CAAA,IAAAH,CAAA,CAAAG,CAAA,WAAAM,CAAA,KAAAT,CAAA,EAAAG,CAAA;AA9BtG;;AAGA;AACA;AACA;;AAKA;;AAQA;;AAKA;;AAGA;;AAGA;;AASA;;AAoCA;AACO,MAAMgB,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG;EAC1BE,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,MAAM;EACZC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE;AACV,CAAU","ignoreList":[]}

package/lib/commonjs/types/Arbiter.js

@@ -28,6 +28,33 @@ const CloudXArbiterBid = exports.CloudXArbiterBid = {
       platform: 'CUSTOM',
       ...params
     };
+  },
+  /**
+   * Creates an AdMob bid candidate.
+   *
+   * `manualRevenuePerImpressionUSD` of `0.0` is a real price, not an absent one; negative and
+   * non-finite values are dropped natively with a warning. Omitting it leaves pricing to the
+   * realized price recorded for `adUnitId`.
+   */
+  adMob(params) {
+    return {
+      platform: 'ADMOB',
+      ...params
+    };
+  },
+  /**
+   * Creates a Google Ad Manager bid candidate. Priced exactly like {@link adMob}; Ad Manager
+   * is a separate demand source, so both may bid in the same arbitration.
+   *
+   * `manualRevenuePerImpressionUSD` of `0.0` is a real price, not an absent one; negative and
+   * non-finite values are dropped natively with a warning. Omitting it leaves pricing to the
+   * realized price recorded for `adUnitId`.
+   */
+  gam(params) {
+    return {
+      platform: 'GAM',
+      ...params
+    };
   }
 };
 //# sourceMappingURL=Arbiter.js.map

package/lib/commonjs/types/Arbiter.js.map

@@ -1 +1 @@
-{"version":3,"names":["CloudXArbiterBid","exports","cloudX","ad","platform","levelPlay","params","pubMatic","custom"],"sourceRoot":"../../../src","sources":["types/Arbiter.ts"],"mappings":";;;;;;AAuCO,MAAMA,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG;EAC5BE,MAAMA,CAACC,EAAgB,EAAuB;IAC1C,OAAO;MACHC,QAAQ,EAAE,QAAQ;MAClBD;IACJ,CAAC;EACL,CAAC;EAEDE,SAASA,CAACC,MAAmD,EAA6B;IACtF,OAAO;MACHF,QAAQ,EAAE,WAAW;MACrB,GAAGE;IACP,CAAC;EACL,CAAC;EAEDC,QAAQA,CAACD,MAAkD,EAA4B;IACnF,OAAO;MACHF,QAAQ,EAAE,UAAU;MACpB,GAAGE;IACP,CAAC;EACL,CAAC;EAEDE,MAAMA,CAACF,MAAgD,EAA0B;IAC7E,OAAO;MACHF,QAAQ,EAAE,QAAQ;MAClB,GAAGE;IACP,CAAC;EACL;AACJ,CAAU","ignoreList":[]}
+{"version":3,"names":["CloudXArbiterBid","exports","cloudX","ad","platform","levelPlay","params","pubMatic","custom","adMob","gam"],"sourceRoot":"../../../src","sources":["types/Arbiter.ts"],"mappings":";;;;;;AAqEO,MAAMA,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG;EAC5BE,MAAMA,CAACC,EAAgB,EAAuB;IAC1C,OAAO;MACHC,QAAQ,EAAE,QAAQ;MAClBD;IACJ,CAAC;EACL,CAAC;EAEDE,SAASA,CAACC,MAAmD,EAA6B;IACtF,OAAO;MACHF,QAAQ,EAAE,WAAW;MACrB,GAAGE;IACP,CAAC;EACL,CAAC;EAEDC,QAAQA,CAACD,MAAkD,EAA4B;IACnF,OAAO;MACHF,QAAQ,EAAE,UAAU;MACpB,GAAGE;IACP,CAAC;EACL,CAAC;EAEDE,MAAMA,CAACF,MAAgD,EAA0B;IAC7E,OAAO;MACHF,QAAQ,EAAE,QAAQ;MAClB,GAAGE;IACP,CAAC;EACL,CAAC;EAED;AACJ;AACA;AACA;AACA;AACA;AACA;EACIG,KAAKA,CAACH,MAA+C,EAAyB;IAC1E,OAAO;MACHF,QAAQ,EAAE,OAAO;MACjB,GAAGE;IACP,CAAC;EACL,CAAC;EAED;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACII,GAAGA,CAACJ,MAA6C,EAAuB;IACpE,OAAO;MACHF,QAAQ,EAAE,KAAK;MACf,GAAGE;IACP,CAAC;EACL;AACJ,CAAU","ignoreList":[]}