@bigcrunch/react-native-ads 0.3.1 → 0.5.0

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

@@ -0,0 +1,623 @@
+package com.bigcrunch.ads.core
+
+import android.app.Activity
+import android.content.Context
+import android.view.ViewGroup
+import com.bigcrunch.ads.adapters.BannerAdCallback
+import com.bigcrunch.ads.adapters.GoogleAdsAdapter
+import com.bigcrunch.ads.adapters.InterstitialAdCallback
+import com.bigcrunch.ads.adapters.RewardedAdCallback
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.models.PlacementConfig
+import com.google.android.gms.ads.admanager.AdManagerAdRequest
+import com.google.android.gms.ads.admanager.AdManagerAdView
+import com.google.android.gms.ads.admanager.AdManagerInterstitialAd
+import com.google.android.gms.ads.rewarded.RewardedAd
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Callback interface for banner ad events
+ */
+interface BannerCallback {
+    fun onAdLoaded()
+    fun onAdFailedToLoad(error: String)
+    fun onAdClicked()
+    fun onAdImpression()
+}
+
+/**
+ * Callback interface for interstitial ad events
+ */
+interface InterstitialCallback {
+    fun onAdLoaded()
+    fun onAdFailedToLoad(error: String)
+    fun onAdShowed()
+    fun onAdDismissed()
+    fun onAdClicked()
+}
+
+/**
+ * AdOrchestrator - Central orchestration for ad loading lifecycle
+ *
+ * Coordinates the flow between ConfigManager, BidRequestClient, GoogleAdsAdapter,
+ * and AnalyticsClient to load and display ads.
+ *
+ * Flow:
+ * 1. Get PlacementConfig from ConfigManager
+ * 2. Track ad request via AnalyticsClient
+ * 3. Fetch S2S demand via BidRequestClient
+ * 4. Load Google ad via GoogleAdsAdapter (with targeting from S2S)
+ * 5. Wire up all callbacks for analytics
+ */
+internal class AdOrchestrator(
+    private val context: Context,
+    private val configManager: ConfigManager,
+    private val analyticsClient: AnalyticsClient,
+    private val bidRequestClient: BidRequestClient,
+    private val googleAdsAdapter: GoogleAdsAdapter
+) {
+    private val TAG = "AdOrchestrator"
+
+    /**
+     * Exception handler for coroutines - catches any uncaught exceptions
+     * to prevent SDK errors from crashing the host app.
+     */
+    private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+        BCLogger.e(TAG, "Uncaught exception in SDK coroutine - SDK will not propagate this to prevent app crash", throwable)
+        // Don't rethrow - SDK errors should not crash the host app
+    }
+
+    /**
+     * Coroutine scope with SupervisorJob (child failures don't cancel siblings)
+     * and exception handler (uncaught exceptions are logged, not propagated).
+     */
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob() + exceptionHandler)
+
+    // Cache for preloaded interstitial ads
+    private val interstitialCache = ConcurrentHashMap<String, AdManagerInterstitialAd>()
+    private val interstitialMutex = Mutex()
+
+    // Cache for preloaded rewarded ads
+    private val rewardedCache = ConcurrentHashMap<String, RewardedAd>()
+    private val rewardedMutex = Mutex()
+
+    // Track active banner views for cleanup
+    private val activeBanners = ConcurrentHashMap<String, AdManagerAdView>()
+
+    /**
+     * Load a banner ad
+     *
+     * @param placementId The placement ID from the BigCrunch dashboard
+     * @param container The ViewGroup to add the banner to
+     * @param callback Callback for ad events
+     * @param adSizeOverride Optional size override (takes precedence over backend config)
+     */
+    fun loadBannerAd(
+        placementId: String,
+        container: ViewGroup,
+        callback: BannerCallback,
+        adSizeOverride: com.bigcrunch.ads.models.AdSize? = null,
+        refreshCount: Int = 0
+    ) {
+        BCLogger.d(TAG, "Loading banner ad: $placementId with adSizeOverride: $adSizeOverride")
+
+        // 1. Get placement config
+        val placement = configManager.getPlacement(placementId)
+        if (placement == null) {
+            BCLogger.e(TAG, "Placement not found: $placementId")
+            callback.onAdFailedToLoad("Placement not found: $placementId")
+            return
+        }
+
+        if (placement.format != "banner") {
+            BCLogger.e(TAG, "Invalid format for banner: ${placement.format}")
+            callback.onAdFailedToLoad("Invalid placement format: ${placement.format}")
+            return
+        }
+
+        // 2. Track ad request
+        analyticsClient.trackAdRequest(placementId, placement.format)
+
+        // 3. Start the async ad loading flow
+        scope.launch {
+            loadBannerAsync(placement, container, callback, adSizeOverride, refreshCount)
+        }
+    }
+
+    private suspend fun loadBannerAsync(
+        placement: PlacementConfig,
+        container: ViewGroup,
+        callback: BannerCallback,
+        adSizeOverride: com.bigcrunch.ads.models.AdSize? = null,
+        refreshCount: Int = 0
+    ) {
+        // Get GAM network code from config
+        val gamNetworkCode = configManager.getGamNetworkCode()
+        if (gamNetworkCode == null) {
+            BCLogger.e(TAG, "GAM network code not available")
+            callback.onAdFailedToLoad("Config not loaded")
+            return
+        }
+
+        // Resolve effective size for S2S bid request (adaptive → concrete dimensions)
+        val effectiveSize = adSizeOverride ?: placement.sizes?.firstOrNull()
+        val resolvedSize: com.bigcrunch.ads.models.AdSize? = if (effectiveSize?.isAdaptive == true) {
+            val displayMetrics = context.resources.displayMetrics
+            val widthDp = if (effectiveSize.width > 0) effectiveSize.width
+                          else (displayMetrics.widthPixels / displayMetrics.density).toInt()
+            val googleAdSize = com.google.android.gms.ads.AdSize
+                .getCurrentOrientationAnchoredAdaptiveBannerAdSize(context, widthDp)
+            BCLogger.d(TAG, "Resolved adaptive size to ${googleAdSize.width}x${googleAdSize.height}")
+            com.bigcrunch.ads.models.AdSize(googleAdSize.width, googleAdSize.height)
+        } else {
+            effectiveSize
+        }
+
+        // Create ad request builder
+        val adRequestBuilder = AdManagerAdRequest.Builder()
+
+        // 3. Fetch S2S demand (even if it fails, continue with Google)
+        val targeting = bidRequestClient.fetchDemand(placement)
+        if (targeting != null && targeting.isNotEmpty()) {
+            for ((key, value) in targeting) {
+                adRequestBuilder.addCustomTargeting(key, value)
+            }
+            BCLogger.d(TAG, "S2S demand fetched for: ${placement.placementId} (${targeting.size} keys)")
+        } else {
+            BCLogger.w(TAG, "S2S demand fetch returned no targeting, continuing with Google only")
+        }
+
+        // 4. Load Google ad with the (possibly enriched) ad request
+        val adRequest = adRequestBuilder.build()
+        val adapterCallback = object : BannerAdCallback {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Banner ad loaded: ${placement.placementId}")
+                callback.onAdLoaded()
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Banner ad failed to load: ${placement.placementId} - $error")
+                callback.onAdFailedToLoad(error)
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Banner ad clicked: ${placement.placementId}")
+                callback.onAdClicked()
+            }
+
+            override fun onAdImpression() {
+                BCLogger.d(TAG, "Banner ad impression: ${placement.placementId}")
+                callback.onAdImpression()
+            }
+        }
+
+        // Get test ads flag from config
+        val useTestAds = configManager.shouldUseTestAds()
+
+        // Clean up existing banner for refresh
+        activeBanners.remove(placement.placementId)?.let { oldView ->
+            googleAdsAdapter.destroyBannerAd(oldView)
+        }
+
+        // Load the ad through GoogleAdsAdapter
+        val adView = googleAdsAdapter.loadBannerAd(
+            placement,
+            gamNetworkCode,
+            adRequest,
+            container,
+            adapterCallback,
+            useTestAds,
+            adSizeOverride,
+            refreshCount
+        )
+
+        // Track the active banner for cleanup
+        activeBanners[placement.placementId] = adView
+    }
+
+    /**
+     * Destroy a banner ad
+     *
+     * @param placementId The placement ID of the banner to destroy
+     */
+    fun destroyBannerAd(placementId: String) {
+        BCLogger.d(TAG, "Destroying banner ad: $placementId")
+        activeBanners.remove(placementId)?.let { adView ->
+            googleAdsAdapter.destroyBannerAd(adView)
+        }
+    }
+
+    /**
+     * Preload an interstitial ad
+     *
+     * @param placementId The placement ID from the BigCrunch dashboard
+     * @param callback Callback for ad events
+     */
+    fun preloadInterstitialAd(
+        placementId: String,
+        callback: InterstitialCallback
+    ) {
+        BCLogger.d(TAG, "Preloading interstitial ad: $placementId")
+
+        // 1. Get placement config
+        val placement = configManager.getPlacement(placementId)
+        if (placement == null) {
+            BCLogger.e(TAG, "Placement not found: $placementId")
+            callback.onAdFailedToLoad("Placement not found: $placementId")
+            return
+        }
+
+        if (placement.format != "interstitial") {
+            BCLogger.e(TAG, "Invalid format for interstitial: ${placement.format}")
+            callback.onAdFailedToLoad("Invalid placement format: ${placement.format}")
+            return
+        }
+
+        // 2. Track ad request
+        analyticsClient.trackAdRequest(placementId, placement.format)
+
+        // 3. Start the async ad loading flow
+        scope.launch {
+            preloadInterstitialAsync(placement, callback)
+        }
+    }
+
+    private suspend fun preloadInterstitialAsync(
+        placement: PlacementConfig,
+        callback: InterstitialCallback
+    ) = interstitialMutex.withLock {
+        // Check if already cached
+        if (interstitialCache.containsKey(placement.placementId)) {
+            BCLogger.d(TAG, "Interstitial already cached: ${placement.placementId}")
+            callback.onAdLoaded()
+            return@withLock
+        }
+
+        // Get GAM network code from config
+        val gamNetworkCode = configManager.getGamNetworkCode()
+        if (gamNetworkCode == null) {
+            BCLogger.e(TAG, "GAM network code not available")
+            callback.onAdFailedToLoad("Config not loaded")
+            return@withLock
+        }
+
+        // Create ad request builder
+        val adRequestBuilder = AdManagerAdRequest.Builder()
+
+        // 3. Fetch S2S demand
+        val targeting = bidRequestClient.fetchDemand(placement)
+        if (targeting != null && targeting.isNotEmpty()) {
+            for ((key, value) in targeting) {
+                adRequestBuilder.addCustomTargeting(key, value)
+            }
+            BCLogger.d(TAG, "S2S demand fetched for: ${placement.placementId} (${targeting.size} keys)")
+        } else {
+            BCLogger.w(TAG, "S2S demand fetch returned no targeting, continuing with Google only")
+        }
+
+        // Get test ads flag from config
+        val useTestAds = configManager.shouldUseTestAds()
+
+        // 4. Load Google interstitial ad
+        val adRequest = adRequestBuilder.build()
+        val result = googleAdsAdapter.loadInterstitialAd(placement, gamNetworkCode, adRequest, useTestAds)
+
+        when {
+            result.isSuccess -> {
+                val interstitialAd = result.getOrNull()
+                if (interstitialAd == null) {
+                    BCLogger.e(TAG, "Interstitial ad was null despite success result")
+                    callback.onAdFailedToLoad("Internal error: ad was null")
+                    return@withLock
+                }
+                interstitialCache[placement.placementId] = interstitialAd
+                BCLogger.d(TAG, "Interstitial ad preloaded: ${placement.placementId}")
+                callback.onAdLoaded()
+            }
+            else -> {
+                val error = result.exceptionOrNull()?.message ?: "Unknown error"
+                BCLogger.w(TAG, "Interstitial ad failed to load: ${placement.placementId} - $error")
+                callback.onAdFailedToLoad(error)
+            }
+        }
+    }
+
+    /**
+     * Show an interstitial ad
+     *
+     * @param activity The activity to show the interstitial from
+     * @param placementId The placement ID from the BigCrunch dashboard
+     * @param callback Callback for ad events
+     * @return true if an ad was available and shown, false otherwise
+     */
+    fun showInterstitialAd(
+        activity: Activity,
+        placementId: String,
+        callback: InterstitialCallback
+    ): Boolean {
+        BCLogger.d(TAG, "Showing interstitial ad: $placementId")
+
+        // Get placement config
+        val placement = configManager.getPlacement(placementId)
+        if (placement == null) {
+            BCLogger.e(TAG, "Placement not found: $placementId")
+            callback.onAdFailedToLoad("Placement not found: $placementId")
+            return false
+        }
+
+        // Get cached interstitial
+        val interstitialAd = interstitialCache.remove(placementId)
+        if (interstitialAd == null) {
+            BCLogger.w(TAG, "No preloaded interstitial for: $placementId")
+            callback.onAdFailedToLoad("No preloaded ad available")
+            return false
+        }
+
+        // Create adapter callback
+        val adapterCallback = object : InterstitialAdCallback {
+            override fun onAdLoaded() {
+                // Already loaded, this won't be called during show
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                callback.onAdFailedToLoad(error)
+            }
+
+            override fun onAdShowed() {
+                callback.onAdShowed()
+            }
+
+            override fun onAdDismissed() {
+                callback.onAdDismissed()
+            }
+
+            override fun onAdClicked() {
+                callback.onAdClicked()
+            }
+
+            override fun onAdImpression() {
+                // Handled by GoogleAdsAdapter analytics tracking
+            }
+        }
+
+        // Show the ad
+        googleAdsAdapter.showInterstitialAd(
+            interstitialAd,
+            activity,
+            placement,
+            adapterCallback
+        )
+
+        return true
+    }
+
+    /**
+     * Check if an interstitial ad is ready to show
+     *
+     * @param placementId The placement ID to check
+     * @return true if an ad is preloaded and ready
+     */
+    fun isInterstitialReady(placementId: String): Boolean {
+        return interstitialCache.containsKey(placementId)
+    }
+
+    /**
+     * Preload a rewarded ad
+     *
+     * @param placementId The placement ID from the BigCrunch dashboard
+     * @param callback Callback for ad events
+     */
+    fun preloadRewardedAd(
+        placementId: String,
+        callback: RewardedCallback
+    ) {
+        BCLogger.d(TAG, "Preloading rewarded ad: $placementId")
+
+        // 1. Get placement config
+        val placement = configManager.getPlacement(placementId)
+        if (placement == null) {
+            BCLogger.e(TAG, "Placement not found: $placementId")
+            callback.onAdFailedToLoad("Placement not found: $placementId")
+            return
+        }
+
+        if (placement.format != "rewarded") {
+            BCLogger.e(TAG, "Invalid format for rewarded: ${placement.format}")
+            callback.onAdFailedToLoad("Invalid placement format: ${placement.format}")
+            return
+        }
+
+        // 2. Track ad request
+        analyticsClient.trackAdRequest(placementId, placement.format)
+
+        // 3. Start the async ad loading flow
+        scope.launch {
+            preloadRewardedAsync(placement, callback)
+        }
+    }
+
+    private suspend fun preloadRewardedAsync(
+        placement: PlacementConfig,
+        callback: RewardedCallback
+    ) = rewardedMutex.withLock {
+        // Check if already cached
+        if (rewardedCache.containsKey(placement.placementId)) {
+            BCLogger.d(TAG, "Rewarded ad already cached: ${placement.placementId}")
+            callback.onAdLoaded()
+            return@withLock
+        }
+
+        // Get GAM network code from config
+        val gamNetworkCode = configManager.getGamNetworkCode()
+        if (gamNetworkCode == null) {
+            BCLogger.e(TAG, "GAM network code not available")
+            callback.onAdFailedToLoad("Config not loaded")
+            return@withLock
+        }
+
+        // Create ad request builder
+        val adRequestBuilder = AdManagerAdRequest.Builder()
+
+        // 3. Fetch S2S demand
+        val targeting = bidRequestClient.fetchDemand(placement)
+        if (targeting != null && targeting.isNotEmpty()) {
+            for ((key, value) in targeting) {
+                adRequestBuilder.addCustomTargeting(key, value)
+            }
+            BCLogger.d(TAG, "S2S demand fetched for: ${placement.placementId} (${targeting.size} keys)")
+        } else {
+            BCLogger.w(TAG, "S2S demand fetch returned no targeting, continuing with Google only")
+        }
+
+        // Get test ads flag from config
+        val useTestAds = configManager.shouldUseTestAds()
+
+        // 4. Load Google rewarded ad
+        val adRequest = adRequestBuilder.build()
+        val result = googleAdsAdapter.loadRewardedAd(placement, gamNetworkCode, adRequest, useTestAds)
+
+        when {
+            result.isSuccess -> {
+                val rewardedAd = result.getOrNull()
+                if (rewardedAd == null) {
+                    BCLogger.e(TAG, "Rewarded ad was null despite success result")
+                    callback.onAdFailedToLoad("Internal error: ad was null")
+                    return@withLock
+                }
+                rewardedCache[placement.placementId] = rewardedAd
+                BCLogger.d(TAG, "Rewarded ad preloaded: ${placement.placementId}")
+                callback.onAdLoaded()
+            }
+            else -> {
+                val error = result.exceptionOrNull()?.message ?: "Unknown error"
+                BCLogger.w(TAG, "Rewarded ad failed to load: ${placement.placementId} - $error")
+                callback.onAdFailedToLoad(error)
+            }
+        }
+    }
+
+    /**
+     * Show a rewarded ad
+     *
+     * @param activity The activity to show the rewarded ad from
+     * @param placementId The placement ID from the BigCrunch dashboard
+     * @param callback Callback for ad events
+     * @return true if an ad was available and shown, false otherwise
+     */
+    fun showRewardedAd(
+        activity: Activity,
+        placementId: String,
+        callback: RewardedCallback
+    ): Boolean {
+        BCLogger.d(TAG, "Showing rewarded ad: $placementId")
+
+        // Get placement config
+        val placement = configManager.getPlacement(placementId)
+        if (placement == null) {
+            BCLogger.e(TAG, "Placement not found: $placementId")
+            callback.onAdFailedToLoad("Placement not found: $placementId")
+            return false
+        }
+
+        // Get cached rewarded ad
+        val rewardedAd = rewardedCache.remove(placementId)
+        if (rewardedAd == null) {
+            BCLogger.w(TAG, "No preloaded rewarded ad for: $placementId")
+            callback.onAdFailedToLoad("No preloaded ad available")
+            return false
+        }
+
+        // Create adapter callback
+        val adapterCallback = object : RewardedAdCallback {
+            override fun onAdLoaded() {
+                // Already loaded, this won't be called during show
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                callback.onAdFailedToLoad(error)
+            }
+
+            override fun onAdShowed() {
+                callback.onAdShowed()
+            }
+
+            override fun onAdDismissed() {
+                callback.onAdDismissed()
+            }
+
+            override fun onAdClicked() {
+                callback.onAdClicked()
+            }
+
+            override fun onUserEarnedReward(type: String, amount: Int) {
+                callback.onUserEarnedReward(type, amount)
+            }
+
+            override fun onAdImpression() {
+                // Handled by GoogleAdsAdapter analytics tracking
+            }
+        }
+
+        // Show the ad
+        googleAdsAdapter.showRewardedAd(
+            rewardedAd,
+            activity,
+            placement,
+            adapterCallback
+        )
+
+        return true
+    }
+
+    /**
+     * Check if a rewarded ad is ready to show
+     *
+     * @param placementId The placement ID to check
+     * @return true if an ad is preloaded and ready
+     */
+    fun isRewardedReady(placementId: String): Boolean {
+        return rewardedCache.containsKey(placementId)
+    }
+
+    /**
+     * Destroy a specific interstitial ad
+     *
+     * @param placementId The placement ID to destroy
+     */
+    fun destroyInterstitialAd(placementId: String) {
+        BCLogger.d(TAG, "Destroying interstitial: $placementId")
+        interstitialCache.remove(placementId)
+    }
+
+    /**
+     * Destroy a specific rewarded ad
+     *
+     * @param placementId The placement ID to destroy
+     */
+    fun destroyRewardedAd(placementId: String) {
+        BCLogger.d(TAG, "Destroying rewarded ad: $placementId")
+        rewardedCache.remove(placementId)
+    }
+
+    /**
+     * Clear all cached ads
+     */
+    fun clearCache() {
+        BCLogger.d(TAG, "Clearing ad cache")
+        interstitialCache.clear()
+        rewardedCache.clear()
+
+        // Destroy all active banners
+        activeBanners.values.forEach { adView ->
+            googleAdsAdapter.destroyBannerAd(adView)
+        }
+        activeBanners.clear()
+    }
+}