@capgo/capacitor-admob 8.1.20 → 8.2.0

package/android/src/main/kotlin/admob/plus/capacitor/ConsentHelper.kt

@@ -0,0 +1,140 @@
+package admob.plus.capacitor
+
+import android.app.Activity
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.PluginCall
+import com.google.android.ump.ConsentDebugSettings
+import com.google.android.ump.ConsentInformation
+import com.google.android.ump.ConsentRequestParameters
+import com.google.android.ump.UserMessagingPlatform
+
+class ConsentHelper(private val plugin: AdMobPlusPlugin) {
+    private var consentInformation: ConsentInformation? = null
+
+    fun requestConsentInfo(call: PluginCall) {
+        try {
+            val consentInfo = ensureConsentInfo()
+            val activity = plugin.activity
+            if (activity == null) {
+                call.reject("Trying to request consent info but the Activity is null")
+                return
+            }
+
+            val debugSettingsBuilder = ConsentDebugSettings.Builder(plugin.context)
+            val data = call.data
+
+            if (data.has("testDeviceIdentifiers")) {
+                val devices = call.getArray("testDeviceIdentifiers") ?: JSArray()
+                for (i in 0 until devices.length()) {
+                    debugSettingsBuilder.addTestDeviceHashedId(devices.getString(i))
+                }
+            }
+
+            if (data.has("debugGeography")) {
+                debugSettingsBuilder.setDebugGeography(data.getInt("debugGeography"))
+            }
+
+            val paramsBuilder = ConsentRequestParameters.Builder()
+                .setConsentDebugSettings(debugSettingsBuilder.build())
+
+            if (data.has("tagForUnderAgeOfConsent")) {
+                paramsBuilder.setTagForUnderAgeOfConsent(data.getBoolean("tagForUnderAgeOfConsent"))
+            }
+
+            consentInfo.requestConsentInfoUpdate(
+                activity,
+                paramsBuilder.build(),
+                {
+                    call.resolve(buildConsentInfo(consentInfo))
+                },
+                { formError ->
+                    call.reject(formError.message)
+                },
+            )
+        } catch (ex: Exception) {
+            call.reject(ex.localizedMessage, ex)
+        }
+    }
+
+    fun showPrivacyOptionsForm(call: PluginCall) {
+        try {
+            val activity = plugin.activity
+            if (activity == null) {
+                call.reject("Trying to show the privacy options form but the Activity is null")
+                return
+            }
+
+            ensureConsentInfo()
+            activity.runOnUiThread {
+                UserMessagingPlatform.showPrivacyOptionsForm(activity) { formError ->
+                    if (formError != null) {
+                        call.reject("Error when show privacy form", formError.message)
+                    } else {
+                        call.resolve()
+                    }
+                }
+            }
+        } catch (ex: Exception) {
+            call.reject(ex.localizedMessage, ex)
+        }
+    }
+
+    fun showConsentForm(call: PluginCall) {
+        try {
+            val activity = plugin.activity
+            if (activity == null) {
+                call.reject("Trying to show the consent form but the Activity is null")
+                return
+            }
+
+            val consentInfo = ensureConsentInfo()
+            activity.runOnUiThread {
+                UserMessagingPlatform.loadAndShowConsentFormIfRequired(activity) { formError ->
+                    if (formError != null) {
+                        call.reject("Error when show consent form", formError.message)
+                        return@loadAndShowConsentFormIfRequired
+                    }
+
+                    call.resolve(buildConsentInfo(consentInfo, includeFormAvailability = false))
+                }
+            }
+        } catch (ex: Exception) {
+            call.reject(ex.localizedMessage, ex)
+        }
+    }
+
+    private fun ensureConsentInfo(): ConsentInformation {
+        if (consentInformation == null) {
+            consentInformation = UserMessagingPlatform.getConsentInformation(plugin.context)
+        }
+        return consentInformation!!
+    }
+
+    private fun buildConsentInfo(
+        consentInfo: ConsentInformation,
+        includeFormAvailability: Boolean = true,
+    ): JSObject {
+        val result = JSObject()
+        result.put("status", getConsentStatusString(consentInfo.consentStatus))
+        if (includeFormAvailability) {
+            result.put("isConsentFormAvailable", consentInfo.isConsentFormAvailable)
+        }
+        result.put("canRequestAds", consentInfo.canRequestAds())
+        result.put(
+            "privacyOptionsRequirementStatus",
+            consentInfo.privacyOptionsRequirementStatus.name,
+        )
+        return result
+    }
+
+    private fun getConsentStatusString(consentStatus: Int): String {
+        return when (consentStatus) {
+            ConsentInformation.ConsentStatus.REQUIRED -> "REQUIRED"
+            ConsentInformation.ConsentStatus.NOT_REQUIRED -> "NOT_REQUIRED"
+            ConsentInformation.ConsentStatus.OBTAINED -> "OBTAINED"
+            ConsentInformation.ConsentStatus.UNKNOWN -> "UNKNOWN"
+            else -> "UNKNOWN"
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/capacitor/Generated.kt

@@ -38,5 +38,12 @@ class Generated {
         const val REWARDED_REWARD = "rewarded.reward"
         const val REWARDED_SHOW = "rewarded.show"
         const val REWARDED_SHOW_FAIL = "rewarded.showfail"
+        const val FEED_CLICK = "feed.click"
+        const val FEED_CLOSE = "feed.close"
+        const val FEED_IMPRESSION = "feed.impression"
+        const val FEED_LOAD = "feed.load"
+        const val FEED_LOAD_FAIL = "feed.loadfail"
+        const val FEED_OPEN = "feed.open"
+        const val FEED_REFRESH = "feed.refresh"
     }
 }

package/android/src/main/kotlin/admob/plus/capacitor/feed/FeedAdManager.kt

@@ -0,0 +1,512 @@
+package admob.plus.capacitor.feed
+
+import admob.plus.capacitor.AdMobPlusPlugin
+import admob.plus.capacitor.Generated
+import android.content.pm.ApplicationInfo
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.util.Log
+import android.os.Handler
+import android.os.Looper
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import java.io.File
+import java.io.FileOutputStream
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.getcapacitor.JSObject
+import com.google.android.libraries.ads.mobile.sdk.banner.AdSize
+import com.google.android.libraries.ads.mobile.sdk.banner.AdView
+import com.google.android.libraries.ads.mobile.sdk.banner.BannerAd
+import com.google.android.libraries.ads.mobile.sdk.banner.BannerAdEventCallback
+import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError
+import com.google.android.libraries.ads.mobile.sdk.nativead.MediaView
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAd
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdLoader
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdLoaderCallback
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdRequest
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdView
+import kotlin.math.max
+
+private const val MIN_AUTO_REFRESH_MS = 30_000L
+private const val FEED_SCREENSHOT_LOG_TAG = "CapgoAdmobFeed"
+private const val MAX_NATIVE_NO_FILL_RETRIES = 0
+private const val NATIVE_NO_FILL_RETRY_DELAY_MS = 2_000L
+
+class FeedAdManager(private val plugin: AdMobPlusPlugin) {
+    private val entries = mutableMapOf<Int, FeedAdEntry>()
+    private var nextId = 1
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    fun create(
+        format: String,
+        adUnitId: String,
+        positionKey: String?,
+        autoRefreshMs: Int?,
+        nativeStyle: Map<String, String>,
+    ): Int {
+        val id = nextId++
+        val entry = FeedAdEntry(
+            id = id,
+            format = if (format == "banner") FeedAdFormat.BANNER else FeedAdFormat.NATIVE,
+            adUnitId = adUnitId,
+            positionKey = positionKey,
+            nativeStyle = nativeStyle,
+            plugin = plugin,
+            mainHandler = mainHandler,
+        )
+        autoRefreshMs?.let { entry.setAutoRefresh(it) }
+        entries[id] = entry
+        return id
+    }
+
+    fun destroy(id: Int) {
+        entries.remove(id)?.destroy()
+    }
+
+    fun load(id: Int, onComplete: (String?) -> Unit) {
+        val entry = entries[id]
+        if (entry == null) {
+            onComplete("Feed ad not found")
+            return
+        }
+        entry.load(onComplete)
+    }
+
+    fun isLoaded(id: Int): Boolean = entries[id]?.isLoaded == true
+
+    fun updateBounds(
+        id: Int,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        visible: Boolean,
+    ) {
+        entries[id]?.updateBounds(x, y, width, height, visible)
+    }
+
+    fun setAutoRefresh(id: Int, autoRefreshMs: Int?) {
+        entries[id]?.setAutoRefresh(autoRefreshMs)
+    }
+}
+
+private enum class FeedAdFormat {
+    NATIVE,
+    BANNER,
+}
+
+private class FeedAdEntry(
+    val id: Int,
+    val format: FeedAdFormat,
+    val adUnitId: String,
+    val positionKey: String?,
+    val nativeStyle: Map<String, String>,
+    private val plugin: AdMobPlusPlugin,
+    private val mainHandler: Handler,
+) {
+    private var adHost: View? = null
+    private var nativeAd: NativeAd? = null
+    private var bannerAdView: AdView? = null
+    private var loaded = false
+    private var refreshRunnable: Runnable? = null
+    private var loadCallback: ((String?) -> Unit)? = null
+    private var nativeNoFillRetries = 0
+    private var nativeNoFillRetryRunnable: Runnable? = null
+    private var overlayVisibleLogged = false
+    private var ciBannerSnapshotWritten = false
+    private val ciBannerSnapshotToken = Any()
+
+    val isLoaded: Boolean
+        get() = loaded
+
+    fun destroy() {
+        mainHandler.removeCallbacksAndMessages(ciBannerSnapshotToken)
+        refreshRunnable?.let { mainHandler.removeCallbacks(it) }
+        refreshRunnable = null
+        nativeNoFillRetryRunnable?.let { mainHandler.removeCallbacks(it) }
+        nativeNoFillRetryRunnable = null
+        nativeAd?.destroy()
+        nativeAd = null
+        adHost?.let { (it.parent as? ViewGroup)?.removeView(it) }
+        adHost = null
+        bannerAdView?.destroy()
+        bannerAdView = null
+        loaded = false
+    }
+
+    fun setAutoRefresh(autoRefreshMs: Int?) {
+        refreshRunnable?.let { mainHandler.removeCallbacks(it) }
+        refreshRunnable = null
+        if (autoRefreshMs == null || autoRefreshMs < MIN_AUTO_REFRESH_MS) {
+            return
+        }
+        val runnable = object : Runnable {
+            override fun run() {
+                emitFeed(Generated.Events.FEED_REFRESH, null)
+                load { }
+                mainHandler.postDelayed(this, autoRefreshMs.toLong())
+            }
+        }
+        refreshRunnable = runnable
+        mainHandler.postDelayed(runnable, autoRefreshMs.toLong())
+    }
+
+    fun load(onComplete: (String?) -> Unit) {
+        loadCallback = onComplete
+        mainHandler.post {
+            when (format) {
+                FeedAdFormat.NATIVE -> loadNative()
+                FeedAdFormat.BANNER -> loadBanner()
+            }
+        }
+    }
+
+    fun updateBounds(x: Double, y: Double, width: Double, height: Double, visible: Boolean) {
+        mainHandler.post {
+            val webView = plugin.bridge.webView
+            val host = adHost ?: return@post
+            val parent = webView.parent as? ViewGroup ?: return@post
+            if (host.parent == null) {
+                parent.addView(host)
+            }
+            val density = webView.resources.displayMetrics.density
+            val left = (x * density).toInt()
+            val top = (y * density).toInt() + webView.top
+            val w = max(1, (width * density).toInt())
+            val h = max(1, (height * density).toInt())
+            val params = ViewGroup.MarginLayoutParams(w, h).apply {
+                leftMargin = left
+                topMargin = top
+            }
+            host.layoutParams = params
+            host.visibility = if (visible && loaded) View.VISIBLE else View.INVISIBLE
+            host.bringToFront()
+            if (visible && loaded && !overlayVisibleLogged && w > 40 && h > 20) {
+                overlayVisibleLogged = true
+                val formatLabel = if (format == FeedAdFormat.BANNER) "banner" else "native"
+                Log.i(FEED_SCREENSHOT_LOG_TAG, "overlay_visible id=$id format=$formatLabel")
+                if (format == FeedAdFormat.BANNER) {
+                    Log.i(FEED_SCREENSHOT_LOG_TAG, "ci_banner_slot_ready id=$id")
+                    writeCiBannerOverlaySnapshotNow(host, w, h)
+                }
+            } else if (
+                visible &&
+                loaded &&
+                format == FeedAdFormat.BANNER &&
+                !ciBannerSnapshotWritten &&
+                w > 40 &&
+                h > 20
+            ) {
+                writeCiBannerOverlaySnapshotNow(host, w, h)
+            }
+        }
+    }
+
+    private fun scheduleCiBannerOverlaySnapshotAfterLoad() {
+        if (ciBannerSnapshotWritten || format != FeedAdFormat.BANNER) {
+            return
+        }
+        Log.i(FEED_SCREENSHOT_LOG_TAG, "ci_banner_snapshot_schedule id=$id")
+        adHost?.let { host ->
+            val lp = host.layoutParams
+            val w = host.width.takeIf { it > 20 } ?: lp?.width ?: 0
+            val h = host.height.takeIf { it > 10 } ?: lp?.height ?: 0
+            if (w > 20 && h > 10) {
+                mainHandler.postDelayed(
+                    {
+                        if (!ciBannerSnapshotWritten) {
+                            writeCiBannerOverlaySnapshotNow(host, w, h)
+                        }
+                    },
+                    ciBannerSnapshotToken,
+                    0L,
+                )
+            }
+        }
+        val delaysMs = longArrayOf(150L, 400L, 900L, 1_600L, 2_400L)
+        for (delayMs in delaysMs) {
+            mainHandler.postDelayed(
+                {
+                    if (!ciBannerSnapshotWritten) {
+                        adHost?.let { host ->
+                            val lp = host.layoutParams
+                            val w = host.width.takeIf { it > 20 } ?: lp?.width ?: 0
+                            val h = host.height.takeIf { it > 10 } ?: lp?.height ?: 0
+                            writeCiBannerOverlaySnapshotNow(host, w, h)
+                        }
+                    }
+                },
+                ciBannerSnapshotToken,
+                delayMs,
+            )
+        }
+    }
+
+    private fun writeCiBannerOverlaySnapshotNow(host: View, layoutW: Int, layoutH: Int) {
+        var width = if (host.width >= 20) host.width else layoutW
+        var height = if (host.height >= 10) host.height else layoutH
+        if (width < 20 || height < 10) {
+            Log.i(
+                FEED_SCREENSHOT_LOG_TAG,
+                "ci_banner_snapshot_failed message=host_not_laid_out w=${host.width} h=${host.height} lw=$layoutW lh=$layoutH",
+            )
+            return
+        }
+        if (host.width < 20 || host.height < 10) {
+            host.measure(
+                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY),
+            )
+            host.layout(0, 0, width, height)
+        }
+        Log.i(FEED_SCREENSHOT_LOG_TAG, "ci_banner_snapshot_attempt id=$id")
+        var bitmap: Bitmap? = null
+        try {
+            width = host.width.coerceAtLeast(width).coerceAtLeast(1)
+            height = host.height.coerceAtLeast(height).coerceAtLeast(1)
+            bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+            val canvas = Canvas(bitmap)
+            canvas.drawColor(Color.WHITE)
+            host.draw(canvas)
+            val file = File(plugin.context.cacheDir, "ci_feed_banner.png")
+            FileOutputStream(file).use { out ->
+                bitmap.compress(Bitmap.CompressFormat.PNG, 100, out)
+            }
+            ciBannerSnapshotWritten = true
+            Log.i(FEED_SCREENSHOT_LOG_TAG, "ci_banner_snapshot_written path=${file.absolutePath}")
+        } catch (e: Exception) {
+            Log.i(
+                FEED_SCREENSHOT_LOG_TAG,
+                "ci_banner_snapshot_failed message=${e.message}",
+            )
+        } finally {
+            bitmap?.recycle()
+        }
+    }
+
+    private fun finishLoad(errorMessage: String?) {
+        val cb = loadCallback
+        loadCallback = null
+        cb?.invoke(errorMessage)
+    }
+
+    private fun loadNative() {
+        Log.i(FEED_SCREENSHOT_LOG_TAG, "feed_load_start id=$id format=native")
+        val request = NativeAdRequest.Builder(adUnitId, listOf(NativeAd.NativeAdType.NATIVE)).build()
+        NativeAdLoader.load(
+            request,
+            object : NativeAdLoaderCallback {
+                override fun onNativeAdLoaded(ad: NativeAd) {
+                    mainHandler.post {
+                        displayNativeAd(ad)
+                    }
+                }
+
+                override fun onAdFailedToLoad(adError: LoadAdError) {
+                    Log.i(
+                        FEED_SCREENSHOT_LOG_TAG,
+                        "feed_load_fail id=$id format=native code=${adError.code.value} message=${adError.message}",
+                    )
+                    if (shouldRetryNativeNoFill(adError)) {
+                        nativeNoFillRetries += 1
+                        nativeNoFillRetryRunnable?.let { mainHandler.removeCallbacks(it) }
+                        val retry = Runnable { loadNative() }
+                        nativeNoFillRetryRunnable = retry
+                        mainHandler.postDelayed(retry, NATIVE_NO_FILL_RETRY_DELAY_MS)
+                        return
+                    }
+                    emitFeedFail(adError)
+                    loaded = false
+                    finishLoad(adError.message)
+                }
+            },
+        )
+    }
+
+    private fun displayNativeAd(ad: NativeAd) {
+        val oldHost = adHost
+        val oldParent = oldHost?.parent as? ViewGroup
+        oldParent?.removeView(oldHost)
+        nativeAd?.destroy()
+        nativeAd = ad
+        val nativeAdView = buildNativeAdView(ad)
+        adHost = nativeAdView
+        oldHost?.layoutParams?.let { nativeAdView.layoutParams = it }
+        oldParent?.addView(nativeAdView)
+        loaded = true
+        nativeAdView.visibility = View.VISIBLE
+
+        val assets = JSObject()
+        assets.put("headline", ad.headline ?: "")
+        assets.put("body", ad.body ?: "")
+        assets.put("callToAction", ad.callToAction ?: "")
+        assets.put("advertiser", ad.advertiser ?: "")
+        assets.put("price", ad.price ?: "")
+        assets.put("store", ad.store ?: "")
+        ad.starRating?.let { assets.put("starRating", it) }
+        ad.mediaContent?.aspectRatio?.let { assets.put("mediaAspectRatio", it) }
+        nativeNoFillRetries = 0
+        emitFeed(Generated.Events.FEED_LOAD, assets)
+        Log.i(FEED_SCREENSHOT_LOG_TAG, "feed_load id=$id format=native")
+        finishLoad(null)
+    }
+
+    private fun shouldRetryNativeNoFill(adError: LoadAdError): Boolean {
+        val isDebuggable =
+            (plugin.context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+        return isDebuggable &&
+            adError.message.equals("No fill.", ignoreCase = true) &&
+            nativeNoFillRetries < MAX_NATIVE_NO_FILL_RETRIES
+    }
+
+    private fun buildNativeAdView(ad: NativeAd): NativeAdView {
+        val context = plugin.context
+        val nativeAdView = NativeAdView(context)
+        nativeAdView.setBackgroundColor(parseColor(nativeStyle["backgroundColor"]) ?: Color.parseColor("#F2F2F2"))
+
+        val column = LinearLayout(context)
+        column.orientation = LinearLayout.VERTICAL
+        column.setPadding(24, 24, 24, 24)
+
+        val attribution = TextView(context)
+        attribution.text = "Ad"
+        attribution.gravity = Gravity.END
+        attribution.setTextSize(TypedValue.COMPLEX_UNIT_SP, 10f)
+        column.addView(attribution)
+
+        val mediaView = MediaView(context)
+        mediaView.layoutParams = LinearLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            (180 * context.resources.displayMetrics.density).toInt(),
+        )
+        column.addView(mediaView)
+
+        val headline = TextView(context)
+        headline.text = ad.headline
+        headline.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
+        headline.setTextColor(parseColor(nativeStyle["headlineTextColor"]) ?: Color.BLACK)
+        nativeAdView.headlineView = headline
+        column.addView(headline)
+
+        if (!ad.body.isNullOrBlank()) {
+            val body = TextView(context)
+            body.text = ad.body
+            body.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14f)
+            body.setTextColor(parseColor(nativeStyle["bodyTextColor"]) ?: Color.DKGRAY)
+            nativeAdView.bodyView = body
+            column.addView(body)
+        }
+
+        val cta = Button(context)
+        cta.text = ad.callToAction
+        cta.isClickable = false
+        cta.isEnabled = false
+        cta.setBackgroundColor(parseColor(nativeStyle["ctaBackgroundColor"]) ?: Color.parseColor("#2563EB"))
+        cta.setTextColor(parseColor(nativeStyle["ctaTextColor"]) ?: Color.WHITE)
+        nativeAdView.callToActionView = cta
+        column.addView(cta)
+
+        nativeAdView.addView(
+            column,
+            ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+            ),
+        )
+        nativeAdView.registerNativeAd(ad, mediaView)
+        return nativeAdView
+    }
+
+    private fun loadBanner() {
+        Log.i(FEED_SCREENSHOT_LOG_TAG, "feed_load_start id=$id format=banner")
+        val activity = plugin.activity
+        val webView = plugin.bridge.webView
+        if (bannerAdView == null) {
+            bannerAdView = AdView(activity)
+            adHost = bannerAdView
+        }
+        loaded = false
+        val adWidth = (webView.width / webView.resources.displayMetrics.density).toInt().coerceAtLeast(320)
+        val adSize = AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(activity, adWidth)
+        bannerAdView!!.loadAd(
+            com.google.android.libraries.ads.mobile.sdk.banner.BannerAdRequest.Builder(adUnitId, adSize).build(),
+            object : AdLoadCallback<BannerAd> {
+                override fun onAdLoaded(bannerAd: BannerAd) {
+                    loaded = true
+                    bannerAd.adEventCallback = object : BannerAdEventCallback {
+                        override fun onAdClicked() {
+                            emitFeed(Generated.Events.FEED_CLICK, null)
+                        }
+
+                        override fun onAdDismissedFullScreenContent() {
+                            emitFeed(Generated.Events.FEED_CLOSE, null)
+                        }
+
+                        override fun onAdImpression() {
+                            emitFeed(Generated.Events.FEED_IMPRESSION, null)
+                        }
+
+                        override fun onAdShowedFullScreenContent() {
+                            emitFeed(Generated.Events.FEED_OPEN, null)
+                        }
+                    }
+                    val assets = JSObject()
+                    assets.put("width", adSize.width)
+                    assets.put("height", adSize.height)
+                    emitFeed(Generated.Events.FEED_LOAD, assets)
+                    Log.i(FEED_SCREENSHOT_LOG_TAG, "feed_load id=$id format=banner")
+                    scheduleCiBannerOverlaySnapshotAfterLoad()
+                    finishLoad(null)
+                }
+
+                override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+                    Log.i(
+                        FEED_SCREENSHOT_LOG_TAG,
+                        "feed_load_fail id=$id format=banner code=${loadAdError.code.value} message=${loadAdError.message}",
+                    )
+                    emitFeedFail(loadAdError)
+                    loaded = false
+                    finishLoad(loadAdError.message)
+                }
+            },
+        )
+    }
+
+    private fun emitFeed(event: String, assets: JSObject?) {
+        val payload = JSObject()
+        payload.put("feedAdId", id)
+        positionKey?.let { payload.put("positionKey", it) }
+        payload.put("format", if (format == FeedAdFormat.BANNER) "banner" else "native")
+        assets?.let { payload.put("assets", it) }
+        plugin.emit(event, payload)
+    }
+
+    private fun emitFeedFail(error: LoadAdError) {
+        val payload = JSObject()
+        payload.put("feedAdId", id)
+        positionKey?.let { payload.put("positionKey", it) }
+        payload.put("format", if (format == FeedAdFormat.BANNER) "banner" else "native")
+        payload.put("code", error.code.value)
+        payload.put("message", error.message)
+        plugin.emit(Generated.Events.FEED_LOAD_FAIL, payload)
+    }
+
+    private fun parseColor(hex: String?): Int? {
+        if (hex.isNullOrBlank() || !hex.startsWith("#") || hex.length != 7) {
+            return null
+        }
+        return try {
+            Color.parseColor(hex)
+        } catch (_: IllegalArgumentException) {
+            null
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/core/Ad.kt

@@ -6,16 +6,14 @@ import android.view.ViewGroup
 import com.google.android.libraries.ads.mobile.sdk.common.FullScreenContentError
 import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError
 import com.google.android.libraries.ads.mobile.sdk.rewarded.RewardItem
-import java.util.Objects
-
 abstract class Ad(val id: Int, val adUnitId: String) {
     init {
         Helper.ads.put(id, this)
     }
 
     constructor(ctx: Context) : this(
-        Objects.requireNonNull<Int?>(ctx.optId()),
-        Objects.requireNonNull<String?>(ctx.optAdUnitID())
+        requireNotNull(ctx.optId()),
+        requireNotNull(ctx.optAdUnitID()),
     )
 
     open fun destroy() {