@bigcrunch/react-native-ads 0.4.0 → 0.5.0

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

@@ -0,0 +1,409 @@
+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.RewardedCallback
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.listeners.RewardedAdListener
+
+/**
+ * BigCrunch Rewarded Ads - Static API for rewarded video ads
+ *
+ * Rewarded ads are full-screen video ads that reward users for watching.
+ * Users have the option to watch the ad in exchange for in-app rewards.
+ *
+ * Usage:
+ * ```kotlin
+ * // 1. Preload the ad
+ * BigCrunchRewarded.preload(
+ *     context = applicationContext,
+ *     placementId = "daily_reward",
+ *     callback = object : BigCrunchRewarded.PreloadCallback {
+ *         override fun onAdLoaded() { /* ad ready to show */ }
+ *         override fun onAdFailedToLoad(error: String) { /* handle error */ }
+ *     }
+ * )
+ *
+ * // 2. Check if ready
+ * if (BigCrunchRewarded.isReady("daily_reward")) {
+ *     // Ad is ready to show
+ * }
+ *
+ * // 3. Show when user requests
+ * BigCrunchRewarded.show(
+ *     activity = this,
+ *     placementId = "daily_reward",
+ *     callback = object : BigCrunchRewarded.ShowCallback {
+ *         override fun onUserEarnedReward(type: String, amount: Int) {
+ *             // Give user their reward
+ *         }
+ *         override fun onAdDismissed() { /* ad closed */ }
+ *         override fun onAdFailedToShow(error: String) { /* handle error */ }
+ *     }
+ * )
+ * ```
+ */
+object BigCrunchRewarded {
+
+    private val TAG = "BigCrunchRewarded"
+    private var adOrchestrator: AdOrchestrator? = null
+    private val orchestratorLock = Any()
+
+    // Listeners for React Native compatibility
+    private val listeners = mutableMapOf<String, RewardedAdListener>()
+
+    /**
+     * Callback interface for preloading rewarded ads
+     */
+    interface PreloadCallback {
+        /**
+         * Called when the ad has been successfully loaded and is ready to show
+         */
+        fun onAdLoaded()
+
+        /**
+         * Called when the ad fails to load
+         * @param error Description of what went wrong
+         */
+        fun onAdFailedToLoad(error: String)
+    }
+
+    /**
+     * Callback interface for showing rewarded ads
+     */
+    interface ShowCallback {
+        /**
+         * Called when the user has earned a reward by watching the ad
+         * @param type The type of reward (e.g., "coins", "points")
+         * @param amount The amount of reward earned
+         */
+        fun onUserEarnedReward(type: String, amount: Int)
+
+        /**
+         * Called when the ad is dismissed (whether reward was earned or not)
+         */
+        fun onAdDismissed()
+
+        /**
+         * Called when the ad was shown successfully
+         */
+        fun onAdShowed() {}
+
+        /**
+         * Called when the user clicks on the ad
+         */
+        fun onAdClicked() {}
+
+        /**
+         * Called when the ad fails to show
+         * @param error Description of what went wrong
+         */
+        fun onAdFailedToShow(error: String)
+    }
+
+    /**
+     * Combined callback interface (for compatibility)
+     */
+    interface Callback : PreloadCallback, ShowCallback
+
+    /**
+     * Preload a rewarded ad with callback
+     *
+     * @param context Application or Activity context
+     * @param placementId The placement ID from BigCrunch dashboard
+     * @param callback Callback for load events
+     */
+    fun preload(
+        context: Context,
+        placementId: String,
+        callback: PreloadCallback? = null
+    ) {
+        BCLogger.d(TAG, "Preloading rewarded ad: $placementId")
+
+        try {
+            BigCrunchAds.requireInitialized()
+        } catch (e: IllegalStateException) {
+            BCLogger.e(TAG, "SDK not initialized", e)
+            callback?.onAdFailedToLoad("SDK not initialized")
+            return
+        }
+
+        val orchestrator = getOrCreateOrchestrator(context)
+
+        // Create internal callback
+        val rewardedCallback = object : RewardedCallback {
+            override fun onAdLoaded() {
+                BCLogger.d(TAG, "Rewarded ad loaded: $placementId")
+                callback?.onAdLoaded()
+                listeners[placementId]?.onAdLoaded()
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Rewarded ad failed to load: $placementId - $error")
+                callback?.onAdFailedToLoad(error)
+                listeners[placementId]?.onAdFailedToLoad("LOAD_ERROR", error)
+            }
+
+            override fun onAdShowed() {
+                BCLogger.d(TAG, "Rewarded ad showed: $placementId")
+                listeners[placementId]?.onAdShowed()
+            }
+
+            override fun onAdDismissed() {
+                BCLogger.d(TAG, "Rewarded ad dismissed: $placementId")
+                listeners[placementId]?.onAdDismissed()
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Rewarded ad clicked: $placementId")
+                listeners[placementId]?.onAdClicked()
+            }
+
+            override fun onUserEarnedReward(type: String, amount: Int) {
+                BCLogger.d(TAG, "User earned reward: $type x$amount for $placementId")
+                listeners[placementId]?.onUserEarnedReward(type, amount)
+            }
+        }
+
+        // Load through AdOrchestrator
+        orchestrator.preloadRewardedAd(placementId, rewardedCallback)
+    }
+
+    /**
+     * Preload a rewarded ad without callback
+     *
+     * @param placementId The placement ID from BigCrunch dashboard
+     */
+    fun preload(placementId: String) {
+        // Need context from somewhere - could get from last show() call
+        BCLogger.w(TAG, "Preload called without context - not implemented")
+    }
+
+    /**
+     * Load a rewarded 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) {
+        BCLogger.d(TAG, "Loading rewarded ad: $placementId")
+        if (customTargeting != null) {
+            BCLogger.d(TAG, "Custom targeting requested: ${customTargeting.size} parameters")
+        }
+        // Need context - could store from initialization
+        preload(placementId)
+    }
+
+    /**
+     * Show a preloaded rewarded ad
+     *
+     * @param activity The activity to show the ad in
+     * @param placementId The placement ID
+     * @param callback Callback for ad events
+     * @return true if the ad was shown, false if not ready
+     */
+    fun show(
+        activity: Activity,
+        placementId: String,
+        callback: ShowCallback? = null
+    ): Boolean {
+        BCLogger.d(TAG, "Attempting to show rewarded ad: $placementId")
+
+        try {
+            BigCrunchAds.requireInitialized()
+        } catch (e: IllegalStateException) {
+            BCLogger.e(TAG, "SDK not initialized", e)
+            callback?.onAdFailedToShow("SDK not initialized")
+            listeners[placementId]?.onAdFailedToLoad("SDK_NOT_INITIALIZED", "SDK not initialized")
+            return false
+        }
+
+        if (!isReady(placementId)) {
+            val error = "Rewarded ad not ready: $placementId"
+            BCLogger.w(TAG, error)
+            callback?.onAdFailedToShow(error)
+            listeners[placementId]?.onAdFailedToLoad("NOT_READY", error)
+            return false
+        }
+
+        val orchestrator = getOrCreateOrchestrator(activity)
+
+        // Create internal callback
+        val rewardedCallback = object : RewardedCallback {
+            override fun onAdLoaded() {
+                // Not used during show
+            }
+
+            override fun onAdFailedToLoad(error: String) {
+                BCLogger.w(TAG, "Rewarded ad failed to show: $placementId - $error")
+                callback?.onAdFailedToShow(error)
+                listeners[placementId]?.onAdFailedToLoad("SHOW_ERROR", error)
+            }
+
+            override fun onAdShowed() {
+                BCLogger.d(TAG, "Rewarded ad showed: $placementId")
+                callback?.onAdShowed()
+                listeners[placementId]?.onAdShowed()
+            }
+
+            override fun onAdDismissed() {
+                BCLogger.d(TAG, "Rewarded ad dismissed: $placementId")
+                callback?.onAdDismissed()
+                listeners[placementId]?.onAdDismissed()
+            }
+
+            override fun onAdClicked() {
+                BCLogger.d(TAG, "Rewarded ad clicked: $placementId")
+                callback?.onAdClicked()
+                listeners[placementId]?.onAdClicked()
+            }
+
+            override fun onUserEarnedReward(type: String, amount: Int) {
+                BCLogger.d(TAG, "User earned reward: $type x$amount for $placementId")
+                callback?.onUserEarnedReward(type, amount)
+                listeners[placementId]?.onUserEarnedReward(type, amount)
+            }
+        }
+
+        return orchestrator.showRewardedAd(activity, placementId, rewardedCallback)
+    }
+
+    /**
+     * Show a preloaded rewarded ad with listener
+     *
+     * @param activity The activity to show the ad in
+     * @param placementId The placement ID
+     * @param listener Listener for ad events
+     * @return true if the ad was shown, false if not ready
+     */
+    fun show(
+        activity: Activity,
+        placementId: String,
+        listener: RewardedAdListener? = null
+    ): Boolean {
+        if (listener != null) {
+            listeners[placementId] = listener
+        }
+
+        // Convert listener to callback
+        val callback = if (listener != null) {
+            object : ShowCallback {
+                override fun onUserEarnedReward(type: String, amount: Int) {
+                    listener.onUserEarnedReward(type, amount)
+                }
+                override fun onAdDismissed() {
+                    listener.onAdDismissed()
+                }
+                override fun onAdShowed() {
+                    listener.onAdShowed()
+                }
+                override fun onAdClicked() {
+                    listener.onAdClicked()
+                }
+                override fun onAdFailedToShow(error: String) {
+                    listener.onAdFailedToLoad("SHOW_ERROR", error)
+                }
+            }
+        } else null
+
+        return show(activity, placementId, callback)
+    }
+
+    /**
+     * Check if a rewarded ad is ready to show
+     *
+     * @param placementId The placement ID
+     * @return true if ad is loaded and ready
+     */
+    fun isReady(placementId: String): Boolean {
+        return synchronized(orchestratorLock) {
+            adOrchestrator?.isRewardedReady(placementId) ?: false
+        }
+    }
+
+    /**
+     * Check if a rewarded ad is loaded (alias for isReady)
+     *
+     * @param placementId The placement ID
+     * @return true if ad is loaded and ready
+     */
+    fun isLoaded(placementId: String): Boolean = isReady(placementId)
+
+    /**
+     * Destroy a specific rewarded ad
+     *
+     * @param placementId The placement ID to destroy
+     */
+    fun destroy(placementId: String) {
+        BCLogger.d(TAG, "Destroying rewarded ad: $placementId")
+        synchronized(orchestratorLock) {
+            adOrchestrator?.destroyRewardedAd(placementId)
+            listeners.remove(placementId)
+        }
+    }
+
+    /**
+     * Destroy all cached rewarded ads
+     */
+    fun destroyAll() {
+        BCLogger.d(TAG, "Destroying all rewarded ads")
+        synchronized(orchestratorLock) {
+            adOrchestrator?.clearCache()
+            listeners.clear()
+        }
+    }
+
+    /**
+     * Clear all cached rewarded ads
+     */
+    fun clearCache() {
+        destroyAll()
+    }
+
+    /**
+     * Set a listener for a placement
+     *
+     * @param placementId The placement ID
+     * @param listener The listener for events
+     */
+    fun setListener(placementId: String, listener: RewardedAdListener?) {
+        if (listener != null) {
+            listeners[placementId] = listener
+        } else {
+            listeners.remove(placementId)
+        }
+    }
+
+    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
+                )
+
+                BCLogger.d(TAG, "Created new AdOrchestrator for rewarded ads")
+            }
+            return adOrchestrator!!
+        }
+    }
+}