@capacitor-community/admob 8.2.0 → 8.2.1

package/ios/Sources/AdMobPlugin/AdMobPlugin.swift

@@ -23,6 +23,11 @@ public class AdMobPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "resumeBanner", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "hideBanner", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "removeBanner", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startNativeAdFeed", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyNativeAdFeed", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "loadNativeAd", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "updateNativeAdPlacements", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeNativeAd", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "prepareInterstitial", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "showInterstitial", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "prepareRewardVideoAd", returnType: CAPPluginReturnPromise),
@@ -64,25 +69,40 @@ public class AdMobPlugin: CAPPlugin, CAPBridgedPlugin {
     private let adRewardExecutor = AdRewardExecutor()
     private let adRewardInterstitialExecutor = AdRewardInterstitialExecutor()
     private let consentExecutor = ConsentExecutor()
+    private let nativeAdExecutor = NativeAdExecutor()
 
     public override func load() {
         self.consentExecutor.plugin = self
     }
 
-    /**
-     * Enable SKAdNetwork to track conversions
-     * https://developers.google.com/admob/ios/ios14
-     */
-    @objc func initialize(_ call: CAPPluginCall) {
-        self.bannerExecutor.plugin = self
-        self.adInterstitialExecutor.plugin = self
-        self.adRewardExecutor.plugin = self
-        self.adRewardInterstitialExecutor.plugin = self
-        self.adInterstitialExecutor.plugin = self
-        self.setRequestConfiguration(call)
+    /// Full-screen ads that currently have web media suspended.
+    private var webMediaSuspenders = Set<ObjectIdentifier>()
+
+    /// Pauses all web media while a full-screen ad is up, so WebKit releases its audio before the ad plays
+    /// and sets it up again afterwards, instead of leaving web audio silent until the app restarts.
+    func suspendWebMedia(for owner: AnyObject) {
+        Task { @MainActor [weak self] in
+            guard let self, self.webMediaSuspenders.insert(ObjectIdentifier(owner)).inserted,
+                self.webMediaSuspenders.count == 1
+            else { return }
+            self.setWebMediaPlaybackSuspended(true)
+        }
+    }
 
-        MobileAds.shared.start(completionHandler: nil)
-        call.resolve([:])
+    /// Only resumes once every ad that suspended has resumed, so a failed present (which can arrive
+    /// without a preceding adWillPresentFullScreenContent) can't release another ad's suspension.
+    func resumeWebMedia(for owner: AnyObject) {
+        Task { @MainActor [weak self] in
+            guard let self, self.webMediaSuspenders.remove(ObjectIdentifier(owner)) != nil,
+                self.webMediaSuspenders.isEmpty
+            else { return }
+            self.setWebMediaPlaybackSuspended(false)
+        }
+    }
+
+    @MainActor
+    func setWebMediaPlaybackSuspended(_ suspended: Bool) {
+        self.bridge?.webView?.setAllMediaPlaybackSuspended(suspended, completionHandler: nil)
     }
 
     /**
@@ -126,34 +146,12 @@ public class AdMobPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
-    /**
-     *  AdMob: Banner
-     *  https://developers.google.com/ad-manager/mobile-ads-sdk/ios/banner?hl=ja
-     */
-    @objc func showBanner(_ call: CAPPluginCall) {
-        let adUnitID = getAdId(call, "ca-app-pub-3940256099942544/6300978111")
-        let request = self.GADRequestWithOption(call.getBool("npa") ?? false)
-
-        DispatchQueue.main.async {
-            self.bannerExecutor.showBanner(call, request, adUnitID)
-        }
-    }
-
-    @objc func hideBanner(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            self.bannerExecutor.hideBanner(call)
-        }
-    }
-
-    @objc func resumeBanner(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            self.bannerExecutor.resumeBanner(call)
-        }
-    }
-
-    @objc func removeBanner(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            self.bannerExecutor.removeBanner(call)
+    deinit {
+        let executor = nativeAdExecutor
+        if Thread.isMainThread {
+            executor.destroyAll()
+        } else {
+            DispatchQueue.main.async { executor.destroyAll() }
         }
     }
 
@@ -349,3 +347,67 @@ public class AdMobPlugin: CAPPlugin, CAPBridgedPlugin {
         return window?.rootViewController
     }
 }
+
+extension AdMobPlugin {
+    // MARK: SDK initialization
+
+    @objc func initialize(_ call: CAPPluginCall) {
+        bannerExecutor.plugin = self
+        adInterstitialExecutor.plugin = self
+        adRewardExecutor.plugin = self
+        adRewardInterstitialExecutor.plugin = self
+        adInterstitialExecutor.plugin = self
+        nativeAdExecutor.plugin = self
+        setRequestConfiguration(call)
+
+        MobileAds.shared.start(completionHandler: nil)
+        call.resolve([:])
+    }
+
+    // MARK: Banner ads
+
+    @objc func showBanner(_ call: CAPPluginCall) {
+        let adUnitID = getAdId(call, "ca-app-pub-3940256099942544/6300978111")
+        let request = GADRequestWithOption(call.getBool("npa") ?? false)
+        DispatchQueue.main.async {
+            self.bannerExecutor.showBanner(call, request, adUnitID)
+        }
+    }
+
+    @objc func hideBanner(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.bannerExecutor.hideBanner(call) }
+    }
+
+    @objc func resumeBanner(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.bannerExecutor.resumeBanner(call) }
+    }
+
+    @objc func removeBanner(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.bannerExecutor.removeBanner(call) }
+    }
+
+    // MARK: Native ads research preview
+
+    @objc func startNativeAdFeed(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.nativeAdExecutor.startFeed(call) }
+    }
+
+    @objc func destroyNativeAdFeed(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.nativeAdExecutor.destroyFeed(call) }
+    }
+
+    @objc func loadNativeAd(_ call: CAPPluginCall) {
+        let request = GADRequestWithOption(call.getBool("npa") ?? false)
+        DispatchQueue.main.async {
+            self.nativeAdExecutor.load(call, request: request)
+        }
+    }
+
+    @objc func updateNativeAdPlacements(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.nativeAdExecutor.updatePlacements(call) }
+    }
+
+    @objc func removeNativeAd(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { self.nativeAdExecutor.remove(call) }
+    }
+}

package/ios/Sources/AdMobPlugin/Interstitial/AdInterstitialExecutor.swift

@@ -73,6 +73,7 @@ class AdInterstitialExecutor: NSObject, FullScreenContentDelegate {
     }
 
     func ad(_ ad: FullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        self.plugin?.resumeWebMedia(for: ad)
         removeCurrentlyShowingAd()
         NSLog("InterstitialFullScreenDelegate Ad failed to present full screen content with error \(error.localizedDescription).")
         self.plugin?.notifyListeners(InterstitialAdPluginEvents.FailedToShow.rawValue, data: [
@@ -82,11 +83,13 @@ class AdInterstitialExecutor: NSObject, FullScreenContentDelegate {
     }
 
     func adWillPresentFullScreenContent(_ ad: FullScreenPresentingAd) {
+        self.plugin?.suspendWebMedia(for: ad)
         NSLog("InterstitialFullScreenDelegate Ad did present full screen content.")
         self.plugin?.notifyListeners(InterstitialAdPluginEvents.Showed.rawValue, data: [:])
     }
 
     func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
+        self.plugin?.resumeWebMedia(for: ad)
         removeCurrentlyShowingAd()
         NSLog("InterstitialFullScreenDelegate Ad did dismiss full screen content.")
         self.plugin?.notifyListeners(InterstitialAdPluginEvents.Dismissed.rawValue, data: [:])

package/ios/Sources/AdMobPlugin/NativeAds/NativeAdExecutor.swift

@@ -0,0 +1,354 @@
+import Capacitor
+import Foundation
+import GoogleMobileAds
+import UIKit
+
+final class NativeAdExecutor: NSObject, NativeAdLoaderDelegate, NativeAdDelegate {
+    static let testAdUnitID = "ca-app-pub-3940256099942544/3986624511"
+    private let maxAdsPerFeed = 3
+
+    weak var plugin: AdMobPlugin?
+
+    private final class State {
+        let feedId: String
+        let isSmall: Bool
+        let sessionId: String
+        let slotKey: String
+        let nativeAd: NativeAd
+        let adView: PluginNativeAdView
+        let clippingView: UIView
+        var generation = -1
+
+        init(
+            feedId: String,
+            isSmall: Bool,
+            sessionId: String,
+            slotKey: String,
+            nativeAd: NativeAd,
+            adView: PluginNativeAdView,
+            clippingView: UIView
+        ) {
+            self.feedId = feedId
+            self.isSmall = isSmall
+            self.sessionId = sessionId
+            self.slotKey = slotKey
+            self.nativeAd = nativeAd
+            self.adView = adView
+            self.clippingView = clippingView
+        }
+    }
+
+    private struct Pending {
+        let loader: AdLoader
+        let call: CAPPluginCall
+        let feedId: String
+        let sessionId: String
+        let slotKey: String
+        let template: String
+        let style: [String: Any]
+    }
+
+    private var states: [String: State] = [:]
+    private var pending: [ObjectIdentifier: Pending] = [:]
+    private let feedSessions = NativeAdFeedSessions()
+    private var scrollTrackers: [String: NativeAdScrollTracker] = [:]
+
+    func startFeed(_ call: CAPPluginCall) {
+        guard let session = NativeAdValues.session(call) else { return }
+        let (feedId, sessionId) = session
+        if !feedSessions.isCurrent(feedId: feedId, sessionId: sessionId) { clearFeed(feedId) }
+        guard feedSessions.start(feedId: feedId, sessionId: sessionId) else {
+            call.reject("At most two native ad feeds can be active")
+            return
+        }
+        call.resolve()
+    }
+
+    func destroyFeed(_ call: CAPPluginCall) {
+        guard let session = NativeAdValues.session(call) else { return }
+        let (feedId, sessionId) = session
+        if feedSessions.isCurrent(feedId: feedId, sessionId: sessionId) {
+            clearFeed(feedId)
+            feedSessions.remove(feedId: feedId)
+        }
+        call.resolve()
+    }
+
+    func load(_ call: CAPPluginCall, request: Request) {
+        guard
+            let feedId = NativeAdValues.requiredString(call, "feedId"),
+            let sessionId = NativeAdValues.requiredString(call, "sessionId"),
+            let slotKey = NativeAdValues.requiredString(call, "slotKey")
+        else { return }
+        guard feedSessions.isCurrent(feedId: feedId, sessionId: sessionId) else {
+            call.reject("Native ad feed session is no longer active")
+            return
+        }
+        let adUnitID: String
+        if call.getBool("isTesting") == true {
+            adUnitID = Self.testAdUnitID
+        } else {
+            guard let requestedID = NativeAdValues.requiredString(call, "adId") else { return }
+            adUnitID = requestedID
+        }
+        let loader = AdLoader(
+            adUnitID: adUnitID,
+            rootViewController: plugin?.getRootVC(),
+            adTypes: [.native],
+            options: nil
+        )
+        let identifier = ObjectIdentifier(loader)
+        destroyState(NativeAdValues.key(feedId, slotKey))
+        cancelPending(feedId: feedId, slotKey: slotKey)
+        let feedAdCount = states.values.filter { $0.feedId == feedId }.count
+            + pending.values.filter { $0.feedId == feedId }.count
+        guard feedAdCount < maxAdsPerFeed else {
+            call.reject("At most three native ads can be active in a feed")
+            return
+        }
+        pending[identifier] = Pending(
+            loader: loader,
+            call: call,
+            feedId: feedId,
+            sessionId: sessionId,
+            slotKey: slotKey,
+            template: call.getString("template") ?? "medium",
+            style: call.getObject("style") ?? [:]
+        )
+        loader.delegate = self
+        loader.load(request)
+    }
+
+    func updatePlacements(_ call: CAPPluginCall) {
+        guard
+            let feedId = NativeAdValues.requiredString(call, "feedId"),
+            let sessionId = NativeAdValues.requiredString(call, "sessionId")
+        else { return }
+        guard feedSessions.isCurrent(feedId: feedId, sessionId: sessionId) else {
+            call.resolve()
+            return
+        }
+        let sequence = call.getInt("sequence") ?? -1
+        guard feedSessions.accepts(feedId: feedId, sequence: sequence) else {
+            call.resolve()
+            return
+        }
+        scrollTrackers.removeValue(forKey: feedId)
+        states.values.filter { $0.feedId == feedId }.forEach { $0.clippingView.isHidden = true }
+
+        if updateTrackedPlacements(call, feedId: feedId) { return }
+
+        for case let placement as [String: Any] in call.getArray("placements") ?? [] {
+            applyPlacement(placement, expectedFeedId: feedId)
+        }
+        call.resolve()
+    }
+
+    func remove(_ call: CAPPluginCall) {
+        guard
+            let feedId = NativeAdValues.requiredString(call, "feedId"),
+            let sessionId = NativeAdValues.requiredString(call, "sessionId"),
+            let slotKey = NativeAdValues.requiredString(call, "slotKey")
+        else { return }
+        guard feedSessions.isCurrent(feedId: feedId, sessionId: sessionId) else {
+            call.resolve()
+            return
+        }
+        cancelPending(feedId: feedId, slotKey: slotKey)
+        destroyState(NativeAdValues.key(feedId, slotKey))
+        call.resolve()
+    }
+
+    func destroyAll() {
+        scrollTrackers.removeAll()
+        for request in pending.values { request.call.reject("Native ad load was cancelled") }
+        for stateKey in Array(states.keys) { destroyState(stateKey) }
+        pending.removeAll()
+        feedSessions.removeAll()
+    }
+
+    func adLoader(_ adLoader: AdLoader, didReceive nativeAd: NativeAd) {
+        let identifier = ObjectIdentifier(adLoader)
+        guard let request = pending.removeValue(forKey: identifier) else { return }
+
+        if request.template == "small", nativeAd.mediaContent.hasVideoContent {
+            let message = "Small native ad template does not support video ads; use Medium"
+            var event = NativeAdValues.identity(request.feedId, request.sessionId, request.slotKey)
+            event["code"] = -1
+            event["message"] = message
+            plugin?.notifyListeners(NativeAdPluginEvents.failedToLoad.rawValue, data: event)
+            request.call.reject(message, "-1")
+            return
+        }
+        nativeAd.delegate = self
+        let adView = PluginNativeAdView(nativeAd: nativeAd, template: request.template, style: request.style)
+        let clippingView = UIView(frame: .zero)
+        clippingView.clipsToBounds = true
+        clippingView.isHidden = true
+        clippingView.addSubview(adView)
+
+        guard let webView = plugin?.bridge?.webView, let parent = webView.superview else {
+            nativeAd.delegate = nil
+            request.call.reject("AdMob WebView is unavailable")
+            return
+        }
+        parent.addSubview(clippingView)
+        let state = State(
+            feedId: request.feedId,
+            isSmall: request.template == "small",
+            sessionId: request.sessionId,
+            slotKey: request.slotKey,
+            nativeAd: nativeAd,
+            adView: adView,
+            clippingView: clippingView
+        )
+        states[NativeAdValues.key(request.feedId, request.slotKey)] = state
+
+        let feedId = request.feedId
+        let sessionId = request.sessionId
+        let slotKey = request.slotKey
+        let adUnitID = adLoader.adUnitID
+        nativeAd.paidEventHandler = { [weak self, weak nativeAd, weak state] adValue in
+            guard let self, let nativeAd, let state,
+                  self.states[NativeAdValues.key(feedId, slotKey)] === state else { return }
+            self.plugin?.notifyListeners(NativeAdPluginEvents.adPaid.rawValue, data: [
+                "feedId": feedId,
+                "sessionId": sessionId,
+                "slotKey": slotKey,
+                "adUnitId": adUnitID,
+                "valueMicros": adValue.value.multiplying(byPowerOf10: 6).int64Value,
+                "currencyCode": adValue.currencyCode,
+                "precision": adValue.precision.rawValue,
+                "networkName": nativeAd.responseInfo.loadedAdNetworkResponseInfo?.adNetworkClassName ?? "",
+                "impressionId": nativeAd.responseInfo.responseIdentifier ?? ""
+            ])
+        }
+
+        plugin?.notifyListeners(
+            NativeAdPluginEvents.loaded.rawValue,
+            data: NativeAdValues.identity(request.feedId, request.sessionId, request.slotKey)
+        )
+        request.call.resolve()
+    }
+
+    private func applyPlacement(_ placement: [String: Any], expectedFeedId: String) {
+        guard let value = NativeAdPlacementValue(placement, expectedFeedId: expectedFeedId) else { return }
+        applyPlacement(value)
+    }
+
+    private func applyPlacement(_ placement: NativeAdPlacementValue) {
+        guard
+            let state = states[NativeAdValues.key(placement.feedId, placement.slotKey)],
+            placement.generation >= state.generation,
+            placement.rect.width >= (state.isSmall ? 120 : 144),
+            placement.rect.height >= (state.isSmall ? 120 : 300),
+            let webView = plugin?.bridge?.webView
+        else { return }
+
+        let webOrigin = webView.frame.origin
+        state.clippingView.frame = placement.clip.offsetBy(dx: webOrigin.x, dy: webOrigin.y)
+        state.adView.frame = CGRect(
+            x: placement.rect.minX - placement.clip.minX,
+            y: placement.rect.minY - placement.clip.minY,
+            width: placement.rect.width,
+            height: placement.rect.height
+        )
+        state.generation = placement.generation
+        state.clippingView.isHidden = false
+        state.clippingView.superview?.bringSubviewToFront(state.clippingView)
+    }
+
+    private func notify(_ event: NativeAdPluginEvents, nativeAd: NativeAd) {
+        guard let state = states.values.first(where: { $0.nativeAd === nativeAd }) else { return }
+        plugin?.notifyListeners(
+            event.rawValue,
+            data: NativeAdValues.identity(state.feedId, state.sessionId, state.slotKey)
+        )
+    }
+
+    private func destroyState(_ stateKey: String) {
+        guard let state = states.removeValue(forKey: stateKey) else { return }
+        state.nativeAd.delegate = nil
+        state.nativeAd.paidEventHandler = nil
+        state.adView.nativeAd = nil
+        state.clippingView.removeFromSuperview()
+    }
+
+    private func cancelPending(feedId: String, slotKey: String) {
+        let identifiers = pending.compactMap { identifier, request in
+            request.feedId == feedId && request.slotKey == slotKey ? identifier : nil
+        }
+        for identifier in identifiers {
+            pending.removeValue(forKey: identifier)?.call.reject("Native ad load was cancelled")
+        }
+    }
+
+    private func clearFeed(_ feedId: String) {
+        scrollTrackers.removeValue(forKey: feedId)
+        let requests = pending.filter { $0.value.feedId == feedId }
+        for (identifier, request) in requests {
+            pending.removeValue(forKey: identifier)
+            request.call.reject("Native ad load was cancelled")
+        }
+        for stateKey in states.filter({ $0.value.feedId == feedId }).keys {
+            destroyState(stateKey)
+        }
+    }
+
+}
+
+extension NativeAdExecutor {
+    private func updateTrackedPlacements(_ call: CAPPluginCall, feedId: String) -> Bool {
+        guard let container = call.getObject("scrollContainer") else { return false }
+        let placements = (call.getArray("placements") ?? []).compactMap { value -> NativeAdPlacementValue? in
+            guard let value = value as? [String: Any] else { return nil }
+            return NativeAdPlacementValue(value, expectedFeedId: feedId)
+        }
+        if placements.isEmpty {
+            call.resolve()
+            return true
+        }
+        guard let webView = plugin?.bridge?.webView,
+              let tracker = NativeAdScrollTracker(container: container, webView: webView, placements: placements, render: { [weak self] values in
+                  guard let self else { return }
+                  self.states.values.filter { $0.feedId == feedId }.forEach { $0.clippingView.isHidden = true }
+                  values.forEach { self.applyPlacement($0) }
+              }) else {
+            call.reject("Cannot uniquely bind native ad scroll container")
+            return true
+        }
+        scrollTrackers[feedId] = tracker
+        tracker.update()
+        call.resolve()
+        return true
+    }
+
+    func adLoader(_ adLoader: AdLoader, didFailToReceiveAdWithError error: Error) {
+        let identifier = ObjectIdentifier(adLoader)
+        guard let request = pending.removeValue(forKey: identifier) else { return }
+        plugin?.notifyListeners(NativeAdPluginEvents.failedToLoad.rawValue, data: [
+            "feedId": request.feedId,
+            "sessionId": request.sessionId,
+            "slotKey": request.slotKey,
+            "code": (error as NSError).code,
+            "message": error.localizedDescription
+        ])
+        request.call.reject(error.localizedDescription, String((error as NSError).code), error)
+    }
+
+    func nativeAdDidRecordClick(_ nativeAd: NativeAd) {
+        notify(.clicked, nativeAd: nativeAd)
+    }
+
+    func nativeAdDidRecordImpression(_ nativeAd: NativeAd) {
+        notify(.impression, nativeAd: nativeAd)
+    }
+
+    func nativeAdWillPresentScreen(_ nativeAd: NativeAd) {
+        notify(.opened, nativeAd: nativeAd)
+    }
+
+    func nativeAdDidDismissScreen(_ nativeAd: NativeAd) {
+        notify(.closed, nativeAd: nativeAd)
+    }
+}

package/ios/Sources/AdMobPlugin/NativeAds/NativeAdFeedSessions.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+final class NativeAdFeedSessions {
+    private let maxFeeds = 2
+    private var sessions: [String: String] = [:]
+    private var placementSequences: [String: Int] = [:]
+
+    func start(feedId: String, sessionId: String) -> Bool {
+        guard sessions[feedId] != nil || sessions.count < maxFeeds else { return false }
+        sessions[feedId] = sessionId
+        placementSequences[feedId] = -1
+        return true
+    }
+
+    func isCurrent(feedId: String, sessionId: String) -> Bool {
+        sessions[feedId] == sessionId
+    }
+
+    func accepts(feedId: String, sequence: Int) -> Bool {
+        guard sequence > (placementSequences[feedId] ?? -1) else { return false }
+        placementSequences[feedId] = sequence
+        return true
+    }
+
+    func remove(feedId: String) {
+        sessions.removeValue(forKey: feedId)
+        placementSequences.removeValue(forKey: feedId)
+    }
+
+    func removeAll() {
+        sessions.removeAll()
+        placementSequences.removeAll()
+    }
+}

package/ios/Sources/AdMobPlugin/NativeAds/NativeAdPlacementValue.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+struct NativeAdPlacementValue {
+    let feedId: String
+    let slotKey: String
+    let generation: Int
+    var rect: CGRect
+    var clip: CGRect
+
+    init?(_ value: [String: Any], expectedFeedId: String) {
+        guard
+            value["visible"] as? Bool == true,
+            let feedId = value["feedId"] as? String,
+            feedId == expectedFeedId,
+            let slotKey = value["slotKey"] as? String,
+            let generation = (value["generation"] as? NSNumber)?.intValue,
+            let rectValue = value["rect"] as? [String: Any],
+            let clipValue = value["clipRect"] as? [String: Any],
+            let rect = Self.rect(rectValue),
+            let clip = Self.rect(clipValue),
+            rect.width > 0,
+            rect.height > 0,
+            clip.width > 0,
+            clip.height > 0
+        else { return nil }
+
+        self.feedId = feedId
+        self.slotKey = slotKey
+        self.generation = generation
+        self.rect = rect
+        self.clip = clip
+    }
+
+    func projected(origin: CGPoint, viewport: CGRect) -> Self? {
+        var result = self
+        result.rect = rect.offsetBy(dx: origin.x, dy: origin.y)
+        result.clip = clip.offsetBy(dx: origin.x, dy: origin.y).intersection(viewport)
+        return result.clip.isNull || result.clip.isEmpty ? nil : result
+    }
+
+    static func rect(_ value: [String: Any]) -> CGRect? {
+        guard
+            let originX = (value["x"] as? NSNumber)?.doubleValue,
+            let originY = (value["y"] as? NSNumber)?.doubleValue,
+            let width = (value["width"] as? NSNumber)?.doubleValue,
+            let height = (value["height"] as? NSNumber)?.doubleValue
+        else { return nil }
+        return CGRect(x: originX, y: originY, width: width, height: height)
+    }
+}

package/ios/Sources/AdMobPlugin/NativeAds/NativeAdPluginEvents.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+enum NativeAdPluginEvents: String {
+    case loaded = "nativeAdLoaded"
+    case failedToLoad = "nativeAdFailedToLoad"
+    case clicked = "nativeAdClicked"
+    case impression = "nativeAdImpression"
+    case opened = "nativeAdOpened"
+    case closed = "nativeAdClosed"
+    case adPaid = "nativeAdPaid"
+}