@bigcrunch/react-native-ads 0.1.0

package/android/src/main/java/com/bigcrunch/ads/react/BigCrunchAdsModule.kt

@@ -0,0 +1,653 @@
+package com.bigcrunch.ads.react
+
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.bigcrunch.ads.*
+import com.bigcrunch.ads.models.*
+import kotlinx.coroutines.*
+
+/**
+ * React Native bridge module for BigCrunch Ads SDK
+ */
+class BigCrunchAdsModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private val interstitialCache = mutableMapOf<String, Any>() // Placeholder for interstitial instances
+    private val rewardedCache = mutableMapOf<String, Any>() // Placeholder for rewarded instances
+
+    override fun getName(): String = "BigCrunchAdsModule"
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        scope.cancel()
+    }
+
+    /**
+     * Initialize the SDK
+     */
+    @ReactMethod
+    fun initialize(options: ReadableMap, promise: Promise) {
+        try {
+            val propertyId = options.getString("propertyId")
+                ?: throw IllegalArgumentException("propertyId is required")
+            val apiKey = options.getString("apiKey")
+                ?: throw IllegalArgumentException("apiKey is required")
+            val environment = options.getString("environment") ?: "production"
+            val debug = if (options.hasKey("debug")) options.getBoolean("debug") else false
+
+            // Initialize the native SDK
+            val context = reactApplicationContext.applicationContext
+
+            scope.launch {
+                try {
+                    BigCrunchAds.initialize(
+                        context = context,
+                        propertyId = propertyId,
+                        apiKey = apiKey,
+                        env = if (environment == "staging")
+                            BigCrunchAds.Environment.Staging
+                        else
+                            BigCrunchAds.Environment.Prod,
+                        // Use mock config for testing/development
+                        useMockConfig = environment == "sandbox"
+                    )
+
+                    if (debug) {
+                        BigCrunchAds.setDebugMode(true)
+                    }
+
+                    // SDK initialization is complete
+                    // The Android SDK now handles config loading internally
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject("INIT_ERROR", "Failed to initialize SDK: ${e.message}", e)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", "Failed to initialize SDK: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Check if SDK is initialized
+     */
+    @ReactMethod
+    fun isInitialized(promise: Promise) {
+        promise.resolve(BigCrunchAds.isInitialized())
+    }
+
+    /**
+     * Track screen view
+     */
+    @ReactMethod
+    fun trackScreenView(screenName: String, promise: Promise) {
+        scope.launch {
+            try {
+                BigCrunchAds.trackScreenView(screenName)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("TRACK_ERROR", "Failed to track screen view: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Get app configuration
+     */
+    @ReactMethod
+    fun getAppConfig(promise: Promise) {
+        scope.launch {
+            try {
+                val config = BigCrunchAds.getAppConfig()
+                if (config != null) {
+                    promise.resolve(convertAppConfigToMap(config))
+                } else {
+                    promise.resolve(null)
+                }
+            } catch (e: Exception) {
+                promise.reject("CONFIG_ERROR", "Failed to get app config: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Refresh configuration
+     */
+    @ReactMethod
+    fun refreshConfig(promise: Promise) {
+        scope.launch {
+            try {
+                BigCrunchAds.refreshConfig()
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("CONFIG_ERROR", "Failed to refresh config: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Load interstitial ad
+     */
+    @ReactMethod
+    fun loadInterstitial(options: ReadableMap, promise: Promise) {
+        try {
+            val placementId = options.getString("placementId")
+                ?: throw IllegalArgumentException("placementId is required")
+
+            scope.launch {
+                try {
+                    // Create ad request options
+                    val customTargeting = options.getMap("customTargeting")?.let {
+                        convertMapToStringMap(it)
+                    }
+
+                    // Set up callbacks to emit events to JavaScript
+                    val context = reactApplicationContext.applicationContext
+                    BigCrunchInterstitial.preload(
+                        context = context,
+                        placementId = placementId,
+                        callback = object : BigCrunchInterstitial.PreloadCallback {
+                            override fun onAdLoaded() {
+                                val eventParams = Arguments.createMap()
+                                eventParams.putString("placementId", placementId)
+                                sendEvent("BigCrunchInterstitialAdLoaded", eventParams)
+
+                                // Store the loaded ad in cache (for tracking)
+                                interstitialCache[placementId] = true
+                            }
+
+                            override fun onAdFailedToLoad(error: String) {
+                                val eventParams = Arguments.createMap()
+                                eventParams.putString("placementId", placementId)
+                                eventParams.putString("errorCode", "LOAD_FAILED")
+                                eventParams.putString("errorMessage", error)
+                                sendEvent("BigCrunchInterstitialAdFailedToLoad", eventParams)
+                            }
+                        }
+                    )
+
+                    // Apply custom targeting if provided (will be implemented in AdOrchestrator later)
+                    if (customTargeting != null) {
+                        // TODO: Pass custom targeting to AdOrchestrator
+                    }
+
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject("LOAD_ERROR", "Failed to load interstitial: ${e.message}", e)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("LOAD_ERROR", "Failed to load interstitial: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Show interstitial ad
+     */
+    @ReactMethod
+    fun showInterstitial(placementId: String, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "No current activity available")
+            return
+        }
+
+        scope.launch {
+            try {
+                val callback = object : BigCrunchInterstitial.ShowCallback {
+                    override fun onAdShowed() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchInterstitialAdOpened", eventParams)
+
+                        // Also emit impression event
+                        sendEvent("BigCrunchInterstitialAdImpression", eventParams)
+                    }
+
+                    override fun onAdDismissed() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchInterstitialAdClosed", eventParams)
+
+                        // Clear from cache on dismissal
+                        interstitialCache.remove(placementId)
+                    }
+
+                    override fun onAdClicked() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchInterstitialAdClicked", eventParams)
+                    }
+
+                    override fun onAdFailedToShow(error: String) {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        eventParams.putString("errorCode", "SHOW_FAILED")
+                        eventParams.putString("errorMessage", error)
+                        sendEvent("BigCrunchInterstitialAdFailedToShow", eventParams)
+                    }
+                }
+
+                BigCrunchInterstitial.show(activity, placementId, callback)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("SHOW_ERROR", "Failed to show interstitial: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Check if interstitial is loaded
+     */
+    @ReactMethod
+    fun isInterstitialLoaded(placementId: String, promise: Promise) {
+        promise.resolve(BigCrunchInterstitial.isLoaded(placementId))
+    }
+
+    /**
+     * Destroy interstitial
+     */
+    @ReactMethod
+    fun destroyInterstitial(placementId: String, promise: Promise) {
+        try {
+            BigCrunchInterstitial.destroy(placementId)
+            interstitialCache.remove(placementId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("DESTROY_ERROR", "Failed to destroy interstitial: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Load rewarded ad
+     */
+    @ReactMethod
+    fun loadRewarded(options: ReadableMap, promise: Promise) {
+        try {
+            val placementId = options.getString("placementId")
+                ?: throw IllegalArgumentException("placementId is required")
+
+            scope.launch {
+                try {
+                    val customTargeting = options.getMap("customTargeting")?.let {
+                        convertMapToStringMap(it)
+                    }
+
+                    // Set up callbacks to emit events to JavaScript
+                    val context = reactApplicationContext.applicationContext
+                    BigCrunchRewarded.preload(
+                        context = context,
+                        placementId = placementId,
+                        callback = object : BigCrunchRewarded.PreloadCallback {
+                            override fun onAdLoaded() {
+                                val eventParams = Arguments.createMap()
+                                eventParams.putString("placementId", placementId)
+                                sendEvent("BigCrunchRewardedAdLoaded", eventParams)
+
+                                // Store the loaded ad in cache (for tracking)
+                                rewardedCache[placementId] = true
+                            }
+
+                            override fun onAdFailedToLoad(error: String) {
+                                val eventParams = Arguments.createMap()
+                                eventParams.putString("placementId", placementId)
+                                eventParams.putString("errorCode", "LOAD_FAILED")
+                                eventParams.putString("errorMessage", error)
+                                sendEvent("BigCrunchRewardedAdFailedToLoad", eventParams)
+                            }
+                        }
+                    )
+
+                    // Apply custom targeting if provided (will be implemented in AdOrchestrator later)
+                    if (customTargeting != null) {
+                        // TODO: Pass custom targeting to AdOrchestrator
+                    }
+
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject("LOAD_ERROR", "Failed to load rewarded: ${e.message}", e)
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("LOAD_ERROR", "Failed to load rewarded: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Show rewarded ad
+     */
+    @ReactMethod
+    fun showRewarded(placementId: String, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "No current activity available")
+            return
+        }
+
+        scope.launch {
+            try {
+                val callback = object : BigCrunchRewarded.ShowCallback {
+                    override fun onAdShowed() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchRewardedAdOpened", eventParams)
+
+                        // Also emit impression event
+                        sendEvent("BigCrunchRewardedAdImpression", eventParams)
+                    }
+
+                    override fun onUserEarnedReward(type: String, amount: Int) {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        eventParams.putString("type", type)
+                        eventParams.putInt("amount", amount)
+                        sendEvent("BigCrunchRewardedAdEarned", eventParams)
+                    }
+
+                    override fun onAdDismissed() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchRewardedAdClosed", eventParams)
+
+                        // Clear from cache on dismissal
+                        rewardedCache.remove(placementId)
+                    }
+
+                    override fun onAdClicked() {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        sendEvent("BigCrunchRewardedAdClicked", eventParams)
+                    }
+
+                    override fun onAdFailedToShow(error: String) {
+                        val eventParams = Arguments.createMap()
+                        eventParams.putString("placementId", placementId)
+                        eventParams.putString("errorCode", "SHOW_FAILED")
+                        eventParams.putString("errorMessage", error)
+                        sendEvent("BigCrunchRewardedAdFailedToShow", eventParams)
+                    }
+                }
+
+                BigCrunchRewarded.show(activity, placementId, callback)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("SHOW_ERROR", "Failed to show rewarded: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Check if rewarded is loaded
+     */
+    @ReactMethod
+    fun isRewardedLoaded(placementId: String, promise: Promise) {
+        promise.resolve(BigCrunchRewarded.isLoaded(placementId))
+    }
+
+    /**
+     * Destroy rewarded
+     */
+    @ReactMethod
+    fun destroyRewarded(placementId: String, promise: Promise) {
+        try {
+            BigCrunchRewarded.destroy(placementId)
+            rewardedCache.remove(placementId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("DESTROY_ERROR", "Failed to destroy rewarded: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Get session info
+     */
+    @ReactMethod
+    fun getSessionInfo(promise: Promise) {
+        scope.launch {
+            try {
+                val sessionInfo = BigCrunchAds.getSessionInfo()
+                promise.resolve(convertSessionInfoToMap(sessionInfo))
+            } catch (e: Exception) {
+                promise.reject("SESSION_ERROR", "Failed to get session info: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Start new session
+     */
+    @ReactMethod
+    fun startNewSession(promise: Promise) {
+        scope.launch {
+            try {
+                BigCrunchAds.startNewSession()
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("SESSION_ERROR", "Failed to start new session: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Get device context
+     */
+    @ReactMethod
+    fun getDeviceContext(promise: Promise) {
+        scope.launch {
+            try {
+                val deviceData = BigCrunchAds.getDeviceData()
+                promise.resolve(convertDeviceDataToMap(deviceData))
+            } catch (e: Exception) {
+                promise.reject("DEVICE_ERROR", "Failed to get device data: ${e.message}", e)
+            }
+        }
+    }
+
+    /**
+     * Set GDPR consent
+     */
+    @ReactMethod
+    fun setGdprConsent(consent: String, promise: Promise) {
+        try {
+            BigCrunchAds.setGdprConsent(consent)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("PRIVACY_ERROR", "Failed to set GDPR consent: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Set CCPA string
+     */
+    @ReactMethod
+    fun setCcpaString(ccpaString: String, promise: Promise) {
+        try {
+            BigCrunchAds.setCcpaString(ccpaString)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("PRIVACY_ERROR", "Failed to set CCPA string: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Set COPPA compliant
+     */
+    @ReactMethod
+    fun setCoppaCompliant(isCompliant: Boolean, promise: Promise) {
+        try {
+            BigCrunchAds.setCoppaCompliant(isCompliant)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("PRIVACY_ERROR", "Failed to set COPPA compliance: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Set debug mode
+     */
+    @ReactMethod
+    fun setDebugMode(enabled: Boolean, promise: Promise) {
+        try {
+            BigCrunchAds.setDebugMode(enabled)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("DEBUG_ERROR", "Failed to set debug mode: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Add test device
+     */
+    @ReactMethod
+    fun addTestDevice(deviceId: String, promise: Promise) {
+        try {
+            BigCrunchAds.addTestDevice(deviceId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("TEST_ERROR", "Failed to add test device: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Remove test device
+     */
+    @ReactMethod
+    fun removeTestDevice(deviceId: String, promise: Promise) {
+        try {
+            BigCrunchAds.removeTestDevice(deviceId)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("TEST_ERROR", "Failed to remove test device: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Get test devices
+     */
+    @ReactMethod
+    fun getTestDevices(promise: Promise) {
+        try {
+            val devices = BigCrunchAds.getTestDevices()
+            promise.resolve(Arguments.fromList(devices))
+        } catch (e: Exception) {
+            promise.reject("TEST_ERROR", "Failed to get test devices: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Add event listener (required for NativeEventEmitter)
+     */
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep track of listeners if needed
+        // This is required for NativeEventEmitter to work properly
+    }
+
+    /**
+     * Remove event listeners (required for NativeEventEmitter)
+     */
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Remove listeners if needed
+        // This is required for NativeEventEmitter to work properly
+    }
+
+    /**
+     * Send event to JavaScript
+     */
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    // Helper conversion methods
+    private fun convertAppConfigToMap(config: AppConfig): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("propertyId", config.propertyId)
+        map.putString("appName", config.appName)
+
+        val placements = Arguments.createArray()
+        config.placements.forEach { placement ->
+            placements.pushMap(convertPlacementConfigToMap(placement))
+        }
+        map.putArray("placements", placements)
+
+        return map
+    }
+
+    private fun convertPlacementConfigToMap(config: PlacementConfig): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("placementId", config.placementId)
+        map.putString("format", config.format)
+        map.putString("gamAdUnit", config.gamAdUnit)
+
+        // Add sizes array if available
+        config.sizes?.let { sizes ->
+            val sizesArray = Arguments.createArray()
+            for (size in sizes) {
+                val sizeMap = Arguments.createMap()
+                sizeMap.putInt("width", size.width)
+                sizeMap.putInt("height", size.height)
+                sizesArray.pushMap(sizeMap)
+            }
+            map.putArray("sizes", sizesArray)
+        }
+
+        // Add Prebid config ID if available
+        config.prebidConfigId?.let {
+            map.putString("prebidConfigId", it)
+        }
+
+        // Add refresh config if available
+        config.refresh?.let { refresh ->
+            val refreshMap = Arguments.createMap()
+            refreshMap.putBoolean("enabled", refresh.enabled)
+            refreshMap.putInt("intervalMs", refresh.intervalMs)
+            refresh.maxRefreshes?.let { refreshMap.putInt("maxRefreshes", it) }
+            map.putMap("refresh", refreshMap)
+        }
+
+        return map
+    }
+
+    private fun convertSessionInfoToMap(info: SessionInfo): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("sessionId", info.sessionId)
+        map.putString("startTime", info.startTime)  // Changed from toDouble() - now ISO 8601 string
+        map.putInt("screenViewCount", info.screenViewCount)
+        map.putInt("adRequestCount", info.adRequestCount)
+        map.putInt("adImpressionCount", info.adImpressionCount)
+        map.putDouble("totalRevenueMicros", info.totalRevenueMicros.toDouble())
+        return map
+    }
+
+    private fun convertDeviceDataToMap(data: DeviceData): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("deviceId", data.deviceId)
+        map.putString("deviceModel", data.deviceModel)
+        map.putString("osVersion", data.osVersion)
+        map.putString("appVersion", data.appVersion)
+        map.putInt("screenWidth", data.screenWidth)
+        map.putInt("screenHeight", data.screenHeight)
+        map.putString("language", data.language)
+        map.putString("country", data.country)
+        map.putBoolean("isTablet", data.isTablet)
+        data.carrier?.let { map.putString("carrier", it) }
+        data.networkType?.let { map.putString("networkType", it) }
+        return map
+    }
+
+    private fun convertMapToStringMap(map: ReadableMap): Map<String, String> {
+        val result = mutableMapOf<String, String>()
+        val iterator = map.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            map.getString(key)?.let { value ->
+                result[key] = value
+            }
+        }
+        return result
+    }
+}

package/android/src/main/java/com/bigcrunch/ads/react/BigCrunchAdsPackage.kt

@@ -0,0 +1,20 @@
+package com.bigcrunch.ads.react
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package for BigCrunch Ads SDK
+ */
+class BigCrunchAdsPackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(BigCrunchAdsModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(BigCrunchBannerViewManager())
+    }
+}