@bigcrunch/react-native-ads 0.4.0 → 0.6.0

package/ios/BigCrunchAds/Sources/Core/BidRequestClient.swift

@@ -0,0 +1,344 @@
+import Foundation
+
+/**
+ * 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.
+ *
+ * Usage:
+ * ```swift
+ * let targeting = await bidRequestClient.fetchDemand(placement: placement)
+ * // targeting is [String: String] with GAM custom targeting KVPs
+ * ```
+ */
+internal class BidRequestClient {
+
+    private let httpClient: HTTPClient
+    private let configManager: ConfigManager
+    private let privacyStore: PrivacyStore
+    private let s2sConfig: S2SConfig
+
+    private let lock = NSLock()
+    private var pendingRequests: [PendingRequest] = []
+    private var batchTimer: Timer?
+
+    private static let batchDelayMs: Int = 100
+
+    // MARK: - Types
+
+    private struct PendingRequest {
+        let placement: PlacementConfig
+        let continuation: CheckedContinuation<[String: String]?, Never>
+    }
+
+    // MARK: - Init
+
+    init(
+        httpClient: HTTPClient,
+        configManager: ConfigManager,
+        privacyStore: PrivacyStore,
+        s2sConfig: S2SConfig
+    ) {
+        self.httpClient = httpClient
+        self.configManager = configManager
+        self.privacyStore = privacyStore
+        self.s2sConfig = s2sConfig
+    }
+
+    // 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, nil on failure.
+     *
+     * - Parameter placement: The placement to fetch demand for
+     * - Returns: Targeting KVPs to apply to GAM request, or nil
+     */
+    func fetchDemand(placement: PlacementConfig) async -> [String: String]? {
+        return await withCheckedContinuation { continuation in
+            lock.lock()
+            pendingRequests.append(PendingRequest(
+                placement: placement,
+                continuation: continuation
+            ))
+
+            if batchTimer == nil {
+                let delay = TimeInterval(Self.batchDelayMs) / 1000.0
+                let timer = Timer(timeInterval: delay, repeats: false) { [weak self] _ in
+                    self?.flushBatch()
+                }
+                RunLoop.main.add(timer, forMode: .common)
+                batchTimer = timer
+            }
+            lock.unlock()
+        }
+    }
+
+    // MARK: - Batching
+
+    private func flushBatch() {
+        lock.lock()
+        let batch = pendingRequests
+        pendingRequests = []
+        batchTimer?.invalidate()
+        batchTimer = nil
+        lock.unlock()
+
+        guard !batch.isEmpty else { return }
+
+        let placements = batch.map { $0.placement }
+        BCLogger.debug("BidRequestClient: Flushing batch of \(placements.count) placements")
+
+        Task {
+            let results = await executeBidRequest(placements: placements)
+
+            // Distribute results to each pending continuation
+            for pending in batch {
+                let targeting = results[pending.placement.placementId]
+                pending.continuation.resume(returning: targeting)
+            }
+        }
+    }
+
+    // MARK: - Request Building & Execution
+
+    private func executeBidRequest(placements: [PlacementConfig]) async -> [String: [String: String]] {
+        let requestBody = buildRequestJSON(placements: placements)
+
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: requestBody),
+              let jsonString = String(data: jsonData, encoding: .utf8) else {
+            BCLogger.error("BidRequestClient: Failed to serialize bid request")
+            return [:]
+        }
+
+        BCLogger.verbose("BidRequestClient: Sending bid request to \(s2sConfig.serverUrl)")
+
+        let result = await httpClient.post(
+            url: s2sConfig.serverUrl,
+            body: jsonString,
+            headers: [:]
+        )
+
+        switch result {
+        case .success(let responseJson):
+            return parseResponse(responseJson)
+        case .failure(let error):
+            BCLogger.error("BidRequestClient: Bid request failed: \(error)")
+            return [:]
+        }
+    }
+
+    /**
+     * Build OpenRTB-style bid request JSON with ext.bidders format
+     */
+    private func buildRequestJSON(placements: [PlacementConfig]) -> [String: Any] {
+        var request: [String: Any] = [:]
+
+        // Request ID
+        request["id"] = UUID().uuidString
+
+        // Impressions
+        request["imp"] = placements.map { buildImp($0) }
+
+        // App object
+        let deviceContext = DeviceContext.shared
+        request["app"] = [
+            "bundle": deviceContext.appBundleId,
+            "ver": deviceContext.appVersion,
+            "publisher": ["id": BigCrunchAds.propertyId]
+        ]
+
+        // Device object
+        request["device"] = buildDevice(deviceContext)
+
+        // Privacy: regs & user
+        let regs = privacyStore.buildRegsDict()
+        if !regs.isEmpty {
+            request["regs"] = regs
+        }
+
+        let user = privacyStore.buildUserDict()
+        if !user.isEmpty {
+            request["user"] = user
+        }
+
+        // ext.bidders — the new format
+        let biddersExt = buildBiddersExt(placements: placements)
+        if !biddersExt.isEmpty {
+            request["ext"] = ["bidders": biddersExt]
+        }
+
+        return request
+    }
+
+    private func buildImp(_ placement: PlacementConfig) -> [String: Any] {
+        var imp: [String: Any] = [
+            "id": placement.placementId
+        ]
+
+        switch placement.format {
+        case "banner":
+            var banner: [String: Any] = [:]
+            if let sizes = placement.sizes {
+                banner["format"] = sizes.map { size -> [String: Any] in
+                    if size.isAdaptive {
+                        // Use screen width for adaptive
+                        let screenWidth = DeviceContext.shared.screenWidth
+                        return ["w": screenWidth, "h": 0]
+                    }
+                    return ["w": size.width, "h": size.height]
+                }
+            }
+            imp["banner"] = banner
+
+        case "interstitial":
+            imp["instl"] = 1
+            imp["banner"] = [
+                "format": [
+                    ["w": DeviceContext.shared.screenWidth,
+                     "h": DeviceContext.shared.screenHeight]
+                ]
+            ]
+
+        case "rewarded":
+            imp["instl"] = 1
+            imp["video"] = [
+                "mimes": ["video/mp4"],
+                "protocols": [2, 5], // VAST 2.0, VAST 2.0 Wrapper
+                "w": DeviceContext.shared.screenWidth,
+                "h": DeviceContext.shared.screenHeight
+            ]
+            imp["ext"] = ["rewarded": 1]
+
+        default:
+            break
+        }
+
+        return imp
+    }
+
+    private func buildDevice(_ ctx: DeviceContext) -> [String: Any] {
+        var device: [String: Any] = [
+            "os": ctx.osName,
+            "osv": ctx.osVersion,
+            "make": "Apple",
+            "model": ctx.deviceModel,
+            "w": ctx.screenWidth,
+            "h": ctx.screenHeight,
+            "pxratio": ctx.screenScale,
+            "language": ctx.languageCode
+        ]
+
+        // User-Agent — use a reasonable default
+        device["ua"] = ctx.getBrowserField()
+
+        return device
+    }
+
+    /**
+     * 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 func buildBiddersExt(placements: [PlacementConfig]) -> [String: Any] {
+        guard let bidders = configManager.getCachedConfig()?.bidders else {
+            return [:]
+        }
+
+        let placementIds = Set(placements.map { $0.placementId })
+        var biddersExt: [String: Any] = [:]
+
+        for (bidderName, bidderEntry) in bidders {
+            var bidderObj: [String: Any] = [:]
+
+            // Shared params
+            if let params = bidderEntry.params {
+                bidderObj["params"] = params.mapValues { $0.value }
+            }
+
+            // Per-imp params (only for placements in this batch)
+            var impEntries: [[String: Any]] = []
+            if let bidderPlacements = bidderEntry.placements {
+                for placementId in placementIds {
+                    if let impParams = bidderPlacements[placementId] {
+                        impEntries.append([
+                            "impid": placementId,
+                            "params": impParams.mapValues { $0.value }
+                        ])
+                    }
+                }
+            }
+
+            // Only include bidder if it has relevant impressions
+            if !impEntries.isEmpty {
+                bidderObj["imp"] = impEntries
+                biddersExt[bidderName] = bidderObj
+            }
+        }
+
+        return biddersExt
+    }
+
+    // MARK: - Response Parsing
+
+    /**
+     * Parse S2S response and extract per-placement targeting
+     *
+     * Expected format:
+     * ```json
+     * {
+     *   "seatbid": [{
+     *     "bid": [{
+     *       "impid": "leaderboard",
+     *       "price": 2.50,
+     *       "ext": { "targeting": { "hb_pb": "2.50", ... } }
+     *     }]
+     *   }]
+     * }
+     * ```
+     *
+     * Groups bids by impid, picks winner (highest price), copies ext.targeting.
+     */
+    private func parseResponse(_ jsonString: String) -> [String: [String: String]] {
+        guard let data = jsonString.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let seatbids = json["seatbid"] as? [[String: Any]] else {
+            BCLogger.error("BidRequestClient: Failed to parse bid response")
+            return [:]
+        }
+
+        // Collect all bids grouped by impid
+        var bidsByImpId: [String: [(price: Double, targeting: [String: String])]] = [:]
+
+        for seatbid in seatbids {
+            guard let bids = seatbid["bid"] as? [[String: Any]] else { continue }
+            for bid in bids {
+                guard let impid = bid["impid"] as? String,
+                      let price = bid["price"] as? Double,
+                      let ext = bid["ext"] as? [String: Any],
+                      let targeting = ext["targeting"] as? [String: String] else {
+                    continue
+                }
+                bidsByImpId[impid, default: []].append((price: price, targeting: targeting))
+            }
+        }
+
+        // Pick winner (highest price) for each impid
+        var results: [String: [String: String]] = [:]
+        for (impid, bids) in bidsByImpId {
+            if let winner = bids.max(by: { $0.price < $1.price }) {
+                results[impid] = winner.targeting
+                BCLogger.debug("BidRequestClient: Winner for \(impid): $\(winner.price)")
+            }
+        }
+
+        BCLogger.info("BidRequestClient: Parsed \(results.count) winning bids")
+        return results
+    }
+}

package/ios/BigCrunchAds/Sources/Core/ConfigManager.swift

@@ -0,0 +1,305 @@
+import Foundation
+
+/**
+ * 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 let httpClient: HTTPClient
+    private let storage: KeyValueStore
+    private let lock = NSLock()
+
+    private var cachedConfig: AppConfig?
+
+    private static let configStorageKey = "app_config"
+    private static let prodBaseURL = "https://ship.bigcrunch.com"
+    private static let stagingBaseURL = "https://dev-ship.bigcrunch.com"
+
+    init(httpClient: HTTPClient, storage: KeyValueStore) {
+        self.httpClient = httpClient
+        self.storage = storage
+    }
+
+    /**
+     * Generate mock configuration for testing
+     *
+     * Uses Google's official sample ad units:
+     * - Banner: ca-app-pub-3940256099942544/2435281174 (320x50)
+     * - MREC: ca-app-pub-3940256099942544/6300978111 (300x250 - same as banner sample)
+     * - Interstitial: ca-app-pub-3940256099942544/4411468910
+     *
+     * For GAM, we need to use a GAM-style ad unit path format.
+     * Using empty network code with sample ad unit IDs for testing.
+     */
+    private static func getMockConfig(propertyId: String) -> AppConfig {
+        return AppConfig(
+            propertyId: propertyId,
+            appName: "Mock Test App",
+            gamNetworkCode: "",  // Empty for AdMob sample ads
+            s2s: S2SConfig(
+                serverUrl: "https://s2s.bigcrunch.com/auction",
+                timeoutMs: 3000
+            ),
+            bidders: nil,  // No bidders in mock/test mode
+            amazonAps: nil,
+            useTestAds: true,  // Use Google's test ad units in mock mode
+            refresh: RefreshConfig(enabled: true, intervalMs: 30000, maxRefreshes: 20),
+            placements: [
+                PlacementConfig(
+                    placementId: "test_banner_320x50",
+                    format: "banner",
+                    gamAdUnit: "ca-app-pub-3940256099942544/2435281174",
+                    sizes: [AdSize(width: 320, height: 50)]
+                ),
+                PlacementConfig(
+                    placementId: "test_mrec",
+                    format: "banner",
+                    gamAdUnit: "ca-app-pub-3940256099942544/2435281174",
+                    sizes: [AdSize(width: 300, height: 250)],
+                    refresh: RefreshConfig(enabled: true, intervalMs: 15000, maxRefreshes: 40)
+                ),
+                PlacementConfig(
+                    placementId: "test_adaptive_banner",
+                    format: "banner",
+                    gamAdUnit: "ca-app-pub-3940256099942544/2435281174",
+                    sizes: [AdSize.adaptive()]
+                ),
+                PlacementConfig(
+                    placementId: "test_interstitial",
+                    format: "interstitial",
+                    gamAdUnit: "ca-app-pub-3940256099942544/4411468910",
+                    sizes: nil
+                ),
+                PlacementConfig(
+                    placementId: "test_rewarded",
+                    format: "rewarded",
+                    gamAdUnit: "ca-app-pub-3940256099942544/1712485313",
+                    sizes: nil
+                )
+            ]
+        )
+    }
+
+    /**
+     * 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
+     *
+     * - Parameters:
+     *   - propertyId: BigCrunch property ID
+     *   - isProd: True for production, false for staging
+     *   - useMockConfig: If true, returns mock config for testing
+     * - Returns: Result containing AppConfig or error
+     */
+    func loadConfig(
+        propertyId: String,
+        isProd: Bool,
+        useMockConfig: Bool = false
+    ) async -> Result<AppConfig, Error> {
+        lock.lock()
+        defer { lock.unlock() }
+
+        BCLogger.debug("Loading config for property: \(propertyId) (mock: \(useMockConfig))")
+
+        // If mock mode enabled, return mock config immediately
+        if useMockConfig {
+            let mockConfig = Self.getMockConfig(propertyId: propertyId)
+            cachedConfig = mockConfig
+            BCLogger.info("Using mock config (\(mockConfig.placements.count) placements)")
+            return .success(mockConfig)
+        }
+
+        // 1. Try to load from storage first (for offline/cold start)
+        if let storedConfig = loadFromStorage() {
+            cachedConfig = storedConfig
+            BCLogger.debug("Loaded config from storage")
+        }
+
+        // 2. Fetch fresh config from network
+        let baseURL = isProd ? Self.prodBaseURL : Self.stagingBaseURL
+        let url = "\(baseURL)/config-app/\(propertyId).json"
+
+        let result = await httpClient.get(
+            url: url,
+            headers: [:]
+        )
+
+        switch result {
+        case .success(let json):
+            // Network request succeeded
+            do {
+                let data = json.data(using: .utf8)!
+                let config = try JSONDecoder().decode(AppConfig.self, from: data)
+                cachedConfig = config
+                saveToStorage(json)
+                BCLogger.info("Config loaded successfully from network (\(config.placements.count) placements)")
+                return .success(config)
+            } catch {
+                BCLogger.error("Failed to parse config JSON: \(error)")
+                return .failure(error)
+            }
+
+        case .failure(let error):
+            // Network failed, check for cached version
+            if let cached = cachedConfig {
+                BCLogger.warning("Using cached config, network fetch failed: \(error)")
+                return .success(cached)
+            } else {
+                BCLogger.error("Config load failed and no cache available")
+                return .failure(error)
+            }
+        }
+    }
+
+    /**
+     * 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.
+     *
+     * - Parameter placementId: The placement ID to look up
+     * - Returns: PlacementConfig if found, nil otherwise
+     */
+    func getPlacement(_ placementId: String) -> PlacementConfig? {
+        let placement = cachedConfig?.placements.first {
+            $0.placementId == placementId
+        }
+
+        if placement == nil {
+            BCLogger.warning("Placement not found: \(placementId)")
+        } else {
+            BCLogger.verbose("Found placement: \(placementId) (\(placement!.format))")
+        }
+
+        return placement
+    }
+
+    /**
+     * Get all placements from cached config
+     *
+     * - Returns: List of all placements, or empty list if config not loaded
+     */
+    func getAllPlacements() -> [PlacementConfig] {
+        return cachedConfig?.placements ?? []
+    }
+
+    /**
+     * Get the GAM network code from cached config
+     *
+     * - Returns: The GAM network code, or nil if config not loaded
+     */
+    func getGamNetworkCode() -> String? {
+        return cachedConfig?.gamNetworkCode
+    }
+
+    /**
+     * Get the S2S config from cached config
+     *
+     * - Returns: The S2S config, or nil if config not loaded
+     */
+    func getS2SConfig() -> S2SConfig? {
+        return cachedConfig?.s2s
+    }
+
+    /**
+     * Get the cached app configuration
+     *
+     * - Returns: The cached AppConfig, or nil if not yet loaded
+     */
+    func getCachedConfig() -> AppConfig? {
+        lock.lock()
+        defer { lock.unlock() }
+        return cachedConfig
+    }
+
+    /**
+     * Check if test ads should be used
+     *
+     * Returns true if the cached config has useTestAds enabled.
+     * When true, GoogleAdsAdapter should substitute production ad units with Google's test ad units.
+     *
+     * - Returns: True if test ads should be used, false otherwise
+     */
+    func shouldUseTestAds() -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return cachedConfig?.useTestAds ?? false
+    }
+
+    /**
+     * 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. nil (no refresh)
+     *
+     * - Parameter placementId: The placement ID to look up
+     * - Returns: RefreshConfig if refresh is configured, nil otherwise
+     */
+    func getEffectiveRefreshConfig(placementId: String) -> RefreshConfig? {
+        guard let placement = getPlacement(placementId) else { return nil }
+        // Placement-level override takes priority
+        if let placementRefresh = placement.refresh {
+            return placementRefresh
+        }
+        // Fall back to global config
+        return cachedConfig?.refresh
+    }
+
+    /**
+     * Clear cached config (for testing)
+     */
+    func clearCache() {
+        lock.lock()
+        defer { lock.unlock() }
+
+        cachedConfig = nil
+        storage.clear()
+        BCLogger.debug("Cache cleared")
+    }
+
+    /**
+     * Load config from persistent storage
+     */
+    private func loadFromStorage() -> AppConfig? {
+        guard let json = storage.getString(key: Self.configStorageKey, default: nil),
+              let data = json.data(using: .utf8) else {
+            return nil
+        }
+
+        do {
+            return try JSONDecoder().decode(AppConfig.self, from: data)
+        } catch {
+            BCLogger.error("Failed to load config from storage: \(error)")
+            return nil
+        }
+    }
+
+    /**
+     * Save config to persistent storage
+     */
+    private func saveToStorage(_ json: String) {
+        do {
+            storage.putString(key: Self.configStorageKey, value: json)
+            BCLogger.verbose("Config saved to storage")
+        } catch {
+            BCLogger.error("Failed to save config to storage: \(error)")
+        }
+    }
+}