cloudx-react-native 2.0.0-beta.1

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

@@ -0,0 +1,861 @@
+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))
+            }
+        }
+    }
+}