@bigcrunch/react-native-ads 0.3.1 → 0.5.0

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

@@ -0,0 +1,403 @@
+package com.bigcrunch.ads
+
+import android.app.Activity
+import android.content.Context
+import com.bigcrunch.ads.adapters.GoogleAdsAdapter
+import com.bigcrunch.ads.core.AdOrchestrator
+import com.bigcrunch.ads.core.InterstitialCallback
+import com.bigcrunch.ads.internal.BCLogger
+
+/**
+ * BigCrunch Interstitial Ads - Static API for full-screen interstitial ads
+ *
+ * Interstitial ads are full-screen ads that cover the interface of an app until
+ * closed by the user. They're best used at natural transition points in the app.
+ *
+ * Usage:
+ * ```kotlin
+ * // 1. Preload the ad (do this early, e.g., when entering a screen)
+ * BigCrunchInterstitial.preload(
+ *     context = applicationContext,
+ *     placementId = "article_interstitial",
+ *     callback = object : BigCrunchInterstitial.PreloadCallback {
+ *         override fun onAdLoaded() { /* ad ready to show */ }
+ *         override fun onAdFailedToLoad(error: String) { /* handle error */ }
+ *     }
+ * )
+ *
+ * // 2. Check if ready (optional)
+ * if (BigCrunchInterstitial.isReady("article_interstitial")) {
+ *     // Ad is ready to show
+ * }
+ *
+ * // 3. Show when appropriate (e.g., after completing an action)
+ * BigCrunchInterstitial.show(
+ *     activity = this,
+ *     placementId = "article_interstitial",
+ *     callback = object : BigCrunchInterstitial.ShowCallback {
+ *         override fun onAdShowed() { /* ad displayed */ }
+ *         override fun onAdDismissed() { /* ad closed, resume app */ }
+ *         override fun onAdClicked() { /* ad clicked */ }
+ *         override fun onAdFailedToShow(error: String) { /* handle error */ }
+ *     }
+ * )
+ * ```
+ */
+object BigCrunchInterstitial {
+
+    private const val TAG = "BigCrunchInterstitial"
+    private var adOrchestrator: AdOrchestrator? = null
+    private val orchestratorLock = Any()
+
+    /**
+     * Safely execute a block, catching exceptions to prevent SDK crashes from affecting the host app.
+     */
+    private inline fun <T> safeExecute(default: T, block: () -> T): T {
+        return try {
+            block()
+        } catch (e: Exception) {
+            BCLogger.e(TAG, "Exception caught in interstitial - SDK will not propagate to prevent app crash", e)
+            default
+        }
+    }
+
+    /**
+     * Safely execute a Unit-returning block.
+     */
+    private inline fun safeExecute(block: () -> Unit) {
+        try {
+            block()
+        } catch (e: Exception) {
+            BCLogger.e(TAG, "Exception caught in interstitial - SDK will not propagate to prevent app crash", e)
+        }
+    }
+
+    /**
+     * Callback interface for preload events
+     */
+    interface PreloadCallback {
+        /**
+         * Called when the ad has been successfully preloaded and is ready to show
+         */
+        fun onAdLoaded()
+
+        /**
+         * Called when the ad fails to load
+         * @param error Description of the error
+         */
+        fun onAdFailedToLoad(error: String)
+    }
+
+    /**
+     * Callback interface for show events
+     */
+    interface ShowCallback {
+        /**
+         * Called when the ad is displayed on screen
+         */
+        fun onAdShowed()
+
+        /**
+         * Called when the ad is dismissed by the user
+         */
+        fun onAdDismissed()
+
+        /**
+         * Called when the user clicks on the ad
+         */
+        fun onAdClicked()
+
+        /**
+         * Called when the ad fails to show
+         * @param error Description of the error
+         */
+        fun onAdFailedToShow(error: String)
+    }
+
+    /**
+     * Legacy callback interface (for backwards compatibility)
+     */
+    interface Callback {
+        fun onAdShown()
+        fun onAdDismissed()
+        fun onAdFailed(error: String)
+    }
+
+    /**
+     * Preload an interstitial ad for the given placement
+     *
+     * Call this early (e.g., when entering a screen) to give the ad time to load.
+     * When the ad is ready, the callback's onAdLoaded() will be called.
+     *
+     * @param context Application context
+     * @param placementId The placement ID from BigCrunch dashboard
+     * @param callback Optional callback for load events
+     */
+    fun preload(
+        context: Context,
+        placementId: String,
+        callback: PreloadCallback? = null
+    ) = safeExecute {
+        BCLogger.d(TAG, "Preloading interstitial: $placementId")
+
+        if (!BigCrunchAds.isInitialized()) {
+            BCLogger.e(TAG, "SDK not initialized")
+            callback?.onAdFailedToLoad("SDK not initialized. Call BigCrunchAds.initialize() first.")
+            return@safeExecute
+        }
+
+        if (placementId.isBlank()) {
+            BCLogger.e(TAG, "Invalid placementId: cannot be blank")
+            callback?.onAdFailedToLoad("Invalid placementId: cannot be blank")
+            return@safeExecute
+        }
+
+        val orchestrator = getOrCreateOrchestrator(context)
+
+        val internalCallback = object : InterstitialCallback {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Interstitial preloaded: $placementId")
+                callback?.onAdLoaded()
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Interstitial failed to preload: $placementId - $error")
+                callback?.onAdFailedToLoad(error)
+            }
+
+            override fun onAdShowed() {
+                // Not used during preload
+            }
+
+            override fun onAdDismissed() {
+                // Not used during preload
+            }
+
+            override fun onAdClicked() {
+                // Not used during preload
+            }
+        }
+
+        orchestrator.preloadInterstitialAd(placementId, internalCallback)
+    }
+
+    /**
+     * Preload an interstitial ad (simplified version without callback)
+     *
+     * @param placementId The placement ID from BigCrunch dashboard
+     */
+    fun preload(placementId: String) = safeExecute {
+        if (!BigCrunchAds.isInitialized()) {
+            BCLogger.e(TAG, "SDK not initialized")
+            return@safeExecute
+        }
+        // Use application context from BigCrunchAds
+        val orchestrator = getOrCreateOrchestrator(null)
+        orchestrator.preloadInterstitialAd(placementId, object : InterstitialCallback {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Interstitial preloaded: $placementId")
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Interstitial failed to preload: $placementId - $error")
+            }
+
+            override fun onAdShowed() {}
+            override fun onAdDismissed() {}
+            override fun onAdClicked() {}
+        })
+    }
+
+    /**
+     * Show a preloaded interstitial ad
+     *
+     * The ad must be preloaded first using [preload]. Check [isReady] before calling
+     * this to ensure an ad is available.
+     *
+     * @param activity The activity to show the ad from
+     * @param placementId The placement ID
+     * @param callback Optional callback for show events
+     * @return true if an ad was available and will be shown, false otherwise
+     */
+    fun show(
+        activity: Activity,
+        placementId: String,
+        callback: ShowCallback? = null
+    ): Boolean = safeExecute(false) {
+        BCLogger.d(TAG, "Showing interstitial: $placementId")
+
+        if (!BigCrunchAds.isInitialized()) {
+            BCLogger.e(TAG, "SDK not initialized")
+            callback?.onAdFailedToShow("SDK not initialized. Call BigCrunchAds.initialize() first.")
+            return@safeExecute false
+        }
+
+        if (placementId.isBlank()) {
+            BCLogger.e(TAG, "Invalid placementId: cannot be blank")
+            callback?.onAdFailedToShow("Invalid placementId: cannot be blank")
+            return@safeExecute false
+        }
+
+        val orchestrator = getOrCreateOrchestrator(activity)
+
+        val internalCallback = object : InterstitialCallback {
+            override fun onAdLoaded() {
+                // Not used during show
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Interstitial failed to show: $placementId - $error")
+                callback?.onAdFailedToShow(error)
+            }
+
+            override fun onAdShowed() {
+                BCLogger.d(TAG, "Interstitial showed: $placementId")
+                callback?.onAdShowed()
+            }
+
+            override fun onAdDismissed() {
+                BCLogger.d(TAG, "Interstitial dismissed: $placementId")
+                callback?.onAdDismissed()
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Interstitial clicked: $placementId")
+                callback?.onAdClicked()
+            }
+        }
+
+        orchestrator.showInterstitialAd(activity, placementId, internalCallback)
+    }
+
+    /**
+     * Show a preloaded interstitial ad (legacy API)
+     *
+     * @param activity The activity to show the ad in
+     * @param placementId The placement ID
+     * @param callback Legacy callback for ad events
+     */
+    fun show(
+        activity: Activity,
+        placementId: String,
+        callback: Callback? = null
+    ) {
+        show(
+            activity = activity,
+            placementId = placementId,
+            callback = callback?.let { legacyCallback ->
+                object : ShowCallback {
+                    override fun onAdShowed() = legacyCallback.onAdShown()
+                    override fun onAdDismissed() = legacyCallback.onAdDismissed()
+                    override fun onAdClicked() {}
+                    override fun onAdFailedToShow(error: String) = legacyCallback.onAdFailed(error)
+                }
+            }
+        )
+    }
+
+    /**
+     * Check if an interstitial ad is ready to show
+     *
+     * @param placementId The placement ID
+     * @return true if an ad is preloaded and ready to show
+     */
+    fun isReady(placementId: String): Boolean = safeExecute(false) {
+        if (!BigCrunchAds.isInitialized()) {
+            BCLogger.w(TAG, "isReady called before SDK initialized")
+            return@safeExecute false
+        }
+        adOrchestrator?.isInterstitialReady(placementId) ?: false
+    }
+
+    /**
+     * Load an interstitial ad with custom targeting
+     *
+     * @param placementId The placement ID for the ad
+     * @param customTargeting Optional custom targeting parameters
+     */
+    fun load(placementId: String, customTargeting: Map<String, String>? = null) {
+        // For now, just call preload - custom targeting will be added in AdOrchestrator
+        preload(placementId)
+        if (customTargeting != null) {
+            BCLogger.d(TAG, "Custom targeting requested: ${customTargeting.size} parameters")
+        }
+    }
+
+    /**
+     * Check if an interstitial ad is loaded and ready to show
+     *
+     * @param placementId The placement ID to check
+     * @return true if the ad is loaded and ready, false otherwise
+     */
+    fun isLoaded(placementId: String): Boolean = isReady(placementId)
+
+    /**
+     * Destroy a specific interstitial ad
+     *
+     * @param placementId The placement ID to destroy
+     */
+    fun destroy(placementId: String) = safeExecute {
+        BCLogger.d(TAG, "Destroying interstitial: $placementId")
+        synchronized(orchestratorLock) {
+            adOrchestrator?.destroyInterstitialAd(placementId)
+        }
+    }
+
+    /**
+     * Destroy all cached interstitial ads
+     */
+    fun destroyAll() = safeExecute {
+        clearCache()
+    }
+
+    /**
+     * Clear all cached interstitial ads
+     *
+     * Call this to free up memory when ads are no longer needed.
+     */
+    fun clearCache() = safeExecute {
+        BCLogger.d(TAG, "Clearing interstitial cache")
+        synchronized(orchestratorLock) {
+            adOrchestrator?.clearCache()
+        }
+    }
+
+    private fun getOrCreateOrchestrator(context: Context?): AdOrchestrator {
+        synchronized(orchestratorLock) {
+            if (adOrchestrator == null) {
+                val ctx = context?.applicationContext
+                    ?: throw IllegalStateException("Context required to create AdOrchestrator")
+
+                val configManager = BigCrunchAds.getConfigManager()
+                val analyticsClient = BigCrunchAds.getAnalyticsClient()
+                val googleAdsAdapter = GoogleAdsAdapter(ctx, analyticsClient)
+
+                val bidRequestClient = BigCrunchAds.bidRequestClient ?: com.bigcrunch.ads.core.BidRequestClient(
+                    httpClient = com.bigcrunch.ads.internal.HttpClient(),
+                    configManager = configManager,
+                    privacyStore = BigCrunchAds.privacyStore,
+                    s2sConfig = com.bigcrunch.ads.models.S2SConfig(enabled = false, serverUrl = "", timeoutMs = 0)
+                )
+
+                adOrchestrator = AdOrchestrator(
+                    ctx,
+                    configManager,
+                    analyticsClient,
+                    bidRequestClient,
+                    googleAdsAdapter
+                )
+            }
+            return adOrchestrator!!
+        }
+    }
+
+    /**
+     * Reset for testing purposes only
+     */
+    internal fun resetForTesting() {
+        synchronized(orchestratorLock) {
+            adOrchestrator?.clearCache()
+            adOrchestrator = null
+        }
+    }
+}