@capacitor-community/admob 8.2.0-beta.pr484.shaa6be63853bbd → 8.2.1

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"
+}

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

@@ -0,0 +1,66 @@
+import UIKit
+import WebKit
+
+/// Research-preview binding to a single HTML overflow scroll container.
+final class NativeAdScrollTracker {
+    private weak var webView: WKWebView?
+    private weak var scrollView: UIScrollView?
+    private let placements: [NativeAdPlacementValue]
+    private let clip: CGRect
+    private let render: ([NativeAdPlacementValue]) -> Void
+    private var observation: NSKeyValueObservation?
+
+    init?(
+        container: [String: Any],
+        webView: WKWebView,
+        placements: [NativeAdPlacementValue],
+        render: @escaping ([NativeAdPlacementValue]) -> Void
+    ) {
+        guard
+            let rectValue = container["rect"] as? [String: Any],
+            let clipValue = container["clipRect"] as? [String: Any],
+            let rect = NativeAdPlacementValue.rect(rectValue),
+            let clip = NativeAdPlacementValue.rect(clipValue),
+            let width = container["contentWidth"] as? Double,
+            let height = container["contentHeight"] as? Double,
+            [rect.minX, rect.minY, rect.width, rect.height,
+             clip.minX, clip.minY, clip.width, clip.height, width, height].allSatisfy({ $0.isFinite }),
+            rect.width > 0, rect.height > 0
+        else { return nil }
+
+        let candidates = Self.scrollViews(in: webView).filter { scroll in
+            let frame = scroll.convert(scroll.bounds, to: webView)
+            return scroll !== webView.scrollView && !scroll.isHidden && scroll.window != nil &&
+                abs(scroll.zoomScale - 1) < 0.001 &&
+                abs(frame.minX - rect.minX) < 2 && abs(frame.minY - rect.minY) < 2 &&
+                abs(frame.width - rect.width) < 2 && abs(frame.height - rect.height) < 2 &&
+                abs(scroll.contentSize.width - width) < 3 && abs(scroll.contentSize.height - height) < 3
+        }
+        guard candidates.count == 1, let scroll = candidates.first else { return nil }
+        self.webView = webView
+        self.scrollView = scroll
+        self.placements = placements
+        self.clip = clip
+        self.render = render
+        observation = scroll.observe(\.contentOffset, options: [.new]) { [weak self] _, _ in
+            self?.update()
+        }
+    }
+
+    func update() {
+        guard let webView, let scrollView, scrollView.isDescendant(of: webView) else {
+            render([])
+            return
+        }
+        let frame = scrollView.convert(scrollView.bounds, to: webView)
+        let viewport = clip.intersection(webView.bounds).intersection(frame)
+        let origin = CGPoint(x: frame.minX - scrollView.contentOffset.x, y: frame.minY - scrollView.contentOffset.y)
+        render(placements.compactMap { $0.projected(origin: origin, viewport: viewport) })
+    }
+
+    private static func scrollViews(in view: UIView) -> [UIScrollView] {
+        view.subviews.flatMap { child in
+            ((child as? UIScrollView).map { [$0] } ?? []) + scrollViews(in: child)
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import Capacitor
+import Foundation
+
+enum NativeAdValues {
+    static func session(_ call: CAPPluginCall) -> (feedId: String, sessionId: String)? {
+        guard let feedId = requiredString(call, "feedId"), let sessionId = requiredString(call, "sessionId") else {
+            return nil
+        }
+        return (feedId, sessionId)
+    }
+
+    static func requiredString(_ call: CAPPluginCall, _ name: String) -> String? {
+        guard let value = call.getString(name)?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            call.reject("\(name) must not be empty")
+            return nil
+        }
+        return value
+    }
+
+    static func key(_ feedId: String, _ slotKey: String) -> String {
+        "\(feedId)\u{0}\(slotKey)"
+    }
+
+    static func identity(_ feedId: String, _ sessionId: String, _ slotKey: String) -> [String: Any] {
+        ["feedId": feedId, "sessionId": sessionId, "slotKey": slotKey]
+    }
+}