@bigcrunch/react-native-ads 0.3.1 → 0.5.0

package/android/bigcrunch-ads/com/bigcrunch/ads/adapters/GoogleAdsAdapter.kt

@@ -0,0 +1,592 @@
+package com.bigcrunch.ads.adapters
+
+import android.app.Activity
+import android.content.Context
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.bigcrunch.ads.core.AnalyticsClient
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.models.PlacementConfig
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.AdListener
+import com.google.android.gms.ads.AdSize
+import com.google.android.gms.ads.FullScreenContentCallback
+import com.google.android.gms.ads.LoadAdError
+import com.google.android.gms.ads.OnPaidEventListener
+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.admanager.AdManagerInterstitialAdLoadCallback
+import com.google.android.gms.ads.rewarded.RewardedAd
+import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback
+import com.google.android.gms.ads.rewarded.RewardItem
+import com.google.android.gms.ads.OnUserEarnedRewardListener
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+/**
+ * Callback interface for banner ad events
+ */
+interface BannerAdCallback {
+    fun onAdLoaded()
+    fun onAdFailedToLoad(error: String)
+    fun onAdClicked()
+    fun onAdImpression()
+}
+
+/**
+ * Callback interface for interstitial ad events
+ */
+interface InterstitialAdCallback {
+    fun onAdLoaded()
+    fun onAdFailedToLoad(error: String)
+    fun onAdShowed()
+    fun onAdDismissed()
+    fun onAdClicked()
+    fun onAdImpression()
+}
+
+/**
+ * Callback interface for rewarded ad events
+ */
+interface RewardedAdCallback {
+    fun onAdLoaded()
+    fun onAdFailedToLoad(error: String)
+    fun onAdShowed()
+    fun onAdDismissed()
+    fun onAdClicked()
+    fun onAdImpression()
+    fun onUserEarnedReward(type: String, amount: Int)
+}
+
+/**
+ * Adapter for Google Mobile Ads SDK (Ad Manager)
+ *
+ * Wraps GMA SDK calls and translates callbacks to AnalyticsClient events.
+ * Handles banner, interstitial, and rewarded ad formats.
+ */
+internal class GoogleAdsAdapter(
+    private val context: Context,
+    private val analyticsClient: AnalyticsClient
+) {
+    companion object {
+        private const val TAG = "GoogleAdsAdapter"
+
+        /**
+         * Safely execute a callback, catching any exceptions thrown by user code.
+         * This ensures SDK stability even if app's callback implementation throws.
+         */
+        private inline fun safeCallback(block: () -> Unit) {
+            try {
+                block()
+            } catch (e: Exception) {
+                BCLogger.e(TAG, "Callback threw exception - SDK will not propagate this to prevent app crash", e)
+            }
+        }
+
+        // Google's official test ad unit IDs
+        // These are guaranteed to return test ads and will always fill
+        private const val TEST_BANNER_AD_UNIT = "ca-app-pub-3940256099942544/6300978111"
+        private const val TEST_INTERSTITIAL_AD_UNIT = "ca-app-pub-3940256099942544/1033173712"
+        private const val TEST_REWARDED_AD_UNIT = "ca-app-pub-3940256099942544/5224354917"
+    }
+
+    /**
+     * Resolve the ad unit ID to use - test ID if useTestAds is true, otherwise production
+     */
+    private fun resolveAdUnitId(
+        placementConfig: PlacementConfig,
+        gamNetworkCode: String,
+        useTestAds: Boolean
+    ): String {
+        if (useTestAds) {
+            val testAdUnit = when (placementConfig.format) {
+                "banner" -> TEST_BANNER_AD_UNIT
+                "interstitial" -> TEST_INTERSTITIAL_AD_UNIT
+                "rewarded" -> TEST_REWARDED_AD_UNIT
+                else -> TEST_BANNER_AD_UNIT // fallback
+            }
+            BCLogger.d(TAG, "Using TEST ad unit for ${placementConfig.format}: $testAdUnit")
+            return testAdUnit
+        } else {
+            // Production ad unit path
+            return "/$gamNetworkCode/${placementConfig.gamAdUnit}"
+        }
+    }
+
+    /**
+     * Resolve a BigCrunch AdSize to a Google AdSize.
+     * For adaptive sizes, calculates the optimal ad size based on screen width.
+     */
+    private fun resolveGoogleAdSize(
+        bcAdSize: com.bigcrunch.ads.models.AdSize
+    ): AdSize {
+        if (bcAdSize.isAdaptive) {
+            val widthDp = if (bcAdSize.width > 0) {
+                bcAdSize.width
+            } else {
+                val displayMetrics = context.resources.displayMetrics
+                (displayMetrics.widthPixels / displayMetrics.density).toInt()
+            }
+            BCLogger.d(TAG, "Resolving adaptive banner with width: ${widthDp}dp")
+            return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(context, widthDp)
+        }
+        return AdSize(bcAdSize.width, bcAdSize.height)
+    }
+
+    /**
+     * Create and load a banner ad
+     *
+     * @param placementConfig Configuration for the placement
+     * @param gamNetworkCode The GAM network code from app config
+     * @param adRequest Pre-configured ad request (with S2S targeting)
+     * @param container ViewGroup to add the banner to
+     * @param callback Callback for ad events
+     * @param useTestAds Whether to use test ad units
+     * @param adSizeOverride Optional size override (takes precedence over backend config)
+     * @return The loaded AdManagerAdView
+     */
+    fun loadBannerAd(
+        placementConfig: PlacementConfig,
+        gamNetworkCode: String,
+        adRequest: AdManagerAdRequest,
+        container: ViewGroup,
+        callback: BannerAdCallback,
+        useTestAds: Boolean = false,
+        adSizeOverride: com.bigcrunch.ads.models.AdSize? = null,
+        refreshCount: Int = 0
+    ): AdManagerAdView {
+        BCLogger.d(TAG, "Loading banner ad for: ${placementConfig.placementId} with adSizeOverride: $adSizeOverride")
+
+        // Resolve ad unit ID (test or production)
+        val adUnitId = resolveAdUnitId(placementConfig, gamNetworkCode, useTestAds)
+
+        val adView = AdManagerAdView(context)
+        adView.adUnitId = adUnitId
+
+        // Set ad size: use override first, then placement config, then default
+        if (adSizeOverride != null) {
+            BCLogger.d(TAG, "Using size override: $adSizeOverride (adaptive=${adSizeOverride.isAdaptive})")
+            adView.setAdSize(resolveGoogleAdSize(adSizeOverride))
+        } else {
+            val size = placementConfig.sizes?.firstOrNull()
+            if (size != null) {
+                adView.setAdSize(resolveGoogleAdSize(size))
+            } else {
+                // Default to banner size
+                adView.setAdSize(AdSize.BANNER)
+            }
+        }
+
+        // Set up ad listener for callbacks
+        adView.adListener = object : AdListener() {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Banner ad loaded: ${placementConfig.placementId}")
+
+                // Manually measure and layout the ad view for React Native compatibility
+                // React Native suppresses normal Android layout passes, so we need to do this explicitly
+                val adSize = adView.adSize
+                if (adSize != null) {
+                    val width = adSize.getWidthInPixels(context)
+                    val height = adSize.getHeightInPixels(context)
+                    val left = adView.left
+                    val top = adView.top
+
+                    BCLogger.d(TAG, """
+                        === MANUAL LAYOUT IN onAdLoaded ===
+                        Ad size: ${adSize.width}x${adSize.height} dp
+                        Pixels: ${width}x${height}
+                        Position: left=$left, top=$top
+                        ====================================
+                    """.trimIndent())
+
+                    adView.measure(
+                        View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+                        View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
+                    )
+                    adView.layout(left, top, left + width, top + height)
+                }
+
+                // Log ad view dimensions after manual layout
+                BCLogger.d(TAG, """
+                    === AD VIEW AFTER LOAD (post-layout) ===
+                    Ad View dimensions: ${adView.width}x${adView.height}
+                    Ad View measured: ${adView.measuredWidth}x${adView.measuredHeight}
+                    Ad View visibility: ${adView.visibility}
+                    Ad View parent: ${adView.parent}
+                    Container dimensions: ${container.width}x${container.height}
+                    =========================================
+                """.trimIndent())
+
+                // Force container to re-layout its children (triggers measureAndLayout runnable)
+                container.requestLayout()
+                container.invalidate()
+
+                // Extract GAM metadata from ResponseInfo
+                val responseInfo = adView.responseInfo
+                val advertiserId = responseInfo?.loadedAdapterResponseInfo?.adSourceId
+                val adMetadata = extractAdMetadata(responseInfo)
+
+                analyticsClient.trackAdImpression(
+                    placementId = placementConfig.placementId,
+                    format = placementConfig.format,
+                    advertiserId = adMetadata["advertiser_id"] as? String,
+                    campaignId = adMetadata["campaign_id"] as? String,
+                    lineItemId = adMetadata["line_item_id"] as? String,
+                    creativeId = adMetadata["creative_id"] as? String,
+                    refreshCount = refreshCount
+                )
+                safeCallback { callback.onAdLoaded() }
+            }
+
+            override fun onAdFailedToLoad(error: LoadAdError) {
+                BCLogger.w(TAG, "Banner ad failed to load: ${error.message}")
+                safeCallback { callback.onAdFailedToLoad(error.message) }
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Banner ad clicked: ${placementConfig.placementId}")
+                analyticsClient.trackAdClick(placementConfig.placementId, placementConfig.format)
+                safeCallback { callback.onAdClicked() }
+            }
+
+            override fun onAdImpression() {
+                BCLogger.d(TAG, "Banner ad impression: ${placementConfig.placementId}")
+                safeCallback { callback.onAdImpression() }
+            }
+        }
+
+        // Set up paid event listener for ILRD (Impression-Level Revenue Data)
+        adView.onPaidEventListener = OnPaidEventListener { adValue ->
+            BCLogger.d(TAG, "Banner paid event: ${adValue.valueMicros} ${adValue.currencyCode}")
+            // TODO: Track revenue separately when revenue tracking is implemented
+            // Revenue is included in the impression event via adPrice field
+        }
+
+        // Add to container with proper layout parameters
+        // Use actual pixel dimensions from the ad size
+        val adSize = adView.adSize
+        val widthPixels = if (adSize != null) {
+            adSize.getWidthInPixels(context)
+        } else {
+            // Default banner width in pixels (320dp)
+            (320 * context.resources.displayMetrics.density).toInt()
+        }
+        val heightPixels = if (adSize != null) {
+            adSize.getHeightInPixels(context)
+        } else {
+            // Default banner height in pixels (50dp)
+            (50 * context.resources.displayMetrics.density).toInt()
+        }
+
+        val layoutParams = FrameLayout.LayoutParams(widthPixels, heightPixels).apply {
+            gravity = Gravity.CENTER
+        }
+
+        // Ensure the AdView is visible
+        adView.visibility = View.VISIBLE
+
+        BCLogger.d(TAG, """
+            === BEFORE ADDING AD VIEW ===
+            Container: $container
+            Container children: ${container.childCount}
+            Ad View: $adView
+            Ad size: ${adSize?.width}x${adSize?.height}
+            Layout params: ${widthPixels}x${heightPixels}
+            ============================
+        """.trimIndent())
+
+        container.addView(adView, layoutParams)
+
+        // Trigger requestLayout on container to ensure child views get measured/laid out
+        // This is critical for React Native where layout passes are suppressed
+        container.requestLayout()
+
+        BCLogger.d(TAG, """
+            === AFTER ADDING AD VIEW ===
+            Container children: ${container.childCount}
+            Ad View parent: ${adView.parent}
+            Ad View visibility: ${adView.visibility}
+            Ad View dimensions: ${adView.width}x${adView.height}
+            ===========================
+        """.trimIndent())
+
+        adView.loadAd(adRequest)
+
+        return adView
+    }
+
+    /**
+     * Load an interstitial ad
+     *
+     * @param placementConfig Configuration for the placement
+     * @param gamNetworkCode The GAM network code from app config
+     * @param adRequest Pre-configured ad request (with S2S targeting)
+     * @return Result containing loaded interstitial or error
+     */
+    suspend fun loadInterstitialAd(
+        placementConfig: PlacementConfig,
+        gamNetworkCode: String,
+        adRequest: AdManagerAdRequest,
+        useTestAds: Boolean = false
+    ): Result<AdManagerInterstitialAd> = suspendCoroutine { continuation ->
+        BCLogger.d(TAG, "Loading interstitial ad for: ${placementConfig.placementId}")
+
+        // Resolve ad unit ID (test or production)
+        val adUnitId = resolveAdUnitId(placementConfig, gamNetworkCode, useTestAds)
+
+        AdManagerInterstitialAd.load(
+            context,
+            adUnitId,
+            adRequest,
+            object : AdManagerInterstitialAdLoadCallback() {
+                override fun onAdLoaded(interstitialAd: AdManagerInterstitialAd) {
+                    BCLogger.d(TAG, "Interstitial ad loaded: ${placementConfig.placementId}")
+
+                    // Set up paid event listener for ILRD
+                    interstitialAd.onPaidEventListener = OnPaidEventListener { adValue ->
+                        BCLogger.d(TAG, "Interstitial paid event: ${adValue.valueMicros} ${adValue.currencyCode}")
+                        // TODO: Track revenue separately when revenue tracking is implemented
+                        // Revenue is included in the impression event via adPrice field
+                    }
+
+                    continuation.resume(Result.success(interstitialAd))
+                }
+
+                override fun onAdFailedToLoad(error: LoadAdError) {
+                    BCLogger.w(TAG, "Interstitial ad failed to load: ${error.message}")
+                    continuation.resume(Result.failure(Exception(error.message)))
+                }
+            }
+        )
+    }
+
+    /**
+     * Show an interstitial ad
+     *
+     * @param interstitialAd The loaded interstitial ad
+     * @param activity Activity to show the ad from
+     * @param placementConfig Configuration for the placement
+     * @param callback Callback for ad events
+     */
+    fun showInterstitialAd(
+        interstitialAd: AdManagerInterstitialAd,
+        activity: Activity,
+        placementConfig: PlacementConfig,
+        callback: InterstitialAdCallback
+    ) {
+        BCLogger.d(TAG, "Showing interstitial ad: ${placementConfig.placementId}")
+
+        interstitialAd.fullScreenContentCallback = object : FullScreenContentCallback() {
+            override fun onAdShowedFullScreenContent() {
+                BCLogger.d(TAG, "Interstitial ad shown: ${placementConfig.placementId}")
+
+                // Extract GAM metadata from ResponseInfo
+                val responseInfo = interstitialAd.responseInfo
+                val adMetadata = extractAdMetadata(responseInfo)
+
+                analyticsClient.trackAdImpression(
+                    placementId = placementConfig.placementId,
+                    format = placementConfig.format,
+                    advertiserId = adMetadata["advertiser_id"] as? String,
+                    campaignId = adMetadata["campaign_id"] as? String,
+                    lineItemId = adMetadata["line_item_id"] as? String,
+                    creativeId = adMetadata["creative_id"] as? String
+                )
+                safeCallback { callback.onAdShowed() }
+            }
+
+            override fun onAdDismissedFullScreenContent() {
+                BCLogger.d(TAG, "Interstitial ad dismissed: ${placementConfig.placementId}")
+                safeCallback { callback.onAdDismissed() }
+            }
+
+            override fun onAdFailedToShowFullScreenContent(error: AdError) {
+                BCLogger.w(TAG, "Interstitial ad failed to show: ${error.message}")
+                safeCallback { callback.onAdFailedToLoad(error.message) }
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Interstitial ad clicked: ${placementConfig.placementId}")
+                analyticsClient.trackAdClick(placementConfig.placementId, placementConfig.format)
+                safeCallback { callback.onAdClicked() }
+            }
+
+            override fun onAdImpression() {
+                BCLogger.d(TAG, "Interstitial ad impression: ${placementConfig.placementId}")
+                safeCallback { callback.onAdImpression() }
+            }
+        }
+
+        interstitialAd.show(activity)
+    }
+
+    /**
+     * Load a rewarded ad
+     *
+     * @param placementConfig Configuration for the placement
+     * @param gamNetworkCode The GAM network code from app config
+     * @param adRequest Pre-configured ad request (with S2S targeting)
+     * @return Result containing the loaded RewardedAd or an error
+     */
+    suspend fun loadRewardedAd(
+        placementConfig: PlacementConfig,
+        gamNetworkCode: String,
+        adRequest: AdManagerAdRequest,
+        useTestAds: Boolean = false
+    ): Result<RewardedAd> = suspendCoroutine { continuation ->
+        BCLogger.d(TAG, "Loading rewarded ad for: ${placementConfig.placementId}")
+
+        // Resolve ad unit ID (test or production)
+        val adUnitId = resolveAdUnitId(placementConfig, gamNetworkCode, useTestAds)
+
+        RewardedAd.load(
+            context,
+            adUnitId,
+            adRequest,
+            object : RewardedAdLoadCallback() {
+                override fun onAdLoaded(ad: RewardedAd) {
+                    BCLogger.d(TAG, "Rewarded ad loaded: ${placementConfig.placementId}")
+
+                    // Set up paid event listener for ILRD
+                    ad.onPaidEventListener = OnPaidEventListener { adValue ->
+                        val valueMicros = adValue.valueMicros
+                        val currencyCode = adValue.currencyCode
+                        BCLogger.d(TAG, "Rewarded ad paid event: $valueMicros $currencyCode")
+                        // TODO: Track revenue separately when revenue tracking is implemented
+                        // Revenue is included in the impression event via adPrice field
+                    }
+
+                    continuation.resume(Result.success(ad))
+                }
+
+                override fun onAdFailedToLoad(error: LoadAdError) {
+                    BCLogger.w(TAG, "Rewarded ad failed to load: ${error.message}")
+                    continuation.resume(Result.failure(Exception(error.message)))
+                }
+            }
+        )
+    }
+
+    /**
+     * Show a rewarded ad
+     *
+     * @param rewardedAd The loaded rewarded ad to show
+     * @param activity The activity to show from
+     * @param placementConfig Configuration for the placement
+     * @param callback Callback for ad events
+     */
+    fun showRewardedAd(
+        rewardedAd: RewardedAd,
+        activity: Activity,
+        placementConfig: PlacementConfig,
+        callback: RewardedAdCallback
+    ) {
+        BCLogger.d(TAG, "Showing rewarded ad for: ${placementConfig.placementId}")
+
+        rewardedAd.fullScreenContentCallback = object : FullScreenContentCallback() {
+            override fun onAdShowedFullScreenContent() {
+                BCLogger.d(TAG, "Rewarded ad shown: ${placementConfig.placementId}")
+
+                // Extract GAM metadata from ResponseInfo
+                val responseInfo = rewardedAd.responseInfo
+                val adMetadata = extractAdMetadata(responseInfo)
+
+                analyticsClient.trackAdImpression(
+                    placementId = placementConfig.placementId,
+                    format = placementConfig.format,
+                    advertiserId = adMetadata["advertiser_id"] as? String,
+                    campaignId = adMetadata["campaign_id"] as? String,
+                    lineItemId = adMetadata["line_item_id"] as? String,
+                    creativeId = adMetadata["creative_id"] as? String
+                )
+                safeCallback { callback.onAdShowed() }
+            }
+
+            override fun onAdDismissedFullScreenContent() {
+                BCLogger.d(TAG, "Rewarded ad dismissed: ${placementConfig.placementId}")
+                safeCallback { callback.onAdDismissed() }
+            }
+
+            override fun onAdFailedToShowFullScreenContent(error: AdError) {
+                BCLogger.w(TAG, "Rewarded ad failed to show: ${error.message}")
+                safeCallback { callback.onAdFailedToLoad(error.message) }
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Rewarded ad clicked: ${placementConfig.placementId}")
+                analyticsClient.trackAdClick(placementConfig.placementId, placementConfig.format)
+                safeCallback { callback.onAdClicked() }
+            }
+
+            override fun onAdImpression() {
+                BCLogger.d(TAG, "Rewarded ad impression: ${placementConfig.placementId}")
+                safeCallback { callback.onAdImpression() }
+            }
+        }
+
+        // Show the ad with reward handler
+        rewardedAd.show(activity) { rewardItem: RewardItem ->
+            val rewardAmount = rewardItem.amount
+            val rewardType = rewardItem.type
+            BCLogger.d(TAG, "User earned reward: $rewardType x$rewardAmount")
+            safeCallback { callback.onUserEarnedReward(rewardType, rewardAmount) }
+        }
+    }
+
+    /**
+     * Destroy a banner ad view
+     *
+     * @param adView The AdManagerAdView to destroy
+     */
+    fun destroyBannerAd(adView: AdManagerAdView) {
+        BCLogger.d(TAG, "Destroying banner ad")
+        adView.destroy()
+    }
+
+    /**
+     * Extract GAM metadata from ResponseInfo
+     *
+     * Google Ad Manager provides limited metadata in ResponseInfo. The main fields available are:
+     * - adSourceId: Can contain advertiser ID or network ID
+     * - responseId: Unique response identifier (can be used as creative ID proxy)
+     *
+     * Note: GAM doesn't directly expose campaignId or lineItemId in mobile SDK ResponseInfo.
+     * These fields may be available in server-side logs but not in the client SDK.
+     *
+     * @param responseInfo The ResponseInfo from the ad response
+     * @return Map of available metadata fields
+     */
+    private fun extractAdMetadata(responseInfo: com.google.android.gms.ads.ResponseInfo?): Map<String, Any?> {
+        if (responseInfo == null) {
+            return emptyMap()
+        }
+
+        val metadata = mutableMapOf<String, Any?>()
+
+        // Extract adSourceId (often contains advertiser/network ID)
+        val loadedAdapter = responseInfo.loadedAdapterResponseInfo
+        if (loadedAdapter != null) {
+            metadata["advertiser_id"] = loadedAdapter.adSourceId
+            metadata["creative_id"] = loadedAdapter.adSourceInstanceId
+        }
+
+        // Response ID can serve as a creative identifier
+        val responseId = responseInfo.responseId
+        if (responseId != null && !responseId.isEmpty()) {
+            // Use responseId as creative_id if we don't have a better one
+            if (!metadata.containsKey("creative_id")) {
+                metadata["creative_id"] = responseId
+            }
+        }
+
+        // Log extracted metadata for debugging
+        if (metadata.isNotEmpty()) {
+            BCLogger.d(TAG, "Extracted GAM metadata: $metadata")
+        }
+
+        return metadata
+    }
+}