@bigcrunch/react-native-ads 0.4.0 → 0.5.0

package/android/bigcrunch-ads/com/bigcrunch/ads/core/BidRequestClient.kt

@@ -0,0 +1,364 @@
+package com.bigcrunch.ads.core
+
+import com.bigcrunch.ads.BigCrunchAds
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.internal.HttpClient
+import com.bigcrunch.ads.internal.PrivacyStore
+import com.bigcrunch.ads.models.PlacementConfig
+import com.bigcrunch.ads.models.S2SConfig
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+
+/**
+ * Custom S2S bid request client
+ *
+ * Replaces Prebid SDK's `fetchDemand()` with a direct HTTP call to the BigCrunch
+ * S2S endpoint. Builds OpenRTB-style requests with `ext.bidders` format and
+ * implements screen-level batching (100ms debounce) to combine multiple placements
+ * into a single multi-impression request.
+ */
+internal class BidRequestClient(
+    private val httpClient: HttpClient,
+    private val configManager: ConfigManager,
+    private val privacyStore: PrivacyStore,
+    private val s2sConfig: S2SConfig
+) {
+    private val mutex = Mutex()
+    private val pendingRequests = mutableListOf<PendingRequest>()
+    private var batchJob: Job? = null
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+    companion object {
+        private const val TAG = "BidRequestClient"
+        private const val BATCH_DELAY_MS = 100L
+    }
+
+    private class PendingRequest(
+        val placement: PlacementConfig,
+        val deferred: CompletableDeferred<Map<String, String>?>
+    )
+
+    // MARK: - Public API
+
+    /**
+     * Fetch demand for a single placement
+     *
+     * The placement is queued and batched with other placements requested within
+     * a 100ms window. Returns GAM custom targeting KVPs on success, null on failure.
+     *
+     * @param placement The placement to fetch demand for
+     * @return Targeting KVPs to apply to GAM request, or null
+     */
+    suspend fun fetchDemand(placement: PlacementConfig): Map<String, String>? {
+        val deferred = CompletableDeferred<Map<String, String>?>()
+
+        mutex.withLock {
+            pendingRequests.add(PendingRequest(placement, deferred))
+
+            if (batchJob == null || batchJob?.isCompleted == true) {
+                batchJob = scope.launch {
+                    delay(BATCH_DELAY_MS)
+                    flushBatch()
+                }
+            }
+        }
+
+        return deferred.await()
+    }
+
+    // MARK: - Batching
+
+    private suspend fun flushBatch() {
+        val batch: List<PendingRequest>
+        mutex.withLock {
+            batch = pendingRequests.toList()
+            pendingRequests.clear()
+            batchJob = null
+        }
+
+        if (batch.isEmpty()) return
+
+        val placements = batch.map { it.placement }
+        BCLogger.d(TAG, "Flushing batch of ${placements.size} placements")
+
+        val results = executeBidRequest(placements)
+
+        // Distribute results to each pending deferred
+        for (pending in batch) {
+            val targeting = results[pending.placement.placementId]
+            pending.deferred.complete(targeting)
+        }
+    }
+
+    // MARK: - Request Building & Execution
+
+    private suspend fun executeBidRequest(
+        placements: List<PlacementConfig>
+    ): Map<String, Map<String, String>> {
+        val requestBody = buildRequestJSON(placements)
+        val jsonString = requestBody.toString()
+
+        BCLogger.v(TAG, "Sending bid request to ${s2sConfig.serverUrl}")
+
+        val result = httpClient.post(
+            url = s2sConfig.serverUrl,
+            body = jsonString,
+            headers = emptyMap()
+        )
+
+        return when {
+            result.isSuccess -> {
+                val responseJson = result.getOrNull()!!
+                parseResponse(responseJson)
+            }
+            else -> {
+                BCLogger.e(TAG, "Bid request failed: ${result.exceptionOrNull()?.message}")
+                emptyMap()
+            }
+        }
+    }
+
+    /**
+     * Build OpenRTB-style bid request JSON with ext.bidders format
+     */
+    private fun buildRequestJSON(placements: List<PlacementConfig>): JSONObject {
+        val request = JSONObject()
+
+        // Request ID
+        request.put("id", UUID.randomUUID().toString())
+
+        // Impressions
+        val impArray = JSONArray()
+        for (placement in placements) {
+            impArray.put(buildImp(placement))
+        }
+        request.put("imp", impArray)
+
+        // App object
+        val deviceContext = DeviceContext.getInstance()
+        val app = JSONObject().apply {
+            put("bundle", deviceContext.appPackageName)
+            put("ver", deviceContext.appVersion)
+            put("publisher", JSONObject().apply {
+                put("id", BigCrunchAds.propertyId)
+            })
+        }
+        request.put("app", app)
+
+        // Device object
+        request.put("device", buildDevice(deviceContext))
+
+        // Privacy: regs & user
+        val regs = privacyStore.buildRegsMap()
+        if (regs.isNotEmpty()) {
+            request.put("regs", mapToJson(regs))
+        }
+
+        val user = privacyStore.buildUserMap()
+        if (user.isNotEmpty()) {
+            request.put("user", mapToJson(user))
+        }
+
+        // ext.bidders — the new format
+        val biddersExt = buildBiddersExt(placements)
+        if (biddersExt.length() > 0) {
+            request.put("ext", JSONObject().apply {
+                put("bidders", biddersExt)
+            })
+        }
+
+        return request
+    }
+
+    private fun buildImp(placement: PlacementConfig): JSONObject {
+        val imp = JSONObject()
+        imp.put("id", placement.placementId)
+
+        val deviceContext = DeviceContext.getInstance()
+
+        when (placement.format) {
+            "banner" -> {
+                val banner = JSONObject()
+                val formatArray = JSONArray()
+                placement.sizes?.forEach { size ->
+                    val fmt = JSONObject()
+                    if (size.isAdaptive) {
+                        fmt.put("w", deviceContext.screenWidth)
+                        fmt.put("h", 0)
+                    } else {
+                        fmt.put("w", size.width)
+                        fmt.put("h", size.height)
+                    }
+                    formatArray.put(fmt)
+                }
+                banner.put("format", formatArray)
+                imp.put("banner", banner)
+            }
+
+            "interstitial" -> {
+                imp.put("instl", 1)
+                val banner = JSONObject()
+                val formatArray = JSONArray()
+                formatArray.put(JSONObject().apply {
+                    put("w", deviceContext.screenWidth)
+                    put("h", deviceContext.screenHeight)
+                })
+                banner.put("format", formatArray)
+                imp.put("banner", banner)
+            }
+
+            "rewarded" -> {
+                imp.put("instl", 1)
+                val video = JSONObject().apply {
+                    put("mimes", JSONArray().apply {
+                        put("video/mp4")
+                    })
+                    put("protocols", JSONArray().apply {
+                        put(2)  // VAST 2.0
+                        put(5)  // VAST 2.0 Wrapper
+                    })
+                    put("w", deviceContext.screenWidth)
+                    put("h", deviceContext.screenHeight)
+                }
+                imp.put("video", video)
+                imp.put("ext", JSONObject().apply {
+                    put("rewarded", 1)
+                })
+            }
+        }
+
+        return imp
+    }
+
+    private fun buildDevice(ctx: DeviceContext): JSONObject {
+        return JSONObject().apply {
+            put("os", ctx.osName)
+            put("osv", ctx.osVersion)
+            put("make", ctx.deviceManufacturer)
+            put("model", ctx.deviceModel)
+            put("w", ctx.screenWidth)
+            put("h", ctx.screenHeight)
+            put("pxratio", ctx.screenDensity.toDouble())
+            put("language", ctx.languageCode)
+            put("ua", ctx.getBrowserField())
+        }
+    }
+
+    /**
+     * Build the ext.bidders section
+     *
+     * For each bidder in AppConfig.bidders, check which of the requested placements
+     * have entries in that bidder's placements map. Only include relevant bidders/imps.
+     */
+    private fun buildBiddersExt(placements: List<PlacementConfig>): JSONObject {
+        val bidders = configManager.getCachedConfig()?.bidders ?: return JSONObject()
+        val placementIds = placements.map { it.placementId }.toSet()
+        val biddersExt = JSONObject()
+
+        for ((bidderName, bidderEntry) in bidders) {
+            val bidderObj = JSONObject()
+
+            // Shared params
+            bidderEntry.params?.let { params ->
+                bidderObj.put("params", mapToJson(params))
+            }
+
+            // Per-imp params (only for placements in this batch)
+            val impArray = JSONArray()
+            bidderEntry.placements?.let { bidderPlacements ->
+                for (placementId in placementIds) {
+                    bidderPlacements[placementId]?.let { impParams ->
+                        impArray.put(JSONObject().apply {
+                            put("impid", placementId)
+                            put("params", mapToJson(impParams))
+                        })
+                    }
+                }
+            }
+
+            // Only include bidder if it has relevant impressions
+            if (impArray.length() > 0) {
+                bidderObj.put("imp", impArray)
+                biddersExt.put(bidderName, bidderObj)
+            }
+        }
+
+        return biddersExt
+    }
+
+    // MARK: - Response Parsing
+
+    /**
+     * Parse S2S response and extract per-placement targeting
+     *
+     * Groups bids by impid, picks winner (highest price), copies ext.targeting.
+     */
+    private fun parseResponse(jsonString: String): Map<String, Map<String, String>> {
+        return try {
+            val json = JSONObject(jsonString)
+            val seatbids = json.optJSONArray("seatbid") ?: return emptyMap()
+
+            // Collect all bids grouped by impid
+            val bidsByImpId = mutableMapOf<String, MutableList<Pair<Double, Map<String, String>>>>()
+
+            for (i in 0 until seatbids.length()) {
+                val seatbid = seatbids.getJSONObject(i)
+                val bids = seatbid.optJSONArray("bid") ?: continue
+
+                for (j in 0 until bids.length()) {
+                    val bid = bids.getJSONObject(j)
+                    val impid = bid.optString("impid", "")
+                    val price = bid.optDouble("price", 0.0)
+                    val ext = bid.optJSONObject("ext") ?: continue
+                    val targetingJson = ext.optJSONObject("targeting") ?: continue
+
+                    val targeting = mutableMapOf<String, String>()
+                    val keys = targetingJson.keys()
+                    while (keys.hasNext()) {
+                        val key = keys.next()
+                        targeting[key] = targetingJson.getString(key)
+                    }
+
+                    if (impid.isNotEmpty()) {
+                        bidsByImpId.getOrPut(impid) { mutableListOf() }
+                            .add(Pair(price, targeting))
+                    }
+                }
+            }
+
+            // Pick winner (highest price) for each impid
+            val results = mutableMapOf<String, Map<String, String>>()
+            for ((impid, bids) in bidsByImpId) {
+                val winner = bids.maxByOrNull { it.first }
+                if (winner != null) {
+                    results[impid] = winner.second
+                    BCLogger.d(TAG, "Winner for $impid: $${winner.first}")
+                }
+            }
+
+            BCLogger.i(TAG, "Parsed ${results.size} winning bids")
+            results
+        } catch (e: Exception) {
+            BCLogger.e(TAG, "Failed to parse bid response", e)
+            emptyMap()
+        }
+    }
+
+    // MARK: - Helpers
+
+    private fun mapToJson(map: Map<String, Any>): JSONObject {
+        val obj = JSONObject()
+        for ((key, value) in map) {
+            when (value) {
+                is Map<*, *> -> obj.put(key, mapToJson(@Suppress("UNCHECKED_CAST") (value as Map<String, Any>)))
+                is List<*> -> obj.put(key, JSONArray(value))
+                else -> obj.put(key, value)
+            }
+        }
+        return obj
+    }
+}

package/android/bigcrunch-ads/com/bigcrunch/ads/core/ConfigManager.kt

@@ -0,0 +1,301 @@
+package com.bigcrunch.ads.core
+
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.internal.HttpClient
+import com.bigcrunch.ads.internal.KeyValueStore
+import com.bigcrunch.ads.models.AppConfig
+import com.bigcrunch.ads.models.PlacementConfig
+import com.squareup.moshi.Moshi
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Manages application configuration fetching, caching, and access
+ *
+ * ConfigManager is responsible for:
+ * - Fetching config from BigCrunch backend
+ * - Caching config in memory for fast access
+ * - Persisting config to storage for offline/cold start
+ * - Thread-safe config access
+ * - Placement lookup by ID
+ *
+ * The config is fetched once at SDK initialization and cached for the app session.
+ */
+internal class ConfigManager(
+    private val httpClient: HttpClient,
+    private val storage: KeyValueStore,
+    private val moshi: Moshi
+) {
+    private val mutex = Mutex()
+
+    @Volatile
+    private var cachedConfig: AppConfig? = null
+
+    private val adapter = moshi.adapter(AppConfig::class.java)
+
+    companion object {
+        private const val CONFIG_STORAGE_KEY = "app_config"
+        private const val PROD_BASE_URL = "https://ship.bigcrunch.com"
+        private const val STAGING_BASE_URL = "https://dev-ship.bigcrunch.com"
+
+        /**
+         * Generate mock configuration for testing
+         *
+         * Uses Google's official sample ad units:
+         * - Banner: ca-app-pub-3940256099942544/6300978111 (adaptive banner)
+         * - MREC: ca-app-pub-3940256099942544/6300978111 (adaptive banner - same)
+         * - Interstitial: ca-app-pub-3940256099942544/1033173712
+         */
+        private fun getMockConfig(propertyId: String): AppConfig {
+            return AppConfig(
+                propertyId = propertyId,
+                appName = "Mock Test App",
+                environment = "test",
+                gamNetworkCode = "",  // Empty for AdMob sample ads
+                s2s = com.bigcrunch.ads.models.S2SConfig(
+                    serverUrl = "https://s2s.bigcrunch.com/auction",
+                    timeoutMs = 3000
+                ),
+                bidders = null,  // No bidders in mock/test mode
+                amazonAps = null,
+                useTestAds = true,
+                refresh = com.bigcrunch.ads.models.RefreshConfig(enabled = true, intervalMs = 30000, maxRefreshes = 20),
+                placements = listOf(
+                    PlacementConfig(
+                        placementId = "test_banner_320x50",
+                        format = "banner",
+                        gamAdUnit = "ca-app-pub-3940256099942544/6300978111",
+                        sizes = listOf(com.bigcrunch.ads.models.AdSize(width = 320, height = 50))
+                    ),
+                    PlacementConfig(
+                        placementId = "test_mrec",
+                        format = "banner",
+                        gamAdUnit = "ca-app-pub-3940256099942544/6300978111",
+                        sizes = listOf(com.bigcrunch.ads.models.AdSize(width = 300, height = 250)),
+                        refresh = com.bigcrunch.ads.models.RefreshConfig(enabled = true, intervalMs = 15000, maxRefreshes = 40)
+                    ),
+                    PlacementConfig(
+                        placementId = "test_adaptive_banner",
+                        format = "banner",
+                        gamAdUnit = "ca-app-pub-3940256099942544/6300978111",
+                        sizes = listOf(com.bigcrunch.ads.models.AdSize.adaptive())
+                    ),
+                    PlacementConfig(
+                        placementId = "test_interstitial",
+                        format = "interstitial",
+                        gamAdUnit = "ca-app-pub-3940256099942544/1033173712",
+                        sizes = null
+                    ),
+                    PlacementConfig(
+                        placementId = "test_rewarded",
+                        format = "rewarded",
+                        gamAdUnit = "ca-app-pub-3940256099942544/5224354917",
+                        sizes = null
+                    )
+                )
+            )
+        }
+    }
+
+    /**
+     * Load configuration from BigCrunch backend or mock data
+     *
+     * This method:
+     * 1. If useMockConfig is true, returns hardcoded mock config immediately
+     * 2. Attempts to load cached config from storage first (for offline/cold start)
+     * 3. Fetches fresh config from network
+     * 4. If network succeeds, updates cache and storage
+     * 5. If network fails but cache exists, returns cached version
+     * 6. If network fails and no cache, returns error
+     *
+     * @param propertyId BigCrunch property ID
+     * @param isProd True for production, false for staging
+     * @param useMockConfig If true, returns mock config for testing
+     * @return Result containing AppConfig or error
+     */
+    suspend fun loadConfig(
+        propertyId: String,
+        isProd: Boolean,
+        useMockConfig: Boolean = false
+    ): Result<AppConfig> = mutex.withLock {
+        BCLogger.d("ConfigManager", "Loading config for property: $propertyId (mock: $useMockConfig)")
+
+        // If mock mode enabled, return mock config immediately
+        if (useMockConfig) {
+            val mockConfig = getMockConfig(propertyId)
+            cachedConfig = mockConfig
+            BCLogger.i("ConfigManager", "Using mock config (${mockConfig.placements.size} placements)")
+            return Result.success(mockConfig)
+        }
+
+        // 1. Try to load from storage first (for offline/cold start)
+        val storedConfig = loadFromStorage()
+        if (storedConfig != null) {
+            cachedConfig = storedConfig
+            BCLogger.d("ConfigManager", "Loaded config from storage")
+        }
+
+        // 2. Fetch fresh config from network
+        val baseUrl = if (isProd) PROD_BASE_URL else STAGING_BASE_URL
+        val url = "$baseUrl/config-app/$propertyId.json"
+
+        val result = httpClient.get(
+            url = url,
+            headers = emptyMap() // No authentication required for public config files
+        )
+
+        return when {
+            result.isSuccess -> {
+                // Network request succeeded
+                val json = result.getOrNull()!!
+                val config = try {
+                    adapter.fromJson(json)
+                } catch (e: Exception) {
+                    BCLogger.e("ConfigManager", "Failed to parse config JSON", e)
+                    null
+                }
+
+                if (config != null) {
+                    cachedConfig = config
+                    saveToStorage(json)
+                    BCLogger.i("ConfigManager", "Config loaded successfully from network (${config.placements.size} placements)")
+                    Result.success(config)
+                } else {
+                    BCLogger.e("ConfigManager", "Invalid config JSON")
+                    Result.failure(Exception("Invalid config JSON"))
+                }
+            }
+            storedConfig != null -> {
+                // Network failed but we have cached version
+                BCLogger.w("ConfigManager", "Using cached config, network fetch failed: ${result.exceptionOrNull()?.message}")
+                Result.success(storedConfig)
+            }
+            else -> {
+                // Network failed and no cache available
+                BCLogger.e("ConfigManager", "Config load failed and no cache available")
+                Result.failure(result.exceptionOrNull() ?: Exception("Config load failed"))
+            }
+        }
+    }
+
+    /**
+     * Get the cached app configuration
+     *
+     * @return The cached AppConfig, or null if not loaded
+     */
+    fun getCachedConfig(): AppConfig? = cachedConfig
+
+    /**
+     * Get placement configuration by ID
+     *
+     * This is a synchronous operation that looks up the placement in the cached config.
+     * Must be called after loadConfig() has succeeded at least once.
+     *
+     * @param placementId The placement ID to look up
+     * @return PlacementConfig if found, null otherwise
+     */
+    fun getPlacement(placementId: String): PlacementConfig? {
+        val placement = cachedConfig?.placements?.firstOrNull {
+            it.placementId == placementId
+        }
+
+        if (placement == null) {
+            BCLogger.w("ConfigManager", "Placement not found: $placementId")
+        } else {
+            BCLogger.v("ConfigManager", "Found placement: $placementId (${placement.format})")
+        }
+
+        return placement
+    }
+
+    /**
+     * Get all placements from cached config
+     *
+     * @return List of all placements, or empty list if config not loaded
+     */
+    fun getAllPlacements(): List<PlacementConfig> {
+        return cachedConfig?.placements ?: emptyList()
+    }
+
+    /**
+     * Get the GAM network code from cached config
+     *
+     * @return The GAM network code, or null if config not loaded
+     */
+    fun getGamNetworkCode(): String? {
+        return cachedConfig?.gamNetworkCode
+    }
+
+    /**
+     * Get the S2S config from cached config
+     *
+     * @return The S2S config, or null if config not loaded
+     */
+    fun getS2SConfig(): com.bigcrunch.ads.models.S2SConfig? {
+        return cachedConfig?.s2s
+    }
+
+    /**
+     * Get the effective refresh config for a placement
+     *
+     * Resolution order:
+     * 1. Placement-level refresh config (if present, even if disabled)
+     * 2. Global refresh config from AppConfig
+     * 3. null (no refresh)
+     *
+     * @param placementId The placement ID to look up
+     * @return RefreshConfig if refresh is configured, null otherwise
+     */
+    fun getEffectiveRefreshConfig(placementId: String): com.bigcrunch.ads.models.RefreshConfig? {
+        val placement = getPlacement(placementId) ?: return null
+        // Placement-level override takes priority
+        if (placement.refresh != null) {
+            return placement.refresh
+        }
+        // Fall back to global config
+        return cachedConfig?.refresh
+    }
+
+    /**
+     * Check if test ads mode is enabled in config
+     *
+     * @return true if test ads should be used, false otherwise
+     */
+    fun shouldUseTestAds(): Boolean {
+        return cachedConfig?.useTestAds ?: false
+    }
+
+    /**
+     * Clear cached config (for testing)
+     */
+    internal fun clearCache() {
+        cachedConfig = null
+        storage.clear()
+        BCLogger.d("ConfigManager", "Cache cleared")
+    }
+
+    /**
+     * Load config from persistent storage
+     */
+    private fun loadFromStorage(): AppConfig? {
+        return try {
+            val json = storage.getString(CONFIG_STORAGE_KEY) ?: return null
+            adapter.fromJson(json)
+        } catch (e: Exception) {
+            BCLogger.e("ConfigManager", "Failed to load config from storage", e)
+            null
+        }
+    }
+
+    /**
+     * Save config to persistent storage
+     */
+    private fun saveToStorage(json: String) {
+        try {
+            storage.putString(CONFIG_STORAGE_KEY, json)
+            BCLogger.v("ConfigManager", "Config saved to storage")
+        } catch (e: Exception) {
+            BCLogger.e("ConfigManager", "Failed to save config to storage", e)
+        }
+    }
+}