cloudx-react-native 2.0.0-beta.1 → 2.0.0

package/android/src/main/java/com/cloudxreactnative/CloudXReactNativeModuleImpl.kt

@@ -1,861 +0,0 @@
-package com.cloudxreactnative
-
-import android.graphics.Color
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import android.view.Gravity
-import android.view.OrientationEventListener
-import android.view.Surface
-import android.view.View
-import android.view.ViewGroup
-import android.view.WindowInsets
-import android.widget.FrameLayout
-import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import io.cloudx.sdk.*
-import java.util.concurrent.ConcurrentHashMap
-
-class CloudXReactNativeModuleImpl(reactContext: ReactApplicationContext) {
-
-    // Strong reference is safe — module lifecycle is tied to the ReactApplicationContext
-    private val reactApplicationContext: ReactApplicationContext = reactContext
-
-    private val interstitials = ConcurrentHashMap<String, CloudXInterstitialAd>()
-    private val rewardeds = ConcurrentHashMap<String, CloudXRewardedAd>()
-    private val banners = ConcurrentHashMap<String, CloudXAdView>()
-    private val mrecs = ConcurrentHashMap<String, CloudXAdView>()
-    private val windowPositionedAds = ConcurrentHashMap.newKeySet<String>()
-    private val adViewPositions = ConcurrentHashMap<String, String>()
-    private val adViewOffsets = ConcurrentHashMap<String, Pair<Float, Float>>()
-    private val adUnitIdsToShowAfterCreate = ConcurrentHashMap.newKeySet<String>()
-    private var orientationListener: OrientationEventListener? = null
-    private var currentRotation: Int = -1
-
-    companion object {
-        private const val TAG = "CloudXModule"
-        const val MODULE_NAME = "CloudXModule"
-
-        private const val ON_BANNER_AD_LOADED_EVENT = "OnBannerAdLoadedEvent"
-        private const val ON_BANNER_AD_LOAD_FAILED_EVENT = "OnBannerAdLoadFailedEvent"
-        private const val ON_BANNER_AD_CLICKED_EVENT = "OnBannerAdClickedEvent"
-        private const val ON_BANNER_AD_EXPANDED_EVENT = "OnBannerAdExpandedEvent"
-        private const val ON_BANNER_AD_COLLAPSED_EVENT = "OnBannerAdCollapsedEvent"
-        private const val ON_BANNER_AD_REVENUE_PAID = "OnBannerAdRevenuePaid"
-
-        private const val ON_MREC_AD_LOADED_EVENT = "OnMRecAdLoadedEvent"
-        private const val ON_MREC_AD_LOAD_FAILED_EVENT = "OnMRecAdLoadFailedEvent"
-        private const val ON_MREC_AD_CLICKED_EVENT = "OnMRecAdClickedEvent"
-        private const val ON_MREC_AD_EXPANDED_EVENT = "OnMRecAdExpandedEvent"
-        private const val ON_MREC_AD_COLLAPSED_EVENT = "OnMRecAdCollapsedEvent"
-        private const val ON_MREC_AD_REVENUE_PAID = "OnMRecAdRevenuePaid"
-
-        private const val ON_INTERSTITIAL_LOADED_EVENT = "OnInterstitialLoadedEvent"
-        private const val ON_INTERSTITIAL_LOAD_FAILED_EVENT = "OnInterstitialLoadFailedEvent"
-        private const val ON_INTERSTITIAL_CLICKED_EVENT = "OnInterstitialClickedEvent"
-        private const val ON_INTERSTITIAL_DISPLAYED_EVENT = "OnInterstitialDisplayedEvent"
-        private const val ON_INTERSTITIAL_DISPLAY_FAILED_EVENT = "OnInterstitialDisplayFailedEvent"
-        private const val ON_INTERSTITIAL_HIDDEN_EVENT = "OnInterstitialHiddenEvent"
-        private const val ON_INTERSTITIAL_AD_REVENUE_PAID = "OnInterstitialAdRevenuePaid"
-
-        private const val ON_REWARDED_AD_LOADED_EVENT = "OnRewardedAdLoadedEvent"
-        private const val ON_REWARDED_AD_LOAD_FAILED_EVENT = "OnRewardedAdLoadFailedEvent"
-        private const val ON_REWARDED_AD_CLICKED_EVENT = "OnRewardedAdClickedEvent"
-        private const val ON_REWARDED_AD_DISPLAYED_EVENT = "OnRewardedAdDisplayedEvent"
-        private const val ON_REWARDED_AD_DISPLAY_FAILED_EVENT = "OnRewardedAdDisplayFailedEvent"
-        private const val ON_REWARDED_AD_HIDDEN_EVENT = "OnRewardedAdHiddenEvent"
-        private const val ON_REWARDED_AD_RECEIVED_REWARD_EVENT = "OnRewardedAdReceivedRewardEvent"
-        private const val ON_REWARDED_AD_REVENUE_PAID = "OnRewardedAdRevenuePaid"
-    }
-
-    fun getConstants(): MutableMap<String, Any> = mutableMapOf(
-        "ON_BANNER_AD_LOADED_EVENT" to ON_BANNER_AD_LOADED_EVENT,
-        "ON_BANNER_AD_LOAD_FAILED_EVENT" to ON_BANNER_AD_LOAD_FAILED_EVENT,
-        "ON_BANNER_AD_CLICKED_EVENT" to ON_BANNER_AD_CLICKED_EVENT,
-        "ON_BANNER_AD_EXPANDED_EVENT" to ON_BANNER_AD_EXPANDED_EVENT,
-        "ON_BANNER_AD_COLLAPSED_EVENT" to ON_BANNER_AD_COLLAPSED_EVENT,
-        "ON_BANNER_AD_REVENUE_PAID" to ON_BANNER_AD_REVENUE_PAID,
-        "ON_MREC_AD_LOADED_EVENT" to ON_MREC_AD_LOADED_EVENT,
-        "ON_MREC_AD_LOAD_FAILED_EVENT" to ON_MREC_AD_LOAD_FAILED_EVENT,
-        "ON_MREC_AD_CLICKED_EVENT" to ON_MREC_AD_CLICKED_EVENT,
-        "ON_MREC_AD_EXPANDED_EVENT" to ON_MREC_AD_EXPANDED_EVENT,
-        "ON_MREC_AD_COLLAPSED_EVENT" to ON_MREC_AD_COLLAPSED_EVENT,
-        "ON_MREC_AD_REVENUE_PAID" to ON_MREC_AD_REVENUE_PAID,
-        "ON_INTERSTITIAL_LOADED_EVENT" to ON_INTERSTITIAL_LOADED_EVENT,
-        "ON_INTERSTITIAL_LOAD_FAILED_EVENT" to ON_INTERSTITIAL_LOAD_FAILED_EVENT,
-        "ON_INTERSTITIAL_CLICKED_EVENT" to ON_INTERSTITIAL_CLICKED_EVENT,
-        "ON_INTERSTITIAL_DISPLAYED_EVENT" to ON_INTERSTITIAL_DISPLAYED_EVENT,
-        "ON_INTERSTITIAL_DISPLAY_FAILED_EVENT" to ON_INTERSTITIAL_DISPLAY_FAILED_EVENT,
-        "ON_INTERSTITIAL_HIDDEN_EVENT" to ON_INTERSTITIAL_HIDDEN_EVENT,
-        "ON_INTERSTITIAL_AD_REVENUE_PAID" to ON_INTERSTITIAL_AD_REVENUE_PAID,
-        "ON_REWARDED_AD_LOADED_EVENT" to ON_REWARDED_AD_LOADED_EVENT,
-        "ON_REWARDED_AD_LOAD_FAILED_EVENT" to ON_REWARDED_AD_LOAD_FAILED_EVENT,
-        "ON_REWARDED_AD_CLICKED_EVENT" to ON_REWARDED_AD_CLICKED_EVENT,
-        "ON_REWARDED_AD_DISPLAYED_EVENT" to ON_REWARDED_AD_DISPLAYED_EVENT,
-        "ON_REWARDED_AD_DISPLAY_FAILED_EVENT" to ON_REWARDED_AD_DISPLAY_FAILED_EVENT,
-        "ON_REWARDED_AD_HIDDEN_EVENT" to ON_REWARDED_AD_HIDDEN_EVENT,
-        "ON_REWARDED_AD_RECEIVED_REWARD_EVENT" to ON_REWARDED_AD_RECEIVED_REWARD_EVENT,
-        "ON_REWARDED_AD_REVENUE_PAID" to ON_REWARDED_AD_REVENUE_PAID,
-
-        // Position constants
-        "TOP_LEFT_POSITION" to "top_left",
-        "TOP_CENTER_POSITION" to "top_center",
-        "TOP_RIGHT_POSITION" to "top_right",
-        "CENTER_LEFT_POSITION" to "center_left",
-        "CENTERED_POSITION" to "centered",
-        "CENTER_RIGHT_POSITION" to "center_right",
-        "BOTTOM_LEFT_POSITION" to "bottom_left",
-        "BOTTOM_CENTER_POSITION" to "bottom_center",
-        "BOTTOM_RIGHT_POSITION" to "bottom_right",
-
-        // Error code constants
-        "ERROR_CODE_INTERNAL_ERROR" to 0,
-        "ERROR_CODE_NETWORK_ERROR" to 100,
-        "ERROR_CODE_NETWORK_TIMEOUT" to 101,
-        "ERROR_CODE_NO_FILL" to 302,
-        "ERROR_CODE_AD_NOT_READY" to 400,
-        "ERROR_CODE_AD_ALREADY_SHOWING" to 401,
-        "ERROR_CODE_INVALID_AD_UNIT" to 300,
-        "ERROR_CODE_NOT_INITIALIZED" to 200,
-        "ERROR_CODE_NO_CONNECTION" to 106,
-    )
-
-    fun onCatalystInstanceDestroy() {
-        orientationListener?.disable()
-        orientationListener = null
-
-        Handler(Looper.getMainLooper()).post {
-            banners.values.forEach {
-                it.listener = null; it.revenueListener = null; it.stopAutoRefresh()
-                (it.parent as? ViewGroup)?.removeView(it)
-                it.destroy()
-            }
-            mrecs.values.forEach {
-                it.listener = null; it.revenueListener = null; it.stopAutoRefresh()
-                (it.parent as? ViewGroup)?.removeView(it)
-                it.destroy()
-            }
-            interstitials.values.forEach { it.listener = null; it.revenueListener = null; it.destroy() }
-            rewardeds.values.forEach { it.listener = null; it.revenueListener = null; it.destroy() }
-            banners.clear()
-            mrecs.clear()
-            interstitials.clear()
-            rewardeds.clear()
-            windowPositionedAds.clear()
-            adViewPositions.clear()
-            adViewOffsets.clear()
-            adUnitIdsToShowAfterCreate.clear()
-        }
-    }
-
-    // =========================================================================
-    // Initialization
-    // =========================================================================
-
-    private enum class InitState { IDLE, INITIALIZING, INITIALIZED }
-    @Volatile private var initState = InitState.IDLE
-
-    @Synchronized
-    fun initialize(pluginVersion: String, appKey: String, promise: Promise) {
-        if (initState == InitState.INITIALIZED) {
-            val result = Arguments.createMap()
-            result.putBoolean("success", true)
-            result.putString("message", "SDK already initialized")
-            promise.resolve(result)
-            return
-        }
-
-        if (initState == InitState.INITIALIZING) {
-            promise.reject("INIT_IN_PROGRESS", "SDK initialization already in progress", null)
-            return
-        }
-
-        initState = InitState.INITIALIZING
-
-        val config = CloudXInitializationConfiguration.builder(appKey)
-            .setPluginVersion(pluginVersion)
-            .build()
-
-        CloudX.initialize(config, object : CloudXInitializationListener {
-            override fun onInitialized(configuration: CloudXSdkConfiguration) {
-                initState = InitState.INITIALIZED
-                setupOrientationListener()
-                val result = Arguments.createMap()
-                result.putBoolean("success", true)
-                result.putString("message", "SDK initialized successfully")
-                promise.resolve(result)
-            }
-
-            override fun onInitializationFailed(cloudXError: CloudXError) {
-                Log.e(TAG, "CloudX SDK initialization failed: ${cloudXError.message}")
-                initState = InitState.IDLE
-                promise.reject(cloudXError.code.name, cloudXError.message, null)
-            }
-        })
-    }
-
-    fun isInitialized(promise: Promise) {
-        promise.resolve(CloudX.isInitialized())
-    }
-
-    fun isTablet(promise: Promise) {
-        val isTablet = reactApplicationContext.resources.configuration.smallestScreenWidthDp >= 600
-        promise.resolve(isTablet)
-    }
-
-    fun getVersion(promise: Promise) {
-        promise.resolve(CloudX.getVersion())
-    }
-
-    // =========================================================================
-    // Configuration
-    // =========================================================================
-
-    fun setMinLogLevel(level: String) {
-        val logLevel = when (level.lowercase()) {
-            "verbose" -> CloudXLogLevel.VERBOSE
-            "debug" -> CloudXLogLevel.DEBUG
-            "info" -> CloudXLogLevel.INFO
-            "warn" -> CloudXLogLevel.WARN
-            "error" -> CloudXLogLevel.ERROR
-            "none" -> CloudXLogLevel.NONE
-            else -> CloudXLogLevel.INFO
-        }
-        CloudX.setMinLogLevel(logLevel)
-    }
-
-    fun setVisualDebuggingEnabled(enabled: Boolean) {
-        // Visual debugging is iOS-only; no-op on Android
-    }
-
-    // =========================================================================
-    // User Targeting
-    // =========================================================================
-
-    fun setHashedUserID(hashedUserID: String) {
-        CloudX.setHashedUserId(hashedUserID)
-    }
-
-    fun setUserKeyValue(key: String, value: String) {
-        CloudX.setUserKeyValue(key, value)
-    }
-
-    fun setAppKeyValue(key: String, value: String) {
-        CloudX.setAppKeyValue(key, value)
-    }
-
-    fun clearAllKeyValues() {
-        CloudX.clearAllKeyValues()
-    }
-
-    // =========================================================================
-    // Programmatic Banner/MREC Positioning
-    // =========================================================================
-
-    private fun attachAdToWindow(adView: CloudXAdView, position: String, isMREC: Boolean, xOffsetDp: Float = 0f, yOffsetDp: Float = 0f) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) {
-            Log.e(TAG, "attachAdToWindow: no activity available")
-            return
-        }
-        val contentFrame = activity.window.decorView.findViewById<FrameLayout>(android.R.id.content)
-        if (contentFrame == null) {
-            Log.e(TAG, "attachAdToWindow: no content frame available")
-            return
-        }
-
-        (adView.parent as? ViewGroup)?.removeView(adView)
-        val density = reactApplicationContext.resources.displayMetrics.density
-
-        val isTablet = reactApplicationContext.resources.configuration.smallestScreenWidthDp >= 600
-        val bannerWidthPx = ((if (isMREC) 300 else if (isTablet) 728 else 320) * density).toInt()
-        val bannerHeightPx = ((if (isMREC) 250 else if (isTablet) 90 else 50) * density).toInt()
-
-        val decorView = activity.window.decorView
-        var insetTop = 0; var insetBottom = 0; var insetLeft = 0; var insetRight = 0
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            decorView.rootWindowInsets?.let { insets ->
-                val systemBars = insets.getInsets(WindowInsets.Type.systemBars())
-                insetTop = systemBars.top; insetBottom = systemBars.bottom
-                insetLeft = systemBars.left; insetRight = systemBars.right
-            }
-        } else {
-            @Suppress("DEPRECATION")
-            decorView.rootWindowInsets?.let { insets ->
-                insetTop = insets.systemWindowInsetTop; insetBottom = insets.systemWindowInsetBottom
-                insetLeft = insets.systemWindowInsetLeft; insetRight = insets.systemWindowInsetRight
-            }
-        }
-
-        val pos = position.uppercase()
-        val gravity = when (pos) {
-            "TOP_LEFT" -> Gravity.TOP or Gravity.START
-            "TOP_CENTER" -> Gravity.TOP or Gravity.CENTER_HORIZONTAL
-            "TOP_RIGHT" -> Gravity.TOP or Gravity.END
-            "CENTER_LEFT" -> Gravity.CENTER_VERTICAL or Gravity.START
-            "CENTERED" -> Gravity.CENTER
-            "CENTER_RIGHT" -> Gravity.CENTER_VERTICAL or Gravity.END
-            "BOTTOM_LEFT" -> Gravity.BOTTOM or Gravity.START
-            "BOTTOM_CENTER" -> Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
-            "BOTTOM_RIGHT" -> Gravity.BOTTOM or Gravity.END
-            else -> Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
-        }
-
-        val offsetXPx = (xOffsetDp * density).toInt()
-        val offsetYPx = (yOffsetDp * density).toInt()
-
-        val marginTop = (if (pos.startsWith("TOP")) insetTop else 0) + offsetYPx
-        val marginBottom = (if (pos.startsWith("BOTTOM")) insetBottom else 0) + offsetYPx
-        val marginLeft = (if (pos.endsWith("LEFT")) insetLeft else 0) + offsetXPx
-        val marginRight = (if (pos.endsWith("RIGHT")) insetRight else 0) + offsetXPx
-
-        val layoutParams = FrameLayout.LayoutParams(bannerWidthPx, bannerHeightPx).apply {
-            this.gravity = gravity
-            setMargins(marginLeft, marginTop, marginRight, marginBottom)
-        }
-
-        contentFrame.addView(adView, layoutParams)
-        adView.visibility = View.VISIBLE
-        adView.bringToFront()
-    }
-
-    // =========================================================================
-    // Banner (Programmatic)
-    // =========================================================================
-
-    // Use Handler(Looper.getMainLooper()) so the block executes even when
-    // currentActivity is null (e.g., during backgrounding or config changes).
-    fun createBanner(adUnitId: String, position: String) {
-        createBannerWithOffsets(adUnitId, position, 0.0, 0.0)
-    }
-
-    fun createBannerWithOffsets(adUnitId: String, position: String, xOffset: Double, yOffset: Double) {
-        Handler(Looper.getMainLooper()).post {
-            banners.remove(adUnitId)?.let { old ->
-                old.listener = null
-                old.revenueListener = null
-                old.stopAutoRefresh()
-                if (windowPositionedAds.remove(adUnitId)) {
-                    (old.parent as? ViewGroup)?.removeView(old)
-                }
-                old.destroy()
-            }
-
-            val banner = CloudX.createBanner(adUnitId)
-            banner.listener = createBannerListener(adUnitId, false)
-            banner.revenueListener = createBannerRevenueListener(adUnitId, false)
-            banners[adUnitId] = banner
-            adViewPositions[adUnitId] = position
-            adViewOffsets[adUnitId] = Pair(xOffset.toFloat(), yOffset.toFloat())
-            attachAdToWindow(banner, position, false, xOffset.toFloat(), yOffset.toFloat())
-            windowPositionedAds.add(adUnitId)
-            banner.load()
-
-            if (adUnitIdsToShowAfterCreate.remove(adUnitId)) {
-                banner.visibility = View.VISIBLE
-            }
-        }
-    }
-
-    fun showBanner(adUnitId: String) {
-        val banner = banners[adUnitId]
-        if (banner != null) {
-            val activity = reactApplicationContext.currentActivity
-            if (activity == null) { Log.w(TAG, "showBanner: no activity"); return }
-            activity.runOnUiThread { banner.visibility = View.VISIBLE }
-        } else {
-            adUnitIdsToShowAfterCreate.add(adUnitId)
-        }
-    }
-
-    fun hideBanner(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "hideBanner: no activity"); return }
-        activity.runOnUiThread { banners[adUnitId]?.visibility = View.GONE }
-    }
-
-    fun destroyBanner(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            banners.remove(adUnitId)?.let {
-                it.listener = null
-                it.revenueListener = null
-                it.stopAutoRefresh()
-                if (windowPositionedAds.remove(adUnitId)) {
-                    (it.parent as? ViewGroup)?.removeView(it)
-                }
-                it.destroy()
-            }
-            adViewPositions.remove(adUnitId)
-            adViewOffsets.remove(adUnitId)
-            adUnitIdsToShowAfterCreate.remove(adUnitId)
-        }
-    }
-
-    fun setBannerPlacement(adUnitId: String, placement: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "setBannerPlacement: no activity"); return }
-        activity.runOnUiThread { banners[adUnitId]?.setPlacement(placement) }
-    }
-
-    fun setBannerCustomData(adUnitId: String, customData: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "setBannerCustomData: no activity"); return }
-        activity.runOnUiThread { banners[adUnitId]?.setCustomData(customData) }
-    }
-
-    fun startBannerAutoRefresh(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "startBannerAutoRefresh: no activity"); return }
-        activity.runOnUiThread { banners[adUnitId]?.startAutoRefresh() }
-    }
-
-    fun stopBannerAutoRefresh(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "stopBannerAutoRefresh: no activity"); return }
-        activity.runOnUiThread { banners[adUnitId]?.stopAutoRefresh() }
-    }
-
-    // =========================================================================
-    // MREC (Programmatic)
-    // =========================================================================
-
-    fun createMRec(adUnitId: String, position: String) {
-        createMRecWithOffsets(adUnitId, position, 0.0, 0.0)
-    }
-
-    fun createMRecWithOffsets(adUnitId: String, position: String, xOffset: Double, yOffset: Double) {
-        Handler(Looper.getMainLooper()).post {
-            mrecs.remove(adUnitId)?.let { old ->
-                old.listener = null
-                old.revenueListener = null
-                old.stopAutoRefresh()
-                if (windowPositionedAds.remove(adUnitId)) {
-                    (old.parent as? ViewGroup)?.removeView(old)
-                }
-                old.destroy()
-            }
-
-            val mrec = CloudX.createMREC(adUnitId)
-            mrec.listener = createBannerListener(adUnitId, true)
-            mrec.revenueListener = createBannerRevenueListener(adUnitId, true)
-            mrecs[adUnitId] = mrec
-            adViewPositions[adUnitId] = position
-            adViewOffsets[adUnitId] = Pair(xOffset.toFloat(), yOffset.toFloat())
-            attachAdToWindow(mrec, position, true, xOffset.toFloat(), yOffset.toFloat())
-            windowPositionedAds.add(adUnitId)
-            mrec.load()
-
-            if (adUnitIdsToShowAfterCreate.remove(adUnitId)) {
-                mrec.visibility = View.VISIBLE
-            }
-        }
-    }
-
-    fun showMRec(adUnitId: String) {
-        val mrec = mrecs[adUnitId]
-        if (mrec != null) {
-            val activity = reactApplicationContext.currentActivity
-            if (activity == null) { Log.w(TAG, "showMRec: no activity"); return }
-            activity.runOnUiThread { mrec.visibility = View.VISIBLE }
-        } else {
-            adUnitIdsToShowAfterCreate.add(adUnitId)
-        }
-    }
-
-    fun hideMRec(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "hideMRec: no activity"); return }
-        activity.runOnUiThread { mrecs[adUnitId]?.visibility = View.GONE }
-    }
-
-    fun destroyMRec(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            mrecs.remove(adUnitId)?.let {
-                it.listener = null
-                it.revenueListener = null
-                it.stopAutoRefresh()
-                if (windowPositionedAds.remove(adUnitId)) {
-                    (it.parent as? ViewGroup)?.removeView(it)
-                }
-                it.destroy()
-            }
-            adViewPositions.remove(adUnitId)
-            adViewOffsets.remove(adUnitId)
-            adUnitIdsToShowAfterCreate.remove(adUnitId)
-        }
-    }
-
-    fun setMRecPlacement(adUnitId: String, placement: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "setMRecPlacement: no activity"); return }
-        activity.runOnUiThread { mrecs[adUnitId]?.setPlacement(placement) }
-    }
-
-    fun setMRecCustomData(adUnitId: String, customData: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "setMRecCustomData: no activity"); return }
-        activity.runOnUiThread { mrecs[adUnitId]?.setCustomData(customData) }
-    }
-
-    fun startMRecAutoRefresh(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "startMRecAutoRefresh: no activity"); return }
-        activity.runOnUiThread { mrecs[adUnitId]?.startAutoRefresh() }
-    }
-
-    fun stopMRecAutoRefresh(adUnitId: String) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) { Log.w(TAG, "stopMRecAutoRefresh: no activity"); return }
-        activity.runOnUiThread { mrecs[adUnitId]?.stopAutoRefresh() }
-    }
-
-    // =========================================================================
-    // Dynamic Repositioning
-    // =========================================================================
-
-    fun updateBannerPosition(adUnitId: String, position: String) {
-        Handler(Looper.getMainLooper()).post {
-            val banner = banners[adUnitId] ?: return@post
-            adViewPositions[adUnitId] = position
-            val offsets = adViewOffsets[adUnitId] ?: Pair(0f, 0f)
-            attachAdToWindow(banner, position, false, offsets.first, offsets.second)
-        }
-    }
-
-    fun updateMRecPosition(adUnitId: String, position: String) {
-        Handler(Looper.getMainLooper()).post {
-            val mrec = mrecs[adUnitId] ?: return@post
-            adViewPositions[adUnitId] = position
-            val offsets = adViewOffsets[adUnitId] ?: Pair(0f, 0f)
-            attachAdToWindow(mrec, position, true, offsets.first, offsets.second)
-        }
-    }
-
-    fun updateBannerOffsets(adUnitId: String, xOffset: Double, yOffset: Double) {
-        Handler(Looper.getMainLooper()).post {
-            val banner = banners[adUnitId] ?: return@post
-            adViewOffsets[adUnitId] = Pair(xOffset.toFloat(), yOffset.toFloat())
-            val position = adViewPositions[adUnitId] ?: "BOTTOM_CENTER"
-            attachAdToWindow(banner, position, false, xOffset.toFloat(), yOffset.toFloat())
-        }
-    }
-
-    fun updateMRecOffsets(adUnitId: String, xOffset: Double, yOffset: Double) {
-        Handler(Looper.getMainLooper()).post {
-            val mrec = mrecs[adUnitId] ?: return@post
-            adViewOffsets[adUnitId] = Pair(xOffset.toFloat(), yOffset.toFloat())
-            val position = adViewPositions[adUnitId] ?: "BOTTOM_CENTER"
-            attachAdToWindow(mrec, position, true, xOffset.toFloat(), yOffset.toFloat())
-        }
-    }
-
-    // =========================================================================
-    // Background Color
-    // =========================================================================
-
-    fun setBannerBackgroundColor(adUnitId: String, hexColorString: String) {
-        Handler(Looper.getMainLooper()).post {
-            banners[adUnitId]?.setBackgroundColor(parseHexColor(hexColorString))
-        }
-    }
-
-    fun setMRecBackgroundColor(adUnitId: String, hexColorString: String) {
-        Handler(Looper.getMainLooper()).post {
-            mrecs[adUnitId]?.setBackgroundColor(parseHexColor(hexColorString))
-        }
-    }
-
-    private fun parseHexColor(hex: String): Int {
-        val cleaned = if (hex.startsWith("#")) hex else "#$hex"
-        return Color.parseColor(cleaned)
-    }
-
-    // =========================================================================
-    // Orientation Change Handler
-    // =========================================================================
-
-    private fun setupOrientationListener() {
-        if (orientationListener != null) return
-
-        orientationListener = object : OrientationEventListener(reactApplicationContext) {
-            override fun onOrientationChanged(orientation: Int) {
-                val activity = reactApplicationContext.currentActivity ?: return
-                @Suppress("DEPRECATION")
-                val newRotation = activity.windowManager.defaultDisplay.rotation
-                if (currentRotation != newRotation) {
-                    currentRotation = newRotation
-                    repositionAllAdViews()
-                }
-            }
-        }
-        orientationListener?.enable()
-    }
-
-    private fun repositionAllAdViews() {
-        Handler(Looper.getMainLooper()).post {
-            for ((adUnitId, banner) in banners) {
-                val position = adViewPositions[adUnitId] ?: continue
-                if (!windowPositionedAds.contains(adUnitId)) continue
-                val offsets = adViewOffsets[adUnitId] ?: Pair(0f, 0f)
-                attachAdToWindow(banner, position, false, offsets.first, offsets.second)
-            }
-            for ((adUnitId, mrec) in mrecs) {
-                val position = adViewPositions[adUnitId] ?: continue
-                if (!windowPositionedAds.contains(adUnitId)) continue
-                val offsets = adViewOffsets[adUnitId] ?: Pair(0f, 0f)
-                attachAdToWindow(mrec, position, true, offsets.first, offsets.second)
-            }
-        }
-    }
-
-    // =========================================================================
-    // Interstitial
-    // =========================================================================
-
-    fun loadInterstitial(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            var interstitial = interstitials[adUnitId]
-            if (interstitial == null) {
-                interstitial = CloudX.createInterstitial(adUnitId)
-                interstitial.listener = createInterstitialListener(adUnitId)
-                interstitial.revenueListener = createFullscreenRevenueListener(adUnitId, ON_INTERSTITIAL_AD_REVENUE_PAID)
-                interstitials[adUnitId] = interstitial
-            }
-            interstitial.load()
-        }
-    }
-
-    fun isInterstitialReady(adUnitId: String, promise: Promise) {
-        promise.resolve(interstitials[adUnitId]?.isAdReady ?: false)
-    }
-
-    fun showInterstitial(adUnitId: String, placement: String?, customData: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) {
-            Log.e(TAG, "showInterstitial: no activity available")
-            sendEvent(ON_INTERSTITIAL_DISPLAY_FAILED_EVENT, Arguments.createMap().apply {
-                putString("adUnitId", adUnitId)
-                putInt("code", -1)
-                putString("message", "No activity available")
-            })
-            return
-        }
-        val interstitial = interstitials[adUnitId]
-        if (interstitial == null) {
-            sendEvent(ON_INTERSTITIAL_DISPLAY_FAILED_EVENT, Arguments.createMap().apply {
-                putString("adUnitId", adUnitId)
-                putInt("code", -1)
-                putString("message", "Interstitial not loaded")
-            })
-            return
-        }
-        // Show unconditionally — the native SDK fires onAdDisplayFailed if the ad
-        // cannot be presented, ensuring JS always receives a display-failed event.
-        activity.runOnUiThread { interstitial.show(activity, placement, customData) }
-    }
-
-    fun destroyInterstitial(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            interstitials.remove(adUnitId)?.let {
-                it.listener = null
-                it.revenueListener = null
-                it.destroy()
-            }
-        }
-    }
-
-    // =========================================================================
-    // Rewarded
-    // =========================================================================
-
-    fun loadRewarded(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            var rewarded = rewardeds[adUnitId]
-            if (rewarded == null) {
-                rewarded = CloudX.createRewarded(adUnitId)
-                rewarded.listener = createRewardedListener(adUnitId)
-                rewarded.revenueListener = createFullscreenRevenueListener(adUnitId, ON_REWARDED_AD_REVENUE_PAID)
-                rewardeds[adUnitId] = rewarded
-            }
-            rewarded.load()
-        }
-    }
-
-    fun isRewardedReady(adUnitId: String, promise: Promise) {
-        promise.resolve(rewardeds[adUnitId]?.isAdReady ?: false)
-    }
-
-    fun showRewarded(adUnitId: String, placement: String?, customData: String?) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) {
-            Log.e(TAG, "showRewarded: no activity available")
-            sendEvent(ON_REWARDED_AD_DISPLAY_FAILED_EVENT, Arguments.createMap().apply {
-                putString("adUnitId", adUnitId)
-                putInt("code", -1)
-                putString("message", "No activity available")
-            })
-            return
-        }
-        val rewarded = rewardeds[adUnitId]
-        if (rewarded == null) {
-            sendEvent(ON_REWARDED_AD_DISPLAY_FAILED_EVENT, Arguments.createMap().apply {
-                putString("adUnitId", adUnitId)
-                putInt("code", -1)
-                putString("message", "Rewarded ad not loaded")
-            })
-            return
-        }
-        // Show unconditionally — the native SDK fires onAdDisplayFailed if the ad
-        // cannot be presented, ensuring JS always receives a display-failed event.
-        activity.runOnUiThread { rewarded.show(activity, placement, customData) }
-    }
-
-    fun destroyRewarded(adUnitId: String) {
-        Handler(Looper.getMainLooper()).post {
-            rewardeds.remove(adUnitId)?.let {
-                it.listener = null
-                it.revenueListener = null
-                it.destroy()
-            }
-        }
-    }
-
-    // =========================================================================
-    // Event Helpers
-    // =========================================================================
-
-    private fun sendEvent(eventName: String, data: WritableMap) {
-        try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                ?.emit(eventName, data)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to send event: $eventName", e)
-        }
-    }
-
-    private fun adInfoMap(ad: CloudXAd): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("adUnitId", ad.adUnitId)
-        map.putString("adFormat", ad.adFormat.name)
-        map.putString("networkName", ad.networkName)
-        map.putString("networkPlacement", ad.networkPlacement ?: "")
-        map.putString("placement", ad.placement ?: "")
-        map.putDouble("revenue", ad.revenue)
-        return map
-    }
-
-    private fun errorMap(adUnitId: String, error: CloudXError): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("adUnitId", adUnitId)
-        map.putInt("code", error.code.code)
-        map.putString("message", error.message)
-        return map
-    }
-
-    // =========================================================================
-    // Listener Factories
-    // =========================================================================
-
-    private fun createInterstitialListener(adUnitId: String): CloudXInterstitialListener {
-        return object : CloudXInterstitialListener {
-            override fun onAdLoaded(cloudXAd: CloudXAd) {
-                sendEvent(ON_INTERSTITIAL_LOADED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdLoadFailed(failedAdUnitId: String, cloudXError: CloudXError) {
-                sendEvent(ON_INTERSTITIAL_LOAD_FAILED_EVENT, errorMap(failedAdUnitId, cloudXError))
-            }
-            override fun onAdClicked(cloudXAd: CloudXAd) {
-                sendEvent(ON_INTERSTITIAL_CLICKED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdDisplayed(cloudXAd: CloudXAd) {
-                sendEvent(ON_INTERSTITIAL_DISPLAYED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdDisplayFailed(cloudXAd: CloudXAd, cloudXError: CloudXError) {
-                val data = adInfoMap(cloudXAd)
-                data.putInt("code", cloudXError.code.code)
-                data.putString("message", cloudXError.message)
-                sendEvent(ON_INTERSTITIAL_DISPLAY_FAILED_EVENT, data)
-            }
-            override fun onAdHidden(cloudXAd: CloudXAd) {
-                sendEvent(ON_INTERSTITIAL_HIDDEN_EVENT, adInfoMap(cloudXAd))
-            }
-        }
-    }
-
-    private fun createRewardedListener(adUnitId: String): CloudXRewardedListener {
-        return object : CloudXRewardedListener {
-            override fun onAdLoaded(cloudXAd: CloudXAd) {
-                sendEvent(ON_REWARDED_AD_LOADED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdLoadFailed(failedAdUnitId: String, cloudXError: CloudXError) {
-                sendEvent(ON_REWARDED_AD_LOAD_FAILED_EVENT, errorMap(failedAdUnitId, cloudXError))
-            }
-            override fun onAdClicked(cloudXAd: CloudXAd) {
-                sendEvent(ON_REWARDED_AD_CLICKED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdDisplayed(cloudXAd: CloudXAd) {
-                sendEvent(ON_REWARDED_AD_DISPLAYED_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onAdDisplayFailed(cloudXAd: CloudXAd, cloudXError: CloudXError) {
-                val data = adInfoMap(cloudXAd)
-                data.putInt("code", cloudXError.code.code)
-                data.putString("message", cloudXError.message)
-                sendEvent(ON_REWARDED_AD_DISPLAY_FAILED_EVENT, data)
-            }
-            override fun onAdHidden(cloudXAd: CloudXAd) {
-                sendEvent(ON_REWARDED_AD_HIDDEN_EVENT, adInfoMap(cloudXAd))
-            }
-            override fun onUserRewarded(cloudXAd: CloudXAd, reward: CloudXReward) {
-                val data = adInfoMap(cloudXAd)
-                data.putString("rewardLabel", reward.label)
-                data.putInt("rewardAmount", reward.amount)
-                sendEvent(ON_REWARDED_AD_RECEIVED_REWARD_EVENT, data)
-            }
-        }
-    }
-
-    private fun createBannerListener(adUnitId: String, isMrec: Boolean): CloudXAdViewListener {
-        val loadedEvent = if (isMrec) ON_MREC_AD_LOADED_EVENT else ON_BANNER_AD_LOADED_EVENT
-        val loadFailedEvent = if (isMrec) ON_MREC_AD_LOAD_FAILED_EVENT else ON_BANNER_AD_LOAD_FAILED_EVENT
-        val clickedEvent = if (isMrec) ON_MREC_AD_CLICKED_EVENT else ON_BANNER_AD_CLICKED_EVENT
-        val expandedEvent = if (isMrec) ON_MREC_AD_EXPANDED_EVENT else ON_BANNER_AD_EXPANDED_EVENT
-        val collapsedEvent = if (isMrec) ON_MREC_AD_COLLAPSED_EVENT else ON_BANNER_AD_COLLAPSED_EVENT
-
-        return object : CloudXAdViewListener {
-            override fun onAdLoaded(cloudXAd: CloudXAd) {
-                sendEvent(loadedEvent, adInfoMap(cloudXAd))
-            }
-            override fun onAdLoadFailed(failedAdUnitId: String, cloudXError: CloudXError) {
-                sendEvent(loadFailedEvent, errorMap(failedAdUnitId, cloudXError))
-            }
-            override fun onAdClicked(cloudXAd: CloudXAd) {
-                sendEvent(clickedEvent, adInfoMap(cloudXAd))
-            }
-            override fun onAdExpanded(cloudXAd: CloudXAd) {
-                sendEvent(expandedEvent, adInfoMap(cloudXAd))
-            }
-            override fun onAdCollapsed(cloudXAd: CloudXAd) {
-                sendEvent(collapsedEvent, adInfoMap(cloudXAd))
-            }
-        }
-    }
-
-    private fun createBannerRevenueListener(adUnitId: String, isMrec: Boolean): CloudXAdRevenueListener {
-        val revenueEvent = if (isMrec) ON_MREC_AD_REVENUE_PAID else ON_BANNER_AD_REVENUE_PAID
-        return object : CloudXAdRevenueListener {
-            override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
-                sendEvent(revenueEvent, adInfoMap(cloudXAd))
-            }
-        }
-    }
-
-    private fun createFullscreenRevenueListener(adUnitId: String, eventName: String): CloudXAdRevenueListener {
-        return object : CloudXAdRevenueListener {
-            override fun onAdRevenuePaid(cloudXAd: CloudXAd) {
-                sendEvent(eventName, adInfoMap(cloudXAd))
-            }
-        }
-    }
-}