@bigcrunch/react-native-ads 0.4.0 → 0.6.0

package/android/bigcrunch-ads/com/bigcrunch/ads/BigCrunchBannerView.kt

@@ -0,0 +1,484 @@
+package com.bigcrunch.ads
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.AttributeSet
+import android.view.View
+import android.widget.FrameLayout
+import com.bigcrunch.ads.adapters.GoogleAdsAdapter
+import com.bigcrunch.ads.core.AdOrchestrator
+import com.bigcrunch.ads.core.BidRequestClient
+import com.bigcrunch.ads.core.BannerCallback
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.listeners.BannerAdListener
+import com.bigcrunch.ads.models.AdSize
+import com.bigcrunch.ads.models.RefreshConfig
+
+/**
+ * BigCrunch Banner View - UI component for displaying banner ads
+ *
+ * Usage:
+ * ```kotlin
+ * val bannerView = BigCrunchBannerView(context)
+ * bannerView.configure("banner_placement_id")
+ * bannerView.listener = object : BigCrunchBannerView.Listener {
+ *     override fun onAdLoaded() { /* ad loaded */ }
+ *     override fun onAdFailedToLoad(error: String) { /* handle error */ }
+ *     override fun onAdClicked() { /* ad clicked */ }
+ *     override fun onAdImpression() { /* impression recorded */ }
+ * }
+ * bannerView.loadAd()
+ *
+ * // When done:
+ * bannerView.destroy()
+ * ```
+ *
+ * Add to layout XML:
+ * ```xml
+ * <com.bigcrunch.ads.BigCrunchBannerView
+ *     android:id="@+id/banner_ad"
+ *     android:layout_width="match_parent"
+ *     android:layout_height="wrap_content" />
+ * ```
+ */
+class BigCrunchBannerView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : FrameLayout(context, attrs, defStyleAttr) {
+
+    companion object {
+        private const val TAG = "BigCrunchBannerView"
+        private const val MIN_REFRESH_INTERVAL_MS = 10000L // 10 seconds minimum
+
+        /**
+         * Safely execute a block, catching exceptions to prevent SDK crashes from affecting the host app.
+         */
+        private inline fun safeExecute(block: () -> Unit) {
+            try {
+                block()
+            } catch (e: Exception) {
+                BCLogger.e(TAG, "Exception caught in banner view - SDK will not propagate to prevent app crash", e)
+            }
+        }
+    }
+
+    /**
+     * Optional listener for ad events
+     */
+    var listener: BannerAdListener? = null
+        set(value) {
+            field = value
+            bannerAdListener = value
+        }
+
+    // Keep reference to support both old and new listener interfaces
+    private var bannerAdListener: BannerAdListener? = null
+
+    private var placementId: String? = null
+    private var adSize: AdSize? = null
+    private var customTargeting: Map<String, String>? = null
+    private var isConfigured = false
+    private var isDestroyed = false
+    private var isPaused = false
+    private var adOrchestrator: AdOrchestrator? = null
+
+    // Refresh properties
+    private val refreshHandler = Handler(Looper.getMainLooper())
+    private var refreshRunnable: Runnable? = null
+    private var refreshCount: Int = 0
+    private var effectiveRefreshConfig: RefreshConfig? = null
+
+    /**
+     * Runnable that manually measures and lays out child views.
+     * This is needed for React Native compatibility because React Native's UIManagerModule
+     * intercepts requestLayout() calls, preventing dynamically added child views
+     * (like AdManagerAdView) from being properly measured and laid out.
+     * See: https://github.com/facebook/react-native/issues/17968
+     */
+    private val measureAndLayout = Runnable {
+        BCLogger.d(TAG, "=== measureAndLayout START === childCount=$childCount, parent=${width}x${height}, measured=${measuredWidth}x${measuredHeight}")
+
+        for (i in 0 until childCount) {
+            val child = getChildAt(i)
+
+            // For AdManagerAdView, use its own ad size for measurement
+            val childWidth: Int
+            val childHeight: Int
+
+            if (child is com.google.android.gms.ads.admanager.AdManagerAdView) {
+                val adSize = child.adSize
+                BCLogger.d(TAG, "Child $i is AdManagerAdView, adSize=$adSize")
+                if (adSize != null) {
+                    val adWidthPx = adSize.getWidthInPixels(context)
+                    val adHeightPx = adSize.getHeightInPixels(context)
+                    // Constrain width to parent to prevent overflow (important for adaptive banners)
+                    val parentWidth = if (width > 0) width else measuredWidth
+                    childWidth = if (parentWidth > 0) minOf(adWidthPx, parentWidth) else adWidthPx
+                    childHeight = adHeightPx
+                    BCLogger.d(TAG, "Using adSize pixels: ${adWidthPx}x${adHeightPx}, constrained width: $childWidth (parent: $parentWidth)")
+                } else {
+                    // Fallback to parent dimensions
+                    childWidth = if (width > 0) width else measuredWidth
+                    childHeight = if (height > 0) height else measuredHeight
+                    BCLogger.d(TAG, "adSize is null, using parent: ${childWidth}x${childHeight}")
+                }
+            } else {
+                // For other views, use parent dimensions
+                childWidth = if (width > 0) width else measuredWidth
+                childHeight = if (height > 0) height else measuredHeight
+                BCLogger.d(TAG, "Child $i is ${child.javaClass.simpleName}, using parent: ${childWidth}x${childHeight}")
+            }
+
+            // Skip if we don't have valid dimensions
+            if (childWidth <= 0 || childHeight <= 0) {
+                BCLogger.w(TAG, "Skipping child $i - invalid dimensions: ${childWidth}x${childHeight}")
+                continue
+            }
+
+            BCLogger.d(TAG, "BEFORE measure/layout - child dimensions: ${child.width}x${child.height}, measured: ${child.measuredWidth}x${child.measuredHeight}, visibility: ${child.visibility}")
+
+            child.measure(
+                View.MeasureSpec.makeMeasureSpec(childWidth, View.MeasureSpec.EXACTLY),
+                View.MeasureSpec.makeMeasureSpec(childHeight, View.MeasureSpec.EXACTLY)
+            )
+            child.layout(0, 0, child.measuredWidth, child.measuredHeight)
+
+            // Force invalidation to ensure the view is redrawn after layout
+            child.invalidate()
+
+            BCLogger.d(TAG, "AFTER measure/layout - child dimensions: ${child.width}x${child.height}, measured: ${child.measuredWidth}x${child.measuredHeight}, visibility: ${child.visibility}")
+
+            // Log additional view properties for debugging
+            if (child is com.google.android.gms.ads.admanager.AdManagerAdView) {
+                BCLogger.d(TAG, """
+                    === AD VIEW DEBUG ===
+                    isShown: ${child.isShown}
+                    alpha: ${child.alpha}
+                    isAttachedToWindow: ${child.isAttachedToWindow}
+                    hasWindowFocus: ${child.hasWindowFocus()}
+                    parent: ${child.parent}
+                    clipChildren (this): $clipChildren
+                    clipToPadding (this): $clipToPadding
+                    =====================
+                """.trimIndent())
+            }
+        }
+
+        // Invalidate this container as well to ensure redraw
+        invalidate()
+        BCLogger.d(TAG, "=== measureAndLayout END ===")
+    }
+
+    init {
+        // Disable clipping to ensure child views can be fully drawn
+        // This is important for React Native where clipping can cause issues
+        clipChildren = false
+        clipToPadding = false
+        BCLogger.v(TAG, "BigCrunchBannerView created")
+    }
+
+    /**
+     * Override requestLayout to ensure child views are properly measured and laid out.
+     * React Native suppresses normal Android layout passes, so we manually trigger them.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+
+    /**
+     * Configure the banner view with a placement ID
+     *
+     * @param placementId The placement ID from the BigCrunch dashboard
+     */
+    fun configure(placementId: String) {
+        if (isDestroyed) {
+            BCLogger.w(TAG, "Cannot configure destroyed banner view")
+            return
+        }
+
+        if (placementId.isBlank()) {
+            BCLogger.e(TAG, "Invalid placementId: cannot be blank")
+            return
+        }
+
+        this.placementId = placementId
+        this.isConfigured = true
+        BCLogger.d(TAG, "Banner configured with placement: $placementId")
+    }
+
+    /**
+     * Load a banner ad
+     *
+     * Must call [configure] before calling this method.
+     * The listener will be notified of load success or failure.
+     */
+    fun loadAd() = safeExecute {
+        if (isDestroyed) {
+            BCLogger.w(TAG, "Cannot load ad on destroyed banner view")
+            bannerAdListener?.onAdFailedToLoad("DESTROYED", "Banner view has been destroyed")
+            return@safeExecute
+        }
+
+        if (!isConfigured || placementId == null) {
+            BCLogger.e(TAG, "Banner not configured. Call configure() first.")
+            bannerAdListener?.onAdFailedToLoad("NOT_CONFIGURED", "Banner not configured. Call configure() first.")
+            return@safeExecute
+        }
+
+        val pid = placementId ?: return@safeExecute
+        BCLogger.d(TAG, "Loading banner ad: $pid with adSize override: $adSize (refreshCount: $refreshCount)")
+
+        if (!BigCrunchAds.isInitialized()) {
+            BCLogger.e(TAG, "SDK not initialized")
+            bannerAdListener?.onAdFailedToLoad("SDK_NOT_INITIALIZED", "SDK not initialized. Call BigCrunchAds.initialize() first.")
+            return@safeExecute
+        }
+
+        // Resolve effective refresh config on first load
+        if (effectiveRefreshConfig == null) {
+            val configManager = BigCrunchAds.getConfigManager()
+            effectiveRefreshConfig = configManager.getEffectiveRefreshConfig(pid)
+            effectiveRefreshConfig?.let { config ->
+                BCLogger.d(TAG, "Refresh config resolved - enabled: ${config.enabled}, interval: ${config.intervalMs}ms, max: ${config.maxRefreshes}")
+            }
+        }
+
+        // Create AdOrchestrator lazily
+        if (adOrchestrator == null) {
+            adOrchestrator = createAdOrchestrator()
+        }
+
+        // Create callback wrapper
+        val callback = object : BannerCallback {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Banner ad loaded: $pid")
+                bannerAdListener?.onAdLoaded()
+                // Schedule next refresh after successful load
+                scheduleRefresh()
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Banner ad failed to load: $pid - $error")
+                bannerAdListener?.onAdFailedToLoad("LOAD_ERROR", error)
+                // Note: Do NOT schedule refresh on failure to avoid retry loops
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Banner ad clicked: $pid")
+                bannerAdListener?.onAdClicked()
+            }
+
+            override fun onAdImpression() {
+                BCLogger.d(TAG, "Banner ad impression: $pid")
+                bannerAdListener?.onAdImpression()
+            }
+        }
+
+        // Load the ad through the orchestrator, passing the ad size override if set
+        adOrchestrator?.loadBannerAd(pid, this, callback, adSize, refreshCount)
+    }
+
+    /**
+     * Destroy the banner view and release resources
+     *
+     * Call this when the banner is no longer needed (e.g., in Activity.onDestroy())
+     */
+    fun destroy() = safeExecute {
+        if (isDestroyed) {
+            BCLogger.v(TAG, "Banner already destroyed")
+            return@safeExecute
+        }
+
+        BCLogger.d(TAG, "Destroying banner: $placementId")
+
+        // Stop refresh timer
+        cancelRefreshTimer()
+
+        placementId?.let { pid ->
+            adOrchestrator?.destroyBannerAd(pid)
+        }
+
+        removeAllViews()
+        listener = null
+        adOrchestrator = null
+        effectiveRefreshConfig = null
+        refreshCount = 0
+        isDestroyed = true
+    }
+
+    /**
+     * Check if the banner view has been destroyed
+     */
+    fun isDestroyed(): Boolean = isDestroyed
+
+    /**
+     * Get the configured placement ID
+     */
+    fun getPlacementId(): String? = placementId
+
+    /**
+     * Get the current refresh count
+     */
+    fun getRefreshCount(): Int = refreshCount
+
+    /**
+     * Set the placement ID (alternative to configure method)
+     *
+     * @param placementId The placement ID from the BigCrunch dashboard
+     */
+    fun setPlacementId(placementId: String) {
+        configure(placementId)
+    }
+
+    /**
+     * Set the ad size for this banner
+     *
+     * @param adSize The desired ad size
+     */
+    fun setAdSize(adSize: AdSize) {
+        this.adSize = adSize
+        BCLogger.d(TAG, "Ad size set to: $adSize")
+    }
+
+    /**
+     * Get the current ad size
+     *
+     * @return The ad size, or null if not set
+     */
+    fun getAdSize(): AdSize? = adSize
+
+    /**
+     * Set custom targeting parameters for ad requests
+     *
+     * @param targeting Map of key-value pairs for custom targeting
+     */
+    fun setCustomTargeting(targeting: Map<String, String>) {
+        this.customTargeting = targeting
+        BCLogger.d(TAG, "Custom targeting set: ${targeting.size} parameters")
+    }
+
+    /**
+     * Set the refresh interval for auto-refreshing ads
+     *
+     * This overrides the config-driven refresh interval.
+     *
+     * @param intervalMs Refresh interval in milliseconds (0 to disable)
+     */
+    fun setRefreshInterval(intervalMs: Int) {
+        if (intervalMs <= 0) {
+            effectiveRefreshConfig = RefreshConfig(enabled = false, intervalMs = 0, maxRefreshes = 0)
+            cancelRefreshTimer()
+        } else {
+            effectiveRefreshConfig = RefreshConfig(
+                enabled = true,
+                intervalMs = intervalMs,
+                maxRefreshes = effectiveRefreshConfig?.maxRefreshes ?: 99
+            )
+        }
+        BCLogger.d(TAG, "Refresh interval set to: ${intervalMs}ms")
+    }
+
+    /**
+     * Set the banner ad listener
+     *
+     * @param listener The listener for ad events
+     */
+    fun setBannerAdListener(listener: BannerAdListener) {
+        this.listener = listener
+    }
+
+    /**
+     * Pause ad refresh (if auto-refresh is enabled)
+     */
+    fun pause() {
+        isPaused = true
+        cancelRefreshTimer()
+        BCLogger.d(TAG, "Banner ad refresh paused")
+    }
+
+    /**
+     * Resume ad refresh (if auto-refresh is enabled)
+     */
+    fun resume() {
+        isPaused = false
+        BCLogger.d(TAG, "Banner ad refresh resumed")
+        scheduleRefresh()
+    }
+
+    // MARK: - Refresh Logic
+
+    private fun scheduleRefresh() {
+        // Don't schedule if destroyed or paused
+        if (isDestroyed || isPaused) return
+
+        val config = effectiveRefreshConfig ?: return
+        if (!config.enabled) return
+
+        // Check max refreshes limit
+        if (refreshCount >= config.maxRefreshes) {
+            BCLogger.d(TAG, "Max refreshes reached (${config.maxRefreshes}) for $placementId")
+            return
+        }
+
+        // Enforce minimum interval
+        val intervalMs = maxOf(config.intervalMs.toLong(), MIN_REFRESH_INTERVAL_MS)
+
+        // Cancel any existing timer
+        cancelRefreshTimer()
+
+        BCLogger.d(TAG, "Scheduling refresh in ${intervalMs}ms (count: $refreshCount/${config.maxRefreshes}) for $placementId")
+
+        val runnable = Runnable {
+            performRefresh()
+        }
+        refreshRunnable = runnable
+        refreshHandler.postDelayed(runnable, intervalMs)
+    }
+
+    private fun performRefresh() {
+        if (isDestroyed || isPaused) return
+
+        refreshCount++
+        BCLogger.d(TAG, "Refreshing banner ad (refresh #$refreshCount) for $placementId")
+
+        loadAd()
+    }
+
+    private fun cancelRefreshTimer() {
+        refreshRunnable?.let { refreshHandler.removeCallbacks(it) }
+        refreshRunnable = null
+    }
+
+    private fun createAdOrchestrator(): AdOrchestrator {
+        val configManager = BigCrunchAds.getConfigManager()
+        val analyticsClient = BigCrunchAds.getAnalyticsClient()
+        val googleAdsAdapter = GoogleAdsAdapter(context, analyticsClient)
+
+        // BidRequestClient is shared across all views for batching
+        val bidRequestClient = BigCrunchAds.bidRequestClient ?: BidRequestClient(
+            httpClient = com.bigcrunch.ads.internal.HttpClient(),
+            configManager = configManager,
+            privacyStore = BigCrunchAds.privacyStore,
+            s2sConfig = com.bigcrunch.ads.models.S2SConfig(enabled = false, serverUrl = "", timeoutMs = 0)
+        )
+
+        return AdOrchestrator(
+            context,
+            configManager,
+            analyticsClient,
+            bidRequestClient,
+            googleAdsAdapter
+        )
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        // Note: We don't auto-destroy here for React Native compatibility
+        // React Native may temporarily detach views during ScrollView recycling
+        // The view manager will call destroy() when appropriate
+        BCLogger.v(TAG, "Banner detached from window (not auto-destroying)")
+    }
+}